Avoid patching on macOS 12

Can harmfully damage the OS if not properly validated first

.github/workflows/build-app.yml

@@ -24,11 +24,6 @@ jobs:
 
       - run: cd dist; zip ../OpenCore-Patcher.zip OpenCore-Patcher; zip -r ../OpenCore-Patcher.app.zip OpenCore-Patcher.app
       - run: ./../sign-app.sh
-      - name: Upload Binary to Artifacts
-        uses: actions/upload-artifact@v2
-        with:
-          name: OpenCore-Patcher
-          path: OpenCore-Patcher.zip
       - name: Upload App to Artifacts
         uses: actions/upload-artifact@v2
         with:

CHANGELOG.md

@@ -1,5 +1,36 @@
 # OpenCore Legacy Patcher changelog
 
+## 0.1.6
+- Add XHCI UEFI Driver for 3rd Party USB 3.0 Controllers
+  - Allows for Boot Support from OpenCore' Picker
+- Fix UEFI output on MacPro3,1 with PC GPUs
+- Increment binaries:
+  - OpenCore 4e0ff2d (0.7.0 rolling - 05-23-2021)
+  - Apple Binaries 59a52a3 (0.0.8 release - 05-24-2021)
+- Allow legacy macOS Booting
+- Fix Photos app distortion on legacy GPUs
+- Fix device tree renaming on Mac Pros and Xserves
+- Ensure no Acceleration Patches applied when no compatible GPU found
+- Allow custom SMBIOS overriding
+- Fix incorrectly setting CPU override for non-Minimal SMBIOS spoofs
+- Support Minimal SMBIOS spoofing on El Capitan era Macs
+- Fix GPU Switching on MacBookPro6,x
+
+## 0.1.5
+- Fix crashing when Wireless module not present
+- Add iMac10,1 default dGPU pathing
+- Add agdpmod=vit9696 to all Nvidia Metal iMacs
+  - Fixes external display support on Nvidia iMac12,x
+- Remove reliance on AppleBacklightFixup
+- Support space in path when downloading Root Patches
+- Enable PanicNoKextDump by default
+- Expand AppleGraphicsPowerManagement and AppleGraphicsDeviceControl Override support
+- Fix MacBookPro8,2/3 Brightness Control
+  - dGPU must be disabled via NVRAM or deMUXed
+- Increment binaries:
+  - Apple Binaries 478f6a6 (0.0.7 release - 05-16-2021)
+- Add SeedUtil option to Advanced Patcher Settings
+
 ## 0.1.4
 - Fix Device Path formatting on 2012+ iMacs
 

OCLP-CLI.command

@@ -3,16 +3,13 @@
 
 from __future__ import print_function
 
-import binascii
-import plistlib
 import subprocess
 import sys
-import time
 import platform
 import argparse
 from pathlib import Path
 
-from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, Utilities, CliMenu, DeviceProbe
+from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, DeviceProbe
 
 
 class OpenCoreLegacyPatcher():
@@ -169,12 +166,6 @@ class OpenCoreLegacyPatcher():
             print("- Set System Volume unpatching")
             self.unpatch_vol()
 
-    def hexswap(self, input_hex: str):
-        hex_pairs = [input_hex[i:i + 2] for i in range(0, len(input_hex), 2)]
-        hex_rev = hex_pairs[::-1]
-        hex_str = "".join(["".join(x) for x in hex_rev])
-        return hex_str.upper()
-
     def patch_vol(self):
         SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_patch()
 

OpenCore-Patcher.command

@@ -3,11 +3,9 @@
 
 from __future__ import print_function
 
-import binascii
 import plistlib
 import subprocess
 import sys
-import time
 import platform
 
 from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, Utilities, CliMenu, DeviceProbe
@@ -17,15 +15,8 @@ class OpenCoreLegacyPatcher():
     def __init__(self):
         self.constants = Constants.Constants()
         self.current_model: str = None
-        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"):
-            opencore_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]
-            self.current_model = opencore_model
-        else:
-            self.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"]
+        self.current_model = DeviceProbe.smbios_probe().model_detect(False)
         self.constants.detected_os = int(platform.uname().release.partition(".")[0])
-        if self.current_model in ModelArray.NoAPFSsupport:
-            self.constants.serial_settings = "Moderate"
         if self.current_model in ModelArray.LegacyGPU:
             dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
 
@@ -58,11 +49,17 @@ class OpenCoreLegacyPatcher():
                 self.constants.custom_cpu_model = 1
                 self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
 
-    def hexswap(self, input_hex: str):
-        hex_pairs = [input_hex[i:i + 2] for i in range(0, len(input_hex), 2)]
-        hex_rev = hex_pairs[::-1]
-        hex_str = "".join(["".join(x) for x in hex_rev])
-        return hex_str.upper()
+        # Check if running in RecoveryOS
+        self.check_recovery()
+
+    def check_recovery(self):
+        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 \
+            root_partition_info["BusProtocol"] == "Disk Image":
+            self.constants.recovery_status = True
+        else:
+            self.constants.recovery_status = False
 
     def build_opencore(self):
         Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).build_opencore()
@@ -87,8 +84,6 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
             if print_models in {"y", "Y", "yes", "Yes"}:
                 print("\n".join(ModelArray.SupportedSMBIOS))
                 input("Press any key to continue...")
-        if self.constants.custom_model in ModelArray.NoAPFSsupport:
-            self.constants.serial_settings = "Moderate"
 
     def patcher_settings(self):
         response = None
@@ -131,7 +126,9 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
                 [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"Download more RAM:\t\t\tCurrently {self.constants.download_ram}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).download_more_ram_dot_com],
                 [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"Set Custom name {self.constants.custom_cpu_model_value}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).custom_cpu],
+                [f"Set SeedUtil Status", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).set_seedutil],
             ]
 
             for option in options:
@@ -227,7 +224,7 @@ B. Exit
 
             response = menu.start()
 
-        if getattr(sys, "frozen", False):
+        if getattr(sys, "frozen", False) and self.constants.recovery_status is False:
             subprocess.run("""osascript -e 'tell application "Terminal" to close first window' & exit""", shell=True)
 
 

README.md

@@ -1,6 +1,7 @@
-# OpenCore Legacy Patcher
-
-<img src="images/OC-Patcher.png" width="256">
+<div align="center">
+             <img src="images/OC-Patcher.png" alt="OpenCore Patcher Logo" width="256" />
+             <h1>OpenCore Legacy Patcher</h1>
+</div>
 
 A python program for building and booting [OpenCore](https://github.com/acidanthera/OpenCorePkg) on both legacy and modern Macs, see our in-depth [Guide](https://dortania.github.io/OpenCore-Legacy-Patcher/) for more information.
 
@@ -27,6 +28,8 @@ To get aid with the patcher, we recommend joining the [OpenCore Patcher Paradise
 
 * [OpenCore Legacy Patcher's Issue's tab](https://github.com/dortania/OpenCore-Legacy-Patcher/issues)
 
+Nightly builds can be found here courteous of nightly.link: [Nightly OpenCore-Patcher.app](https://nightly.link/dortania/OpenCore-Legacy-Patcher/workflows/build-app/main/OpenCore-Patcher.app.zip)
+
 ## Credits
 
 * [Acidanthera](https://github.com/Acidanthera)
@@ -37,6 +40,9 @@ To get aid with the patcher, we recommend joining the [OpenCore Patcher Paradise
   * Main co-author
 * [Ausdauersportler](https://github.com/Ausdauersportler)
   * iMacs Metal GPUs Upgrade Patch set and documentation
+  * Great amounts of help debugging and code suggestions
+* [vit9696](https://github.com/vit9696)
+  * Endless amount of help troubleshooting, determining fixes and writing patches
 * [ASentientBot](https://github.com/ASentientBot)
   * Legacy Acceleration Patch set and documentation
 * [cdf](https://github.com/cdf)
@@ -46,11 +52,9 @@ To get aid with the patcher, we recommend joining the [OpenCore Patcher Paradise
   * [AAAMouSSE](https://forums.macrumors.com/threads/mp3-1-others-sse-4-2-emulation-to-enable-amd-metal-driver.2206682/) and [telemetrap](https://forums.macrumors.com/threads/mp3-1-others-sse-4-2-emulation-to-enable-amd-metal-driver.2206682/post-28447707)
 * [dosdude1](https://github.com/dosdude1) and [BarryKN](https://github.com/BarryKN)
   * Development of previous patchers, laying out much of what needs to be patched
-* [vit9696](https://github.com/vit9696)
-  * Endless amount of help troubleshooting, determining fixes and writing patches
 * [mario_bros_tech](https://github.com/mariobrostech) and the rest of the Unsupported Mac Discord
   * Catalyst that started OpenCore Legacy Patcher
 * MacRumors and Unsupported Mac Communities
   * Endless testing, reporting issues
 * Apple
-  * for macOS and many of the kexts, frameworks and other binaries we reimplemented into newer OSes
+  * for macOS and many of the kexts, frameworks and other binaries we reimplemented into newer OSes

Resources/Build.py

@@ -8,9 +8,6 @@ import shutil
 import subprocess
 import uuid
 import zipfile
-import os
-import sys
-import platform
 import ast
 from pathlib import Path
 from datetime import date
@@ -38,15 +35,63 @@ class BuildOpenCore:
         self.config = None
         self.constants: Constants.Constants = versions
 
-    def hexswap(self, input_hex: str):
-        hex_pairs = [input_hex[i:i + 2] for i in range(0, len(input_hex), 2)]
-        hex_rev = hex_pairs[::-1]
-        hex_str = "".join(["".join(x) for x in hex_rev])
-        return hex_str.upper()
+    def smbios_set(self):
+        if self.model in ModelArray.MacBookAir61:
+            print("- Spoofing to MacBookAir6,1")
+            return "MacBookAir6,1"
+        elif self.model in ModelArray.MacBookAir62:
+            print("- Spoofing to MacBookAir6,2")
+            return "MacBookAir6,2"
+        elif self.model in ModelArray.MacBookPro111:
+            print("- Spoofing to MacBookPro11,1")
+            return "MacBookPro11,1"
+        elif self.model in ModelArray.MacBookPro113:
+            print("- Spoofing to MacBookPro11,3")
+            return "MacBookPro11,3"
+        elif self.model in ModelArray.Macmini71:
+            print("- Spoofing to Macmini7,1")
+            return "Macmini7,1"
+        elif self.model in ModelArray.iMacPro11:
+            print("- Spoofing to iMacPro1,1")
+            return "iMacPro1,1"
+        elif self.model in ModelArray.iMac151:
+            # Check for upgraded GPUs on iMacs
+            if self.constants.drm_support is True:
+                print("- Spoofing to iMacPro1,1")
+                return "iMacPro1,1"
+            else:
+                print("- Spoofing to iMac15,1")
+                return "iMac15,1"
+        elif self.model in ModelArray.iMac144:
+            print("- Spoofing to iMac14,4")
+            return "iMac14,4"
+        elif self.model in ModelArray.MacPro71:
+            print("- Spoofing to MacPro7,1")
+            return "MacPro7,1"
+        else:
+            return self.model
+
+    def fw_feature_detect(self, model):
+        # Values based off OpenCorePkg's Firmwarefeatures and FirmwarefeaturesMask
+        # Additionally, APFS bit(19) flipped
+        # https://github.com/acidanthera/OpenCorePkg/blob/0.6.9/Include/Apple/IndustryStandard/AppleFeatures.h#L136
+        if model == "iMac7,1":
+            fw_feature = b'\x07\x14\x08\xc0\x00\x00\x00\x00'
+            fw_mask = b'\xff\x1f\x08\xc0\x00\x00\x00\x00'
+        elif model in ["MacPro4,1", "Xserve3,1"]:
+            fw_feature = b'7\xf5\t\xe0\x00\x00\x00\x00'
+            fw_mask = b'7\xff\x0b\xc0\x00\x00\x00\x00'
+        else:
+            fw_feature = b'\x03\x14\x08\xc0\x00\x00\x00\x00'
+            fw_mask = b'\xff\x3f\x08\xc0\x00\x00\x00\x00'
+        return fw_feature, fw_mask
 
     def build_efi(self):
         Utilities.cls()
-        print(f"Building Configuration for model: {self.model}")
+        if not self.constants.custom_model:
+            print(f"Building Configuration on model: {self.model}")
+        else:
+            print(f"Building Configuration for external model: {self.model}")
         if not Path(self.constants.build_path).exists():
             Path(self.constants.build_path).mkdir()
             print("Created build folder")
@@ -58,7 +103,7 @@ class BuildOpenCore:
             Path(self.constants.opencore_zip_copied).unlink()
         if Path(self.constants.opencore_release_folder).exists():
             print("Deleting old copy of OpenCore folder")
-            shutil.rmtree(self.constants.opencore_release_folder, onerror=rmtree_handler)
+            shutil.rmtree(self.constants.opencore_release_folder, onerror=rmtree_handler, ignore_errors=True)
 
         print()
         print(f"- Adding OpenCore v{self.constants.opencore_version} {self.constants.opencore_build}")
@@ -85,7 +130,7 @@ class BuildOpenCore:
             ("Lilu.kext", self.constants.lilu_version, self.constants.lilu_path, lambda: True),
             ("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_mbp_version, self.constants.restrictevents_mbp_path, lambda: self.model == "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 not in ModelArray.NightShiftExclude 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),
             # CPU patches
@@ -119,8 +164,8 @@ class BuildOpenCore:
             try:
                 x = 1
                 for i in storage_devices:
-                    storage_vendor = self.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
-                    storage_device = self.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
+                    storage_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
+                    storage_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
                     print(f'- Fixing PCIe Storage Controller ({x}) reporting')
                     try:
                         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]
@@ -141,8 +186,8 @@ class BuildOpenCore:
             try:
                 x = 1
                 for i in nvme_devices:
-                    nvme_vendor = self.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
-                    nvme_device = self.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
+                    nvme_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
+                    nvme_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
                     print(f'- Found 3rd Party NVMe SSD ({x}): {nvme_vendor}:{nvme_device}')
                     nvme_aspm = i["pci-aspm-default"]
                     try:
@@ -213,7 +258,7 @@ class BuildOpenCore:
             wifi_vendor,wifi_device,wifi_ioname,wifi_acpi = DeviceProbe.pci_probe().wifi_probe()
             if wifi_vendor:
                 print(f"- Found Wireless Device {wifi_vendor}:{wifi_device} ({wifi_ioname})")
-                self.config["#Revision"]["Hardware-Wifi"] = f"{wifi_vendor}:{wifi_device} ({wifi_ioname}"
+                self.config["#Revision"]["Hardware-Wifi"] = f"{wifi_vendor}:{wifi_device} ({wifi_ioname})"
         else:
             wifi_vendor = ""
             print("- Unable to run Wireless hardware detection")
@@ -288,26 +333,32 @@ class BuildOpenCore:
             shutil.copy(usb_map_path, self.constants.map_contents_folder)
             self.get_kext_by_bundle_path("USB-Map.kext")["Enabled"] = True
 
-        agdp_map_path = Path(self.constants.plist_folder_path) / Path("AppleGraphicsDevicePolicy/Info.plist")
-        agpm_map_path = Path(self.constants.plist_folder_path) / Path("AppleGraphicsPowerManagement/Info.plist")
-        amc_map_path = Path(self.constants.plist_folder_path) / Path("AppleMuxControl/Info.plist")
 
-        if self.model == "MacBookPro9,1":
-            print(f"- Adding Display Map Overrides")
-            self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"] = {"agdpmod": "vit9696"}
-            Path(self.constants.agdp_kext_folder).mkdir()
-            Path(self.constants.agdp_contents_folder).mkdir()
-            Path(self.constants.agpm_kext_folder).mkdir()
-            Path(self.constants.agpm_contents_folder).mkdir()
-            Path(self.constants.amc_kext_folder).mkdir()
-            Path(self.constants.amc_contents_folder).mkdir()
+        if self.constants.allow_oc_everywhere is False:
+            if self.model == "MacBookPro9,1":
+                print("- Adding AppleMuxControl Override")
+                amc_map_path = Path(self.constants.plist_folder_path) / Path("AppleMuxControl/Info.plist")
+                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"] = {"agdpmod": "vit9696"}
+                Path(self.constants.amc_kext_folder).mkdir()
+                Path(self.constants.amc_contents_folder).mkdir()
+                shutil.copy(amc_map_path, self.constants.amc_contents_folder)
+                self.get_kext_by_bundle_path("AMC-Override.kext")["Enabled"] = True
 
-            shutil.copy(agdp_map_path, self.constants.agdp_contents_folder)
-            shutil.copy(agpm_map_path, self.constants.agpm_contents_folder)
-            shutil.copy(amc_map_path, self.constants.amc_contents_folder)
-            self.get_kext_by_bundle_path("AGDP-Override.kext")["Enabled"] = True
-            self.get_kext_by_bundle_path("AGPM-Override.kext")["Enabled"] = True
-            self.get_kext_by_bundle_path("AMC-Override.kext")["Enabled"] = True
+            if self.model not in ModelArray.NoAGPMSupport:
+                print("- Adding AppleGraphicsPowerManagement Override")
+                agpm_map_path = Path(self.constants.plist_folder_path) / Path("AppleGraphicsPowerManagement/Info.plist")
+                Path(self.constants.agpm_kext_folder).mkdir()
+                Path(self.constants.agpm_contents_folder).mkdir()
+                shutil.copy(agpm_map_path, self.constants.agpm_contents_folder)
+                self.get_kext_by_bundle_path("AGPM-Override.kext")["Enabled"] = True
+
+            if self.model in ModelArray.AGDPSupport:
+                print("- Adding AppleGraphicsDevicePolicy Override")
+                agdp_map_path = Path(self.constants.plist_folder_path) / Path("AppleGraphicsDevicePolicy/Info.plist")
+                Path(self.constants.agdp_kext_folder).mkdir()
+                Path(self.constants.agdp_contents_folder).mkdir()
+                shutil.copy(agdp_map_path, self.constants.agdp_contents_folder)
+                self.get_kext_by_bundle_path("AGDP-Override.kext")["Enabled"] = True
 
         # AGPM Patch
         if self.model in ModelArray.DualGPUPatch:
@@ -352,6 +403,8 @@ class BuildOpenCore:
                     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:
@@ -360,6 +413,8 @@ class BuildOpenCore:
             else:
                 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)"
                 print(f"- Using known GFX0 path: {self.gfx0_path}")
@@ -367,22 +422,20 @@ class BuildOpenCore:
 
         def nvidia_patch(self, backlight_path):
             self.constants.custom_mxm_gpu = True
-            if self.model in ["iMac11,1", "iMac11,2", "iMac11,3"]:
+            if self.model in ["iMac11,1", "iMac11,2", "iMac11,3", "iMac10,1"]:
                 print("- Adding Nvidia Brightness Control and DRM patches")
-                self.config["DeviceProperties"]["Add"][backlight_path] = {"@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":
                     # 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
-                    self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256, "agdpmod": "vit9696"}
-                shutil.copy(self.constants.backlight_path, self.constants.kexts_path)
-                self.get_kext_by_bundle_path("AppleBacklightFixup.kext")["Enabled"] = True
+                    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"]:
                 print("- Adding Nvidia Brightness Control and DRM patches")
-                self.config["DeviceProperties"]["Add"][backlight_path] = {"@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000"), "shikigva": 256}
+                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")
                 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_path, self.constants.kexts_path)
-                self.get_kext_by_bundle_path("AppleBacklightFixup.kext")["Enabled"] = True
+            shutil.copy(self.constants.backlight_injector_path, self.constants.kexts_path)
+            self.get_kext_by_bundle_path("BacklightInjector.kext")["Enabled"] = True
             self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
             self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
 
@@ -428,8 +481,8 @@ class BuildOpenCore:
                 try:
                     x = 1
                     for i in mp_dgpu_devices:
-                        mp_dgpu_vendor = self.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
-                        mp_dgpu_device = self.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
+                        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}')
                         self.config["#Revision"][f"Hardware-MacPro-dGPU-{x}"] = f'{mp_dgpu_vendor}:{mp_dgpu_device}'
@@ -439,10 +492,10 @@ class BuildOpenCore:
                             print(f"- Found dGPU ({x}) at {mp_dgpu_path}")
                             if mp_dgpu_vendor == self.constants.pci_amd_ati:
                                 print("- Adding Mac Pro, Xserve DRM patches")
-                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"shikigva": 128, "unfairgva": 1, "wegtree": 1}
+                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"shikigva": 128, "unfairgva": 1, "rebuild-device-tree": 1}
                             elif mp_dgpu_vendor == self.constants.pci_nvidia:
                                 print("- Enabling Nvidia Output Patch")
-                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"wegtree": 1}
+                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"rebuild-device-tree": 1}
                                 self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
                                 self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
 
@@ -469,11 +522,26 @@ class BuildOpenCore:
                 print("- Adding Mac Pro, Xserve DRM patches")
                 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
+        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())
+            try:
+                devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_xhci)]
+                vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
+                device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
+                print("- Found XHCI Controller, adding Boot Support")
+                shutil.copy(self.constants.xhci_driver_path, self.constants.drivers_path)
+                self.config["UEFI"]["Drivers"] += ["XhciDxe.efi"]
+            except ValueError:
+                print("- No XHCI Controller Found (V)")
+            except IndexError:
+                print("- No XHCI Controller Found (I)")
+
         # Add OpenCanopy
         print("- Adding OpenCanopy GUI")
         shutil.rmtree(self.constants.resources_path, onerror=rmtree_handler)
         shutil.copy(self.constants.gui_path, self.constants.oc_folder)
-        self.config["UEFI"]["Drivers"] = ["OpenCanopy.efi", "OpenRuntime.efi"]
+        self.config["UEFI"]["Drivers"] += ["OpenCanopy.efi", "OpenRuntime.efi"]
         # Exfat check
         if self.model in ModelArray.NoExFat:
             print("- Adding ExFatDxeLegacy.efi")
@@ -483,17 +551,16 @@ class BuildOpenCore:
         # Add UGA to GOP layer
         if self.model in ModelArray.UGAtoGOP:
             print("- Adding UGA to GOP Patch")
-            self.config["UEFI"]["Output"]["GopPassThrough"] = True
+            self.config["UEFI"]["Output"]["GopPassThrough"] = "Apple"
 
         # ThirdPartDrives Check
-        if self.model not in ModelArray.NoSATAPatch:
+        if self.model not in ModelArray.NoSATAPatch and self.constants.allow_oc_everywhere is False:
             print("- Adding SATA Hibernation Patch")
             self.config["Kernel"]["Quirks"]["ThirdPartyDrives"] = True
 
         # DEBUG Settings
         if self.constants.verbose_debug is True:
             print("- Enabling Verbose boot")
-            self.config["Kernel"]["Quirks"]["PanicNoKextDump"] = True
             self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -v debug=0x100"
         if self.constants.kext_debug is True:
             print("- Enabling DEBUG Kexts")
@@ -538,51 +605,14 @@ class BuildOpenCore:
 
     def set_smbios(self):
         spoofed_model = self.model
-        # TODO: Set check as global variable
-        if self.model in ModelArray.MacBookAir61:
-            print("- Spoofing to MacBookAir6,1")
-            spoofed_model = "MacBookAir6,1"
-            spoofed_board = "Mac-35C1E88140C3E6CF"
-        elif self.model in ModelArray.MacBookAir62:
-            print("- Spoofing to MacBookAir6,2")
-            spoofed_model = "MacBookAir6,2"
-            spoofed_board = "Mac-7DF21CB3ED6977E5"
-        elif self.model in ModelArray.MacBookPro111:
-            print("- Spoofing to MacBookPro11,1")
-            spoofed_model = "MacBookPro11,1"
-            spoofed_board = "Mac-189A3D4F975D5FFC"
-        elif self.model in ModelArray.MacBookPro113:
-            print("- Spoofing to MacBookPro11,3")
-            spoofed_model = "MacBookPro11,3"
-            spoofed_board = "Mac-2BD1B31983FE1663"
-        elif self.model in ModelArray.Macmini71:
-            print("- Spoofing to Macmini7,1")
-            spoofed_model = "Macmini7,1"
-            spoofed_board = "Mac-35C5E08120C7EEAF"
-        elif self.model in ModelArray.iMacPro11:
-            print("- Spoofing to iMacPro1,1")
-            spoofed_model = "iMacPro1,1"
-            spoofed_board = "Mac-7BA5B2D9E42DDD94"
-        elif self.model in ModelArray.iMac151:
-            # Check for upgraded GPUs on iMacs
-            if self.constants.drm_support is True:
-                print("- Spoofing to iMacPro1,1")
-                spoofed_model = "iMacPro1,1"
-                spoofed_board = "Mac-7BA5B2D9E42DDD94"
-            else:
-                print("- Spoofing to iMac15,1")
-                spoofed_model = "iMac15,1"
-                spoofed_board = "Mac-42FD25EABCABB274"
-        elif self.model in ModelArray.iMac144:
-            print("- Spoofing to iMac14,4")
-            spoofed_model = "iMac14,4"
-            spoofed_board = "Mac-81E3E92DD6088272"
-        elif self.model in ModelArray.MacPro71:
-            print("- Spoofing to MacPro7,1")
-            spoofed_model = "MacPro7,1"
-            spoofed_board = "Mac-27AD2F918AE68F61"
+        if self.constants.override_smbios == "Default":
+            spoofed_model = self.smbios_set()
         else:
-            spoofed_model = self.model
+            spoofed_model = self.constants.override_smbios
+        try:
+            spoofed_board = self.constants.board_id[spoofed_model]
+            print(f"- Using Board ID: {spoofed_board}")
+        except KeyError:
             spoofed_board = ""
         self.spoofed_model = spoofed_model
         self.spoofed_board = spoofed_board
@@ -592,7 +622,13 @@ class BuildOpenCore:
         # Setup menu
         def minimal_serial_patch(self):
             if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
-                self.config["PlatformInfo"]["PlatformNVRAM"]["ProcessorType"] = 1537
+                self.config["PlatformInfo"]["SMBIOS"]["ProcessorType"] = 1537
+            if self.model in ModelArray.NoAPFSsupport:
+                fw_feature,fw_mask = self.fw_feature_detect(self.model)
+                self.config["PlatformInfo"]["PlatformNVRAM"]["FirmwareFeatures"] = fw_feature
+                self.config["PlatformInfo"]["SMBIOS"]["FirmwareFeatures"] = fw_feature
+                self.config["PlatformInfo"]["PlatformNVRAM"]["FirmwareFeaturesMask"] = fw_mask
+                self.config["PlatformInfo"]["SMBIOS"]["FirmwareFeaturesMask"] = fw_mask
             self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["run-efi-updater"] = "No"
             self.config["PlatformInfo"]["PlatformNVRAM"]["BID"] = self.spoofed_board
             self.config["PlatformInfo"]["SMBIOS"]["BoardProduct"] = self.spoofed_board
@@ -649,24 +685,22 @@ class BuildOpenCore:
         if self.constants.allow_oc_everywhere is False and self.model != "iMac7,1":
             new_map_ls = Path(self.constants.map_contents_folder) / Path("Info.plist")
             map_config = plistlib.load(Path(new_map_ls).open("rb"))
-
-            for model_controller in ModelArray.ControllerTypes:
-                model_patch = f"{self.model}{model_controller}"
-                try:
-                    # Avoid erroring out when specific identity not found
-                    map_config["IOKitPersonalities_x86_64"][model_patch]["model"] = self.spoofed_model
-
-                    # Avoid ACPI renaming when not required
-                    if self.constants.serial_settings == "Minimal":
-                        if map_config["IOKitPersonalities_x86_64"][model_patch]["IONameMatch"] == "EH01":
-                            map_config["IOKitPersonalities_x86_64"][model_patch]["IONameMatch"] = "EHC1"
-                        if map_config["IOKitPersonalities_x86_64"][model_patch]["IONameMatch"] == "EH02":
-                            map_config["IOKitPersonalities_x86_64"][model_patch]["IONameMatch"] = "EHC2"
-                        if map_config["IOKitPersonalities_x86_64"][model_patch]["IONameMatch"] == "SHC1":
-                            map_config["IOKitPersonalities_x86_64"][model_patch]["IONameMatch"] = "XHC1"
-
-                except KeyError:
-                    continue
+            # Strip unused USB maps
+            for entry in list(map_config["IOKitPersonalities_x86_64"]):
+                if not entry.startswith(self.model):
+                    map_config["IOKitPersonalities_x86_64"].pop(entry)
+                else:
+                    try:
+                        map_config["IOKitPersonalities_x86_64"][entry]["model"] = self.spoofed_model
+                        if self.constants.serial_settings == "Minimal":
+                            if map_config["IOKitPersonalities_x86_64"][entry]["IONameMatch"] == "EH01":
+                                map_config["IOKitPersonalities_x86_64"][entry]["IONameMatch"] = "EHC1"
+                            if map_config["IOKitPersonalities_x86_64"][entry]["IONameMatch"] == "EH02":
+                                map_config["IOKitPersonalities_x86_64"][entry]["IONameMatch"] = "EHC2"
+                            if map_config["IOKitPersonalities_x86_64"][entry]["IONameMatch"] == "SHC1":
+                                map_config["IOKitPersonalities_x86_64"][entry]["IONameMatch"] = "XHC1"
+                    except KeyError:
+                        continue
             plistlib.dump(map_config, Path(new_map_ls).open("wb"), sort_keys=True)
         if self.constants.allow_oc_everywhere is False and self.model != "iMac7,1" and self.constants.disallow_cpufriend is False:
             # Adjust CPU Friend Data to correct SMBIOS
@@ -676,27 +710,26 @@ class BuildOpenCore:
             string_stuff = string_stuff.replace(self.model, self.spoofed_model)
             string_stuff = ast.literal_eval(string_stuff)
             cpu_config["IOKitPersonalities"]["CPUFriendDataProvider"]["cf-frequency-data"] = string_stuff
-            #cpu_data_config = plistlib.loads(cpu_config["IOKitPersonalities"]["CPUFriendDataProvider"]["cf-frequency-data"])
-            #print(f'Patching CPUFriend Data to: {cpu_data_config["IOPlatformThermalProfile"]["ConfigArray"][0]["model"]}')
             plistlib.dump(cpu_config, Path(new_cpu_ls).open("wb"), sort_keys=True)
 
 
-        if self.model == "MacBookPro9,1":
-            new_agdp_ls = Path(self.constants.agdp_contents_folder) / Path("Info.plist")
-            new_agpm_ls = Path(self.constants.agpm_contents_folder) / Path("Info.plist")
-            new_amc_ls = Path(self.constants.amc_contents_folder) / Path("Info.plist")
+        if self.constants.allow_oc_everywhere is False:
+            if self.model == "MacBookPro9,1":
+                new_amc_ls = Path(self.constants.amc_contents_folder) / Path("Info.plist")
+                amc_config = plistlib.load(Path(new_amc_ls).open("rb"))
+                amc_config["IOKitPersonalities"]["AppleMuxControl"]["ConfigMap"][self.spoofed_board] = amc_config["IOKitPersonalities"]["AppleMuxControl"]["ConfigMap"].pop(self.model)
+                plistlib.dump(amc_config, Path(new_amc_ls).open("wb"), sort_keys=True)
+            if self.model not in ModelArray.NoAGPMSupport:
+                new_agpm_ls = Path(self.constants.agpm_contents_folder) / Path("Info.plist")
+                agpm_config = plistlib.load(Path(new_agpm_ls).open("rb"))
+                agpm_config["IOKitPersonalities"]["AGPM"]["Machines"][self.spoofed_board] = agpm_config["IOKitPersonalities"]["AGPM"]["Machines"].pop(self.model)
+                plistlib.dump(agpm_config, Path(new_agpm_ls).open("wb"), sort_keys=True)
+            if self.model in ModelArray.AGDPSupport:
+                new_agdp_ls = Path(self.constants.agdp_contents_folder) / Path("Info.plist")
+                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)
+                plistlib.dump(agdp_config, Path(new_agdp_ls).open("wb"), sort_keys=True)
 
-            agdp_config = plistlib.load(Path(new_agdp_ls).open("rb"))
-            agpm_config = plistlib.load(Path(new_agpm_ls).open("rb"))
-            amc_config = plistlib.load(Path(new_amc_ls).open("rb"))
-
-            agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"][self.spoofed_board] = agdp_config["IOKitPersonalities"]["AppleGraphicsDevicePolicy"]["ConfigMap"].pop(self.model)
-            agpm_config["IOKitPersonalities"]["AGPM"]["Machines"][self.spoofed_board] = agpm_config["IOKitPersonalities"]["AGPM"]["Machines"].pop(self.model)
-            amc_config["IOKitPersonalities"]["AppleMuxControl"]["ConfigMap"][self.spoofed_board] = amc_config["IOKitPersonalities"]["AppleMuxControl"]["ConfigMap"].pop(self.model)
-
-            plistlib.dump(agdp_config, Path(new_agdp_ls).open("wb"), sort_keys=True)
-            plistlib.dump(agpm_config, Path(new_agpm_ls).open("wb"), sort_keys=True)
-            plistlib.dump(amc_config, Path(new_amc_ls).open("wb"), sort_keys=True)
 
     @staticmethod
     def get_item_by_kv(iterable, key, value):
@@ -759,8 +792,10 @@ class BuildOpenCore:
                 zip_file.extractall(self.constants.oc_folder)
             item.unlink()
 
-        for i in self.constants.build_path.rglob("__MACOSX"):
-            shutil.rmtree(i)
+        if self.constants.recovery_status == False:
+            # Crashes in RecoveryOS for unknown reason
+            for i in self.constants.build_path.rglob("__MACOSX"):
+                shutil.rmtree(i)
 
         Path(self.constants.opencore_zip_copied).unlink()
 
@@ -874,7 +909,7 @@ Please build OpenCore first!"""
             " without altering line endings",
         ]
 
-        if self.constants.detected_os > self.constants.yosemite:
+        if self.constants.detected_os > self.constants.yosemite and self.constants.recovery_status == False:
             result = subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
         else:
             result = subprocess.run(f"diskutil mount {disk_identifier}s{response}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
@@ -934,9 +969,12 @@ Please build OpenCore first!"""
                 print("- Adding Internal Drive icon")
                 shutil.copy(self.constants.icon_path_internal, mount_path)
             print("- Cleaning install location")
-            subprocess.run(f"dot_clean {mount_path}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-            print("- Unmounting EFI partition")
-            subprocess.run(f"diskutil umount {mount_path}".split(), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            if self.constants.recovery_status == False:
+                # RecoveryOS doesn't support dot_clean
+                # Remove dot_clean, requires full disk access
+                #subprocess.run(["dot_clean", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                print("- Unmounting EFI partition")
+                subprocess.run(["diskutil", "umount", mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
             print("- OpenCore transfer complete")
             print("\nPress [Enter] to continue.\n")
             input()

Resources/CliMenu.py

@@ -1,13 +1,9 @@
 # Handle misc CLI menu options
 # Copyright (C) 2020-2021, Dhinak G, Mykola Grymalyuk
 from __future__ import print_function
-
 import subprocess
-import sys
-import time
-import platform
 
-from Resources import Build, ModelArray, Constants, SysPatch, Utilities
+from Resources import ModelArray, Constants, Utilities
 
 
 class MenuOptions:
@@ -383,3 +379,62 @@ hardware
             self.constants.disallow_cpufriend = False
         else:
             print("Invalid option")
+
+    def set_seedutil(self):
+        Utilities.cls()
+        Utilities.header(["Set SeedUtil Status"])
+        print("""Used for setting OS Update Preferences
+
+Valid options:
+1. Public Release Seed (Default)
+2. Public Beta Seed
+3. Developer Beta Seed
+4. Check SeedUtil's current status
+        """)
+
+        change_menu = input("Set update status(Press [ENTER] to exit): ")
+        if change_menu == "1":
+            subprocess.run(["sudo", "/System/Library/PrivateFrameworks/Seeding.framework/Versions/A/Resources/seedutil", "unenroll"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        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", "enroll", "PublicSeed"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        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", "enroll", "DeveloperSeed"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        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 = [i.partition(":")[2] for i in result.stdout.decode().split("\n") if "Currently enrolled in" in i][0]
+            print(f"SeedUtil Current Status: {result}")
+            input("\nPress [ENTER] to continue")
+            self.set_seedutil()
+        else:
+            print("Returning to main menu")
+
+    def set_smbios(self):
+        Utilities.cls()
+        Utilities.header(["Override SMBIOS Spoof"])
+        print("""Change model OpenCore spoofs Mac too
+
+Valid options:
+1. Default set by OpenCore (Default)
+2. User Override
+3. Disable all spoofing (unsupported configuration)
+        """)
+
+        change_menu = input("Set SMBIOS status: ")
+        if change_menu == "1":
+            print("Setting SMBIOS spoof to default mode")
+            self.constants.override_smbios = "Default"
+        elif change_menu == "2":
+            custom_smbios = input("Set new SMBIOS mode: ")
+            try:
+                test = self.constants.board_id[custom_smbios]
+                self.constants.override_smbios = custom_smbios
+            except KeyError:
+                print("Unsupported SMBIOS, defaulting to Default setting")
+                self.constants.override_smbios = "Default"
+        elif change_menu == "3":
+            print("Disabling SMBIOS spoof")
+            self.constants.override_smbios = self.constants.custom_model or self.current_model
+        else:
+            print("Returning to main menu")

Resources/Constants.py

@@ -9,9 +9,9 @@ from pathlib import Path
 
 class Constants:
     def __init__(self):
-        self.patcher_version = "0.1.4"
-        self.opencore_commit = "65cc81b - 05-03-2021"
-        self.opencore_version = "0.6.9"
+        self.patcher_version = "0.1.6"
+        self.opencore_commit = "4e0ff2d - 05-23-2021"
+        self.opencore_version = "0.7.0"
         self.lilu_version = "1.5.3"
         self.whatevergreen_version = "1.4.9"
         self.airportbcrmfixup_version = "2.1.2"
@@ -30,6 +30,7 @@ class Constants:
         self.restrictevents_mbp_version = "1.0.1"
         self.piixata_version = "1.0.0"
         self.backlight_version = "1.0.1"
+        self.backlight_injector_version = "1.0.0"
         self.cpufriend_version = "1.2.3"
         self.nightshift_version = "1.1.0"
         self.smcspoof_version = "1.0.0"
@@ -38,7 +39,7 @@ class Constants:
         self.nvmefix_version = "1.0.7"
         self.sidecarfixup_version = "1.0.0"
         self.innie_version = "1.3.0"
-        self.payload_version = "0.0.6"
+        self.payload_version = "0.0.8"
 
         # Get resource path
         self.current_path = Path(__file__).parent.parent.resolve()
@@ -77,6 +78,9 @@ class Constants:
         self.custom_color = ""
         self.download_ram = False
         self.disallow_cpufriend = False
+        self.recovery_status = False
+        self.override_smbios = "Default"
+        self.apecid_support = False
 
         # OS Versions
         self.tiger = 8
@@ -109,6 +113,7 @@ class Constants:
         self.classcode_wifi = "00800200"
         self.classcode_gpu = "00000300"
         self.classcode_gpu_variant = "00800300"
+        self.classcode_xhci = "30030C00"
 
         # Nvidia GPU Architecture
         self.arch_tesla = "NV50"
@@ -125,6 +130,10 @@ class Constants:
     @property
     def plist_template(self): return self.payload_path / Path(f"Config/config.plist")
 
+    # Mount Location
+    @property
+    def payload_mnt1_path(self): return self.payload_path / Path("mnt1")
+
     # ACPI
     @property
     def pci_ssdt_path(self): return self.payload_path / Path("ACPI/SSDT-CPBG.aml")
@@ -136,6 +145,8 @@ class Constants:
     def nvme_driver_path(self): return self.payload_path / Path("Drivers/NvmExpressDxe.efi")
     @property
     def exfat_legacy_driver_path(self): return self.payload_path / Path("Drivers/ExFatDxeLegacy.efi")
+    @property
+    def xhci_driver_path(self): return self.payload_path / Path("Drivers/XhciDxe.efi")
 
     # Kexts
     @property
@@ -177,6 +188,8 @@ class Constants:
     @property
     def backlight_path(self): return self.payload_kexts_path / Path(f"Misc/AppleBacklightFixup-v{self.backlight_version}.zip")
     @property
+    def backlight_injector_path(self): return self.payload_kexts_path / Path(f"Misc/BacklightInjector-v{self.backlight_injector_version}.zip")
+    @property
     def cpufriend_path(self): return self.payload_kexts_path / Path(f"Acidanthera/CPUFriend-v{self.cpufriend_version}.zip")
     @property
     def nightshift_path(self): return self.payload_kexts_path / Path(f"Misc/NightShiftEnabler-v{self.nightshift_version}.zip")
@@ -331,18 +344,18 @@ class Constants:
     def skylight_path(self): return self.payload_apple_private_frameworks_path_accel / Path("SkyLight.framework")
 
     csr_values = {
-        "CSR_ALLOW_UNTRUSTED_KEXTS           ": False,  # 0x1   - Introduced in El Capitan
-        "CSR_ALLOW_UNRESTRICTED_FS           ": False,  # 0x2   - Introduced in El Capitan
-        "CSR_ALLOW_TASK_FOR_PID              ": False,  # 0x4   - Introduced in El Capitan
-        "CSR_ALLOW_KERNEL_DEBUGGER           ": False,  # 0x8   - Introduced in El Capitan
-        "CSR_ALLOW_APPLE_INTERNAL            ": False,  # 0x10  - Introduced in El Capitan
-        "CSR_ALLOW_UNRESTRICTED_DTRACE       ": False,  # 0x20  - Introduced in El Capitan
-        "CSR_ALLOW_UNRESTRICTED_NVRAM        ": False,  # 0x40  - Introduced in El Capitan
-        "CSR_ALLOW_DEVICE_CONFIGURATION      ": False,  # 0x80  - Introduced in El Capitan
-        "CSR_ALLOW_ANY_RECOVERY_OS           ": False,  # 0x100 - Introduced in Sierra
-        "CSR_ALLOW_UNAPPROVED_KEXTS          ": False,  # 0x200 - Introduced in High Sierra
-        "CSR_ALLOW_EXECUTABLE_POLICY_OVERRIDE": False,  # 0x400 - Introduced in Mojave
-        "CSR_ALLOW_UNAUTHENTICATED_ROOT      ": False,  # 0x800 - Introduced in Big Sur
+        "CSR_ALLOW_UNTRUSTED_KEXTS":            False,  # 0x1   - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_UNRESTRICTED_FS":            False,  # 0x2   - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_TASK_FOR_PID":               False,  # 0x4   - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_KERNEL_DEBUGGER":            False,  # 0x8   - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_APPLE_INTERNAL":             False,  # 0x10  - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_UNRESTRICTED_DTRACE":        False,  # 0x20  - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_UNRESTRICTED_NVRAM":         False,  # 0x40  - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_DEVICE_CONFIGURATION":       False,  # 0x80  - Introduced in El Capitan  # noqa: E241
+        "CSR_ALLOW_ANY_RECOVERY_OS":            False,  # 0x100 - Introduced in Sierra      # noqa: E241
+        "CSR_ALLOW_UNAPPROVED_KEXTS":           False,  # 0x200 - Introduced in High Sierra # noqa: E241
+        "CSR_ALLOW_EXECUTABLE_POLICY_OVERRIDE": False,  # 0x400 - Introduced in Mojave      # noqa: E241
+        "CSR_ALLOW_UNAUTHENTICATED_ROOT":       False,  # 0x800 - Introduced in Big Sur     # noqa: E241
     }
 
     sbm_values = [
@@ -363,3 +376,129 @@ class Constants:
         "j185",
         "j185f",
     ]
+
+    board_id = {
+        "MacBook1,1": "Mac-F4208CC8",
+        "MacBook2,1": "Mac-F4208CA9",
+        "MacBook3,1": "Mac-F22788C8",
+        "MacBook4,1": "Mac-F22788A9",
+        "MacBook5,1": "Mac-F42D89C8",
+        "MacBook5,2": "Mac-F22788AA",
+        "MacBook6,1": "Mac-F22C8AC8",
+        "MacBook7,1": "Mac-F22C89C8",
+        "MacBook8,1": "Mac-BE0E8AC46FE800CC",
+        "MacBook9,1": "Mac-9AE82516C7C6B903",
+        "MacBook10,1": "Mac-EE2EBD4B90B839A8",
+        "MacBookAir1,1": "Mac-F42C8CC8",
+        "MacBookAir2,1": "Mac-F42D88C8",
+        "MacBookAir3,1": "Mac-942452F5819B1C1B",
+        "MacBookAir3,2": "Mac-942C5DF58193131B",
+        "MacBookAir4,1": "Mac-C08A6BB70A942AC2",
+        "MacBookAir4,2": "Mac-742912EFDBEE19B3",
+        "MacBookAir5,1": "Mac-66F35F19FE2A0D05",
+        "MacBookAir5,2": "Mac-2E6FAB96566FE58C",
+        "MacBookAir6,1": "Mac-35C1E88140C3E6CF",
+        "MacBookAir6,2": "Mac-7DF21CB3ED6977E5",
+        "MacBookAir7,1": "Mac-9F18E312C5C2BF0B",
+        "MacBookAir7,2": "Mac-937CB26E2E02BB01",
+        "MacBookAir8,1": "Mac-827FAC58A8FDFA22",
+        "MacBookAir8,1": "Mac-226CB3C6A851A671",
+        "MacBookAir9,1": "Mac-0CFF9C7C2B63DF8D",
+        "MacBookPro1,1": "Mac-F425BEC8",
+        "MacBookPro1,2": "Mac-F42DBEC8",
+        "MacBookPro2,1": "Mac-F42189C8",
+        "MacBookPro2,2": "Mac-F42187C8",
+        "MacBookPro3,1": "Mac-F4238BC8",
+        "MacBookPro4,1": "Mac-F42C89C8",
+        "MacBookPro5,1": "Mac-F42D86C8",
+        "MacBookPro5,2": "Mac-F2268EC8",
+        "MacBookPro5,3": "Mac-F22587C8",
+        "MacBookPro5,4": "Mac-F22587A1",
+        "MacBookPro5,5": "Mac-F2268AC8",
+        "MacBookPro6,1": "Mac-F22589C8",
+        "MacBookPro6,2": "Mac-F22586C8",
+        "MacBookPro7,1": "Mac-F222BEC8",
+        "MacBookPro8,1": "Mac-94245B3640C91C81",
+        "MacBookPro8,2": "Mac-94245A3940C91C80",
+        "MacBookPro8,3": "Mac-942459F5819B171B",
+        "MacBookPro9,1": "Mac-4B7AC7E43945597E",
+        "MacBookPro9,2": "Mac-6F01561E16C75D06",
+        "MacBookPro10,1": "Mac-C3EC7CD22292981F",
+        "MacBookPro10,2": "Mac-AFD8A9D944EA4843",
+        "MacBookPro11,1": "Mac-189A3D4F975D5FFC",
+        "MacBookPro11,2": "Mac-3CBD00234E554E41",
+        "MacBookPro11,3": "Mac-2BD1B31983FE1663",
+        "MacBookPro11,4": "Mac-06F11FD93F0323C5",
+        "MacBookPro11,5": "Mac-06F11F11946D27C5",
+        "MacBookPro12,1": "Mac-E43C1C25D4880AD6",
+        "MacBookPro13,1": "Mac-473D31EABEB93F9B",
+        "MacBookPro13,2": "Mac-66E35819EE2D0D05",
+        "MacBookPro13,3": "Mac-A5C67F76ED83108C",
+        "MacBookPro14,1": "Mac-B4831CEBD52A0C4C",
+        "MacBookPro14,2": "Mac-CAD6701F7CEA0921",
+        "MacBookPro14,3": "Mac-551B86E5744E2388",
+        "MacBookPro15,1": "Mac-937A206F2EE63C01",
+        "MacBookPro15,2": "Mac-827FB448E656EC26",
+        "MacBookPro15,3": "Mac-1E7E29AD0135F9BC",
+        "MacBookPro15,4": "Mac-53FDB3D8DB8CA971",
+        "MacBookPro16,1": "Mac-E1008331FDC96864",
+        "MacBookPro16,2": "Mac-5F9802EFE386AA28",
+        "MacBookPro16,3": "Mac-E7203C0F68AA0004",
+        "MacBookPro16,4": "Mac-A61BADE1FDAD7B05",
+        "Macmini1,1": "Mac-F4208EC8",
+        "Macmini2,1": "Mac-F4208EAA",
+        "Macmini3,1": "Mac-F22C86C8",
+        "Macmini4,1": "Mac-F2208EC8",
+        "Macmini5,1": "Mac-8ED6AF5B48C039E1",
+        "Macmini5,2": "Mac-4BC72D62AD45599E",
+        "Macmini5,3": "Mac-7BA5B2794B2CDB12",
+        "Macmini6,1": "Mac-031AEE4D24BFF0B1",
+        "Macmini6,2": "Mac-F65AE981FFA204ED",
+        "Macmini7,1": "Mac-35C5E08120C7EEAF",
+        "Macmini8,1": "Mac-7BA5B2DFE22DDD8C",
+        "iMac4,1": "Mac-F42786C8",
+        "iMac4,2": "Mac-F4218EC8",
+        "iMac5,1": "Mac-F4228EC8",
+        "iMac5,2": "Mac-F4218EC8",
+        "iMac6,1": "Mac-F4218FC8",
+        "iMac7,1": "Mac-F42386C8",
+        "iMac8,1": "Mac-F227BEC8",
+        "iMac9,1": "Mac-F2218FA9",
+        "iMac10,1": "Mac-F221DCC8",
+        "iMac10,1": "Mac-F2268CC8",
+        "iMac11,1": "Mac-F2268DAE",
+        "iMac11,2": "Mac-F2238AC8",
+        "iMac11,3": "Mac-F2238BAE",
+        "iMac12,1": "Mac-942B5BF58194151B",
+        "iMac12,2": "Mac-942B59F58194171B",
+        "iMac13,1": "Mac-00BE6ED71E35EB86",
+        "iMac13,1": "Mac-00BE6ED71E35EB86",
+        "iMac13,2": "Mac-FC02E91DDD3FA6A4",
+        "iMac13,3": "Mac-7DF2A3B5E5D671ED",
+        "iMac14,1": "Mac-031B6874CF7F642A",
+        "iMac14,2": "Mac-27ADBB7B4CEE8E61",
+        "iMac14,3": "Mac-77EB7D7DAF985301",
+        "iMac14,4": "Mac-81E3E92DD6088272",
+        "iMac15,1": "Mac-42FD25EABCABB274",
+        "iMac16,1": "Mac-A369DDC4E67F1C45",
+        "iMac16,2": "Mac-FFE5EF870D7BA81A",
+        "iMac17,1": "Mac-DB15BD556843C820",
+        "iMac18,1": "Mac-4B682C642B45593E",
+        "iMac18,2": "Mac-77F17D7DA9285301",
+        "iMac18,3": "Mac-BE088AF8C5EB4FA2",
+        "iMac19,1": "Mac-AA95B1DDAB278B95",
+        "iMac19,2": "Mac-63001698E7A34814",
+        "iMac20,1": "Mac-CFF7D910A743CAAF",
+        "iMac20,2": "Mac-AF89B6D9451A490B",
+        "iMacPro1,1": "Mac-7BA5B2D9E42DDD94",
+        "MacPro1,1": "Mac-F4208DC8",
+        "MacPro2,1": "Mac-F4208DA9",
+        "MacPro3,1": "Mac-F42C88C8",
+        "MacPro4,1": "Mac-F221BEC8",
+        "MacPro5,1": "Mac-F221BEC8",
+        "MacPro6,1": "Mac-F60DEB81FF30ACF6",
+        "MacPro7,1": "Mac-27AD2F918AE68F61",
+        "Xserve1,1": "Mac-F4208AC8",
+        "Xserve2,1": "Mac-F42289C8",
+        "Xserve3,1": "Mac-F223BEC8",
+    }

Resources/DeviceProbe.py

@@ -4,26 +4,14 @@ from __future__ import print_function
 
 import binascii
 import plistlib
-import shutil
 import subprocess
-import uuid
-import os
-import sys
-import platform
-from pathlib import Path
 
-from Resources import Constants, ModelArray, Utilities
+from Resources import Constants, Utilities
 
 class pci_probe:
     def __init__(self):
         self.constants = Constants.Constants()
 
-    def hexswap(self, input_hex: str):
-        hex_pairs = [input_hex[i:i + 2] for i in range(0, len(input_hex), 2)]
-        hex_rev = hex_pairs[::-1]
-        hex_str = "".join(["".join(x) for x in hex_rev])
-        return hex_str.upper()
-
     # 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()
@@ -53,6 +41,7 @@ class pci_probe:
         # IOACPIPlane:/_SB/PCI0@0/P0P2@10000         -> /PCI0@0/P0P2@1
         acpi_path = acpi_path_full.replace("IOACPIPlane:/_SB", "")
         acpi_path = acpi_path.replace("0000", "")
+        acpi_path = acpi_path.replace("0001", "")
         acpi_path = acpi_path.replace("ffff", "0")
         acpi_path = acpi_path.upper()
         return acpi_path
@@ -61,8 +50,8 @@ class pci_probe:
     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 = self.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
-            device_id = self.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
+            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)
@@ -71,18 +60,18 @@ class pci_probe:
                 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}")
+            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):
-        try:
-            devices = plistlib.loads(subprocess.run("ioreg -r -n ARPT -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-        except ValueError:
-            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:
             devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_wifi)]
-            vendor_id = self.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
-            device_id = self.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
+            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"]
@@ -92,5 +81,26 @@ class pci_probe:
                 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")
-            return "", "", "", ""
+            print(f"- No IOService entry found for Wireless Card (V)")
+            return "", "", "", ""
+        except IndexError:
+            print(f"- No IOService entry found for Wireless Card (I)")
+            return "", "", "", ""
+
+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

@@ -442,6 +442,39 @@ NVMePatch = [
     "Dortania1,1"
 ]
 
+XhciSupport = [
+    "MacBookAir5,1",
+    "MacBookAir5,2",
+    "MacBookAir6,1",
+    "MacBookAir6,2",
+    "MacBookAir7,1",
+    "MacBookAir7,2",
+    "MacBookPro9,1",
+    "MacBookPro9,2",
+    "MacBookPro10,1",
+    "MacBookPro10,2",
+    "MacBookPro11,1",
+    "MacBookPro11,2",
+    "MacBookPro11,3",
+    "MacBookPro11,4",
+    "MacBookPro11,5",
+    "MacBookPro12,1",
+    "Macmini6,1",
+    "Macmini6,2",
+    "Macmini7,1",
+    "iMac13,1",
+    "iMac13,2",
+    "iMac13,3",
+    "iMac14,1",
+    "iMac14,2",
+    "iMac14,3",
+    "iMac15,1",
+    "iMac16,1",
+    "iMac16,2",
+    "MacPro6,1",
+    "Dortania1,1"
+]
+
 SidecarPatch = [
     "MacBook8,1",
     "MacBookAir5,1",
@@ -864,6 +897,32 @@ windows_audio = [
     "iMac13,3",
 ]
 
+NoAGPMSupport = [
+    "MacBook4,1",
+    "MacBookPro4,1",
+    "iMac7,1",
+    "iMac8,1",
+    "MacPro3,1",
+    "Xserve2,1"
+]
+
+AGDPSupport = [
+    "MacBookPro9,1",
+    "MacBookPro10,1",
+    "iMac13,1",
+    "iMac13,2",
+    "iMac14,1",
+    "iMac14,2",
+    "iMac14,3",
+]
+
+AMCSupport = [
+    "MacBookPro8,2",
+    "MacBookPro8,3",
+    #"MacBookPro9,1",
+    #"MacBookPro10,1"
+]
+
 DeleteNvidiaAccel11 = [
     "AMDRadeonX4000.kext",
     "AMDRadeonX4000HWServices.kext",
@@ -958,7 +1017,7 @@ AddAMDAccel11 = [
     "AMDLegacySupport.kext",
     "AMDRadeonVADriver.bundle",
     "AMDRadeonVADriver2.bundle",
-    "AMDRadeonX3000.kext",
+    #"AMDRadeonX3000.kext",
     "AMDRadeonX3000GLDriver.bundle",
     "AMDShared.bundle",
     "AMDSupport.kext",
@@ -1017,3 +1076,18 @@ AddVolumeControl = [
     "AppleHDA.kext",
     "IOAudioFamily.kext",
 ]
+
+DeleteVolumeControl = [
+    "AppleVirtIO.kext",
+    "AppleVirtualGraphics.kext",
+    "AppleVirtualPlatform.kext",
+    "ApplePVPanic.kext",
+    "AppleVirtIOStorage.kext",
+]
+
+RecoveryIgnore = [
+    "Update",
+    "VM",
+    "Recovery",
+    "Preboot"
+]

Resources/PCIIDArray.py

@@ -4,6 +4,13 @@ class nvidia_ids:
     # https://envytools.readthedocs.io/en/latest/hw/pciid.html
     # https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/
     tesla_ids = [
+        # G80
+        "0190", # G80 [GeForce 8800 GTS / 8800 GTX]
+        "0191", # G80 [GeForce 8800 GTX]
+        "0193", # G80 [GeForce 8800 GTS]
+        "0194", # G80 [GeForce 8800 Ultra]
+        "019E", # G80GL [Quadro FX 4600]
+        "019D", # G80GL [Quadro FX 5600]
         # G84
         "0400", # G84 [8600 GTS]
         "0401", # G84 [8600 GT]
@@ -73,6 +80,7 @@ class nvidia_ids:
         "0621", # G94 [GT 230]
         "0622", # G94 [9600 GT]
         "0623", # G94 [9600 GS]
+        "0624", # G94 [9600 GT Green Edition]
         "0625", # G94 [9600 GSO 512]
         "0626", # G94 [GT 130]
         "0627", # G94 [GT 140]
@@ -82,6 +90,7 @@ class nvidia_ids:
         "062C", # G94 [9800M GTS ]
         "062D", # G94 [9600 GT]
         "062E", # G94 [9600 GT]
+        "062F", # G94 [9800 S]
         "0631", # G94 [GTS 160M]
         "0635", # G94 [9600 GSO]
         "0637", # G94 [9600 GT]
@@ -118,6 +127,7 @@ class nvidia_ids:
         "06E2", # G98 [8400]
         "06E3", # G98 [8400 SE]
         "06E4", # G98 [8400 GS]
+        "06E5", # G98M [9300M GS]
         "06E6", # G98 [G100]
         "06E7", # G98 [9300 SE]
         "06E8", # G98 [9200M GS]
@@ -125,6 +135,7 @@ class nvidia_ids:
         "06EA", # G98 [NVS 150M]
         "06EB", # G98 [NVS 160M]
         "06EC", # G98 [G 105M]
+        "06ED", # G98 [9600 GT / 9800 GT]
         "06EF", # G98 [G 103M]
         "06F1", # G98 [G105M]
         "06F8", # G98 [NVS 420]
@@ -133,19 +144,22 @@ class nvidia_ids:
         "06FB", # G98 [FX 370M]
         "06FD", # G98 [NVS 295]
         "06FF", # G98 [HICx16]
-        # G200
-        "05E0", # G200 [GTX 295]
-        "05E1", # G200 [GTX 280]
-        "05E2", # G200 [GTX 260]
-        "05E3", # G200 [GTX 285]
-        "05E6", # G200 [GTX 275]
-        "05E7", # G200 [C1060]
-        "05E9", # G200 [CX]
-        "05EA", # G200 [GTX 260]
-        "05EB", # G200 [GTX 295]
-        "05ED", # G200 [FX 5800]
-        "05EE", # G200 [FX 4800]
-        "05EF", # G200 [FX 3800]
+        # GT200
+        "05E0", # GT200 [GTX 295]
+        "05E1", # GT200 [GTX 280]
+        "05E2", # GT200 [GTX 260]
+        "05E3", # GT200 [GTX 285]
+        "05E6", # GT200 [GTX 275]
+        "05E7", # GT200 [C1060]
+        "05E9", # GT200 [CX]
+        "05EA", # GT200 [GTX 260]
+        "05EB", # GT200 [GTX 295]
+        "05ED", # GT200 [FX 5800]
+        "05EE", # GT200 [FX 4800]
+        "05EF", # GT200 [FX 3800]
+        "05FD", # GT200GL [Quadro FX 5800]
+        "05FE", # GT200GL [Quadro FX 4800]
+        "05FF", # GT200GL [Quadro FX 3800]
         # MCP77 GPU
         "0840", # MCP77 GPU [8200M]
         "0844", # MCP77 GPU [9100M G]
@@ -251,7 +265,7 @@ class nvidia_ids:
     ]
 
     fermi_ids = [
-            # GF100
+        # GF100
         "06C0", # GF100 [GTX 480]
         "06C4", # GF100 [GTX 465]
         "06CA", # GF100 [GTX 480M]
@@ -341,6 +355,7 @@ class nvidia_ids:
         "0DFC", # GF108 [NVS 5200M]
         "0F00", # GF108 [GT 630]
         "0F01", # GF108 [GT 620]
+        "0F02", # GF108 [GT 730]
         # GF110
         "1080", # GF110 [GTX 580]
         "1081", # GF110 [GTX 570]
@@ -352,6 +367,7 @@ class nvidia_ids:
         "1089", # GF110 [GTX 580]
         "108B", # GF110 [GTX 580]
         "1091", # GF110 [M2090]
+        "1096", # GF110GL [Tesla C2050 / C2075]
         "109A", # GF110 [5010M]
         "109B", # GF110 [7000]
         # GF119
@@ -360,6 +376,8 @@ class nvidia_ids:
         "1048", # GF119 [605]
         "1049", # GF119 [GT 620]
         "104A", # GF119 [GT 610]
+        "104B", # GF119 [GT 625 OEM]
+        "104C", # GF119 [GT 705]
         "1050", # GF119 [GT 520M]
         "1051", # GF119 [GT 520MX]
         "1052", # GF119 [GT 520M]
@@ -370,6 +388,8 @@ class nvidia_ids:
         "1058", # GF119 [610M]
         "1059", # GF119 [610M]
         "105A", # GF119 [610M]
+        "105B", # GF119M [705M]
+        "107C", # GF119 [NVS 315]
         "107D", # GF119 [NVS 310]
         # GF117
         "1140", # GF117 [GT 620M]
@@ -379,12 +399,18 @@ class nvidia_ids:
         # GK104
         "1180", # GK104 [GTX 680]
         "1183", # GK104 [GTX 660 Ti]
+        "1184", # GK104 [GTX 770]
         "1185", # GK104 [GTX 660]
+        "1186", # GK104 [GTX 660 Ti]
+        "1187", # GK104 [GTX 760]
         "1188", # GK104 [GTX 690]
         "1189", # GK104 [GTX 670]
+        "118E", # GK104 [GTX 760 OEM]
+        "118F", # GK104GL [Tesla K10]
         "1198", # GTX 880M
         "1199", # GK104 [GTX 870M]
         "119A", # GTX 860M
+        "119D", # GK104M [GTX 775M Mac Edition]
         "119E", # GTX 780M
         "119F", # GK104 [GTX 780M]
         "11A0", # GK104 [GTX 680M]
@@ -393,6 +419,7 @@ class nvidia_ids:
         "11A3", # GK104 [GTX 680MX]
         "11A7", # GK104 [GTX 675MX]
         "11A9", # GTX 870M
+        "11B4", # GK104GL [Quadro K4200]
         "11B6",  # Quadro K3100M
         "11B7",  # Quadro K4100M
         "11B8",  # Quadro K5100M
@@ -403,6 +430,7 @@ class nvidia_ids:
         "11BF", # GK104 [GRID K2]
         # GK106
         "11C0", # GK106 [GTX 660]
+        "11C2", # GK106 [GTX 650 Ti BOOST]
         "11C6", # GK106 [GTX 650 Ti]
         "11E0", # GK106 [GTX 770M]
         "11E1",  # GTX 765M
@@ -414,6 +442,8 @@ class nvidia_ids:
         "0FC1", # GK107 [GT 640]
         "0FC2", # GK107 [GT 630]
         "0FC6", # GK107 [GTX 650]
+        "0FC8", # GK107 [GT 740]
+        "0FCD", # GK107M [GT 755M]
         "0FD1", # GK107 [GT 650M]
         "0FD2", # GK107 [GT 640M]
         "0FD3", # GK107 [GT 640M LE]
@@ -421,8 +451,16 @@ class nvidia_ids:
         "0FD5", # GK107 [GT 650M]
         "0FD8", # GK107 [GT 640M]
         "0FD9", # GK107 [GT 645M]
+        "0FDF", # GK107M [ GT 740M]
         "0FE0", # GK107 [GTX 660M]
+        "0FE1", # GK107M [GT 730M]
+        "0FE3", # GK107M [GT 745M]
+        "0FE4", # GK107M [GT 750M]
         "0FE9", # GK107 [GT 750M Mac Edition]
+        "0FEA", # GK107M [GT 755M Mac Edition]
+        "0FEE", # GK107M [810M]
+        "0FF2", # GK107GL [GRID K1]
+        "0FF3", # GK107GL [Quadro K420]
         "0FF6", # Quadro K1100M
         "0FF9", # GK107 [K2000D]
         "0FFA", # GK107 [K600]
@@ -432,25 +470,43 @@ class nvidia_ids:
         "0FFE", # GK107 [K2000]
         "0FFF", # GK107 [410]
         # GK110
+        "1001", # GK110B [GTX TITAN Z]
         "1003", # GK110 [GTX Titan LE]
         "1004", # GK110 [GTX 780]
         "1005", # GK110 [GTX Titan]
+        "1007", # GK110 [GTX 780 Rev. 2]
+        "100A", # GK110B [GTX 780 Ti]
+        "100C", # GK110B [GTX TITAN Black]
         "101F", # GK110 [TEslA K20]
         "1020", # GK110 [TEslA K2]
         "1021", # GK110 [TEslA K2m]
         "1022", # GK110 [TEslA K20C]
+        "1023", # GK110BGL [Tesla K40m]
+        "1024", # GK180GL [Tesla K40c]
         "1026", # GK110 [TEslA K20s]
         "1028", # GK110 [TEslA K20m]
+        "102D", # GK210GL [Tesla K80]
+        "103C", # GK110GL [Quadro K5200]
         # GK208
         "1280", # GK208 [GT 635]
+        "1281", # GK208 [GT 710]
         "1282", # GK208 [GT 640 REv. 2]
         "1284", # GK208 [GT 630 REv. 2]
+        "1286", # GK208 [GT 720]
+        "1287", # GK208B [GT 730]
+        "1288", # GK208B [GT 720]
+        "1289", # GK208 [GT 710]
+        "128B", # GK208B [GT 710]
         "1290", # GK208 [GT 730M]
         "1291", # GK208 [GT 735M]
         "1292", # GK208 [GT 740M]
         "1293", # GK208 [GT 730M]
         "1294", # GK208 [GT 740M]
         "1295", # GK208 [710M]
+        "1296", # GK208M [825M]
+        "1298", # GK208M [GT 720M]
+        "1299", # GK208BM [920M]
+        "129A", # GK208BM [910M]
         "12B9", # GK208 [K610M]
         "12BA", # GK208 [K510M]
     ]
@@ -716,7 +772,7 @@ class broadcom_ids:
         "4320", # BCM4306 - never used by Apple
         "4324", # BCM4309 - never used by Apple
         "4325", # BCM4306 - never used by Apple
-        "4328", # BCM94328
+        "4328", # BCM4328
         "432C", # BCM4322 - never used by Apple
         "432D", # BCM4322 - never used by Apple
     ]
@@ -729,4 +785,4 @@ class atheros_ids:
         "001C", # AR242x / AR542x
         "0023", # AR5416 - never used by Apple
         "0024", # AR5418
-    ]
+    ]

Resources/SysPatch.py

@@ -4,36 +4,46 @@
 # - Full System/Library Snapshotting (need to research how Apple achieves this)
 #   - Temporary Work-around: sudo bless --mount /System/Volumes/Update/mnt1 --bootefi --last-sealed-snapshot
 # - Work-around battery throttling on laptops with no battery (IOPlatformPluginFamily.kext/Contents/PlugIns/ACPI_SMC_PlatformPlugin.kext/Contents/Resources/)
-from __future__ import print_function
 
-import binascii
+import os
 import plistlib
 import shutil
-import signal
 import subprocess
-import sys
-import uuid
 import zipfile
-import os
 from pathlib import Path
-from datetime import date
+from typing import Any
 
-from Resources import Constants, ModelArray, PCIIDArray, Utilities, DeviceProbe
+from Resources import Constants, DeviceProbe, ModelArray, PCIIDArray, Utilities
 
 
 class PatchSysVolume:
     def __init__(self, model, versions):
         self.model = model
         self.constants: Constants.Constants = versions
+        self.sip_patch_status = True
+        self.root_mount_path = None
+        self.sip_status = None
 
-    def hexswap(self, input_hex: str):
-        hex_pairs = [input_hex[i:i + 2] for i in range(0, len(input_hex), 2)]
-        hex_rev = hex_pairs[::-1]
-        hex_str = "".join(["".join(x) for x in hex_rev])
-        return hex_str.upper()
+        # TODO: Put this in a better place
+        if self.constants.recovery_status is True:
+            if not Path("/Volumes/mnt1").exists:
+                self.elevated(["mkdir", "/Volumes/mnt1"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            self.mount_location = "/Volumes/mnt1"
+        else:
+            self.mount_location = "/System/Volumes/Update/mnt1"
+        self.mount_extensions = f"{self.mount_location}/System/Library/Extensions"
+        self.mount_frameworks = f"{self.mount_location}/System/Library/Frameworks"
+        self.mount_lauchd = f"{self.mount_location}/System/Library/LaunchDaemons"
+        self.mount_private_frameworks = f"{self.mount_location}/System/Library/PrivateFrameworks"
 
-    def csr_decode(self, sip_raw, print_status):
-        sip_int = int.from_bytes(sip_raw, byteorder='little')
+    def elevated(self, *args, **kwargs) -> subprocess.CompletedProcess([Any], returncode=0):
+        if os.getuid() == 0:
+            return subprocess.run(*args, **kwargs)
+        else:
+            return subprocess.run(["sudo"] + [args[0][0]] + args[0][1:], **kwargs)
+
+    def csr_decode(self, print_status):
+        sip_int = int.from_bytes(self.sip_status, byteorder="little")
         i = 0
         for current_sip_bit in self.constants.csr_values:
             if sip_int & (1 << i):
@@ -44,45 +54,146 @@ class PatchSysVolume:
             if print_status is True:
                 print(f"- {current_sip_bit}\t {temp}")
             i = i + 1
-        if ((self.constants.csr_values["CSR_ALLOW_UNTRUSTED_KEXTS           "] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_UNRESTRICTED_FS           "] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_UNRESTRICTED_DTRACE       "] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_UNRESTRICTED_NVRAM        "] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_DEVICE_CONFIGURATION      "] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_UNAPPROVED_KEXTS          "] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_EXECUTABLE_POLICY_OVERRIDE"] is True) \
-        and (self.constants.csr_values["CSR_ALLOW_UNAUTHENTICATED_ROOT      "] is True)):
+
+        sip_needs_change = all(
+            self.constants.csr_values[i]
+            for i in [
+                "CSR_ALLOW_UNTRUSTED_KEXTS",
+                "CSR_ALLOW_UNRESTRICTED_FS",
+                "CSR_ALLOW_UNRESTRICTED_DTRACE",
+                "CSR_ALLOW_UNRESTRICTED_NVRAM",
+                "CSR_ALLOW_DEVICE_CONFIGURATION",
+                "CSR_ALLOW_UNAPPROVED_KEXTS",
+                "CSR_ALLOW_EXECUTABLE_POLICY_OVERRIDE",
+                "CSR_ALLOW_UNAUTHENTICATED_ROOT",
+            ]
+        )
+        if sip_needs_change is True:
             self.sip_patch_status = False
         else:
             self.sip_patch_status = True
 
+    def recovery_root_mount(self):
+        def human_fmt(num):
+            for unit in ["B", "KB", "MB", "GB", "TB", "PB"]:
+                if abs(num) < 1000.0:
+                    return "%3.1f %s" % (num, unit)
+                num /= 1000.0
+            return "%.1f %s" % (num, "EB")
+
+        print("- Starting Root Volume Picker")
+        # Planned logic:
+        # Load "diskutil list -plist"
+        # Find all APFSVolumes entries where VolumeName is not named Update, VM, Recovery or Preboot
+        # Omit any VolumeName entries containing "- Data"
+        # Parse remianing options for macOS 11.x with /Volumes/$disk/System/Library/CoreServices/SystemVersion.plist
+        # List remaining drives as user options
+        all_disks = {}
+        disks = plistlib.loads(subprocess.run("diskutil list -plist".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+        for disk in disks["AllDisksAndPartitions"]:
+            disk_info = plistlib.loads(subprocess.run(f"diskutil info -plist {disk['DeviceIdentifier']}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            try:
+                all_disks[disk["DeviceIdentifier"]] = {"identifier": disk_info["DeviceNode"], "name": disk_info["MediaName"], "size": disk_info["TotalSize"], "partitions": {}}
+                for partition in disk["Partitions"] + disk.get("APFSVolumes", []):
+                    partition_info = plistlib.loads(subprocess.run(f"diskutil info -plist {partition['DeviceIdentifier']}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+                    all_disks[disk["DeviceIdentifier"]]["partitions"][partition["DeviceIdentifier"]] = {
+                        "fs": partition_info.get("FilesystemType", partition_info["Content"]),
+                        "type": partition_info["Content"],
+                        "name": partition_info.get("VolumeName", ""),
+                        "size": partition_info["TotalSize"],
+                        "sealed": partition_info.get("Sealed", "No"),
+                    }
+            except KeyError:
+                # Avoid crashing with CDs installed
+                continue
+        menu = Utilities.TUIMenu(
+            ["Select Disk"],
+            "Please select the disk you would like to patch: ",
+            in_between=["Missing disks? Ensure they have a macOS Big Sur install present."],
+            return_number_instead_of_direct_call=True,
+            loop=True,
+        )
+        for disk in all_disks:
+            if not any(all_disks[disk]["partitions"][partition]["fs"] == "apfs" for partition in all_disks[disk]["partitions"]):
+                continue
+            menu.add_menu_option(f"{disk}: {all_disks[disk]['name']} ({human_fmt(all_disks[disk]['size'])})", key=disk[4:])
+
+        response = menu.start()
+
+        if response == -1:
+            return
+
+        disk_identifier = "disk" + response
+        selected_disk = all_disks[disk_identifier]
+
+        menu = Utilities.TUIMenu(
+            ["Select Partition"],
+            "Please select the partition you would like to install OpenCore to: ",
+            return_number_instead_of_direct_call=True,
+            loop=True,
+            in_between=["Missing disks? Ensure they have a macOS Big Sur install present.", "", "* denotes likely candidate."],
+        )
+        # TODO: check if Big Sur, when macOS 12 comes out
+        for partition in selected_disk["partitions"]:
+            if selected_disk["partitions"][partition]["fs"] != "apfs":
+                continue
+            text = f"{partition}: {selected_disk['partitions'][partition]['name']} ({human_fmt(selected_disk['partitions'][partition]['size'])})"
+            if selected_disk["partitions"][partition]["sealed"] != "No":
+                text += " *"
+            menu.add_menu_option(text, key=partition[len(disk_identifier) + 1 :])
+
+        response = menu.start()
+
+        if response == -1:
+            return
+        else:
+            return f"{disk_identifier}s{response}"
+
     def find_mount_root_vol(self, patch):
-        root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-        self.root_mount_path = root_partition_info["DeviceIdentifier"]
-        self.mount_location = "/System/Volumes/Update/mnt1"
-        self.mount_extensions = f"{self.mount_location}/System/Library/Extensions"
-        self.mount_frameworks = f"{self.mount_location}/System/Library/Frameworks"
-        self.mount_lauchd = f"{self.mount_location}/System/Library/LaunchDaemons"
-        self.mount_private_frameworks = f"{self.mount_location}/System/Library/PrivateFrameworks"
+        if self.constants.recovery_status is True:
+            print("- Running RecoveryOS logic")
+            self.root_mount_path = self.recovery_root_mount()
+            if not self.root_mount_path:
+                return
+            print(f"- Root Mount Path: {self.root_mount_path}")
+            if not Path(self.constants.payload_mnt1_path).exists():
+                print("- Creating mnt1 folder")
+                Path(self.constants.payload_mnt1_path).mkdir()
+        else:
+            root_partition_info = plistlib.loads(subprocess.run("diskutil info -plist /".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            self.root_mount_path = root_partition_info["DeviceIdentifier"]
 
         if self.root_mount_path.startswith("disk"):
-            self.root_mount_path = self.root_mount_path[:-2] if self.root_mount_path.endswith('s1') else self.root_mount_path
+            if self.constants.recovery_status is False:
+                self.root_mount_path = self.root_mount_path[:-2] if self.root_mount_path.count("s") > 1 else self.root_mount_path
             print(f"- Found Root Volume at: {self.root_mount_path}")
             if Path(self.mount_extensions).exists():
                 print("- Root Volume is already mounted")
                 if patch is True:
                     self.patch_root_vol()
+                    return True
                 else:
                     self.unpatch_root_vol()
+                    return True
             else:
-                print("- Mounting drive as writable")
-                subprocess.run(f"sudo mount -o nobrowse -t apfs /dev/{self.root_mount_path} {self.mount_location}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                if self.constants.recovery_status is True:
+                    print("- Mounting drive as writable in Recovery")
+
+                    umount_drive = plistlib.loads(subprocess.run(f"diskutil info -plist {self.root_mount_path}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+                    umount_drive = umount_drive["VolumeName"]
+                    self.elevated(["umount", f'/Volumes/{umount_drive}'], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                    self.elevated(["mount", "-t", "apfs", "-rw", f"/dev/{self.root_mount_path}", self.mount_location], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                else:
+                    print("- Mounting drive as writable in OS")
+                    self.elevated(["mount", "-o", "nobrowse", "-t", "apfs", f"/dev/{self.root_mount_path}", self.mount_location], stdout=subprocess.PIPE).stdout.decode().strip().encode()
                 if Path(self.mount_extensions).exists():
                     print("- Successfully mounted the Root Volume")
                     if patch is True:
                         self.patch_root_vol()
+                        return True
                     else:
                         self.unpatch_root_vol()
+                        return True
                 else:
                     print("- Failed to mount the Root Volume")
         else:
@@ -93,7 +204,7 @@ class PatchSysVolume:
             delete_path = Path(self.mount_extensions) / Path(delete_current_kext)
             if Path(delete_path).exists():
                 print(f"- Deleting {delete_current_kext}")
-                subprocess.run(f"sudo rm -R {delete_path}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                self.elevated(["sudo", "rm", "-R", delete_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
             else:
                 print(f"- Couldn't find {delete_current_kext}, skipping")
 
@@ -102,28 +213,23 @@ class PatchSysVolume:
             existing_path = Path(self.mount_extensions) / Path(add_current_kext)
             if Path(existing_path).exists():
                 print(f"- Found conflicting kext, Deleting Root Volume's {add_current_kext}")
-                subprocess.run(f"sudo rm -R {existing_path}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                print(f"- Adding {add_current_kext}")
-                subprocess.run(f"sudo cp -R {vendor_location}/{add_current_kext} {self.mount_extensions}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                subprocess.run(f"sudo chmod -Rf 755 {self.mount_extensions}/{add_current_kext}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                subprocess.run(f"sudo chown -Rf root:wheel {self.mount_extensions}/{add_current_kext}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-            else:
-                print(f"- Adding {add_current_kext}")
-                subprocess.run(f"sudo cp -R {vendor_location}/{add_current_kext} {self.mount_extensions}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                subprocess.run(f"sudo chmod -Rf 755 {self.mount_extensions}/{add_current_kext}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                subprocess.run(f"sudo chown -Rf root:wheel {self.mount_extensions}/{add_current_kext}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+                self.elevated(["rm", "-R", existing_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            print(f"- Adding {add_current_kext}")
+            self.elevated(["cp", "-R", f"{vendor_location}/{add_current_kext}", self.mount_extensions], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            self.elevated(["chmod", "-Rf", "755", f"{self.mount_extensions}/{add_current_kext}"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            self.elevated(["chown", "-Rf", "root:wheel", f"{self.mount_extensions}/{add_current_kext}"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def add_brightness_patch(self):
         print("- Merging legacy Brightness Control Patches")
         self.delete_old_binaries(ModelArray.DeleteBrightness)
         self.add_new_binaries(ModelArray.AddBrightness, self.constants.legacy_brightness)
-        subprocess.run(f"sudo ditto {self.constants.payload_apple_private_frameworks_path_brightness} {self.mount_private_frameworks}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        subprocess.run(f"sudo chmod -R 755 {self.mount_private_frameworks}/DisplayServices.framework".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        subprocess.run(f"sudo chown -R root:wheel {self.mount_private_frameworks}/DisplayServices.framework".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["ditto", self.constants.payload_apple_private_frameworks_path_brightness, self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["chmod", "-Rf", "755", f"{self.mount_private_frameworks}/DisplayServices.framework"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["chown", "-Rf", "root:wheel", f"{self.mount_private_frameworks}/DisplayServices.framework"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def gpu_accel_patches_11(self):
-        igpu_vendor,igpu_device,igpu_acpi = DeviceProbe.pci_probe().gpu_probe("IGPU")
-        dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+        igpu_vendor, igpu_device, igpu_acpi = DeviceProbe.pci_probe().gpu_probe("IGPU")
+        dgpu_vendor, dgpu_device, dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
         if dgpu_vendor:
             print(f"- Found GFX0: {dgpu_vendor}:{dgpu_device}")
             if dgpu_vendor == self.constants.pci_nvidia:
@@ -132,8 +238,9 @@ class PatchSysVolume:
                     self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
                     self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
                     self.add_new_binaries(ModelArray.AddNvidiaAccel11, self.constants.legacy_nvidia_path)
+                    self.added_kexts = True
                 # TODO: Enable below code if macOS 12 drops support
-                #elif dgpu_device in PCIIDArray.nvidia_ids().kepler_ids and self.constants.detected_os > self.constants.big_sur:
+                # elif dgpu_device in PCIIDArray.nvidia_ids().kepler_ids and self.constants.detected_os > self.constants.big_sur:
                 #    print("- Merging legacy Nvidia Kepler Kexts and Bundles")
                 #    self.add_new_binaries(ModelArray.AddNvidiaKeplerAccel11, self.constants.legacy_nvidia_kepler_path)
             elif dgpu_vendor == self.constants.pci_amd_ati:
@@ -142,6 +249,23 @@ class PatchSysVolume:
                     self.delete_old_binaries(ModelArray.DeleteAMDAccel11)
                     self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
                     self.add_new_binaries(ModelArray.AddAMDAccel11, self.constants.legacy_amd_path)
+                    self.added_kexts = True
+                if self.model in ["MacBookPro8,2", "MacBookPro8,3"]:
+                    # This is used for MacBookPro8,2/3 where dGPU is disabled via NVRAM and still requires AMD framebuffer
+                    # For reference:
+                    #- deMUX: Don't need the AMD patches
+                    #- dGPUs enabled:  Don't install the AMD patches (Infinite login loop otherwise)
+                    #- dGPUs disabled: Do need the AMD patches (Restores Brightness control)
+                    dgpu_status: str = subprocess.run("nvram FA4CE28D-B62F-4C99-9CC3-6815686E30F9:gpu-power-prefs".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+                    if dgpu_status.startswith("FA4CE28D-B62F-4C99-9CC3-6815686E30F9:gpu-power-prefs	%01"):
+                        print("- Detected dGPU is disabled via NVRAM")
+                        print("- Merging legacy AMD Kexts and Bundles")
+                        self.delete_old_binaries(ModelArray.DeleteAMDAccel11)
+                        self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
+                        self.add_new_binaries(ModelArray.AddAMDAccel11, self.constants.legacy_amd_path)
+                        self.added_kexts = True
+                    else:
+                        print("- Cannot install Brightness Control, pleas ensure the dGPU is disabled via NVRAM")
         if igpu_vendor:
             print(f"- Found IGPU: {igpu_vendor}:{igpu_device}")
             if igpu_vendor == self.constants.pci_intel:
@@ -150,14 +274,16 @@ class PatchSysVolume:
                     self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
                     self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
                     self.add_new_binaries(ModelArray.AddIntelGen1Accel, self.constants.legacy_intel_gen1_path)
+                    self.added_kexts = True
                 elif igpu_device in PCIIDArray.intel_ids().sandy_ids:
                     print("- Merging legacy Intel 2nd Gen Kexts and Bundles")
                     self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
                     self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
                     self.add_new_binaries(ModelArray.AddIntelGen2Accel, self.constants.legacy_intel_gen2_path)
+                    self.added_kexts = True
 
                 # TODO: Enable below code if macOS 12 drops support
-                #elif igpu_device in PCIIDArray.intel_ids().ivy_ids:
+                # elif igpu_device in PCIIDArray.intel_ids().ivy_ids:
                 #    print("- Merging legacy Intel 3rd Gen Kexts and Bundles")
                 #    self.add_new_binaries(ModelArray.AddIntelGen3Accel, self.constants.legacy_intel_gen3_path)
             elif igpu_vendor == self.constants.pci_nvidia:
@@ -167,31 +293,34 @@ class PatchSysVolume:
                     self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
                     self.add_new_binaries(ModelArray.AddGeneralAccel, self.constants.legacy_general_path)
                     self.add_new_binaries(ModelArray.AddNvidiaAccel11, self.constants.legacy_nvidia_path)
+                    self.added_kexts = True
 
-        # Frameworks
-        print("- Merging legacy Frameworks")
-        subprocess.run(f"sudo ditto {self.constants.payload_apple_frameworks_path_accel} {self.mount_frameworks}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        if self.added_kexts == True:
+            # Frameworks
+            print("- Merging legacy Frameworks")
+            self.elevated(["ditto", self.constants.payload_apple_frameworks_path_accel, self.mount_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
-        if self.model in ModelArray.LegacyBrightness:
-            self.add_brightness_patch()
+            if self.model in ModelArray.LegacyBrightness:
+                self.add_brightness_patch()
 
-        # LaunchDaemons
-        if Path(self.mount_lauchd / Path("HiddHack.plist")).exists():
-            print("- Removing legacy HiddHack")
-            subprocess.run(f"sudo rm {self.mount_lauchd}/HiddHack.plist".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        print("- Adding IOHID-Fixup.plist")
-        subprocess.run(f"sudo ditto {self.constants.payload_apple_lauchd_path_accel} {self.mount_lauchd}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        subprocess.run(f"sudo chmod 755 {self.mount_lauchd}/IOHID-Fixup.plist".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        subprocess.run(f"sudo chown root:wheel {self.mount_lauchd}/IOHID-Fixup.plist".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            # LaunchDaemons
+            if Path(self.mount_lauchd / Path("HiddHack.plist")).exists():
+                print("- Removing legacy HiddHack")
+                self.elevated(["rm", f"{self.mount_lauchd}/HiddHack.plist"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            print("- Adding IOHID-Fixup.plist")
+            self.elevated(["ditto", self.constants.payload_apple_lauchd_path_accel, self.mount_lauchd], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            self.elevated(["chmod", "755", f"{self.mount_lauchd}/IOHID-Fixup.plist"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            self.elevated(["chown", "root:wheel", f"{self.mount_lauchd}/IOHID-Fixup.plist"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
-        # PrivateFrameworks
-        print("- Merging legacy PrivateFrameworks")
-        subprocess.run(f"sudo ditto {self.constants.payload_apple_private_frameworks_path_accel} {self.mount_private_frameworks}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-
-        # Sets AppKit to Catalina Window Drawing codepath
-        # Disabled upon ASentientBot request
-        print("- Enabling NSDefenestratorModeEnabled")
-        subprocess.run("defaults write -g NSDefenestratorModeEnabled -bool true".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            # PrivateFrameworks
+            print("- Merging legacy PrivateFrameworks")
+            self.elevated(["ditto", self.constants.payload_apple_private_frameworks_path_accel, self.mount_private_frameworks], stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            # Sets AppKit to Catalina Window Drawing codepath
+            # Disabled upon ASentientBot request
+            # print("- Enabling NSDefenestratorModeEnabled")
+            # subprocess.run("defaults write -g NSDefenestratorModeEnabled -bool true".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        else:
+            print("- No Acceleration Kexts were installed, skipping remaining acceleration patches")
 
     def patch_root_vol(self):
         print(f"- Detecting patches for {self.model}")
@@ -201,11 +330,20 @@ class PatchSysVolume:
         # Perhaps a basic py2 script to run in recovery to restore
         # Ensures no .DS_Stores got in
         print("- Preparing Files")
-        subprocess.run(f"sudo find {self.constants.payload_apple_root_path} -name '.DS_Store' -delete".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["find", self.constants.payload_apple_root_path, "-name", "'.DS_Store'", "-delete"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
         if self.model in ModelArray.LegacyGPU or self.constants.assume_legacy is True:
-            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
-            if dgpu_vendor and 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):
+            dgpu_vendor, dgpu_device, dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+            if (
+                dgpu_vendor
+                and 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
+                )
+            ):
                 print("- Detected Metal-based AMD GPU, skipping legacy patches")
             elif dgpu_vendor and dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids:
                 print("- Detected Metal-based Nvidia GPU, skipping legacy patches")
@@ -216,46 +354,48 @@ class PatchSysVolume:
 
         if self.model in ["iMac7,1", "iMac8,1"]:
             print("- Fixing Volume Control Support")
+            self.delete_old_binaries(ModelArray.DeleteVolumeControl)
             self.add_new_binaries(ModelArray.AddVolumeControl, self.constants.audio_path)
+            rebuild_required = True
 
         if rebuild_required is True:
             self.rebuild_snapshot()
 
     def unpatch_root_vol(self):
         print("- Reverting to last signed APFS snapshot")
-        subprocess.run(f"sudo bless --mount {self.mount_location} --bootefi --last-sealed-snapshot".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["bless", "--mount", self.mount_location, "--bootefi", "--last-sealed-snapshot"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def rebuild_snapshot(self):
         if self.constants.gui_mode is False:
             input("Press [ENTER] to continue with cache rebuild")
         print("- Rebuilding Kernel Cache (This may take some time)")
-        result = subprocess.run(f"sudo kmutil install --volume-root {self.mount_location} --update-all".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+        result = self.elevated(["kmutil", "install", "--volume-root", self.mount_location, "--update-all"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
 
         if result.returncode != 0:
-            self.sucess_status = False
+            self.success_status = False
             print("- Unable to build new kernel cache")
             print("\nPlease report this to Github")
             print("Reason for Patch Failure:")
             print(result.stdout.decode())
             print("")
         else:
-            self.sucess_status = True
+            self.success_status = True
             print("- Successfully built new kernel cache")
             if self.constants.gui_mode is False:
                 input("Press [ENTER] to continue with snapshotting")
             print("- Creating new APFS snapshot")
-            subprocess.run(f"sudo bless --folder {self.mount_location}/System/Library/CoreServices --bootefi --create-snapshot".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+            self.elevated(["bless", "--folder", f"{self.mount_location}/System/Library/CoreServices", "--bootefi", "--create-snapshot"], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def unmount_drive(self):
         print("- Unmounting Root Volume (Don't worry if this fails)")
-        subprocess.run(f"sudo diskutil unmount {self.root_mount_path}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
+        self.elevated(["diskutil", "unmount", self.root_mount_path], stdout=subprocess.PIPE).stdout.decode().strip().encode()
 
     def check_status(self):
         nvram_dump = plistlib.loads(subprocess.run("nvram -x -p".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
         try:
             self.sip_status = nvram_dump["csr-active-config"]
         except KeyError:
-            self.sip_status = b'\x00\x00\x00\x00'
+            self.sip_status = b"\x00\x00\x00\x00"
 
         self.smb_model: str = subprocess.run("nvram 94B73556-2197-4702-82A8-3E1337DAFBFB:HardwareModel	".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
         if not self.smb_model.startswith("nvram: Error getting variable"):
@@ -267,13 +407,14 @@ class PatchSysVolume:
         else:
             self.smb_status = False
         self.fv_status = True
-        self.fv_status: str = subprocess.run("fdesetup status".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-        if self.fv_status.startswith("FileVault is Off"):
-            self.fv_status = False
+        if self.constants.recovery_status == False:
+            self.fv_status: str = subprocess.run("fdesetup status".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+            if self.fv_status.startswith("FileVault is Off"):
+                self.fv_status = False
         else:
-            self.fv_status = True
-        self.sip_patch_status = True
-        self.csr_decode(self.sip_status, False)
+            # Assume FileVault is off for Recovery purposes
+            self.fv_status = False
+        self.csr_decode(False)
 
     def check_files(self):
         if Path(self.constants.payload_apple_root_path).exists():
@@ -292,7 +433,13 @@ class PatchSysVolume:
     def download_files(self):
         Utilities.cls()
         print("- Downloading Apple binaries")
-        popen_oclp = subprocess.Popen(f"curl -S -L {self.constants.url_apple_binaries}{self.constants.payload_version}.zip --output {self.constants.payload_apple_root_path_zip}".split(), stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True)
+        popen_oclp = subprocess.Popen(
+            ["curl", "-S", "-L", f"{self.constants.url_apple_binaries}{self.constants.payload_version}.zip", "--output", self.constants.payload_apple_root_path_zip],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            universal_newlines=True,
+        )
         for stdout_line in iter(popen_oclp.stdout.readline, ""):
             print(stdout_line, end="")
         popen_oclp.stdout.close()
@@ -300,7 +447,7 @@ class PatchSysVolume:
             print("- Download completed")
             print("- Unzipping download...")
             try:
-                subprocess.run(f"unzip {self.constants.payload_apple_root_path_zip}".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.constants.payload_path).stdout.decode()
+                subprocess.run(["unzip", self.constants.payload_apple_root_path_zip], stdout=subprocess.PIPE, stderr=subprocess.STDOUT, cwd=self.constants.payload_path).stdout.decode()
                 print("- Renaming folder")
                 os.rename(self.constants.payload_apple_root_path_unzip, self.constants.payload_apple_root_path)
                 print("- Binaries downloaded to:")
@@ -323,8 +470,8 @@ class PatchSysVolume:
             print("Root Patching not required for this machine!")
         elif self.model not in ModelArray.SupportedSMBIOS11 and self.constants.assume_legacy is False:
             print("Cannot run on this machine, model is unsupported!")
-        elif self.constants.detected_os < self.constants.big_sur:
-            print(f"Cannot run on this OS, requires macOS 11!")
+        elif self.constants.detected_os != self.constants.big_sur:
+            print("Cannot run on this OS, requires macOS 11!")
         else:
             self.check_status()
             Utilities.cls()
@@ -334,17 +481,18 @@ class PatchSysVolume:
                     input("\nPress [ENTER] to continue")
                 self.check_files()
                 if self.constants.payload_apple_root_path.exists():
-                    self.find_mount_root_vol(True)
+                    if not self.find_mount_root_vol(True):
+                        return
                     self.unmount_drive()
                     print("- Patching complete")
-                    if self.sucess_status is True:
+                    if self.success_status is True:
                         print("\nPlease reboot the machine for patches to take effect")
                     else:
                         print("\nPlease reboot the machine to avoid potential issues rerunning the patcher")
             if self.sip_patch_status is True:
                 print("SIP set incorrectly, cannot patch on this machine!")
                 print("Please disable SIP and SecureBootModel in Patcher Settings")
-                self.csr_decode(self.sip_status, True)
+                self.csr_decode(True)
                 print("")
             if self.smb_status is True:
                 print("SecureBootModel set incorrectly, unable to patch!")
@@ -360,8 +508,8 @@ class PatchSysVolume:
     def start_unpatch(self):
         if self.constants.custom_model is not None:
             print("Unpatching must be done on target machine!")
-        elif self.constants.detected_os < self.constants.big_sur:
-            print(f"Cannot run on this OS, requires macOS 11!")
+        elif self.constants.detected_os != self.constants.big_sur:
+            print("Cannot run on this OS, requires macOS 11!")
         else:
             self.check_status()
             Utilities.cls()
@@ -369,14 +517,15 @@ class PatchSysVolume:
                 print("- Detected SIP and SecureBootModel are disabled, continuing")
                 if self.constants.gui_mode is False:
                     input("\nPress [ENTER] to continue")
-                self.find_mount_root_vol(False)
+                if not self.find_mount_root_vol(False):
+                    return
                 self.unmount_drive()
                 print("- Unpatching complete")
                 print("\nPlease reboot the machine for patches to take effect")
             if self.sip_patch_status is True:
                 print("SIP set incorrectly, cannot unpatch on this machine!")
                 print("Please disable SIP and SecureBootModel in Patcher Settings")
-                self.csr_decode(self.sip_status, True)
+                self.csr_decode(True)
                 print("")
             if self.smb_status is True:
                 print("SecureBootModel set incorrectly, unable to unpatch!")

Resources/Utilities.py

@@ -2,7 +2,16 @@
 from __future__ import print_function
 
 import os
-import math as m
+import math
+import plistlib
+import subprocess
+
+
+def hexswap(input_hex: str):
+    hex_pairs = [input_hex[i : i + 2] for i in range(0, len(input_hex), 2)]
+    hex_rev = hex_pairs[::-1]
+    hex_str = "".join(["".join(x) for x in hex_rev])
+    return hex_str.upper()
 
 
 def header(lines):
@@ -10,13 +19,24 @@ def header(lines):
     total_length = len(max(lines, key=len)) + 4
     print("#" * (total_length))
     for line in lines:
-        left_side = m.floor(((total_length - 2 - len(line.strip())) / 2))
+        left_side = math.floor(((total_length - 2 - len(line.strip())) / 2))
         print("#" + " " * left_side + line.strip() + " " * (total_length - len("#" + " " * left_side + line.strip()) - 1) + "#")
     print("#" * total_length)
 
 
+def check_recovery():
+    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 root_partition_info["BusProtocol"] == "Disk Image":
+        return True
+    else:
+        return False
+
+
 def cls():
-    os.system('cls' if os.name == 'nt' else 'clear')
+    if check_recovery() == False:
+         os.system('cls' if os.name == 'nt' else 'clear')
+    else:
+        print("\u001Bc")
 
 # 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]
@@ -46,7 +66,7 @@ def cls():
 #         menu_options[keys.index(selected.upper())][2]() if menu_options[keys.index(selected.upper())][2] else None
 
 
-class TUIMenu():
+class TUIMenu:
     def __init__(self, title, prompt, options=None, return_number_instead_of_direct_call=False, add_quit=True, auto_number=False, in_between=None, top_level=False, loop=False):
         self.title = title
         self.prompt = prompt
@@ -65,8 +85,7 @@ class TUIMenu():
     def start(self):
         return_option = ["Q", "Quit"] if self.top_level else ["B", "Back"]
         if self.add_quit and not self.added_quit:
-            self.add_menu_option(
-                return_option[1], function=None, key=return_option[0])
+            self.add_menu_option(return_option[1], function=None, key=return_option[0])
             self.added_quit = True
 
         while True:
@@ -105,7 +124,7 @@ class TUIMenu():
                     return
 
 
-class TUIOnlyPrint():
+class TUIOnlyPrint:
     def __init__(self, title, prompt, in_between=None):
         self.title = title
         self.prompt = prompt

Resources/models.json

@@ -1,303 +0,0 @@
-[
-    {
-        "models": [
-            "MacBook5,1",
-            "MacBook5,2"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "LegacyAudio",
-            "MissingSSE42",
-            "EthernetNvidia",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBook6,1",
-            "MacBook7,1"
-        ],
-        "patches": [
-            "WifiBCM943224",
-            "LegacyAudio",
-            "MissingSSE42",
-            "EthernetNvidia",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookAir2,1",
-            "MacBookAir3,1",
-            "MacBookAir3,2"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookAir4,1",
-            "MacBookAir4,2"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "LegacyAudio",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookAir5,1",
-            "MacBookAir5,2"
-        ],
-        "patches": [
-            "WifiBCM94322"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro3,1"
-        ],
-        "patches": [
-            "WifiAtheros",
-            "EthernetMarvell",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro4,1"
-        ],
-        "patches": [
-            "WifiBCM94328",
-            "EthernetMarvell",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro5,1",
-            "MacBookPro5,2",
-            "MacBookPro5,3",
-            "MacBookPro5,4",
-            "MacBookPro5,5"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "EthernetNvidia",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro6,1",
-            "MacBookPro6,2"
-        ],
-        "patches": [
-            "WifiBCM943224",
-            "EthernetBroadcom",
-            "LegacyAudio",
-            "LegacyGPU",
-            "PCIBridge"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro7,1"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "EthernetNvidia",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro8,1",
-            "MacBookPro8,2",
-            "MacBookPro8,3"
-        ],
-        "patches": [
-            "WifiBCM94331",
-            "EthernetBroadcom",
-            "LegacyAudio",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacBookPro9,1",
-            "MacBookPro9,2",
-            "MacBookPro10,1",
-            "MacBookPro10,2"
-        ],
-        "patches": [
-            "WifiBCM94331"
-        ]
-    },
-    {
-        "models": [
-            "MacMini3,1",
-            "MacMini4,1"
-        ],
-        "patches": [
-            "WifiBCM943224",
-            "EthernetNvidia",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "Macmini5,1",
-            "Macmini5,2",
-            "Macmini5,3"
-        ],
-        "patches": [
-            "WifiBCM94331",
-            "EthernetBroadcom",
-            "LegacyAudio",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "MacMini6,1",
-            "MacMini6,2"
-        ],
-        "patches": [
-            "WifiBCM94331"
-        ]
-    },
-    {
-        "models": [
-            "iMac7,1",
-            "iMac8,1"
-        ],
-        "patches": [
-            "WifiBCM94328",
-            "EthernetNvidia",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "iMac9,1"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "EthernetNvidia",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "iMac10,1"
-        ],
-        "patches": [
-            "WifiAtheros",
-            "EthernetNvidia",
-            "LegacyAudio",
-            "MissingSSE42",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "iMac11,1",
-            "iMac11,2",
-            "iMac11,3"
-        ],
-        "patches": [
-            "WifiAtheros",
-            "EthernetBroadcom",
-            "LegacyAudio",
-            "LegacyGPU",
-            "PCIBridge"
-        ]
-    },
-    {
-        "models": [
-            "iMac12,1",
-            "iMac12,2"
-        ],
-        "patches": [
-            "WifiAtheros",
-            "EthernetBroadcom",
-            "LegacyAudio",
-            "LegacyGPU"
-        ]
-    },
-    {
-        "models": [
-            "iMac13,1",
-            "iMac13,2"
-        ],
-        "patches": [
-            "WifiBCM94331"
-        ]
-    },
-    {
-        "models": [
-            "iMac14,1",
-            "iMac14,2",
-            "iMac14,3"
-        ],
-        "patches": []
-    },
-    {
-        "models": [
-            "MacPro3,1"
-        ],
-        "patches": [
-            "WifiAtheros",
-            "LegacyAudio",
-            "MissingSSE42",
-            "SSEEmulator",
-            "DualSocket"
-        ]
-    },
-    {
-        "models": [
-            "MacPro4,1"
-        ],
-        "patches": [
-            "WifiAtheros",
-            "DualSocket"
-        ]
-    },
-    {
-        "models": [
-            "MacPro5,1"
-        ],
-        "patches": [
-            "WifiBCM94322",
-            "DualSocket"
-        ]
-    },
-    {
-        "models": [
-            "Xserve3,1"
-        ],
-        "patches": [
-            "DualSocket"
-        ]
-    }
-]

docs/ACCEL.md

@@ -32,6 +32,15 @@ Currently Zoom relies partially on Metal and so needs a small binary patch. Dosd
 
 Due to the usage of `amfi_get_out_of_my_way=1`, macOS will fail to prompt users for special permissions upon application start as well as omit the entires in System Preferences. To work around this, we recommend users install [tccplus](https://github.com/jslegendre/tccplus) to manage permissions.
 
+Example usage with Discord and microphone permissions:
+
+```sh
+# Open Terminal and run the following commands
+cd ~/Downloads/
+chmod +x tccplus
+./tccplus add Microphone com.hnc.Discord
+```
+
 ## Keyboard Backlight broken
 
 Due to forcing `hidd` into spinning up with the fallback mode enabled, this can break the OS's recognition of backlight keyboards. Thankfully the drivers themselves still do operate so applications such as [LabTick](https://www.macupdate.com/app/mac/22151/lab-tick) are able to set the brightness manually.
@@ -59,7 +68,7 @@ Currently OpenCore Legacy Patcher doesn't have support for the TeraScale 2 serie
 The best way to achieve this is to boot Recovery (or Single User Mode if the dGPU refuses to function at all) and run the following command:
 
 ```sh
-nvram fa4ce28d-b62f-4c99-9cc3-6815686e30f9:gpu-power-prefs=%01%00%00%00
+nvram FA4CE28D-B62F-4C99-9CC3-6815686E30F9:gpu-power-prefs=%01%00%00%00
 ```
 
-This will disable the dGPU and allow graphics acceleration in Big Sur. Note that external display outputs are directly routed to the dGPU and therefore can no longer be used. Solutions such as a [DisplayLink Adapters](https://www.displaylink.com/products/usb-adapters) can work around this limitation.
+This will disable the dGPU and allow graphics acceleration in Big Sur. Note that external display outputs are directly routed to the dGPU and therefore can no longer be used. Solutions such as a [DisplayLink Adapters](https://www.displaylink.com/products/usb-adapters) can work around this limitation.

docs/BENIFITS.md

@@ -7,10 +7,10 @@ With OpenCore Legacy Patcher we recommend users go through the below table to un
 | Features | [OpenCore Legacy Patcher](https://github.com/dortania/OpenCore-Legacy-Patcher/) | [Patched Sur](https://github.com/BenSova/Patched-Sur) |
 | :--- | :--- | :--- |
 | Over The Air Updates | <span style="color:#30BCD5">Native System Preferences, additionally supports Deltas (~2GB) for Metal GPUs</span> | <span style="color:red">Inside Patcher Sur app (~12GB), only available when InstallAssistants release.</span> InstallAssistants generally available same day as System Preference updates, however developer betas will lag behind by 1 day compared to OTAs |
-| FileVault | <span style="color:#30BCD5">Supported on Metal GPUs</span> | <span style="color:red">Not supported</span> | 
+| FileVault | <span style="color:#30BCD5">Supported on Metal GPUs</span> | <span style="color:red">Not supported</span> |
 | System Integrity Protection | <span style="color:#30BCD5">Fully enabled on Metal GPUs</span> | <span style="color:red">Disabled for early 2013 and older during the patching process and first boot afterwards, otherwise enabled</span> |
 | APFS Snapshots | <span style="color:#30BCD5">Fully enabled</span> | <span style="color:red">Disabled</span> |
-| User facing | <span style="color:red">TUI interface</span> | <span style="color:#30BCD5">SwiftUI interface, more user friendly</span> | 
+| User facing | <span style="color:red">TUI interface</span> | <span style="color:#30BCD5">SwiftUI interface, more user friendly</span> |
 | Supported OSes | <span style="color:#30BCD5">10.7-11</span> | <span style="color:red">10.15-11</span> |
 | Firmware Patching | <span style="color:#30BCD5">None required</span> | <span style="color:red">Required for models without native APFS support</span> |
 | BootCamp Switching | <span style="color:red">Requires EFI Conversion for Start Disk support, otherwise still supported</span> | <span style="color:#30BCD5">Native</span> |
@@ -21,4 +21,4 @@ With OpenCore Legacy Patcher we recommend users go through the below table to un
 | HEVC/H.265 Support for Mac Pros and iMacs with Polaris+ GPUs | <span style="color:#30BCD5">Supported</span> | <span style="color:red">Not supported</span> |
 | Big Sur-styled Boot Picker |  <span style="color:#30BCD5">Available</span>, though as a shim to the original boot picker | <span style="color:red">Not available</span> |
 | Hibernation Support | <span style="color:#30BCD5">Supports 3rd party SATA SSDs on 2011 and older models in addition to stock drives</span> | <span style="color:red">Only supports stock drives on 2011 and older models</span> |
-| Sidecar Support | <span style="color:#30BCD5">Supports any Mac with Metal Intel iGPU</span>, artifacting way exhibited on high movement screen content | <span style="color:red">Not supported at all</span> |
+| Sidecar Support | <span style="color:#30BCD5">Supports any Mac with Metal Intel iGPU</span>, artifacting way exhibited on high movement screen content | <span style="color:red">Not supported at all</span> |

docs/BOOT.md

@@ -14,7 +14,6 @@ Now that you've loaded OpenCore, now select Install macOS!:
 
 ![](../images/oc-boot.png)
 
-
 After plenty of verbose booting, you will reach the installer screen! From there it's just like any normal macOS install. For an example of how the boot process looks, see the following video:
 
 * [OpenCore Legacy Patcher Boot Process](https://www.youtube.com/watch?v=AN3zsbQV_n4)

docs/BUILD.md

@@ -2,7 +2,7 @@
 
 Now that we have a macOS installer, lets now build our OpenCore configuration!
 
-First Download the latest release: 
+First Download the latest release:
 
 * [OpenCore Legacy Patcher Releases](https://github.com/dortania/Opencore-Legacy-Patcher/releases)
 
@@ -15,7 +15,7 @@ From here you have a couple important options:
 * Build OpenCore
 * Install OpenCore to USB/internal drive
 * Change Model
-* Patcher Settings 
+* Patcher Settings
 
 If you're patching for a different machine than you're running, please select "Change Model" and enter the updated SMBIOS. For more advanced users, you may also tweak the patcher's build settings via "Patcher Settings"
 
@@ -31,7 +31,6 @@ Next lets run `Install OpenCore to USB/internal drive`:
 | :--- | :--- |
 | ![](../images/disk-start.png) | ![](../images/disk-efi.png) |
 
-  * If you have issues, please ensure you install OpenCore onto a FAT32 partition to ensure your Mac is able to boot it. You will need to format your drive as GUID/GPT in Disk Utility
+* If you have issues, please ensure you install OpenCore onto a FAT32 partition to ensure your Mac is able to boot it. You will need to format your drive as GUID/GPT in Disk Utility
   
-
-# Once finished, head to [Booting OpenCore and macOS](./BOOT.md)
+# Once finished, head to [Booting OpenCore and macOS](./BOOT.md)

docs/CLI.md

@@ -8,9 +8,9 @@ With OpenCore Legacy Patcher, we include an extra binary called [OCLP-CLI](https
   * **--model xxxx**: override default model detection
     * ex. **--model iMac11,2**
   * **--metal_gpu xxxx**: override default GPU detection (ie. Nvidia, AMD)
-    * **--metal_gpu Nvidia** 
+    * **--metal_gpu Nvidia**
   * **--smbios_spoof xxxx**: set spoofing mode, defaults to Minimal if no arg provided (ie. Minimal, Moderate, Advanced)
-    * ex. **--smbios_spoof Moderate** 
+    * ex. **--smbios_spoof Moderate**
   * **--verbose**: enable verbose booting
   * **--debug_oc**: enable debug OpenCore
   * **--debug_kext**: enable debug kexts
@@ -38,4 +38,4 @@ Example usage:
 sudo ./OCLP-CLI --patch_sys_vol
 ```
 
-Note, root volume patching needs to be run as sudo
+Note, root volume patching needs to be run as sudo

docs/DEBUG.md

@@ -12,7 +12,6 @@ The easiest way to debug yourself is via Patcher Settings. Here there are many d
 * "Enable OpenCore DEBUG"
 * "Enable Kext DEBUG"
 
-
 When you've enabled these 3 options, rebuild OpenCore and install to your drive. This will provide much greater debug information as well as write logs to the EFI Partition.
 
 ## Obtaining OpenCore logs from disk
@@ -46,4 +45,4 @@ Now that you have proper logs, you can now [file issues with us](https://github.
 * Upload of your OpenCore log (if applicable)
 * Upload of your Kernel log (if applicable)
 
-Additionally, please search whether the issue has been reported before. This avoids having duplicate issues.
+Additionally, please search whether the issue has been reported before. This avoids having duplicate issues.

docs/DONATE.md

@@ -11,13 +11,13 @@ Main sections of help we'd appreciate:
 * Donating any spare SATA SSDs
   * Having extra SSDs on hand allows us to quickly and easily test specific builds of macOS without having to wipe drives and reinstall as much
 * Aiding by buying items in our Amazon Wishlist
-  * Currently we have a few members within Dortania testing so we recommend messaging the email listed below to see which member at the time would something purchased the most 
-  
+  * Currently we have a few members within Dortania testing so we recommend messaging the email listed below to see which member at the time would require something purchased the most
+
 Additionally, hardware info dumps are greatly beneficial for us to determine what patches a machine might need:
 
 * [IORegistryExplorer](https://github.com/khronokernel/IORegistryClone/blob/master/ioreg-210.zip?raw=true)
   * `File -> SaveAs` and open an issue on Github
-  * Note: We want IOReg dumps of hardware not running on OpenCore, instead running a clean, supported OS
+  * Note: We want IOReg dumps of hardware not running on OpenCore, instead running a clean, officially supported OS by the machine
 
 If you have any legacy hardware you're willing to donate or what to buy us something, please contact us at the following email:
 
@@ -29,7 +29,7 @@ Current hardware we own:
 | :--- | :--- | :--- | :--- | :--- |
 | MacBook7,1 | Penryn | GT320M | Dhinak | N/A |
 | MacBook7,1 | Penryn | GT320M | Mykola | N/A |
-| MacBookPro8,1 | Sandy Bridge | HD 3000 | Mykola | N/A |
 | MacBookPro5,3 | Penryn | 9400M + 9600M | Dhinak | Display's partially broken |
 | Macmini4,1 | Penryn | GT320M | Dhinak | N/A |
 | iMac11,2 | Clarksdale | HD4670 | Mykola | N/A |
+| MacPro3,1 | Penryn | HD5770, RX570, GT710 | Mykola | N/A |

docs/HOW.md

@@ -6,4 +6,4 @@ OpenCore Legacy Patcher itself is actually quite a "dumb" program, and essential
 
 To understand a bit more of how OpenCore is able revive older Macs in such a native-like way, we need to go over *how* OpenCore works with your Mac:
 
-![](../images/oc-explained.png)
+![](../images/oc-explained.png)

docs/ICNS.md

@@ -2,12 +2,10 @@
 
 For users who want to customize your setup to be more personal, OpenCore does allow for custom icons and images in the boot picker.
 
-
 * [Custom OpenCore icons](#custom-opencore-icons)
 * [Custom Mac Boot Picker icons](#custom-mac-boot-picker-icons)
 * [Installing updated icons](#installing-updated-icons)
 
-
 # Custom OpenCore icons
 
 To generate custom OpenCore icons, you'll need the following:
@@ -32,7 +30,6 @@ To generate custom OpenCore icons, you'll need the following:
   
 Note, for each image we recommend having one of double the size. This ensures that icons are scaled correctly since .icns support dedicated images depending on HiDPI or not.
 
-
 Once you have a custom image you want to use(for example, as a background), download the [latest release of OpenCorePkg](https://github.com/acidanthera/OpenCorePkg/releases) and enter the `Utilities/icnspack/` folder:
 
 ![](../images/icnspack-folder.png)
@@ -42,6 +39,7 @@ Now `cd` this folder in terminal and run the following:
 ```sh
 ./icnspack Background.icns <insert_x1_image> <insert_x2_image>
 ```
+
 Once done, you'll see your custom icon generated in `icnspack`'s folder:
 
 ![](../images/icnspack-done.png)
@@ -54,7 +52,7 @@ To generate legacy icons, you'll need the following:
 
 * A machine running macOS 10.4 through 10.11
 * Icon Composer.app (Requires Apple Developer Account for official download)
-  * Users without the developer account can find a mirrors here: 
+  * Users without the developer account can find a mirrors here:
     * [Icon Composer 10.6](https://github.com/dortania/OpenCore-Legacy-Patcher/blob/main/docs/Icon-Composer-10.6.zip)
     * [Icon Composer 10.11](https://github.com/dortania/OpenCore-Legacy-Patcher/blob/main/docs/Icon-Composer-10.11.zip)
 * PNG Image you wish to convert
@@ -102,4 +100,4 @@ To update the Mac Boot Picker icons is actually quite simple, on the root of you
 
 ![](../images/mac-icns-drive.png)
 
-Now reboot and you'll see the new icon!
+Now reboot and you'll see the new icon!

docs/INSTALLER.md

@@ -14,6 +14,7 @@ The simplest way to download macOS installs would be to use installinstallmacos:
 ```sh
 [ ! -d ~/macOS-installer/ ] && mkdir ~/macOS-installer; cd ~/macOS-installer; [ ! -f ~/macOS-installer/installinstallmacos.py ] && curl -O https://raw.githubusercontent.com/munki/macadmin-scripts/main/installinstallmacos.py; sudo python installinstallmacos.py
 ```
+
 * Note: On El Capitan (10.11) and older, you'll need to specify a catalog at the end of the command:
 
 ```

docs/LICENSE.md

@@ -19,21 +19,4 @@ This patcher is made of multiple external applications from different people and
   * [SidecarFixup](https://github.com/khronokernel/SidecarFixup) - Khronokernel
   * Apple Binaries - Apple Inc.
 
-Remaining files within OpenCore Legacy Patcher are copyrighted 2020-2021 Mykola Grymalyuk & Dhinak G, under the BSD-3 Clause license:
-
-```
-Copyright (c) 2020-2021, Dhinak G
-Copyright (c) 2020-2021, Mykola Grymalyuk
-
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-```
+Remaining files within OpenCore Legacy Patcher are copyrighted 2020-2021 Mykola Grymalyuk & Dhinak G. For integration into other projects, please request written permission.

docs/MODELS.md

@@ -20,7 +20,7 @@ Regarding OS support, see below:
 
 | Support Entry | Supported OSes | Description | Comment |
 | :--- | :--- | :--- | :--- |
-| HostOS | macOS 10.9 - macOS 11 | Refers to OSes where running OpenCore-Patcher.app are supported | Supports 10.7+ if [Python 3.6 or higher](https://www.python.org/downloads/) is manually installed, simply run the `OpenCore-Patcher.command` located in the repo |
+| HostOS | macOS 10.9 - macOS 11 | Refers to OSes where running OpenCore-Patcher.app are supported | Supports 10.7+ if [Python 3.9 or higher](https://www.python.org/downloads/) is manually installed, simply run the `OpenCore-Patcher.command` located in the repo |
 | TargetOS | macOS 11 | Refers to OSes that can be patched to run with OpenCore | May support 10.4 and newer (in a potentially broken state). No support provided. |
 
 ### MacBook
@@ -126,7 +126,6 @@ Regarding OS support, see below:
 | MacPro4,1 | Early 2009 | ^^ | <span style="color:green"> Everything is supported as long as GPU is Metal capable </span> |
 | MacPro5,1 | Mid-2010, Mid-2012 | ^^ | ^^ |
 
-
 ### Xserve
 
 | SMBIOS | Year | Supported | Comment |

docs/PATCHEXPLAIN.md

@@ -100,11 +100,12 @@ Below is a run down of the main logic OpenCore Legacy Patcher uses to gain nativ
   * Reason: Fixes DRM support on models with upgraded AMD Metal GPUs
   * Logic: Adds args to NVRAM
   * Models: Models with upgraded AMD Metal GPUs
+
 ### UEFI -> ProtocolOverrides
 
 * GopPassThrough
   * Reason: Used for proper output on machines with UGA firmware but GOP GPU
-  * Logic: Provide GOP protocol instances on top of UGA protocol instances 
+  * Logic: Provide GOP protocol instances on top of UGA protocol instances
   * Models: MacPro3,1, MacBook4,1 iMac7,1-8,1
   
 :::
@@ -191,7 +192,6 @@ Below is an explanation of what Kexts OpenCore Legacy Patcher will inject into m
   * Models: All models require
 :::
 
-
 ## On-Disk Patches
 
 Unfortunately certain on-disk patches are required to achieve full functionality. Below is a breakdown of patches supported
@@ -226,13 +226,15 @@ Note, GPU Acceleration Patches are not public yet, the below section is simply d
   * GeForceGA.bundle
   * GeForceTesla.kext
     * Skip IOFree Panic - Mojave+
-	  * At Offset `0x5CF9A` replace following bytes with `0xEB`
+      * At Offset `0x5CF9A` replace following bytes with `0xEB`
     * Avoids `addMemoryRegion/removeMemoryRegion` calls
       * At Offset `0x5527` and `0x77993`, replace following bytes with `0x909090909090`
   * GeForceTeslaGLDriver.bundle
   * GeForceTeslaVADriver.bundle
   * NVDANV50HalTesla.kext
   * NVDAResmanTesla.kext
+    * 0x1ea59a - 0x1ea5b3: nop
+    * Replace VSLGestalt to IOLockLock or any other known symbol of the same length.
 
 * AMD/ATI Binaries
   * AMD2400Controller.kext
@@ -271,6 +273,8 @@ Note, GPU Acceleration Patches are not public yet, the below section is simply d
   * AppleIntelHD3000GraphicsGLDriver.bundle
   * AppleIntelHD3000GraphicsVADriver.bundle
   * AppleIntelSNBGraphicsFB.kext
+    * Board ID Patch
+      * Replace original Board ID with updated model
   * AppleIntelSNBVA.bundle
 
 ### Frameworks

docs/START.md

@@ -18,7 +18,7 @@ For those who wish to support this patcher, please see the [Supporting the Patch
 Since this patcher tricks macOS into thinking you're running a newer Mac, certain functionality may be broken:
 
 * Boot Camp Assistant.app
-  * We recommend following our [guide on getting a UEFI Windows Install working](). Legacy MBR Based installs won't show up in OpenCore
+  * We recommend following our [guide on getting a UEFI Windows Install working](./WINDOWS.md). Legacy MBR Based installs won't show up in OpenCore
 
 ## How do I get started?
 

docs/TESTED.md

@@ -2,7 +2,6 @@
 
 To aid users in troubleshooting, we've compiled a list of users who've reported success with OpenCore Legacy patcher as well as the version used. This should aid users in verifying whether issues with the patcher are regression-related with newer versions.
 
-
 ### MacBook
 
 | SMBIOS | Tested | Tester | Comment |
@@ -17,12 +16,12 @@ To aid users in troubleshooting, we've compiled a list of users who've reported
 
 ### MacBook Air
 
-| SMBIOS | Year | Supported | Comment |
+| SMBIOS | Tested | Tester | Comment |
 | :--- | :--- | :--- | :--- |
 | MacBookAir2,1 | No reports | N/A | N/A |
 | MacBookAir3,1 | ^^ | ^^ | ^^ |
-| MacBookAir3,2 | ^^ | ^^ | ^^ |
-| MacBookAir4,1 | ^^ | ^^ | ^^ |
+| MacBookAir3,2 | <span style="color:#30BCD5"> YES </span> | houser42 | - Stock model <br/>- Patcher version unknown |
+| MacBookAir4,1 | No reports | N/A | N/A |
 | MacBookAir4,2 | ^^ | ^^ | ^^ |
 | MacBookAir5,1 | <span style="color:#30BCD5"> YES </span> | Ausdauersportler | - Stock Model<br/>- Patcher version 0.0.9 |
 | ^^ | ^^ | webg3 | Stock Model |
@@ -46,7 +45,7 @@ To aid users in troubleshooting, we've compiled a list of users who've reported
 | MacBookPro8,1 | ^^ | AvaQueen | - Stock model <br/>- Patcher version 0.0.19 |
 | MacBookPro8,2 | ^^ | air.man | - Stock model, dGPU disabled <br/>- Patcher version 0.0.22 |
 | ^^ | ^^ | cboukouv | - Stock model <br/>- Patcher version 0.0.19 |
-| MacBookPro8,3 | No reports | N/A | N/A |
+| MacBookPro8,3 | ^^ | lulujyc | - Stock model, dGPU disabled <br/>- Patcher version 0.1.4 |
 | MacBookPro9,1 | <span style="color:#30BCD5"> YES </span> | jbdamiano | - Stock model <br/>- Patcher version 0.0.19 |
 | ^^ | ^^ | dennes544 | ^^|
 | ^^ | ^^ | cgrazy | ^^ |
@@ -106,7 +105,8 @@ To aid users in troubleshooting, we've compiled a list of users who've reported
 
 | SMBIOS | Tested | Tester | Comment |
 | :--- | :--- | :--- | :--- |
-| MacPro3,1 | <span style="color:#30BCD5"> YES </span> | christiann | - Upgraded with RX 560 and BCM94322<br/>- Stock Bluetooth card removed<br/>- Patcher version 0.0.21 |
+| MacPro3,1 | <span style="color:#30BCD5"> YES </span> | MykolaG | - Upgraded with RX 470 and BCM94360CD<br/>- Stock Bluetooth card removed<br/>- Patcher version 0.1.6 |
+| ^^ | ^^ | christiann | - Upgraded with RX 560 and BCM94322<br/>- Stock Bluetooth card removed<br/>- Patcher version 0.0.21 |
 | ^^ | ^^ | gw463 | - Upgraded GTX 680<br/>- Upgraded BCM94360<br/>- Patcher version 0.0.22 |
 | ^^ | ^^ | AlexSakha67 | - Upgraded R9 280<br/>- Patcher version 0.0.20 |
 | ^^ | ^^ | nekton1 | - Upgraded GTX 680<br/>- Patcher version 0.0.20 |

docs/TROUBLESHOOTING.md

@@ -59,7 +59,6 @@ By default, the patcher will try to hide extra boot options such as recovery fro
 
 Full error: "Your Mac needs a firmware update in order to install to this Volume. Please select a Mac OS Extended (Journaled) volume instead."
 
-
 This error occurs when macOS determines the firmware to not have full APFS support. To resolve is quite simple, when building OpenCore head to "Patcher Settings" and enable "Moderate SMBIOS Patching" or higher. This will ensure that the firmware reported will show as supporting full APFS capabilities.
 
 ## No Brightness Control
@@ -68,4 +67,4 @@ With OCLP v0.0.22, we've added support for brightness control on many models. Ho
 
 To work-around, we recommend user try out the below app:
 
-* [Brightness Slider](https://actproductions.net/free-apps/brightness-slider/)
+* [Brightness Slider](https://actproductions.net/free-apps/brightness-slider/)

docs/UNINSTALL.md

@@ -3,10 +3,13 @@
 To remove OpenCore is actually quite simply:
 
 1. Remove OpenCore either from the USB or internal drive
-  * You'll need to mount the drive's EFI partition, and delete the EFI/OC folder as well as the System folder
-    * Note **do not** delete the entire EFI folder, this will likely break any existing Windows and Linux installations
-  * [See here for example how to mount](https://dortania.github.io/OpenCore-Post-Install/universal/oc2hdd.html)
-2. Reset NVRAM
-  * [Reset NVRAM or PRAM on your Mac](https://support.apple.com/HT204063)
 
-Know that if you are on Big Sur when you remove the EFI folder, your Mac will no longer boot and show the prohibited symbol. Be ready to install an older version of macOS before you uninstall OpenCore.
+* You'll need to mount the drive's EFI partition, and delete the EFI/OC folder as well as the System folder
+  * Note **do not** delete the entire EFI folder, this will likely break any existing Windows and Linux installations
+* [See here for example how to mount](https://dortania.github.io/OpenCore-Post-Install/universal/oc2hdd.html)
+
+2. Reset NVRAM
+
+* [Reset NVRAM or PRAM on your Mac](https://support.apple.com/HT204063)
+
+Know that if you are on Big Sur when you remove the EFI folder, your Mac will no longer boot and show the prohibited symbol. Be ready to install an older version of macOS before you uninstall OpenCore.

docs/UPDATE.md

@@ -1,4 +1,4 @@
-# Updating OpenCore and Co.
+# Updating OpenCore and Co
 
 With OpenCore Legacy Patcher, generally there's very little reason for users to update the OpenCore installed on their machine unless you feel there's a benefit with new versions for your setup.
 
@@ -19,4 +19,4 @@ nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:OCLP-Version
 
 ![](../images/oclp-version.png)
 
-From this, we can see we're running a RELEASE version of OpenCore 0.6.8 built on March 27th, 2021 with Patcher Version 0.0.20!
+From this, we can see we're running a RELEASE version of OpenCore 0.6.8 built on March 27th, 2021 with Patcher Version 0.0.20!

docs/WINDOWS.md

@@ -75,7 +75,7 @@ Once done, lets reboot into OpenCore's Menu and you'll see a new Windows' entry:
 
 ![](../images/oc-windows.png)
 
-From there, install Windows as normal and you'll get a new BootCamp entry in OpenCore's picker when done! 
+From there, install Windows as normal and you'll get a new BootCamp entry in OpenCore's picker when done!
 
 * Don't forget to run BootCamp's utilities installer as well to ensure Wifi and such are functioning correctly. This can be downloaded from the BootCamp Assistant app in macOS
 

payloads/Config/config.plist

@@ -842,6 +842,24 @@
 				<key>PlistPath</key>
 				<string>Contents/Info.plist</string>
 			</dict>
+			<dict>
+				<key>Arch</key>
+				<string>x86_64</string>
+				<key>Comment</key>
+				<string>BacklightInjector</string>
+				<key>Enabled</key>
+				<false/>
+				<key>MaxKernel</key>
+				<string></string>
+				<key>MinKernel</key>
+				<string></string>
+				<key>BundlePath</key>
+				<string>BacklightInjector.kext</string>
+				<key>ExecutablePath</key>
+				<string></string>
+				<key>PlistPath</key>
+				<string>Contents/Info.plist</string>
+			</dict>
 		</array>
 		<key>Block</key>
 		<array/>
@@ -954,9 +972,11 @@
 			<key>LegacyCommpage</key>
 			<false/>
 			<key>PanicNoKextDump</key>
-			<false/>
+			<true/>
 			<key>PowerTimeoutKernelPanic</key>
 			<false/>
+			<key>ProvideCurrentCpuInfo</key>
+			<false/>
 			<key>SetApfsTrimTimeout</key>
 			<integer>-1</integer>
 			<key>ThirdPartyDrives</key>
@@ -997,7 +1017,7 @@
 			<key>PickerMode</key>
 			<string>External</string>
 			<key>PickerVariant</key>
-			<string>Modern</string>
+			<string>Acidanthera\GoldenGate</string>
 			<key>PollAppleHotKeys</key>
 			<true/>
 			<key>ShowPicker</key>
@@ -1072,6 +1092,8 @@
 				<string>BootKicker.efi</string>
 				<key>Enabled</key>
 				<true/>
+				<key>Flavour</key>
+				<string>Auto</string>
 				<key>Path</key>
 				<string>BootKicker.efi</string>
 				<key>RealPath</key>
@@ -1088,6 +1110,8 @@
 				<string>OpenShell.efi</string>
 				<key>Comment</key>
 				<string>OpenShell.efi</string>
+				<key>Flavour</key>
+				<string>OpenShell:UEFIShell:Shell</string>
 				<key>Enabled</key>
 				<true/>
 				<key>Path</key>
@@ -1095,7 +1119,7 @@
 				<key>RealPath</key>
 				<false/>
 				<key>TextMode</key>
-				<false/>
+				<true/>
 			</dict>
 		</array>
 	</dict>
@@ -1120,7 +1144,7 @@
 				<key>SystemAudioVolume</key>
 				<data>Rg==</data>
 				<key>boot-args</key>
-				<string>keepsyms=1 debug=0x100</string>
+				<string>keepsyms=1 debug=0x100 -no_compat_check -lilubetaall</string>
 				<key>csr-active-config</key>
 				<data>AAAAAA==</data>
 			</dict>
@@ -1624,7 +1648,7 @@
 			<key>ForceResolution</key>
 			<false/>
 			<key>GopPassThrough</key>
-			<false/>
+			<string>Disabled</string>
 			<key>IgnoreTextInGraphics</key>
 			<false/>
 			<key>ProvideConsoleGop</key>
@@ -1650,6 +1674,8 @@
 			<true/>
 			<key>AppleDebugLog</key>
 			<true/>
+			<key>AppleEg2Info</key>
+			<false/>
 			<key>AppleFramebufferInfo</key>
 			<false/>
 			<key>AppleImageConversion</key>