Avoid patching on macOS 12

Can harmfully damage the OS if not properly validated first

.github/workflows/build-app.yml

@@ -18,17 +18,12 @@ jobs:
       #     python3 -m pip install -U pip
       #     pip3 install pyinstaller
 
-      - run: pyinstaller Opencore-Patcher.spec
+      - run: pyinstaller OpenCore-Patcher.spec
       - run: ./after_pyinstaller.sh
       - run: 'codesign -s "Developer ID Application: Mykola Grymalyuk (S74BDJXQMD)" -v --deep --timestamp --entitlements entitlements.plist -o runtime "dist/OpenCore-Patcher.app"'
 
       - 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:

.gitignore

@@ -1,6 +1,6 @@
 .DS_Store
 OCLP-GUI.command
-/payloads/Apple-Binaries-OCLP-main
+/payloads/Apple
 /payloads/__MACOSX
 /App
 /Build-Folder
@@ -8,6 +8,7 @@ OCLP-GUI.command
 /dist
 /.vscode
 __pycache__/
+*.kext
 *.py[cod]
 *$py.class
 /docs/.vuepress/dist

CHANGELOG.md

@@ -1,5 +1,104 @@
 # 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
+
+## 0.1.3
+- Fix internal PCIe devices reporting as external
+  - Opt for `built-in` when device path is detectable
+  - Innie 0ccd95e (1.3.0 release - 01-16-2021)
+- Fix MacBookPro5,4 audio support
+- Increment binaries
+  - AppleALC 58b57ee (1.6.1 rolling - 05-07-2021)
+  - Apple Binaries 74bd80f (0.0.6 release - 05-09-2021)
+- Support custom CPU names in About This Mac
+- Fix NightShift accidentally disabling on Minimal SMBIOS configs
+- Fix iMac9,1 audio support
+- Heavily expand Graphics ID list
+- Fix iMac7,1 and iMac8,1 audio support
+- Work-around Bluetooth Kernel Panic on Apple's Bluetooth 2.0 Controllers (USB 05AC:8206)
+  - Affects iMac7,1 and MacPro3,1
+- Fix iMac external display support
+- Fix NVMe properties not applying when OpenCore is installed
+
+## 0.1.2
+- Fix IDE support on 2008 era MacBooks, iMacs and Xserves
+- Fix reduced output speeds on BCM94360 series Wifi cards
+- Fix accidentally disabling non-existent iGPU in iMac11,2
+- Remove USB ACPI Patching requirement for Minimal SMBIOS setups
+- Probe hardware for Backlight pathing on iMac10,1, iMac11,x and iMac12,x with Metal GPUs
+- Add Windows UEFI Audio support to Sandy and Ivy Bridge Macs
+- Add 3rd Party NVMe Power Management Patches
+  - NVMeFix fafc52d (1.0.7 release - 05-03-2021)
+- Strip unused ACPI and Kernel entries during build
+- Allow native Macs to use OpenCore
+  - Better 3rd party NVMe support
+  - Better Wireless networking support
+- Fix MacBook6,1 audio support
+- Increment binaries
+  - OpenCore 65cc81b (0.6.9 release - 05-03-2021)
+  - Lilu c77722d (1.5.3 release - 05-03-2021)
+  - AppleALC 84850d0 (1.6.0 rolling - 04-30-2021)
+  - RestrictEvents 9e2bb0f (1.0.1 release - 05-03-2021)
+- Allow CPUFriend on all El-Capitan Era Macs
+- Fix UEFI 2.0 Application support on upgraded Nvidia GPUs
+- Add experimental Sidecar support
+  - Requires Mac with Metal Intel iGPU and the iPad to be directly plugged in, wireless highly unstable
+  - SidecarFixup efdf11c (1.0.0 release - 05-02-2021)
+
+## 0.1.1
+- Fix iMac11,3 GFX0 pathing
+- Add MouSSE support to iMac10,1 with Metal AMD GPU
+- Fix iMac11,1 and iMac11,3 Nvidia boot issues after PRAM reset
+- Fix DRM support on Nvidia-only configurations
+  - Support optional setting between DRM and QuickSync support on iMacs13,x and iMac14,x
+- Add public beta support for Legacy GPU Acceleration (v0.0.4)
+  - Note ATI/AMD TeraScale 2 unsupported (HD 5/6000)
+- Add better kmutil crash handling
+- Fix build crashing when no wifi card is present
+- Allow Legacy Acceleration Patches on Mac Pros and Xserves
+- Fix USB kernel panics on iMac7,1
+- Fix AppleALC support in Mojave
+- Fix TeraScale 1 GPU detection
+- Enable Graphics Acceleration on legacy GPUs by default
+- Fix incorrectly disabling SIP/SMB on Metal GPUs
+- Fix error output when rebuilding kernel cache fails
+- Fix Acceleration Linking for Intel Ironlake iGPUs
+
+## 0.1.0
+- Fix crash on iMacs with Metal GPUs
+
 ## 0.0.23
 - Fix MacBookPro4,1 15" and 17" audio support
 - Fix iMac7,1 24" and iMac9,1 24" audio support
@@ -31,7 +130,7 @@
 ## 0.0.21
 - Fix botched images in OpenCanopy
 - Add support for 3rd party OpenCore usage detection during building
-  - Mainly for users transtioning from Ausdauersportler's OpenCore configuration
+  - Mainly for users transitioning from Ausdauersportler's OpenCore configuration
 
 ## 0.0.20
 - Fix CPU Calculation on early MCP79 chipsets (ie. iMac9,1, MacBook5,x)
@@ -178,4 +277,4 @@
 - Add El Capitan era wireless cards
 
 ## 0.0.1
-- Inital developer preview
+- Initial developer preview

OCLP-CLI.command

@@ -5,12 +5,11 @@ from __future__ import print_function
 
 import subprocess
 import sys
-import time
 import platform
 import argparse
 from pathlib import Path
 
-from Resources import Build, ModelArray, Constants, SysPatch, Utilities, CliMenu
+from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, DeviceProbe
 
 
 class OpenCoreLegacyPatcher():
@@ -28,10 +27,14 @@ class OpenCoreLegacyPatcher():
         if self.current_model in ModelArray.NoAPFSsupport:
             self.constants.serial_settings = "Moderate"
         if self.current_model in ModelArray.LegacyGPU:
-            Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).check_pciid(False)
-            if not (self.constants.dgpu_devices and self.constants.dgpu_vendor == self.constants.pci_amd_ati and self.constants.dgpu_device in ModelArray.AMDMXMGPUs) or not (self.constants.dgpu_devices and self.constants.dgpu_vendor == self.constants.pci_nvidia and self.constants.dgpu_device in ModelArray.NVIDIAMXMGPUs):
-                self.constants.sip_status = False
-                self.constants.secure_status = False
+            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+            if dgpu_vendor:
+                if (dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids)) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids):
+                    self.constants.sip_status = True
+                    self.constants.secure_status = True
+                else:
+                    self.constants.sip_status = False
+                    self.constants.secure_status = False
 
         # Logic for when user runs custom OpenCore build and do not expose it
         # Note: This logic currently only applies for iMacPro1,1 users, see below threads on the culprits:
@@ -47,6 +50,15 @@ class OpenCoreLegacyPatcher():
             if not true_model.startswith("Unknown"):
                 self.current_model = true_model
 
+        custom_cpu_model_value: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:revcpuname".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+
+        if not custom_cpu_model_value.startswith("nvram: Error getting variable"):
+            custom_cpu_model_value = [line.strip().split(":revcpuname	", 1)[1] for line in custom_cpu_model_value.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
+            if custom_cpu_model_value.split("%00")[0] != "":
+                self.constants.custom_cpu_model = 1
+                self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
+
+
         parser = argparse.ArgumentParser()
 
         # Generic building args
@@ -59,6 +71,8 @@ class OpenCoreLegacyPatcher():
         parser.add_argument('--disable_sip', help='Disable SIP', action='store_true', required=False)
         parser.add_argument('--disable_smb', help='Disable SecureBootModel', action='store_true', required=False)
         parser.add_argument('--vault', help='Enable OpenCore Vaulting', action='store_true', required=False)
+        parser.add_argument('--support_all', help='Allow OpenCore on natively supported Models', action='store_true', required=False)
+        parser.add_argument('--force_legacy', help='Allow acceleration on Mac Pros and Xserves', action='store_true', required=False)
 
         # Building args requiring value values
         parser.add_argument('--model', action='store', help='Set custom model', required=False)
@@ -68,7 +82,6 @@ class OpenCoreLegacyPatcher():
         # SysPatch args
         parser.add_argument('--patch_sys_vol', help='Patches root volume', action='store_true', required=False)
         parser.add_argument('--unpatch_sys_vol', help='Unpatches root volume, EXPERIMENTAL', action='store_true', required=False)
-        parser.add_argument('--custom_repo', action='store', help='Set SMBIOS patching mode', required=False)
 
         args = parser.parse_args()
 
@@ -129,6 +142,15 @@ class OpenCoreLegacyPatcher():
             else:
                 print(f"- Unknown SMBIOS arg passed: {args.smbios_spoof}")
 
+        if args.support_all:
+            print("- Building for natively supported model")
+            self.constants.allow_oc_everywhere = True
+            self.constants.serial_settings = "None"
+
+        if args.force_legacy:
+            print("- Allowing legacy acceleration patches on newer models")
+            self.constants.assume_legacy = True
+
         if args.build:
             if args.model:
                 print(f"- Using custom model: {args.model}")
@@ -139,14 +161,16 @@ class OpenCoreLegacyPatcher():
                 self.build_opencore()
         if args.patch_sys_vol:
             print("- Set System Volume patching")
-            if args.custom_repo:
-                self.constants.url_apple_binaries = args.custom_repo
-            print(f"- Custom set repo to: {self.constants.url_apple_binaries}")
-            SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_patch()
+            self.patch_vol()
         elif args.unpatch_sys_vol:
             print("- Set System Volume unpatching")
-            SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_unpatch()
+            self.unpatch_vol()
 
+    def patch_vol(self):
+        SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_patch()
+
+    def unpatch_vol(self):
+        SysPatch.PatchSysVolume(self.constants.custom_model or self.current_model, self.constants).start_unpatch()
 
     def build_opencore(self):
         Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).build_opencore()

OpenCore-Patcher.command

@@ -3,31 +3,27 @@
 
 from __future__ import print_function
 
+import plistlib
 import subprocess
 import sys
-import time
 import platform
 
-from Resources import Build, ModelArray, Constants, SysPatch, Utilities, CliMenu
+from Resources import Build, ModelArray, PCIIDArray, Constants, SysPatch, Utilities, CliMenu, DeviceProbe
 
 
 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 = subprocess.run("system_profiler SPHardwareDataType".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
-            self.current_model = [line.strip().split(": ", 1)[1] for line in self.current_model.stdout.decode().split("\n") if line.strip().startswith("Model Identifier")][0]
+        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:
-            Build.BuildOpenCore(self.constants.custom_model or self.current_model, self.constants).check_pciid(False)
-            if not (self.constants.dgpu_devices and self.constants.dgpu_vendor == self.constants.pci_amd_ati and self.constants.dgpu_device in ModelArray.AMDMXMGPUs) or not (self.constants.dgpu_devices and self.constants.dgpu_vendor == self.constants.pci_nvidia and self.constants.dgpu_device in ModelArray.NVIDIAMXMGPUs):
+            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+
+            if (dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids)) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids):
+                self.constants.sip_status = True
+                self.constants.secure_status = True
+            else:
                 self.constants.sip_status = False
                 self.constants.secure_status = False
 
@@ -45,6 +41,26 @@ class OpenCoreLegacyPatcher():
             if not true_model.startswith("Unknown"):
                 self.current_model = true_model
 
+        custom_cpu_model_value: str = subprocess.run("nvram 4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:revcpuname".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+
+        if not custom_cpu_model_value.startswith("nvram: Error getting variable"):
+            custom_cpu_model_value = [line.strip().split(":revcpuname	", 1)[1] for line in custom_cpu_model_value.split("\n") if line.strip().startswith("4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102:")][0]
+            if custom_cpu_model_value.split("%00")[0] != "":
+                self.constants.custom_cpu_model = 1
+                self.constants.custom_cpu_model_value = custom_cpu_model_value.split("%00")[0]
+
+        # 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()
 
@@ -68,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
@@ -84,14 +98,37 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
                 [f"Enable Verbose Mode:\t\tCurrently {self.constants.verbose_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_verbose],
                 [f"Enable OpenCore DEBUG:\t\tCurrently {self.constants.opencore_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_oc],
                 [f"Enable Kext DEBUG:\t\t\tCurrently {self.constants.kext_debug}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_kext],
-                [f"Force iMac Metal Patch:\t\tCurrently {self.constants.imac_vendor}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_metal],
-                [f"Assume Upgraded Wifi Always:\tCurrently {self.constants.wifi_build}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_wifi],
                 [f"Set ShowPicker Mode:\t\tCurrently {self.constants.showpicker}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_showpicker],
                 [f"Set Vault Mode:\t\t\tCurrently {self.constants.vault}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_vault],
                 [f"Set SIP and SecureBootModel:\tSIP: {self.constants.sip_status} SBM: {self.constants.secure_status}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_sip],
+                [f"Allow OpenCore on native Models:\tCurrently {self.constants.allow_oc_everywhere}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_native_models],
+                [f"Advanced Patch Settings, for developers only", self.advanced_patcher_settings],
+            ]
+
+            for option in options:
+                menu.add_menu_option(option[0], function=option[1])
+
+            response = menu.start()
+
+    def advanced_patcher_settings(self):
+        response = None
+        while not (response and response == -1):
+            title = [
+                "Adjust Advanced Patcher Settings, for developers ONLY"
+            ]
+            menu = Utilities.TUIMenu(title, "Please select an option: ", auto_number=True, top_level=True)
+            options = [
+                [f"Assume Metal GPU Always:\t\tCurrently {self.constants.imac_vendor}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_metal],
+                [f"Assume Upgraded Wifi Always:\tCurrently {self.constants.wifi_build}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_wifi],
                 [f"Set SMBIOS Mode:\t\t\tCurrently {self.constants.serial_settings}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).change_serial],
-                [f"Set Generic Bootstrap:\t\t{self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).bootstrap_setting],
-                ["Set Custom Patch Repo", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).custom_repo],
+                [f"DRM Preferences:\t\t\tCurrently {self.constants.drm_support}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).drm_setting],
+                [f"Set Generic Bootstrap:\t\tCurrently {self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).bootstrap_setting],
+                [f"Assume Legacy GPU:\t\t\tCurrently {self.constants.assume_legacy}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).force_accel_setting],
+                #[f"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:
@@ -109,14 +146,18 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
   - ASentientBot:\tLegacy Acceleration Patches
   - Ausdauersportler:\tLinking fixes for SNBGraphicsFB and AMDX3000
   - Syncretic:\t\tAAAMouSSE and telemetrap
-  - cdf:\t\tNightShiftEnabler"""]).start()
+  - cdf:\t\tNightShiftEnabler and Innie"""]).start()
 
     def PatchVolume(self):
         Utilities.cls()
         Utilities.header(["Patching System Volume"])
         print("""Patches Root volume to fix misc issues such as:
 
-- Brightness control for non-Metal GPUs
+- Graphics Acceleration for non-Metal GPUs
+  - Nvidia: Tesla - Fermi (8000-500 series)
+  - Intel: Ironlake - Sandy Bridge
+  - AMD: TeraScale 1 (2000-4000 series)
+- Audio support for iMac7,1 and iMac8,1
 
 WARNING: Root Volume Patching is still in active development, please
 have all important user data backed up. Note when the system volume
@@ -147,9 +188,9 @@ B. Exit
                 f"Target OS: macOS {self.constants.os_support}",
             ]
 
-            if (self.constants.custom_model or self.current_model) not in ModelArray.SupportedSMBIOS:
+            if (self.constants.custom_model or self.current_model) not in ModelArray.SupportedSMBIOS and self.constants.allow_oc_everywhere is False:
                 in_between = [
-                    'Your model is not supported by this patcher!',
+                    'Your model is not supported by this patcher for running unsupported OSes!',
                     '',
                     'If you plan to create the USB for another machine, please select the "Change Model" option in the menu.'
                 ]
@@ -170,7 +211,7 @@ B. Exit
             menu = Utilities.TUIMenu(title, "Please select an option: ", in_between=in_between, auto_number=True, top_level=True)
 
             options = (
-                [["Build OpenCore", self.build_opencore]] if ((self.constants.custom_model or self.current_model) in ModelArray.SupportedSMBIOS) else []) + [
+                [["Build OpenCore", self.build_opencore]] if ((self.constants.custom_model or self.current_model) in ModelArray.SupportedSMBIOS) or self.constants.allow_oc_everywhere is True else []) + [
                 ["Install OpenCore to USB/internal drive", self.install_opencore],
                 ["Post-Install Volume Patch", self.PatchVolume],
                 ["Change Model", self.change_model],
@@ -183,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,60 +1,60 @@
-# OpenCore Legacy Patcher
+<div align="center">
+             <img src="images/OC-Patcher.png" alt="OpenCore Patcher Logo" width="256" />
+             <h1>OpenCore Legacy Patcher</h1>
+</div>
 
-<img src="images/OC-Patcher.png" width="256">
-
-A python program for building and booting [OpenCore](https://github.com/acidanthera/OpenCorePkg) on legacy Macs, see [Supported SMBIOS](https://dortania.github.io/OpenCore-Legacy-Patcher/MODELS.html) on whether your model is supported. Designed around Big Sur support, however can be used on older OSes.
-  
-| 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 |
-| 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. |
+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.
 
 Supported features:
 
 * System Integrity Protection, FileVault 2, .im4m Secure Boot and Vaulting
+* WPA Wifi and Personal Hotspot support
 * Native OTA OS DELTA updates on all Macs
 * Recovery OS, Safe Mode and Single-user Mode booting
 * Zero firmware patching required (ie. APFS ROM patching)
 * GPU Switching on MacBook Pro models (2012 and newer)
 
-Note: Only clean-installs and upgrades are supported, installs already patched with other patchers, such as [Patched Sur](https://github.com/BenSova/Patched-Sur) or [bigmac](https://github.com/StarPlayrX/bigmac), cannot be used due to broken file integrity with APFS snapshots and SIP.
+Note: Only clean-installs and upgrades are supported, macOS Big Sur installs already patched with other patchers, such as [Patched Sur](https://github.com/BenSova/Patched-Sur) or [bigmac](https://github.com/StarPlayrX/bigmac), cannot be used due to broken file integrity with APFS snapshots and SIP.
 
 * You can however reinstall macOS with this patcher and retain your original data
 
 Note 2: Currently OpenCore Legacy Patcher officially supports patching to run macOS 11, Big Sur installs. For older OSes, OpenCore may function however support is currently not provided from Dortania.
 
-For Mojave and Catalina support, we recommend the use of [dosdude1's patchers](http://dosdude1.com)
-
-## How to use
-
-See the online guide on how:
-
-* [OpenCore Legacy Patcher Guide](https://dortania.github.io/OpenCore-Legacy-Patcher/)
-
-## Patcher Warnings
-
-Since this patcher tricks macOS into thinking you're running a newer Mac, certain functionality may be broken:
-
-* Boot Camp Assistant.app
-  * We recommend running the assistant on a natively supported OS, running via the patcher may result in unforeseen issues
-* Legacy Windows Booting
-  * Currently OpenCore cannot boot MBR-based installs, so Ivy Bridge and older Machines may [not be able to see Windows in OpenCore's Boot Picker](https://github.com/acidanthera/bugtracker/issues/912)
-  * [Solution is to convert install to UEFI](https://docs.microsoft.com/en-us/mem/configmgr/osd/deploy-use/task-sequence-steps-to-manage-bios-to-uefi-conversion), see MacRumors thread for more examples: [Installing Windows 10](https://forums.macrumors.com/threads/opencore-on-the-mac-pro.2207814/)
-* Boot Buddy support
-  * Due to how OpenCore overwrites NVRAM, the usage of Boot Buddy and such tools are **highly** in-advised
+* For Mojave and Catalina support, we recommend the use of [dosdude1's patchers](http://dosdude1.com)
 
 ## Support
 
-To get aid with the patcher, we recommend joining the [Unsupported Mac Discord Server](https://discord.gg/XbbWAsE) and heading over to our `#opencore-patcher` channel. We're actively there and is the quickest way to receive help. For bigger issues such as patcher crashing on build and such, we recommend opening an issue right here on GitHub:
+To get aid with the patcher, we recommend joining the [OpenCore Patcher Paradise Discord Server](https://discord.gg/rqdPgH8xSN). We're actively there and is the quickest way to receive help. For bigger issues such as patcher crashing on build and such, we recommend opening an issue right here on GitHub(Please review [How to debug with OpenCore](https://dortania.github.io/OpenCore-Legacy-Patcher/DEBUG.html) before opening issues):
 
 * [OpenCore Legacy Patcher's Issue's tab](https://github.com/dortania/OpenCore-Legacy-Patcher/issues)
 
-Regarding how to debug OpenCore Patcher, we recommend seeing the below:
+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)
 
-* [How to debug with OpenCore](https://dortania.github.io/OpenCore-Legacy-Patcher/DEBUG.html)
+## Credits
 
-## Supporting us!
-
-To help support this patcher, we recommend checking this page:
-
-* [Supporting the patcher](https://dortania.github.io/OpenCore-Legacy-Patcher/DONATE.html)
+* [Acidanthera](https://github.com/Acidanthera)
+  * OpenCorePkg as well as many of the core kexts and tools
+* [DhinakG](https://github.com/DhinakG)
+  * Main co-author
+* [Khronokernel](https://github.com/Khronokernel)
+  * 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)
+  * Mac Pro on OpenCore Patch set and documentation
+  * [Innie](https://github.com/cdf/Innie) and [NightShiftEnabler](https://github.com/cdf/NightShiftEnabler)
+* [Syncretic](https://forums.macrumors.com/members/syncretic.1173816/)
+  * [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
+* [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

Resources/Build.py

@@ -8,13 +8,11 @@ import shutil
 import subprocess
 import uuid
 import zipfile
-import os
-import sys
-import platform
+import ast
 from pathlib import Path
 from datetime import date
 
-from Resources import Constants, ModelArray, Utilities
+from Resources import Constants, ModelArray, PCIIDArray, Utilities, DeviceProbe
 
 
 def human_fmt(num):
@@ -37,39 +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 check_pciid(self, print_status):
-        try:
-            self.constants.igpu_devices = plistlib.loads(subprocess.run("ioreg -r -n IGPU -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            self.constants.igpu_devices = [i for i in self.constants.igpu_devices if i["class-code"] == binascii.unhexlify("00000300")]
-            self.constants.igpu_vendor = self.hexswap(binascii.hexlify(self.constants.igpu_devices[0]["vendor-id"]).decode()[:4])
-            self.constants.igpu_device = self.hexswap(binascii.hexlify(self.constants.igpu_devices[0]["device-id"]).decode()[:4])
-            if print_status is True:
-                print(f"- Detected iGPU: {self.constants.igpu_vendor}:{self.constants.igpu_device}")
-        except ValueError:
-            if print_status is True:
-                print("- No iGPU detected")
-            self.constants.igpu_devices = ""
-
-        try:
-            self.constants.dgpu_devices = plistlib.loads(subprocess.run("ioreg -r -n GFX0 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            self.constants.dgpu_devices = [i for i in self.constants.dgpu_devices if i["class-code"] == binascii.unhexlify("00000300")]
-            self.constants.dgpu_vendor = self.hexswap(binascii.hexlify(self.constants.dgpu_devices[0]["vendor-id"]).decode()[:4])
-            self.constants.dgpu_device = self.hexswap(binascii.hexlify(self.constants.dgpu_devices[0]["device-id"]).decode()[:4])
-            if print_status is True:
-                print(f"- Detected dGPU: {self.constants.dgpu_vendor}:{self.constants.dgpu_device}")
-        except ValueError:
-            if print_status is True:
-                print("- No dGPU detected")
-            self.constants.dgpu_devices = ""
+    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()
+        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")
@@ -81,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}")
@@ -95,6 +117,10 @@ class BuildOpenCore:
 
         # Set revision in config
         self.config["#Revision"]["Build-Version"] = f"{self.constants.patcher_version} - {date.today()}"
+        if not self.constants.custom_model:
+            self.config["#Revision"]["Build-Type"] = "OpenCore Built on Target Machine"
+        else:
+            self.config["#Revision"]["Build-Type"] = "OpenCore Built for External Machine"
         self.config["#Revision"]["OpenCore-Version"] = f"{self.constants.opencore_version} - {self.constants.opencore_build} - {self.constants.opencore_commit}"
         self.config["#Revision"]["Original-Model"] = self.model
         self.config["NVRAM"]["Add"]["4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102"]["OCLP-Version"] = f"{self.constants.patcher_version}"
@@ -102,16 +128,16 @@ class BuildOpenCore:
         for name, version, path, check in [
             # Essential kexts
             ("Lilu.kext", self.constants.lilu_version, self.constants.lilu_path, lambda: True),
-            ("WhateverGreen.kext", self.constants.whatevergreen_version, self.constants.whatevergreen_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"),
-            ("NightShiftEnabler.kext", self.constants.nightshift_version, self.constants.nightshift_path, lambda: self.model not in ModelArray.NightShiftExclude),
-            ("SMC-Spoof.kext", self.constants.smcspoof_version, self.constants.smcspoof_path, lambda: True),
+            ("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
             ("AppleMCEReporterDisabler.kext", self.constants.mce_version, self.constants.mce_path, lambda: self.model in ModelArray.DualSocket),
             ("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path, lambda: self.model in ModelArray.SSEEmulator),
             ("telemetrap.kext", self.constants.telemetrap_version, self.constants.telemetrap_path, lambda: self.model in ModelArray.MissingSSE42),
-            ("CPUFriend.kext", self.constants.cpufriend_version, self.constants.cpufriend_path, lambda: self.model not in ModelArray.NoAPFSsupport),
+            ("CPUFriend.kext", self.constants.cpufriend_version, self.constants.cpufriend_path, lambda: self.model != "iMac7,1" and self.constants.allow_oc_everywhere is False and self.constants.disallow_cpufriend is False),
             # Ethernet patches
             ("nForceEthernet.kext", self.constants.nforce_version, self.constants.nforce_path, lambda: self.model in ModelArray.EthernetNvidia),
             ("MarvelYukonEthernet.kext", self.constants.marvel_version, self.constants.marvel_path, lambda: self.model in ModelArray.EthernetMarvell),
@@ -120,22 +146,93 @@ class BuildOpenCore:
             ("AppleALC.kext", self.constants.applealc_version, self.constants.applealc_path, lambda: self.model in ModelArray.LegacyAudio or self.model in ModelArray.MacPro71),
             # IDE patch
             ("AppleIntelPIIXATA.kext", self.constants.piixata_version, self.constants.piixata_path, lambda: self.model in ModelArray.IDEPatch),
+            # Misc
+            ("SidecarFixup.kext", self.constants.sidecarfixup_version, self.constants.sidecarfixup_path, lambda: self.model in ModelArray.SidecarPatch),
         ]:
             self.enable_kext(name, version, path, check)
 
+        if self.constants.allow_oc_everywhere is False:
+            self.get_item_by_kv(self.config["Kernel"]["Patch"], "Identifier", "com.apple.driver.AppleSMC")["Enabled"] = True
+
+
+        if not self.constants.custom_model and (self.constants.allow_oc_everywhere is True or self.model in ModelArray.MacPro71):
+            # Use Innie's same logic:
+            # https://github.com/cdf/Innie/blob/v1.3.0/Innie/Innie.cpp#L90-L97
+            storage_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            storage_devices = [i for i in storage_devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_sata) or i["class-code"] == binascii.unhexlify(self.constants.classcode_nvme)]
+            storage_path_gfx: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+            try:
+                x = 1
+                for i in storage_devices:
+                    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]
+                        self.config["DeviceProperties"]["Add"][storage_path] = { "built-in": 1}
+                    except IndexError:
+                        print(f"- Failed to find Device path for PCIe Storage Controller {x}, falling back to Innie")
+                        if self.get_kext_by_bundle_path("Innie.kext")["Enabled"] is False:
+                            self.enable_kext("Innie.kext", self.constants.innie_version, self.constants.innie_path)
+                    x = x + 1
+            except ValueError:
+                print("- No PCIe Storage Controllers found to fix(V)")
+            except IndexError:
+                print("- No PCIe Storage Controllers found to fix(I)")
+
+        if not self.constants.custom_model:
+            nvme_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            nvme_devices = [i for i in nvme_devices if i.get("IORegistryEntryChildren", None) and i["vendor-id"] != binascii.unhexlify("6B100000") and i["IORegistryEntryChildren"][0]["IORegistryEntryName"] == "IONVMeController"]
+            try:
+                x = 1
+                for i in nvme_devices:
+                    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:
+                        nvme_acpi = i["acpi-path"]
+                        nvme_acpi = DeviceProbe.pci_probe().acpi_strip(nvme_acpi)
+                    except KeyError:
+                        print(f"- No ACPI entry found for NVMe SSD ({x})")
+                        nvme_acpi = ""
+                    # Disable Bit 0 (L0s), enable Bit 1 (L1)
+                    if not isinstance(nvme_aspm, int):
+                        nvme_aspm = int.from_bytes(nvme_aspm, byteorder='little')
+                    nvme_aspm = (nvme_aspm & (~3)) | 2
+                    #nvme_aspm &= ~1  # Turn off bit 1
+                    #nvme_aspm |= 2  # Turn on bit 2
+                    self.config["#Revision"][f"Hardware-NVMe-{x}"] = f'{nvme_vendor}:{nvme_device}'
+                    try:
+                        nvme_path = DeviceProbe.pci_probe().deviceproperty_probe(nvme_vendor, nvme_device, nvme_acpi)
+                        if nvme_path == "":
+                            raise IndexError
+                        nvme_path_parent = DeviceProbe.pci_probe().device_property_parent(nvme_path)
+                        print(f"- Found NVMe ({x}) at {nvme_path}")
+                        self.config["DeviceProperties"]["Add"][nvme_path] = {"pci-aspm-default": nvme_aspm, "built-in": 1}
+                        self.config["DeviceProperties"]["Add"][nvme_path_parent] = {"pci-aspm-default": nvme_aspm}
+                    except IndexError:
+                        if "-nvmefaspm" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
+                            print("- Falling back to -nvmefaspm")
+                            self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -nvmefaspm"
+                    if self.get_kext_by_bundle_path("NVMeFix.kext")["Enabled"] is False:
+                        self.enable_kext("NVMeFix.kext", self.constants.nvmefix_version, self.constants.nvmefix_path)
+                    x = x + 1
+            except ValueError:
+                print("- No 3rd Party NVMe drive found(V)")
+            except IndexError:
+                print("- No 3rd Party NVMe drive found(I)")
+
         def wifi_fake_id(self):
             default_path = True
             self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
             self.get_kext_by_bundle_path("AirportBrcmFixup.kext/Contents/PlugIns/AirPortBrcmNIC_Injector.kext")["Enabled"] = True
             if not self.constants.custom_model:
-                # Try finding
-                arpt_path: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
-                try:
-                    arpt_path = [line.strip().split("= ", 1)[1] for line in arpt_path.split("\n") if f"{wifi_vendor}:{wifi_device}".lower() in line.strip()][0]
+                arpt_path = DeviceProbe.pci_probe().deviceproperty_probe(wifi_vendor, wifi_device, wifi_acpi)
+                if arpt_path:
                     print(f"- Found ARPT device at {arpt_path}")
                     default_path = False
-                except IndexError:
-                    print("- Failed to find Device path")
+                else:
                     default_path = True
             if default_path is True:
                 if self.model in ModelArray.nvidiaHDEF:
@@ -157,44 +254,37 @@ class BuildOpenCore:
 
         # WiFi patches
         # TODO: -a is not supported in Lion and older, need to add proper fix
-        if self.constants.detected_os > self.constants.lion:
-            try:
-                wifi_devices = plistlib.loads(subprocess.run("ioreg -r -n ARPT -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            except ValueError:
-                # Work-around Mac Pros where Wifi card may not be named ARPT (ie. installed in dedicated PCIe card slot)
-                wifi_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            vendor_atheros = binascii.unhexlify("E4140000")
-            vendor_broadcom = binascii.unhexlify("8C160000")
-            wifi_devices = [i for i in wifi_devices if i["vendor-id"] == vendor_atheros or i["vendor-id"] == vendor_broadcom and i["class-code"] == binascii.unhexlify("00800200")]
-            wifi_vendor = self.hexswap(binascii.hexlify(wifi_devices[0]["vendor-id"]).decode()[:4])
-            wifi_device = self.hexswap(binascii.hexlify(wifi_devices[0]["device-id"]).decode()[:4])
-            wifi_ioname = wifi_devices[0]["IOName"]
-            if not self.constants.custom_model:
-                print(f"- Detected Wifi Card: {wifi_vendor}:{wifi_device}")
-
+        if self.constants.detected_os > self.constants.lion and not self.constants.custom_model:
+            wifi_vendor,wifi_device,wifi_ioname,wifi_acpi = DeviceProbe.pci_probe().wifi_probe()
+            if 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})"
         else:
-            wifi_devices = ""
-            print("- Can't run Wifi hardware detection on Snow Leopard and older")
+            wifi_vendor = ""
+            print("- Unable to run Wireless hardware detection")
         if self.constants.wifi_build is True:
             print("- Skipping Wifi patches on request")
-        elif not self.constants.custom_model and wifi_devices:
+        elif not self.constants.custom_model and wifi_vendor:
             if wifi_vendor == self.constants.pci_broadcom:
-                if wifi_device in ModelArray.BCM4360Wifi and wifi_ioname not in ["pci14e4,4353", "pci14e4,4331"]:
-                    print("- Found supported WiFi card, skipping wifi patches")
-                elif wifi_ioname in ["pci14e4,4353", "pci14e4,4331"] or wifi_device in ModelArray.BCM94331Wifi:
+                # This works around OCLP spoofing the Wifi card and therefore unable to actually detect the correct device
+                if wifi_device in PCIIDArray.broadcom_ids().BCM4360Wifi and wifi_ioname not in ["pci14e4,4353", "pci14e4,4331"]:
+                    self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
+                elif wifi_ioname in ["pci14e4,4353", "pci14e4,4331"] or wifi_device in PCIIDArray.broadcom_ids().BCM94331Wifi:
                     wifi_fake_id(self)
-                elif wifi_device in ModelArray.BCM94322Wifi:
+                elif wifi_device in PCIIDArray.broadcom_ids().BCM94322Wifi:
                     self.enable_kext("IO80211Mojave.kext", self.constants.io80211mojave_version, self.constants.io80211mojave_path)
                     self.get_kext_by_bundle_path("IO80211Mojave.kext/Contents/PlugIns/AirPortBrcm4331.kext")["Enabled"] = True
-                elif wifi_device in ModelArray.BCM94328Wifi:
+                elif wifi_device in PCIIDArray.broadcom_ids().BCM94328Wifi:
                     self.enable_kext("corecaptureElCap.kext", self.constants.corecaptureelcap_version, self.constants.corecaptureelcap_path)
                     self.enable_kext("IO80211ElCap.kext", self.constants.io80211elcap_version, self.constants.io80211elcap_path)
                     self.get_kext_by_bundle_path("IO80211ElCap.kext/Contents/PlugIns/AppleAirPortBrcm43224.kext")["Enabled"] = True
-            elif wifi_vendor == self.constants.pci_atheros and wifi_device in ModelArray.AtherosWifi:
+            elif wifi_vendor == self.constants.pci_atheros and wifi_device in PCIIDArray.atheros_ids().AtherosWifi:
                 self.enable_kext("IO80211HighSierra.kext", self.constants.io80211high_sierra_version, self.constants.io80211high_sierra_path)
                 self.get_kext_by_bundle_path("IO80211HighSierra.kext/Contents/PlugIns/AirPortAtheros40.kext")["Enabled"] = True
         else:
-            if self.model in ModelArray.WifiBCM94331:
+            if self.model in ["iMac14,1", "iMac14,2", "iMac14,3"]:
+                self.enable_kext("AirportBrcmFixup.kext", self.constants.airportbcrmfixup_version, self.constants.airportbcrmfixup_path)
+            elif self.model in ModelArray.WifiBCM94331:
                 wifi_fake_id(self)
             elif self.model in ModelArray.WifiBCM94322:
                 self.enable_kext("IO80211Mojave.kext", self.constants.io80211mojave_version, self.constants.io80211mojave_path)
@@ -209,7 +299,7 @@ class BuildOpenCore:
 
         # CPUFriend
         pp_map_path = Path(self.constants.platform_plugin_plist_path) / Path(f"{self.model}/Info.plist")
-        if self.model not in ModelArray.NoAPFSsupport:
+        if self.model != "iMac7,1" and self.constants.allow_oc_everywhere is False:
             Path(self.constants.pp_kext_folder).mkdir()
             Path(self.constants.pp_contents_folder).mkdir()
             shutil.copy(pp_map_path, self.constants.pp_contents_folder)
@@ -226,40 +316,69 @@ class BuildOpenCore:
             self.get_item_by_kv(self.config["ACPI"]["Add"], "Path", "SSDT-CPBG.aml")["Enabled"] = True
             shutil.copy(self.constants.pci_ssdt_path, self.constants.acpi_path)
 
+        if self.model in ModelArray.windows_audio:
+            # Based on: https://egpu.io/forums/pc-setup/fix-dsdt-override-to-correct-error-12/
+            print("- Enabling Windows 10 UEFI Audio support")
+            self.get_item_by_kv(self.config["ACPI"]["Add"], "Path", "SSDT-PCI.aml")["Enabled"] = True
+            self.get_item_by_kv(self.config["ACPI"]["Patch"], "Comment", "BUF0 to BUF1")["Enabled"] = True
+            shutil.copy(self.constants.windows_ssdt_path, self.constants.acpi_path)
+
         # USB Map
         usb_map_path = Path(self.constants.plist_folder_path) / Path("AppleUSBMaps/Info.plist")
-        if usb_map_path.exists():
+        # iMac7,1 kernel panics with USB map installed, remove for time being until properly debugged
+        if usb_map_path.exists() and self.constants.allow_oc_everywhere is False and self.model != "iMac7,1":
             print(f"- Adding USB-Map.kext")
             Path(self.constants.map_kext_folder).mkdir()
             Path(self.constants.map_contents_folder).mkdir()
             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:
             print("- Adding dual GPU patch")
-            self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"] = {"agdpmod": "pikera"}
+            if not self.constants.custom_model:
+                dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+                self.gfx0_path = DeviceProbe.pci_probe().deviceproperty_probe(dgpu_vendor,dgpu_device,dgpu_acpi)
+                if self.gfx0_path == "":
+                    print("- Failed to find GFX0 Device path, falling back on known logic")
+                    self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
+                else:
+                    print(f"- Found GFX0 Device Path: {self.gfx0_path}")
+            else:
+                self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
+            if self.model in ModelArray.IntelNvidiaDRM and self.constants.drm_support is True:
+                print("- Prioritizing DRM support over Intel QuickSync")
+                self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696", "shikigva": 256}
+                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"disable-gpu-min": "20.0.0"}
+            else:
+                self.config["DeviceProperties"]["Add"][self.gfx0_path] = {"agdpmod": "vit9696"}
 
         # HiDPI OpenCanopy and FileVault
         if self.model in ModelArray.HiDPIpicker:
@@ -276,58 +395,153 @@ class BuildOpenCore:
             else:
                 self.config["DeviceProperties"]["Add"][hdef_path] = {"apple-layout-id": 90, "use-apple-layout-id": 1, "use-layout-id": 1, }
 
-        def nvidia_patch(self):
+        def backlight_path_detection(self):
+            if not self.constants.custom_model:
+                dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+                self.gfx0_path = DeviceProbe.pci_probe().deviceproperty_probe(dgpu_vendor,dgpu_device,dgpu_acpi)
+                if self.gfx0_path == "":
+                    print("- Failed to find GFX0 Device path, falling back on known logic")
+                    if self.model in ["iMac11,1", "iMac11,3"]:
+                        self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
+                    elif self.model == "iMac10,1":
+                        self.gfx0_path = "PciRoot(0x0)/Pci(0xc,0x0)/Pci(0x0,0x0)"
+                    else:
+                        self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
+                else:
+                    print(f"- Found GFX0 Device Path: {self.gfx0_path}")
+
+            else:
+                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}")
+
+
+        def nvidia_patch(self, backlight_path):
             self.constants.custom_mxm_gpu = True
-            print("- Adding Nvidia Brightness Control patches")
-            if self.model == "iMac11,1":
-                backlight_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
-                self.config["DeviceProperties"]["Add"][backlight_path] = {"@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000")}
-                shutil.copy(self.constants.backlight_path, self.constants.kexts_path)
-                self.get_kext_by_bundle_path("AppleBacklightFixup.kext")["Enabled"] = True
-            elif self.model in ["iMac11,2", "iMac11,3", "iMac12,1", "iMac12,2"]:
-                backlight_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
-                self.config["DeviceProperties"]["Add"][backlight_path] = {"@0,backlight-control": binascii.unhexlify("01000000"), "@0,built-in": binascii.unhexlify("01000000")}
+            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] = {"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)"] = {"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] = {"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
-            else:
-                print("- Failed to determine supported model")
+            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
 
-        def amd_patch(self):
+        def amd_patch(self, backlight_path):
             self.constants.custom_mxm_gpu = True
             print("- Adding AMD DRM patches")
-            if self.model == "iMac11,1":
-                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"] = {"shikigva": 80, "unfairgva": 1}
-            elif self.model in ["iMac11,2", "iMac11,3", "iMac12,1", "iMac12,2"]:
-                self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"] = {"shikigva": 80, "unfairgva": 1}
+            self.config["DeviceProperties"]["Add"][backlight_path] = {"shikigva": 80, "unfairgva": 1}
+            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)"] = {"shikigva": 80, "unfairgva": 1}
+            if self.model in ["iMac12,1", "iMac12,2"]:
                 print("- Disabling unsupported iGPU")
                 self.config["DeviceProperties"]["Add"]["PciRoot(0x0)/Pci(0x2,0x0)"] = {"name": binascii.unhexlify("23646973706C6179"), "IOName": "#display", "class-code": binascii.unhexlify("FFFFFFFF")}
+            elif self.model == "iMac10,1":
+                self.enable_kext("AAAMouSSE.kext", self.constants.mousse_version, self.constants.mousse_path)
 
         # Check GPU Vendor
         if self.constants.metal_build is True:
+            backlight_path_detection(self)
             print("- Adding Metal GPU patches on request")
             if self.constants.imac_vendor == "AMD":
-                amd_patch(self)
+                amd_patch(self, self.gfx0_path)
             elif self.constants.imac_vendor == "Nvidia":
-                nvidia_patch(self)
+                nvidia_patch(self, self.gfx0_path)
             else:
                 print("- Failed to find vendor")
-        elif self.constants.custom_model == "None":
-            self.check_pciid(True)
-            if self.constants.dgpu_devices and self.constants.dgpu_vendor == self.constants.pci_amd_ati and self.constants.dgpu_device in ModelArray.AMDMXMGPUs:
-                amd_patch(self)
-            elif self.constants.dgpu_devices and self.constants.dgpu_vendor == self.constants.pci_nvidia and self.constants.dgpu_device in ModelArray.NVIDIAMXMGPUs:
-                nvidia_patch(self)
-        elif self.model in ModelArray.MacPro71:
-            print("- Adding Mac Pro, Xserve DRM patches")
-            self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree"
+        elif not self.constants.custom_model and self.model in ModelArray.LegacyGPU:
+            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")
+            if dgpu_vendor:
+                print(f"- Detected dGPU: {dgpu_vendor}:{dgpu_device}")
+                if dgpu_vendor == self.constants.pci_amd_ati and (dgpu_device in PCIIDArray.amd_ids().polaris_ids or dgpu_device in PCIIDArray.amd_ids().vega_ids or dgpu_device in PCIIDArray.amd_ids().navi_ids or dgpu_device in PCIIDArray.amd_ids().legacy_gcn_ids):
+                    backlight_path_detection(self)
+                    amd_patch(self, self.gfx0_path)
+                elif dgpu_vendor == self.constants.pci_nvidia and dgpu_device in PCIIDArray.nvidia_ids().kepler_ids:
+                    backlight_path_detection(self)
+                    nvidia_patch(self, self.gfx0_path)
+        if self.model in ModelArray.MacPro71:
+            if not self.constants.custom_model:
+                mp_dgpu_devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+                mp_dgpu_devices = [i for i in mp_dgpu_devices if i["class-code"] == binascii.unhexlify("00000300") or i["class-code"] == binascii.unhexlify("00800300")]
+                mp_dgpu_devices_gfx: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+                try:
+                    x = 1
+                    for i in mp_dgpu_devices:
+                        mp_dgpu_vendor = Utilities.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
+                        mp_dgpu_device = Utilities.hexswap(binascii.hexlify(i["device-id"]).decode()[:4])
+
+                        print(f'- Found dGPU ({x}): {mp_dgpu_vendor}:{mp_dgpu_device}')
+                        self.config["#Revision"][f"Hardware-MacPro-dGPU-{x}"] = f'{mp_dgpu_vendor}:{mp_dgpu_device}'
+
+                        try:
+                            mp_dgpu_path = [line.strip().split("= ", 1)[1] for line in mp_dgpu_devices_gfx.split("\n") if f'{mp_dgpu_vendor}:{mp_dgpu_device}'.lower() in line.strip()][0]
+                            print(f"- 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, "rebuild-device-tree": 1}
+                            elif mp_dgpu_vendor == self.constants.pci_nvidia:
+                                print("- Enabling Nvidia Output Patch")
+                                self.config["DeviceProperties"]["Add"][mp_dgpu_path] = {"rebuild-device-tree": 1}
+                                self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
+                                self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
+
+                        except IndexError:
+                            print(f"- Failed to find Device path for NVMe {x}")
+                            if mp_dgpu_vendor == self.constants.pci_amd_ati:
+                                print("- Adding Mac Pro, Xserve DRM patches")
+                                if "shikigva=128 unfairgva=1 -wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
+                                    print("- Falling back to boot-args")
+                                    self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " shikigva=128 unfairgva=1 -wegtree"
+                            elif mp_dgpu_vendor == self.constants.pci_nvidia:
+                                print("- Enabling Nvidia Output Patch")
+                                if "-wegtree" not in self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"]:
+                                    print("- Falling back to boot-args")
+                                    self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["boot-args"] += " -wegtree"
+                                self.config["UEFI"]["Quirks"]["ForgeUefiSupport"] = True
+                                self.config["UEFI"]["Quirks"]["ReloadOptionRoms"] = True
+                        x = x + 1
+                except ValueError:
+                    print("- No socketed dGPU found")
+                except IndexError:
+                    print("- No socketed dGPU found")
+            else:
+                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")
@@ -337,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"
 
-        # ThridPartDrives Check
-        if self.model not in ModelArray.NoSATAPatch:
+        # ThirdPartDrives Check
+        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")
@@ -375,83 +588,75 @@ class BuildOpenCore:
         if self.constants.secure_status is False:
             print("- Disabling SecureBootModel")
             self.config["Misc"]["Security"]["SecureBootModel"] = "Disabled"
+        if self.constants.serial_settings in ["Moderate", "Advanced"]:
+            print("- Enabling USB Rename Patches")
+            self.get_item_by_kv(self.config["ACPI"]["Patch"], "Comment", "XHC1 to SHC1")["Enabled"] = True
+            self.get_item_by_kv(self.config["ACPI"]["Patch"], "Comment", "EHC1 to EH01")["Enabled"] = True
+            self.get_item_by_kv(self.config["ACPI"]["Patch"], "Comment", "EHC2 to EH02")["Enabled"] = True
+        if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
+            self.config["NVRAM"]["Add"]["4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102"]["revcpu"] = self.constants.custom_cpu_model
+            if self.constants.custom_cpu_model_value != "":
+                print(f"- Adding custom CPU Name: {self.constants.custom_cpu_model_value}")
+                self.config["NVRAM"]["Add"]["4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102"]["revcpuname"] = self.constants.custom_cpu_model_value
+            else:
+                print("- Adding CPU Name Patch")
+            if self.get_kext_by_bundle_path("RestrictEvents.kext")["Enabled"] is False:
+                self.enable_kext("RestrictEvents.kext", self.constants.restrictevents_version, self.constants.restrictevents_path)
 
     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.metal_build is True:
-                print("- Spoofing to iMacPro1,1")
-                spoofed_model = "iMacPro1,1"
-                spoofed_board = "Mac-7BA5B2D9E42DDD94"
-            elif (self.constants.current_gpuv == "AMD (0x1002)") & (self.constants.current_gpud in ModelArray.AMDMXMGPUs) & (self.constants.custom_model == "None"):
-                print("- Spoofing to iMacPro1,1")
-                spoofed_model = "iMacPro1,1"
-                spoofed_board = "Mac-7BA5B2D9E42DDD94"
-            elif (self.constants.current_gpuv == "NVIDIA (0x10de)") & (self.constants.current_gpud in ModelArray.NVIDIAMXMGPUs) & (self.constants.custom_model == "None"):
-                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.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
-        self.config["#Revision"]["Spoofed-Model"] = self.spoofed_model
+        if self.constants.allow_oc_everywhere is False:
+            self.config["#Revision"]["Spoofed-Model"] = f"{self.spoofed_model} - {self.constants.serial_settings}"
 
         # Setup menu
         def minimal_serial_patch(self):
+            if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
+                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
+            self.config["PlatformInfo"]["SMBIOS"]["BIOSVersion"] = "9999.999.999.999.999"
             self.config["PlatformInfo"]["UpdateNVRAM"] = True
+            self.config["PlatformInfo"]["UpdateSMBIOS"] = True
 
         def moderate_serial_patch(self):
+            if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
+                self.config["PlatformInfo"]["Generic"]["ProcessorType"] = 1537
+            self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["run-efi-updater"] = "No"
             self.config["PlatformInfo"]["Automatic"] = True
             self.config["PlatformInfo"]["UpdateDataHub"] = True
             self.config["PlatformInfo"]["UpdateNVRAM"] = True
+            self.config["PlatformInfo"]["UpdateSMBIOS"] = True
             self.config["UEFI"]["ProtocolOverrides"]["DataHub"] = True
             self.config["PlatformInfo"]["Generic"]["SystemProductName"] = self.spoofed_model
 
-        def adanced_serial_patch(self):
+        def advanced_serial_patch(self):
+            if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
+                self.config["PlatformInfo"]["Generic"]["ProcessorType"] = 1537
             macserial_output = subprocess.run([self.constants.macserial_path] + f"-g -m {self.spoofed_model} -n 1".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
             macserial_output = macserial_output.stdout.decode().strip().split(" | ")
+            self.config["NVRAM"]["Add"]["7C436110-AB2A-4BBB-A880-FE41995C9F82"]["run-efi-updater"] = "No"
             self.config["PlatformInfo"]["Automatic"] = True
             self.config["PlatformInfo"]["UpdateDataHub"] = True
             self.config["PlatformInfo"]["UpdateNVRAM"] = True
+            self.config["PlatformInfo"]["UpdateSMBIOS"] = True
             self.config["UEFI"]["ProtocolOverrides"]["DataHub"] = True
             self.config["PlatformInfo"]["Generic"]["ROM"] = binascii.unhexlify("0016CB445566")
             self.config["PlatformInfo"]["Generic"]["SystemProductName"] = self.spoofed_model
@@ -464,42 +669,67 @@ class BuildOpenCore:
             moderate_serial_patch(self)
         elif self.constants.serial_settings == "Advanced":
             print("- Using Advanced SMBIOS patching")
-            adanced_serial_patch(self)
-        else:
+            advanced_serial_patch(self)
+        elif self.constants.serial_settings == "Minimal":
             print("- Using Minimal SMBIOS patching")
             self.spoofed_model = self.model
             minimal_serial_patch(self)
 
-        # USB Map Patching
-        new_map_ls = Path(self.constants.map_contents_folder) / Path("Info.plist")
-        map_config = plistlib.load(Path(new_map_ls).open("rb"))
+        if self.constants.download_ram is False:
+            self.config["PlatformInfo"].pop("Memory")
+        else:
+            print("- Inserting 1.5TB of RAM into your Mac")
+            self.config["PlatformInfo"]["CustomMemory"] = True
 
-        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
-            except KeyError:
-                continue
+        # USB Map and CPUFriend Patching
+        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"))
+            # 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
+            new_cpu_ls = Path(self.constants.pp_contents_folder) / Path("Info.plist")
+            cpu_config = plistlib.load(Path(new_cpu_ls).open("rb"))
+            string_stuff = str(cpu_config["IOKitPersonalities"]["CPUFriendDataProvider"]["cf-frequency-data"])
+            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
+            plistlib.dump(cpu_config, Path(new_cpu_ls).open("wb"), sort_keys=True)
 
-        plistlib.dump(map_config, Path(new_map_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):
@@ -537,10 +767,20 @@ class BuildOpenCore:
 
     def cleanup(self):
         print("- Cleaning up files")
-        # Remove unused kexts
-        for kext in list(self.config["Kernel"]["Add"]):
-            if not kext["Enabled"]:
-                self.config["Kernel"]["Add"].remove(kext)
+        # Remove unused entries
+        for entry in list(self.config["ACPI"]["Add"]):
+            if not entry["Enabled"]:
+                self.config["ACPI"]["Add"].remove(entry)
+        for entry in list(self.config["ACPI"]["Patch"]):
+            if not entry["Enabled"]:
+                self.config["ACPI"]["Patch"].remove(entry)
+        for entry in list(self.config["Kernel"]["Add"]):
+            if not entry["Enabled"]:
+                self.config["Kernel"]["Add"].remove(entry)
+        for entry in list(self.config["Kernel"]["Patch"]):
+            if not entry["Enabled"]:
+                self.config["Kernel"]["Patch"].remove(entry)
+
         plistlib.dump(self.config, Path(self.constants.plist_path).open("wb"), sort_keys=True)
         for kext in self.constants.kexts_path.rglob("*.zip"):
             with zipfile.ZipFile(kext) as zip_file:
@@ -552,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()
 
@@ -568,7 +810,7 @@ class BuildOpenCore:
         self.cleanup()
         self.sign_files()
         print("")
-        print("Your OpenCore EFI has been built at:")
+        print(f"Your OpenCore EFI for {self.model} has been built at:")
         print(f"    {self.constants.opencore_release_folder}")
         print("")
         if self.constants.gui_mode is False:
@@ -667,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)
@@ -702,7 +944,7 @@ Please build OpenCore first!"""
             if (mount_path / Path("System")).exists():
                 print("- Removing preexisting System folder")
                 shutil.rmtree(mount_path / Path("System"), onerror=rmtree_handler)
-            print("- Coping OpenCore onto EFI partition")
+            print("- Copying OpenCore onto EFI partition")
             shutil.copytree(self.constants.opencore_release_folder / Path("EFI/OC"), mount_path / Path("EFI/OC"))
             shutil.copytree(self.constants.opencore_release_folder / Path("System"), mount_path / Path("System"))
             if self.constants.boot_efi is True:
@@ -727,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:
@@ -158,7 +154,7 @@ pressing the "Esc" key
 contents can be tampered with. However for more advanced users, you may
 want to be able to freely edit the config.plist and files.
 
-Note: For secuirty reasons, OpenShell will be disabled when Vault is set.
+Note: For security reasons, OpenShell will be disabled when Vault is set.
 
         """)
         change_menu = input("Enable Vault(y/n): ")
@@ -206,7 +202,7 @@ Valid options:
 
     def change_imac_nvidia(self):
         Utilities.cls()
-        Utilities.header(["Force iMac Nvidia Patches"])
+        Utilities.header(["Assume Metal GPU Always"])
         print("""Specifically for iMac10,x-12,x with Metal Nvidia GPU upgrades
 By default the patcher will try to detect what hardware is
 running, however this will enforce iMac Nvidia Build Patches.
@@ -219,31 +215,6 @@ running, however this will enforce iMac Nvidia Build Patches.
         else:
             print("Invalid option")
 
-    def custom_repo(self):
-        Utilities.cls()
-        Utilities.header(["Set custom patch repo"])
-        print(f"""For users participating in OpenCore Patcher betas, this is
-where you can add custom repos such as Google Drive links.
-
-Valid options:
-
-1. Set custom location
-2. Reset repo location
-3. Exit
-
-Current repo:
-{self.constants.url_apple_binaries}
-        """)
-        change_menu = input("Set custom location?: ")
-        if change_menu == "1":
-            self.constants.url_backup = self.constants.url_apple_binaries
-            self.constants.url_apple_binaries = input("Enter new URL: ")
-        elif change_menu == "2":
-            if self.constants.url_backup != "":
-                self.constants.url_apple_binaries = self.constants.url_backup
-        else:
-            print("Invalid option")
-
     def bootstrap_setting(self):
         Utilities.cls()
         Utilities.header(["Set Bootstrap method"])
@@ -270,3 +241,200 @@ see the EFI Boot entry in the boot picker.
             self.constants.boot_efi = True
         else:
             print("Invalid option")
+
+
+    def drm_setting(self):
+        Utilities.cls()
+        Utilities.header(["Set DRM preferences"])
+        print("""Sets OpenCore's DRM preferences for iMac13,x and iMac14,x.
+In Big Sur, some DRM based content may be broken by
+default in AppleTV, Photobooth, etc.
+
+To resolve, you can opt to disable Intel QuickSync support in
+favor of Nvidia's Software rendering. This can aid in DRM however
+greatly hampers Video rendering performance in Final Cut Pro and
+other programs relying on such features.
+
+Recommend only disabling if absolutely required.
+        """)
+        change_menu = input("Enable Nvidia's Software DRM rendering(y/n): ")
+        if change_menu in {"y", "Y", "yes", "Yes"}:
+            self.constants.drm_support = True
+        elif change_menu in {"n", "N", "no", "No"}:
+            self.constants.drm_support = False
+        else:
+            print("Invalid option")
+
+    def force_accel_setting(self):
+        Utilities.cls()
+        Utilities.header(["Assume Legacy GPU"])
+        print("""Allows any model to force install Legacy Acceleration
+patches. Only required for Mac Pro and Xserve users.
+
+DO NOT RUN IF METAL GPU IS INSTALLED
+        """)
+        change_menu = input("Enable Beta Acceleration Patches(y/n): ")
+        if change_menu in {"y", "Y", "yes", "Yes"}:
+            self.constants.assume_legacy = True
+        elif change_menu in {"n", "N", "no", "No"}:
+            self.constants.assume_legacy = False
+        else:
+            print("Invalid option")
+
+    def allow_native_models(self):
+        Utilities.cls()
+        Utilities.header(["Allow OpenCore on native Models"])
+        print("""Allows natively supported Macs to use OpenCore. Recommended
+for users with 3rd Party NVMe SSDs to achieve improved overall
+power usage.
+
+        """)
+        change_menu = input("Allow OpenCore on all Models(y/n): ")
+        if change_menu in {"y", "Y", "yes", "Yes"}:
+            self.constants.allow_oc_everywhere = True
+            self.constants.serial_settings = "None"
+        elif change_menu in {"n", "N", "no", "No"}:
+            self.constants.allow_oc_everywhere = False
+            self.constants.serial_settings = "Minimal"
+        else:
+            print("Invalid option")
+
+    def custom_cpu(self):
+        Utilities.cls()
+        Utilities.header(["Set custom CPU Model Name"])
+        print("""Change reported CPU Model name in About This Mac
+Custom names will report as follows:
+
+1: Original Name: 2.5 Ghz Dual-Core Intel Core i5
+2. CPU name:      Intel(R) Core(TM) i5-3210M CPU @ 2.50Ghz
+3. Custom Name:   2.5Ghz Cotton Candy (example)
+        """)
+        if self.constants.custom_cpu_model_value == "":
+            if self.constants.custom_cpu_model == 0:
+                print("Currently using original name")
+            else:
+                print("Currently using CPU name")
+        else:
+            print(f"Custom CPU name currently: {self.constants.custom_cpu_model_value}")
+        change_menu = input("Set custom CPU Name(1,2,3): ")
+        if change_menu == "1":
+            self.constants.custom_cpu_model = 2
+            self.constants.custom_cpu_model_value = ""
+        elif change_menu == "2":
+            self.constants.custom_cpu_model = 0
+            self.constants.custom_cpu_model_value = ""
+        elif change_menu == "3":
+            self.constants.custom_cpu_model = 1
+            self.constants.custom_cpu_model_value = input("Enter new CPU Name: ")
+        else:
+            print("Invalid option")
+
+    def custom_color_thing(self):
+        Utilities.cls()
+        Utilities.header(["Set custom CPU Model Name"])
+        print("""Change reported CPU Model name in About This Mac
+Custom names will report as follows:
+
+1: Custom Color
+2. Reset
+        """)
+        change_menu = input("Set custom CPU Name(1,2,3): ")
+        if change_menu == "1":
+            print("")
+            #temp_tk_root = tk.Tk()
+            #temp_tk_root.wm_withdraw()
+            #self.constants.custom_color = colorchooser.askcolor(title="Choose color")
+            #temp_tk_root.destroy()
+        elif change_menu == "2":
+            self.constants.custom_color = ""
+        else:
+            print("Invalid option")
+
+    def download_more_ram_dot_com(self):
+        Utilities.cls()
+        Utilities.header(["Download more RAM"])
+        print("""Downloads more RAM to your Mac!
+Currently only offers 1.5TB bundles
+        """)
+        change_menu = input("Download more RAM?(y/n): ")
+        if change_menu == "y":
+            self.constants.download_ram = True
+        elif change_menu == "n":
+            self.constants.download_ram = False
+        else:
+            print("Invalid option")
+
+    def disable_cpufriend(self):
+        Utilities.cls()
+        Utilities.header(["Disable CPU Friend?"])
+        print("""Only recommended for advanced users
+Disabling CPUFriend forces macOS into using a different
+Mac's power profile for CPUs and GPUs, which can harm the
+hardware
+        """)
+        change_menu = input("Disable CPU Friend?(y/n): ")
+        if change_menu == "y":
+            self.constants.disallow_cpufriend = True
+        elif change_menu == "n":
+            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,10 +9,10 @@ from pathlib import Path
 
 class Constants:
     def __init__(self):
-        self.patcher_version = "0.0.23"
-        self.opencore_commit = "c528597 - 2021-04-05"
-        self.opencore_version = "0.6.8"
-        self.lilu_version = "1.5.2"
+        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"
         self.bcm570_version = "1.0.1"
@@ -25,16 +25,21 @@ class Constants:
         self.io80211elcap_version = "1.0.0"
         self.io80211high_sierra_version = "1.0.0"
         self.io80211mojave_version = "1.0.0"
-        self.applealc_version = "1.6.0"
-        self.restrictevents_version = "1.0.0"
+        self.applealc_version = "1.6.1"
+        self.restrictevents_version = "1.0.1"
         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"
         self.cputscsync = "1.0.3"
         self.hibernationfixup = "1.3.9"
+        self.nvmefix_version = "1.0.7"
+        self.sidecarfixup_version = "1.0.0"
+        self.innie_version = "1.3.0"
+        self.payload_version = "0.0.8"
 
         # Get resource path
         self.current_path = Path(__file__).parent.parent.resolve()
@@ -44,10 +49,6 @@ class Constants:
         self.custom_mxm_gpu: str = None
         self.current_gpuv: str = None
         self.current_gpud: str = None
-        self.igpu_vendor = ""
-        self.igpu_device = ""
-        self.dgpu_vendor = ""
-        self.dgpu_device = ""
 
         # Patcher Settings
         self.opencore_debug = False
@@ -68,6 +69,18 @@ class Constants:
         self.secure_status = True
         self.detected_os = 0
         self.boot_efi = False
+        self.drm_support = False
+        self.legacy_acceleration_patch = True
+        self.assume_legacy = False
+        self.allow_oc_everywhere = False
+        self.custom_cpu_model = 2
+        self.custom_cpu_model_value = ""
+        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
@@ -90,10 +103,25 @@ class Constants:
         self.pci_intel = "8086"
         self.pci_broadcom = "14E4"
         self.pci_atheros = "168C"
+        self.pci_apple = "106B"
+
+        # Class Codes
+        # https://pci-ids.ucw.cz/read/PD
+        self.classcode_sata = "01060100"
+        self.classcode_nvme = "02080100"
+        self.classcode_nvme_generic = "02800100"
+        self.classcode_wifi = "00800200"
+        self.classcode_gpu = "00000300"
+        self.classcode_gpu_variant = "00800300"
+        self.classcode_xhci = "30030C00"
+
+        # Nvidia GPU Architecture
+        self.arch_tesla = "NV50"
+        self.arch_fermi = "GF100"
+        self.arch_kepler = "GK100"
 
         # External Files
-        self.url_backup = ""
-        self.url_apple_binaries = "https://github.com/dortania/Apple-Binaries-OCLP/archive/refs/heads/main.zip"
+        self.url_apple_binaries = "https://github.com/dortania/Apple-Binaries-OCLP/archive/refs/tags/"
 
     # Payload Location
     # OpenCore
@@ -102,15 +130,23 @@ 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")
+    @property
+    def windows_ssdt_path(self): return self.payload_path / Path("ACPI/SSDT-PCI.aml")
 
     # Drivers
     @property
     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
@@ -152,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")
@@ -162,6 +200,12 @@ class Constants:
     @property
     def hibernationfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/HibernationFixup-v{self.hibernationfixup}.zip")
     @property
+    def nvmefix_path(self): return self.payload_kexts_path / Path(f"Acidanthera/NVMeFix-v{self.nvmefix_version}.zip")
+    @property
+    def sidecarfixup_path(self): return self.payload_kexts_path / Path(f"Acidanthera/SidecarFixup-v{self.sidecarfixup_version}.zip")
+    @property
+    def innie_path(self): return self.payload_kexts_path / Path(f"Misc/Innie-v{self.innie_version}.zip")
+    @property
     def plist_folder_path(self): return self.payload_kexts_path / Path(f"Plists")
     @property
     def platform_plugin_plist_path(self): return self.plist_folder_path / Path(f"PlatformPlugin")
@@ -229,9 +273,9 @@ class Constants:
     @property
     def gui_path(self): return self.payload_path / Path("Icon/Resources.zip")
 
-    # Apple Paylods Paths
+    # Apple Payloads Paths
     @property
-    def payload_apple_root_path_unzip(self): return self.payload_path / Path("Apple-Binaries-OCLP-main")
+    def payload_apple_root_path_unzip(self): return self.payload_path / Path(f"Apple-Binaries-OCLP-{self.payload_version}")
     @property
     def payload_apple_root_path_zip(self): return self.payload_path / Path("Apple.zip")
     @property
@@ -255,7 +299,7 @@ class Constants:
 
     # Apple Extensions
     @property
-    def applehda_path(self): return self.payload_apple_kexts_path / Path("Audio/AppleHDA.kext")
+    def audio_path(self): return self.payload_apple_kexts_path / Path("Audio")
 
     # GPU Kexts and Bundles
 
@@ -264,11 +308,17 @@ class Constants:
     @property
     def legacy_nvidia_path(self): return self.legacy_graphics / Path("Nvidia-Tesla-Fermi")
     @property
+    def legacy_nvidia_kepler_path(self): return self.legacy_graphics / Path("Nvidia-Kepler")
+    @property
     def legacy_amd_path(self): return self.legacy_graphics / Path("AMD-ATI")
     @property
     def legacy_intel_gen1_path(self): return self.legacy_graphics / Path("Intel-Gen5-Ironlake")
     @property
     def legacy_intel_gen2_path(self): return self.legacy_graphics / Path("Intel-Gen6-SandyBridge")
+    @property
+    def legacy_intel_gen3_path(self): return self.legacy_graphics / Path("Intel-Gen7-IvyBridge")
+    @property
+    def legacy_general_path(self): return self.legacy_graphics / Path("General-Patches")
 
     @property
     def legacy_brightness(self): return self.payload_apple_kexts_path / Path("Brightness-Control")
@@ -283,7 +333,9 @@ class Constants:
 
     # Apple LaunchDaemons
     @property
-    def hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("HiddHack.plist")
+    def hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("IOHID-Fixup.plist")
+    @property
+    def legacy_hiddhack_path(self): return self.payload_apple_lauchd_path_accel / Path("HiddHack.plist")
 
     # Apple PrivateFrameworks
     @property
@@ -292,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 = [
@@ -324,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

@@ -0,0 +1,106 @@
+# Probe devices, return device entries
+# Copyright (C) 2021 Mykola Grymalyuk
+from __future__ import print_function
+
+import binascii
+import plistlib
+import subprocess
+
+from Resources import Constants, Utilities
+
+class pci_probe:
+    def __init__(self):
+        self.constants = Constants.Constants()
+
+    # Converts given device IDs to DeviceProperty pathing, requires ACPI pathing as DeviceProperties shouldn't be used otherwise
+    def deviceproperty_probe(self, vendor_id, device_id, acpi_path):
+        gfxutil_output: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+        try:
+            if acpi_path == "":
+                acpi_path = "No ACPI Path Given"
+                raise IndexError
+            device_path = [line.strip().split("= ", 1)[1] for line in gfxutil_output.split("\n") if f'{vendor_id}:{device_id}'.lower() in line.strip() and acpi_path in line.strip()][0]
+            return device_path
+        except IndexError:
+            print(f"- No DevicePath found for {vendor_id}:{device_id} ({acpi_path})")
+            return ""
+
+    # Returns the device path of parent controller
+    def device_property_parent(self, device_path):
+        device_path_parent = "/".join(device_path.split("/")[:-1])
+        return device_path_parent
+
+    def acpi_strip(self, acpi_path_full):
+        # Strip IOACPIPlane:/_SB, remove 000's, convert ffff into 0 and finally make everything upper case
+        # IOReg                                      | gfxutil
+        # IOACPIPlane:/_SB/PC00@0/DMI0@0             -> /PC00@0/DMI0@0
+        # IOACPIPlane:/_SB/PC03@0/BR3A@0/SL09@ffff   -> /PC03@0/BR3A@0/SL09@0
+        # IOACPIPlane:/_SB/PC03@0/M2U0@150000        -> /PC03@0/M2U0@15
+        # IOACPIPlane:/_SB/PC01@0/CHA6@100000        -> /PC01@0/CHA6@10
+        # IOACPIPlane:/_SB/PC00@0/RP09@1d0000/PXSX@0 -> /PC00@0/RP09@1D/PXSX@0
+        # IOACPIPlane:/_SB/PCI0@0/P0P2@10000         -> /PCI0@0/P0P2@1
+        acpi_path = acpi_path_full.replace("IOACPIPlane:/_SB", "")
+        acpi_path = acpi_path.replace("0000", "")
+        acpi_path = acpi_path.replace("0001", "")
+        acpi_path = acpi_path.replace("ffff", "0")
+        acpi_path = acpi_path.upper()
+        return acpi_path
+
+    # Note gpu_probe should only be used on IGPU and GFX0 entries
+    def gpu_probe(self, gpu_type):
+        try:
+            devices = plistlib.loads(subprocess.run(f"ioreg -r -n {gpu_type} -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+            vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
+            device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
+            try:
+                acpi_path = devices[0]["acpi-path"]
+                acpi_path = self.acpi_strip(acpi_path)
+                return vendor_id, device_id, acpi_path
+            except KeyError:
+                print(f"- No ACPI entry found for {gpu_type}")
+                return vendor_id, device_id, ""
+        except ValueError:
+            print(f"- No IOService entry found for {gpu_type} (V)")
+            return "", "", ""
+        except IndexError:
+            print(f"- No IOService entry found for {gpu_type} (I)")
+            return "", "", ""
+
+    def wifi_probe(self):
+        devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+        try:
+            devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_wifi)]
+            vendor_id = Utilities.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
+            device_id = Utilities.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
+            ioname = devices[0]["IOName"]
+            try:
+                acpi_path = devices[0]["acpi-path"]
+                acpi_path = self.acpi_strip(acpi_path)
+                return vendor_id, device_id, ioname, acpi_path
+            except KeyError:
+                print(f"- No ACPI entry found for {vendor_id}:{device_id}")
+                return vendor_id, device_id, ioname, ""
+        except ValueError:
+            print(f"- No IOService entry found for Wireless Card (V)")
+            return "", "", "", ""
+        except IndexError:
+            print(f"- No IOService entry found for Wireless Card (I)")
+            return "", "", "", ""
+
+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

@@ -67,7 +67,7 @@ SupportedSMBIOS11 = [
     # Xserve
     "Xserve2,1",
     "Xserve3,1",
-    "Dortania1,1"
+    "Dortania1,1",
 ]
 
 SupportedSMBIOS12 = [
@@ -268,8 +268,8 @@ LegacyAudio = [
     "Macmini5,1",
     "Macmini5,2",
     "Macmini5,3",
-    "iMac7,1",
-    "iMac8,1",
+    #"iMac7,1",
+    #"iMac8,1",
     "iMac9,1",
     "iMac10,1",
     "iMac11,1",
@@ -442,21 +442,71 @@ NVMePatch = [
     "Dortania1,1"
 ]
 
-SidecarPatch = [
+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",
+    "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",
+    "MacPro5,1",
+    "MacPro6,1",
     "Dortania1,1"
 ]
 
@@ -471,6 +521,7 @@ DualGPUPatch = [
     "Macmini5,2",
     "iMac12,1",
     "iMac12,2",
+    "iMac13,1",
     "iMac13,2",
     "iMac14,2",
     "iMac14,3",
@@ -481,6 +532,13 @@ DualGPUPatchRetina = [
     "MacBookPro10,1",
 ]
 
+IntelNvidiaDRM = [
+    "iMac13,1",
+    "iMac13,2",
+    "iMac14,2",
+    "iMac14,3",
+]
+
 HiDPIpicker = [
     "MacBookPro10,1",
     "MacBookPro10,2",
@@ -488,7 +546,12 @@ HiDPIpicker = [
 ]
 
 IDEPatch = [
+    "MacBook4,1",
+    "MacBookPro4,1",
+    "iMac7,1",
+    "iMac8,1",
     "MacPro3,1",
+    "Xserve2,1",
     "Dortania1,1"
 ]
 
@@ -558,12 +621,12 @@ iMacPro11 = [
     "iMac11,1",
     "iMac11,2",
     "iMac11,3",
+    "iMac12,1",
+    "iMac12,2",
 ]
 
 # iMac = AMD and Nvidia GPU with iGPU
 iMac151 = [
-    "iMac12,1",
-    "iMac12,2",
     "iMac13,2",
     "iMac14,2",
     "iMac14,3"
@@ -667,6 +730,10 @@ ControllerTypes = [
     "-XHC1",
     "-OHC1",
     "-OHC2",
+    "-UHC1",
+    "-UHC2",
+    "-UHC3",
+    "-UHC4",
     "-InternalHub-EHC1",
     "-InternalHub-EHC1-InternalHub",
     "-InternalHub-EHC2",
@@ -684,75 +751,6 @@ upgradableMXMGPUs = [
     "Dortania1,1"
 ]
 
-# Reference: https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/
-NVIDIAMXMGPUs = [
-    "12B9",  # Quadro K610M
-    "0FF6",  # Quadro K1100M
-    "11FC",  # Quadro K2100M
-    "0FFC",  # Quadro K1000M
-    "0FFB",  # Quadro K2000M
-    "11B6",  # Quadro K3100M
-    "11B7",  # Quadro K4100M
-    "11BC",  # Quadro K5000M
-    "11B8",  # Quadro K5100M
-    "11E1",  # GTX 765M
-    "11E2",  # GTX 765M
-    "11E0",  # GTX 770M
-    "119E",  # GTX 780M Mac Edition
-    "119E",  # GTX 780M
-    "119F",  # GTX 880M
-    "119A",  # GTX 860M
-    "1392",  # GTX 860M
-    "1199",  # GTX 870M
-    "11A9",  # GTX 870M
-]
-
-AMDMXMGPUs = [
-    "67EF",  # AMD RX 460
-    "67E8",  # AMD WX 4130/WX 4150
-    "67E0",  # AMD WX 4170
-    "67C0",  # AMD WX 7100
-    "67DF",  # AMD RX 480
-]
-
-BCM4360Wifi = [
-    "43BA",  # BCM43602
-    "43A3",  # BCM4350
-    "43A0",  # BCM4360
-]
-
-BCM94331Wifi = [
-    "4331",  # BCM94331
-    "4353",  # BCM943224
-]
-
-BCM94322Wifi = [
-    "432B",  # BCM94322
-]
-
-BCM94328Wifi = [
-    "4311",
-    "4312",
-    "4313",
-    "4318",
-    "4319",
-    "431A",
-    "4320",
-    "4324",
-    "4325",
-    "4328",
-    "432C",
-    "432D",
-]
-
-AtherosWifi = [
-    "0030",
-    "002A",
-    "001C",
-    "0023",
-    "0024",
-]
-
 NightShiftExclude = [
     "MacBookAir5,1",
     "MacBookAir5,2",
@@ -864,6 +862,67 @@ NoExFat = [
     "Dortania1,1"
 ]
 
+SandyIGPU = [
+    "MacBookAir4,1",
+    "MacBookAir4,2",
+    "MacBookPro8,1",
+    "MacBookPro8,2",
+    "MacBookPro8,3",
+    "Macmini5,1",
+    "Macmini5,2",
+    "Macmini5,3",
+]
+
+windows_audio = [
+    "MacBookAir4,1",
+    "MacBookAir4,2",
+    "MacBookAir5,1",
+    "MacBookAir5,2",
+    "MacBookPro8,1",
+    "MacBookPro8,2",
+    "MacBookPro8,3",
+    "MacBookPro9,1",
+    "MacBookPro9,2",
+    "MacBookPro10,1",
+    "MacBookPro10,2",
+    "Macmini5,1",
+    "Macmini5,2",
+    "Macmini5,3",
+    "Macmini6,1",
+    "Macmini6,2",
+    "iMac12,1",
+    "iMac12,2",
+    "iMac13,1",
+    "iMac13,2",
+    "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",
@@ -899,11 +958,11 @@ DeleteAMDAccel11 = [
     "AMDRadeonX6000.kext",
     "AMDRadeonX6000Framebuffer.kext",
     "AMDRadeonX6000HWServices.kext",
-    "AMD7000Controller.kext",  # AMDSupport Dependancy
-    "AMD8000Controller.kext",  # AMDSupport Dependancy
-    "AMD9000Controller.kext",  # AMDSupport Dependancy
-    "AMD9500Controller.kext",  # AMDSupport Dependancy
-    "AMD10000Controller.kext",  # AMDSupport Dependancy
+    "AMD7000Controller.kext",  # AMDSupport Dependency
+    "AMD8000Controller.kext",  # AMDSupport Dependency
+    "AMD9000Controller.kext",  # AMDSupport Dependency
+    "AMD9500Controller.kext",  # AMDSupport Dependency
+    "AMD10000Controller.kext",  # AMDSupport Dependency
     "AppleIntelBDWGraphics.kext",
     "AppleIntelBDWGraphicsFramebuffer.kext",
     "AppleIntelCFLGraphicsFramebuffer.kext",
@@ -919,7 +978,6 @@ DeleteAMDAccel11 = [
     "AppleIntelFramebufferCapri.kext",
     "AppleParavirtGPU.kext",
     "GeForce.kext",
-    "IOAcceleratorFamily2.kext",
     "IOGPUFamily.kext",
 ]
 
@@ -933,13 +991,17 @@ AddNvidiaAccel11 = [
     "IOSurface.kext",
 ]
 
-AddNvidiaBrightness11 = [
-    "GeForceGA.bundle",
-    "GeForceTesla.kext",
-    "GeForceTeslaGLDriver.bundle",
-    "GeForceTeslaVADriver.bundle",
-    "NVDANV50HalTesla.kext",
-    "NVDAResmanTesla.kext",
+AddNvidiaKeplerAccel11 = [
+    "GeForce.kext",
+    "GeForceAIRPlugin.bundle",
+    "GeForceGLDriver.bundle",
+    "GeForceMTLDriver.bundle",
+    "GeForceVADriver.bundle",
+    "NVDAGF100Hal.kext",
+    "NVDAGK100Hal.kext",
+    "NVDAResman.kext",
+    "NVDAStartup.kext",
+    "NVSMU.kext",
 ]
 
 AddAMDAccel11 = [
@@ -955,55 +1017,17 @@ AddAMDAccel11 = [
     "AMDLegacySupport.kext",
     "AMDRadeonVADriver.bundle",
     "AMDRadeonVADriver2.bundle",
-    # "AMDRadeonX3000.kext", # __ZN22IOAccelDisplayMachine210gMetaClassE link issues
-    # "AMDRadeonX3000GLDriver.bundle",
+    #"AMDRadeonX3000.kext",
+    "AMDRadeonX3000GLDriver.bundle",
     "AMDShared.bundle",
     "AMDSupport.kext",
     "ATIRadeonX2000.kext",
     "ATIRadeonX2000GA.plugin",
     "ATIRadeonX2000GLDriver.bundle",
     "ATIRadeonX2000VADriver.bundle",
-    "IOSurface.kext",
-]
-
-AddAMDTeraScale1Brightness11 = [
-    "AMD2400Controller.kext",
-    "AMD2600Controller.kext",
-    "AMD3800Controller.kext",
-    "AMD4600Controller.kext",
-    "AMD4800Controller.kext",
-    "AMDLegacyFramebuffer.kext",
-    "AMDLegacySupport.kext",
-    "ATIRadeonX2000.kext",
-    "ATIRadeonX2000GA.plugin",
-    "ATIRadeonX2000GLDriver.bundle",
-    "ATIRadeonX2000VADriver.bundle",
-]
-
-AddAMDTeraScale2Brightness11 = [
-    "AMD5000Controller.kext",
-    "AMD6000Controller.kext",
-    "AMDLegacyFramebuffer.kext",
-    "AMDLegacySupport.kext",
-    "AMDRadeonX3000.kext",
-    "AMDRadeonX3000GLDriver.bundle",
-    "IOAcceleratorFamily2.kext"
 ]
 
 AddIntelGen1Accel = [
-    "AppleIntelFramebufferAzul.kext",
-    "AppleIntelFramebufferCapri.kext",
-    "AppleIntelHDGraphics.kext",
-    "AppleIntelHDGraphicsFB.kext",
-    "AppleIntelHDGraphicsGA.plugin",
-    "AppleIntelHDGraphicsGLDriver.bundle",
-    "AppleIntelHDGraphicsVADriver.bundle",
-    "IOSurface.kext",
-]
-
-AddIntelGen1Brightness = [
-    "AppleIntelFramebufferAzul.kext",
-    "AppleIntelFramebufferCapri.kext",
     "AppleIntelHDGraphics.kext",
     "AppleIntelHDGraphicsFB.kext",
     "AppleIntelHDGraphicsGA.plugin",
@@ -1018,16 +1042,25 @@ AddIntelGen2Accel = [
     "AppleIntelHD3000GraphicsVADriver.bundle",
     "AppleIntelSNBGraphicsFB.kext",
     "AppleIntelSNBVA.bundle",
-    "IOSurface.kext",
 ]
 
-AddIntelGen2Brightness = [
-    "AppleIntelHD3000Graphics.kext",
-    "AppleIntelHD3000GraphicsGA.plugin",
-    "AppleIntelHD3000GraphicsGLDriver.bundle",
-    "AppleIntelHD3000GraphicsVADriver.bundle",
-    "AppleIntelSNBGraphicsFB.kext",
-    "AppleIntelSNBVA.bundle",
+AddIntelGen3Accel = [
+    "AppleIntelFramebufferCapri.kext",
+    "AppleIntelHD4000Graphics.kext",
+    "AppleIntelHD4000GraphicsGLDriver.bundle",
+    "AppleIntelHD4000GraphicsMTLDriver.bundle",
+    "AppleIntelHD4000GraphicsVADriver.bundle",
+]
+
+AddGeneralAccel = [
+    # Below 5 from dosdude1, unknown whether they benifit
+    #"AppleGraphicsControl.kext",
+    #"AppleGraphicsPowerManagement.kext",
+    #"AppleMCCSControl.kext",
+    #"IOGraphicsFamily.kext",
+    #"IONDRVSupport.kext",
+    "IOAcceleratorFamily2.kext",
+    "IOSurface.kext"
 ]
 
 DeleteBrightness = [
@@ -1039,86 +1072,22 @@ AddBrightness = [
     "AppleBacklightExpert.kext",
 ]
 
-# List supported IDs
-
-TeraScale1pciid = [
-    "9400",
-    "9401",
-    "9402",
-    "9403",
-    "9581",
-    "9583",
-    "9588",
-    "94c8",
-    "94c9",
-    "9500",
-    "9501",
-    "9505",
-    "9507",
-    "9504",
-    "9506",
-    "9598",
-    "9488",
-    "9599",
-    "9591",
-    "9593",
-    "9440",
-    "9442",
-    "944A",
-    "945A",
-    "9490",
-    "949E",
-    "9480",
-    "9540",
-    "9541",
-    "954E",
-    "954F",
-    "9552",
-    "9553",
-    "94a0",
+AddVolumeControl = [
+    "AppleHDA.kext",
+    "IOAudioFamily.kext",
 ]
 
-TeraScale2pciid = [
-    "6738",
-    "6739",
-    "6720",
-    "6722",
-    "6768",
-    "6770",
-    "6779",
-    "6760",
-    "6761",
-    "68E0",
-    "6898",
-    "6899",
-    "68B8",
-    "68B0",
-    "68B1",
-    "68A0",
-    "68A1",
-    "6840",
-    "6841",
-    "68D8",
-    "68C0",
-    "68C1",
-    "68D9",
-    "6750",
-    "6758",
-    "6759",
-    "6740",
-    "6741",
-    "6745",
+DeleteVolumeControl = [
+    "AppleVirtIO.kext",
+    "AppleVirtualGraphics.kext",
+    "AppleVirtualPlatform.kext",
+    "ApplePVPanic.kext",
+    "AppleVirtIOStorage.kext",
 ]
 
-IronLakepciid = [
-    "0044",
-    "0046",
-]
-
-SandyBridgepiciid = [
-    "0106",
-    "0601",
-    "0116",
-    "0102",
-    "0126",
-]
+RecoveryIgnore = [
+    "Update",
+    "VM",
+    "Recovery",
+    "Preboot"
+]

Resources/PCIIDArray.py

@@ -0,0 +1,788 @@
+# Array of Device IDs for different devices
+class nvidia_ids:
+    # Courteous of envytools as well as Macrumors:
+    # 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]
+        "0402", # G84 [8600 GT]
+        "0403", # G84 [8600 GS]
+        "0404", # G84 [8400 GS]
+        "0405", # G84 [9500M GS]
+        "0406", # G84 [8300 GS]
+        "0407", # G84 [8600M GT]
+        "0408", # G84 [9650M GS]
+        "0409", # G84 [8700M GT]
+        "040A", # G84 [FX 370]
+        "040B", # G84 [NVS 320M]
+        "040C", # G84 [FX 570M]
+        "040D", # G84 [FX 1600M]
+        "040E", # G84 [FX 570]
+        "040F", # G84 [FX 1700]
+        # G86
+        "0420", # G86 [8400 SE]
+        "0421", # G86 [8500 GT]
+        "0422", # G86 [8400 GS]
+        "0423", # G86 [8300 GS]
+        "0424", # G86 [8400 GS]
+        "0425", # G86 [8600M GS]
+        "0426", # G86 [8400M GT]
+        "0427", # G86 [8400M GS]
+        "0428", # G86 [8400M G]
+        "0429", # G86 [NVS 140M]
+        "042A", # G86 [NVS 130M]
+        "042B", # G86 [NVS 135M]
+        "042C", # G86 [9400 GT]
+        "042D", # G86 [FX 360M]
+        "042E", # G86 [9300M G]
+        "042F", # G86 [NVS 290]
+        # G92
+        "0410", # G92 [GT 330]
+        "0600", # G92 [8800 GTS 512]
+        "0601", # G92 [9800 GT]
+        "0602", # G92 [8800 GT]
+        "0603", # G92 [GT 230]
+        "0604", # G92 [9800 GX2]
+        "0605", # G92 [9800 GT]
+        "0606", # G92 [8800 GS]
+        "0607", # G92 [GTS 240]
+        "0608", # G92 [9800M GTX]
+        "0609", # G92 [8800M GTS]
+        "060A", # G92 [GTX 280M]
+        "060B", # G92 [9800M GT]
+        "060C", # G92 [8800M GTX]
+        "060F", # G92 [GTX 285M]
+        "0610", # G92 [9600 GSO]
+        "0611", # G92 [8800 GT]
+        "0612", # G92 [9800 GTX/9800 GTX+]
+        "0613", # G92 [9800 GTX+]
+        "0614", # G92 [9800 GT]
+        "0615", # G92 [GTS 250]
+        "0617", # G92 [9800M GTX]
+        "0618", # G92 [GTX 260M]
+        "0619", # G92 [FX 4700 X2]
+        "061A", # G92 [FX 3700]
+        "061B", # G92 [VX 200]
+        "061C", # G92 [FX 3600M]
+        "061D", # G92 [FX 2800M]
+        "061E", # G92 [FX 3700M]
+        "061F", # G92 [FX 3800M]
+        # G94
+        "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]
+        "0628", # G94 [9800M GTS]
+        "062A", # G94 [9700M GTS]
+        "062B", # G94 [9800M GS]
+        "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]
+        "0638", # G94 [FX 1800]
+        "063A", # G94 [FX 2700M]
+        # G96
+        "0640", # G96 [9500 GT]
+        "0641", # G96 [9400 GT]
+        "0643", # G96 [9500 GT]
+        "0644", # G96 [9500 GS]
+        "0645", # G96 [9500 GS]
+        "0646", # G96 [GT 120]
+        "0647", # G96 [9600M GT]
+        "0648", # G96 [9600M GS]
+        "0649", # G96 [9600M GT]
+        "064A", # G96 [9700M GT]
+        "064B", # G96 [9500M G]
+        "064C", # G96 [9650M GT]
+        "0651", # G96 [G 110M]
+        "0652", # G96 [GT 130M]
+        "0653", # G96 [GT 120M]
+        "0654", # G96 [GT 220M]
+        "0655", # G96 [GT 120]
+        "0656", # G96 [GT 120 ]
+        "0658", # G96 [FX 380]
+        "0659", # G96 [FX 580]
+        "065A", # G96 [FX 1700M]
+        "065B", # G96 [9400 GT]
+        "065C", # G96 [FX 770M]
+        "065F", # G96 [G210]
+        # G98
+        "06E0", # G98 [9300 GE]
+        "06E1", # G98 [9300 GS]
+        "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]
+        "06E9", # G98 [9300M GS]
+        "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]
+        "06F9", # G98 [FX 370 LP]
+        "06FA", # G98 [NVS 450]
+        "06FB", # G98 [FX 370M]
+        "06FD", # G98 [NVS 295]
+        "06FF", # G98 [HICx16]
+        # 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]
+        "0845", # MCP77 GPU [8200M G]
+        "0846", # MCP77 GPU [9200]
+        "0847", # MCP77 GPU [9100]
+        "0848", # MCP77 GPU [8300]
+        "0849", # MCP77 GPU [8200]
+        "084A", # MCP77 GPU [730A]
+        "084B", # MCP77 GPU [9200]
+        "084C", # MCP77 GPU [980A/780A SLI]
+        "084D", # MCP77 GPU [750A SLI]
+        "084F", # MCP77 GPU [8100 / 720A]
+        # MCP79 GPU
+        "0860", # MCP79 GPU [9400]
+        "0861", # MCP79 GPU [9400]
+        "0862", # MCP79 GPU [9400M G]
+        "0863", # MCP79 GPU [9400M]
+        "0864", # MCP79 GPU [9300]
+        "0865", # MCP79 GPU [ION]
+        "0866", # MCP79 GPU [9400M G]
+        "0867", # MCP79 GPU [9400]
+        "0868", # MCP79 GPU [760i SLI]
+        "0869", # MCP79 GPU [9400]
+        "086A", # MCP79 GPU [9400]
+        "086C", # MCP79 GPU [9300 / 730i]
+        "086D", # MCP79 GPU [9200]
+        "086E", # MCP79 GPU [9100M G]
+        "086F", # MCP79 GPU [8200M G]
+        "0870", # MCP79 GPU [9400M]
+        "0871", # MCP79 GPU [9200]
+        "0872", # MCP79 GPU [G102M]
+        "0873", # MCP79 GPU [G102M]
+        "0874", # MCP79 GPU [ION]
+        "0876", # MCP79 GPU [ION]
+        "087A", # MCP79 GPU [9400]
+        "087D", # MCP79 GPU [ION]
+        "087E", # MCP79 GPU [ION LE]
+        "087F", # MCP79 GPU [ION LE]
+        # GT215
+        "0CA0", # GT215 [GT 330]
+        "0CA2", # GT215 [GT 320]
+        "0CA3", # GT215 [GT 240]
+        "0CA4", # GT215 [GT 340]
+        "0CA5", # GT215 [GT 220]
+        "0CA7", # GT215 [GT 330]
+        "0CA9", # GT215 [GTS 250M]
+        "0CAC", # GT215 [GT 220]
+        "0CAF", # GT215 [GT 335M]
+        "0CB0", # GT215 [GTS 350M]
+        "0CB1", # GT215 [GTS 360M]
+        "0CBC", # GT215 [FX 1800M]
+        # GT216
+        "0A20", # GT216 [GT 220]
+        "0A22", # GT216 [315]
+        "0A23", # GT216 [210]
+        "0A26", # GT216 [405]
+        "0A27", # GT216 [405]
+        "0A28", # GT216 [GT 230M]
+        "0A29", # GT216 [GT 330M]
+        "0A2A", # GT216 [GT 230M]
+        "0A2B", # GT216 [GT 330M]
+        "0A2C", # GT216 [NVS 5100M]
+        "0A2D", # GT216 [GT 320M]
+        "0A32", # GT216 [GT 415]
+        "0A34", # GT216 [GT 240M]
+        "0A35", # GT216 [GT 325M]
+        "0A38", # GT216 [400]
+        "0A3C", # GT216 [FX 880M]
+        # GT218
+        "0A60", # GT218 [G210]
+        "0A62", # GT218 [205]
+        "0A63", # GT218 [310]
+        "0A64", # GT218 [ION]
+        "0A65", # GT218 [210]
+        "0A66", # GT218 [310]
+        "0A67", # GT218 [315]
+        "0A68", # GT218 [G105M]
+        "0A69", # GT218 [G105M]
+        "0A6A", # GT218 [NVS 2100M]
+        "0A6C", # GT218 [NVS 3100M]
+        "0A6E", # GT218 [305M]
+        "0A6F", # GT218 [ION]
+        "0A70", # GT218 [310M]
+        "0A71", # GT218 [305M]
+        "0A72", # GT218 [310M]
+        "0A73", # GT218 [305M]
+        "0A74", # GT218 [G210M]
+        "0A75", # GT218 [310M]
+        "0A76", # GT218 [ION]
+        "0A78", # GT218 [FX 380 LP]
+        "0A7A", # GT218 [315M]
+        "0A7C", # GT218 [FX 380M]
+        "10C0", # GT218 [9300 GS]
+        "10C3", # GT218 [8400GS]
+        "10C5", # GT218 [405]
+        "10D8", # GT218 [NVS 300]
+        # MCP89 GPU
+        "08A0", # MCP89 GPU [320M]
+        "08A2", # MCP89 GPU [320M]
+        "08A3", # MCP89 GPU [320M]
+        "08A4", # MCP89 GPU [320M]
+    ]
+
+    fermi_ids = [
+        # GF100
+        "06C0", # GF100 [GTX 480]
+        "06C4", # GF100 [GTX 465]
+        "06CA", # GF100 [GTX 480M]
+        "06CB", # GF100 [GTX 480]
+        "06CD", # GF100 [GTX 470]
+        "06D1", # GF100 [C2050 / C2070]
+        "06D2", # GF100 [M2070]
+        "06D8", # GF100 [6000]
+        "06D9", # GF100 [5000]
+        "06DA", # GF100 [5000M]
+        "06DC", # GF100 [6000]
+        "06DD", # GF100 [4000]
+        "06DE", # GF100 [T20]
+        "06DF", # GF100 [M2070-Q]
+        # GF104
+        "0E22", # GF104 [GTX 460]
+        "0E23", # GF104 [GTX 460 SE]
+        "0E24", # GF104 [GTX 460 OEM]
+        "0E30", # GF104 [GTX 470M]
+        "0E31", # GF104 [GTX 485M]
+        "0E3A", # GF104 [3000M]
+        "0E3B", # GF104 [4000M]
+        # GF114
+        "1200", # GF114 [GTX 560 Ti]
+        "1201", # GF114 [GTX 560]
+        "1202", # GF114 [GTX 560 Ti OEM]
+        "1203", # GF114 [GTX 460 SE v2]
+        "1205", # GF114 [GTX 460 v2]
+        "1206", # GF114 [GTX 555]
+        "1207", # GF114 [GT 645 OEM]
+        "1208", # GF114 [GTX 560 SE]
+        "1210", # GF114 [GTX 570M]
+        "1211", # GF114 [GTX 580M]
+        "1212", # GF114 [GTX 675M]
+        "1213", # GF114 [GTX 670M]
+        # GF106
+        "0DC0", # GF106 [GT 440]
+        "0DC4", # GF106 [GTS 450]
+        "0DC5", # GF106 [GTS 450]
+        "0DC6", # GF106 [GTS 450]
+        "0DCD", # GF106 [GT 555M]
+        "0DCE", # GF106 [GT 555M]
+        "0DD1", # GF106 [GTX 460M]
+        "0DD2", # GF106 [GT 445M]
+        "0DD3", # GF106 [GT 435M]
+        "0DD6", # GF106 [GT 550M]
+        "0DD8", # GF106 [2000]
+        "0DDA", # GF106 [2000M]
+        # GF116
+        "1241", # GF116 [GT 545 OEM]
+        "1243", # GF116 [GT 545]
+        "1244", # GF116 [GTX 550 Ti]
+        "1245", # GF116 [GTS 450 Rev. 2]
+        "1246", # GF116 [GT 550M]
+        "1247", # GF116 [GT 635M]
+        "1248", # GF116 [GT 555M]
+        "1249", # GF116 [GTS 450 Rev. 3]
+        "124B", # GF116 [GT 640 OEM]
+        "124D", # GF116 [GT 555M]
+        "1251", # GF116 [GTX 560M]
+        # GF108
+        "0DE0", # GF108 [GT 440]
+        "0DE1", # GF108 [GT 430]
+        "0DE2", # GF108 [GT 420]
+        "0DE3", # GF108 [GT 635M]
+        "0DE4", # GF108 [GT 520]
+        "0DE5", # GF108 [GT 530]
+        "0DE8", # GF108 [GT 620M]
+        "0DE9", # GF108 [GT 630M]
+        "0DEA", # GF108 [610M]
+        "0DEB", # GF108 [GT 555M]
+        "0DEC", # GF108 [GT 525M]
+        "0DED", # GF108 [GT 520M]
+        "0DEE", # GF108 [GT 415M]
+        "0DEF", # GF108 [NVS 5400M]
+        "0DF0", # GF108 [GT 425M]
+        "0DF1", # GF108 [GT 420M]
+        "0DF2", # GF108 [GT 435M]
+        "0DF3", # GF108 [GT 420M]
+        "0DF4", # GF108 [GT 540M]
+        "0DF5", # GF108 [GT 525M]
+        "0DF6", # GF108 [GT 550M]
+        "0DF7", # GF108 [GT 520M]
+        "0DF8", # GF108 [600]
+        "0DF9", # GF108 [500M]
+        "0DFA", # GF108 [1000M]
+        "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]
+        "1082", # GF110 [GTX 560 Ti]
+        "1084", # GF110 [GTX 560]
+        "1086", # GF110 [GTX 570]
+        "1087", # GF110 [GTX 560 Ti]
+        "1088", # GF110 [GTX 590]
+        "1089", # GF110 [GTX 580]
+        "108B", # GF110 [GTX 580]
+        "1091", # GF110 [M2090]
+        "1096", # GF110GL [Tesla C2050 / C2075]
+        "109A", # GF110 [5010M]
+        "109B", # GF110 [7000]
+        # GF119
+        "1040", # GF119 [GT 520]
+        "1042", # GF119 [510]
+        "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]
+        "1054", # GF119 [410M]
+        "1055", # GF119 [410M]
+        "1056", # GF119 [NVS 4200M]
+        "1057", # GF119 [NVS 4200M]
+        "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]
+    ]
+
+    kepler_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]
+        "11A1", # GK104 [GTX 670MX]
+        "11A2", # GK104 [GTX 675MX]
+        "11A3", # GK104 [GTX 680MX]
+        "11A7", # GK104 [GTX 675MX]
+        "11A9", # GTX 870M
+        "11B4", # GK104GL [Quadro K4200]
+        "11B6",  # Quadro K3100M
+        "11B7",  # Quadro K4100M
+        "11B8",  # Quadro K5100M
+        "11BA", # GK104 [K5000]
+        "11BC", # GK104 [K5000M]
+        "11BD", # GK104 [K4000M]
+        "11BE", # GK104 [K3000M]
+        "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
+        "11E2",  # GTX 765M
+        "11FA", # GK106 [K4000]
+        "11FC",  # Quadro K2100M
+        # GK107
+        "0FC0", # GK107 [GT 640]
+        "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]
+        "0FD4", # GK107 [GTX 660M]
+        "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]
+        "0FFB", # GK107 [K2000M]
+        "0FFC", # GK107 [K1000M]
+        "0FFD", # GK107 [NVS 510]
+        "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]
+    ]
+
+class amd_ids:
+    legacy_gcn_ids = [
+        # AMDRadeonX4000
+        # AMDBonaireGraphicsAccelerator
+        "6640",
+        "6641",
+        "6646",
+        "6647",
+        "6650",
+        "6651",
+        "665C",
+        "665D",
+        # AMDFijiGraphicsAccelerator
+        "7300",
+        "730F",
+        # AMDHawaiiGraphicsAccelerator
+        "67B0",
+        # AMDPitcairnGraphicsAccelerator
+        "6800",
+        "6801",
+        "6806",
+        "6808",
+        "6810",
+        "6818",
+        "6819",
+        # AMDTahitiGraphicsAccelerator
+        "6790",
+        "6798",
+        "679A",
+        "679E",
+        "6780",
+        # AMDTongaGraphicsAccelerator
+        "6920",
+        "6921",
+        "6930",
+        "6938",
+        "6939",
+        # AMDVerdeGraphicsAccelerator
+        "6820",
+        "6821",
+        "6823",
+        "6825",
+        "6827",
+        "682B",
+        "682D",
+        "682F",
+        "6835",
+        "6839",
+        "683B",
+        "683D",
+        "683F",
+    ]
+
+    polaris_ids = [
+        # AMDRadeonX4000
+        # AMDBaffinGraphicsAccelerator
+        "67E0",
+        "67E3",
+        "67E8",
+        "67EB",
+        "67EF",
+        "67FF",
+        "67E1",
+        "67E7",
+        "67E9",
+        # AMDEllesmereGraphicsAccelerator
+        "67C0",
+        "67C1",
+        "67C2",
+        "67C4",
+        "67C7",
+        "67DF",
+        "67D0",
+        "67C8",
+        "67C9",
+        "67CA",
+        "67CC",
+        "67CF",
+    ]
+
+    vega_ids = [
+        # AMDRadeonX5000
+        # AMDVega10GraphicsAccelerator
+        "6860",
+        "6861",
+        "6862",
+        "6863",
+        "6864",
+        "6867",
+        "6868",
+        "6869",
+        "686A",
+        "686B",
+        "686C",
+        "686D",
+        "686E",
+        "686F",
+        "687F",
+        # AMDVega12GraphicsAccelerator
+        "69A0",
+        "69A1",
+        "69A2",
+        "69A3",
+        "69AF",
+        # AMDVega20GraphicsAccelerator
+        "66A0",
+        "66A1",
+        "66A2",
+        "66A3",
+        "66A7",
+        "66AF",
+    ]
+
+    navi_ids = [
+        # AMDRadeonX6000
+        # AMDNavi10GraphicsAccelerator
+        "7310",
+        "7312",
+        "7318",
+        "7319",
+        "731A",
+        "731B",
+        "731F",
+        # AMDNavi12GraphicsAccelerator
+        "7360",
+        # AMDNavi14GraphicsAccelerator
+        "7340",
+        "7341",
+        "7343",
+        "7347",
+        "734F",
+        # AMDNavi21GraphicsAccelerator
+        "73A2",
+        "73AB",
+        "73BF",
+    ]
+    terascale_1_ids = [
+        "9400",
+        "9401",
+        "9402",
+        "9403",
+        "9581",
+        "9583",
+        "9588",
+        "94C8",
+        "94C9",
+        "9500",
+        "9501",
+        "9505",
+        "9507",
+        "9504",
+        "9506",
+        "9598",
+        "9488",
+        "9599",
+        "9591",
+        "9593",
+        "9440",
+        "9442",
+        "944A",
+        "945A",
+        "9490",
+        "949E",
+        "9480",
+        "9540",
+        "9541",
+        "954E",
+        "954F",
+        "9552",
+        "9553",
+        "94A0",
+    ]
+
+    terascale_2_ids = [
+        "6738",
+        "6739",
+        "6720",
+        "6722",
+        "6768",
+        "6770",
+        "6779",
+        "6760",
+        "6761",
+        "68E0",
+        "6898",
+        "6899",
+        "68B8",
+        "68B0",
+        "68B1",
+        "68A0",
+        "68A1",
+        "6840",
+        "6841",
+        "68D8",
+        "68C0",
+        "68C1",
+        "68D9",
+        "6750",
+        "6758",
+        "6759",
+        "6740",
+        "6741",
+        "6745",
+    ]
+
+class intel_ids:
+    iron_ids = [
+        # AppleIntelHDGraphics IDs
+        "0044",
+        "0046",
+    ]
+
+    sandy_ids = [
+        # AppleIntelHD3000Graphics IDs
+        # AppleIntelSNBGraphicsFB IDs
+        "0106",
+        "0601",
+        "0116",
+        "0102",
+        "0126",
+    ]
+
+    ivy_ids = [
+        # AppleIntelHD4000Graphics IDs
+        # AppleIntelFramebufferCapri IDs
+        "0152",
+        "0156",
+        "0162",
+        "0166",
+    ]
+
+class broadcom_ids:
+    BCM4360Wifi = [
+        # AirPortBrcmNIC IDs
+        "43BA",  # BCM43602
+        "43A3",  # BCM4350
+        "43A0",  # BCM4360
+    ]
+
+    BCM94331Wifi = [
+        # AirPortBrcm4360 IDs (removed duplicates for 4360 class cards)
+        "4331",  # BCM94331
+        "4353",  # BCM943224
+    ]
+
+    BCM94322Wifi = [
+        # AirPortBrcm4331 IDs (removed duplicates for 4331 class cards)
+        "432B",  # BCM94322
+    ]
+
+    BCM94328Wifi = [
+        # AppleAirPortBrcm43224 IDs
+        "4311", # BCM4311 - never used by Apple
+        "4312", # BCM4311 - never used by Apple
+        "4313", # BCM4311 - never used by Apple
+        "4318", # BCM4318 - never used by Apple
+        "4319", # BCM4318 - never used by Apple
+        "431A", # Unknown - never used by Apple
+        "4320", # BCM4306 - never used by Apple
+        "4324", # BCM4309 - never used by Apple
+        "4325", # BCM4306 - never used by Apple
+        "4328", # BCM4328
+        "432C", # BCM4322 - never used by Apple
+        "432D", # BCM4322 - never used by Apple
+    ]
+
+class atheros_ids:
+    AtherosWifi = [
+        # AirPortAtheros40 IDs
+        "0030", # AR93xx
+        "002A", # AR928X
+        "001C", # AR242x / AR542x
+        "0023", # AR5416 - never used by Apple
+        "0024", # AR5418
+    ]

Resources/SysPatch.py

@@ -2,39 +2,48 @@
 # Copyright (C) 2020-2021, Dhinak G, Mykola Grymalyuk
 # Missing Features:
 # - Full System/Library Snapshotting (need to research how Apple achieves this)
-#   - Temorary Work-around: sudo bless --mount /System/Volumes/Update/mnt1 --bootefi --last-sealed-snapshot
+#   - 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/)
-# - Add kmutil error checking
-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, Utilities
+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):
@@ -45,39 +54,146 @@ class PatchSysVolume:
             if print_status is True:
                 print(f"- {current_sip_bit}\t {temp}")
             i = i + 1
-        # TODO: Fix this garbage when I have more sanity
-        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("- Sucessfully mounted the Root Volume")
+                    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:
@@ -88,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")
 
@@ -97,184 +213,189 @@ 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()
-
-    def check_pciid(self):
-        try:
-            self.igpu_devices = plistlib.loads(subprocess.run("ioreg -r -n IGPU -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            self.igpu_devices = [i for i in self.igpu_devices if i["class-code"] == binascii.unhexlify("00000300")]
-            self.igpu_vendor = self.hexswap(binascii.hexlify(self.igpu_devices[0]["vendor-id"]).decode()[:4])
-            self.igpu_device = self.hexswap(binascii.hexlify(self.igpu_devices[0]["device-id"]).decode()[:4])
-            print(f"- Detected iGPU: {self.igpu_vendor}:{self.igpu_device}")
-        except ValueError:
-            print("- No iGPU detected")
-            self.igpu_devices = ""
-
-        try:
-            self.dgpu_devices = plistlib.loads(subprocess.run("ioreg -r -n GFX0 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-            self.dgpu_devices = [i for i in self.dgpu_devices if i["class-code"] == binascii.unhexlify("00000300")]
-            self.dgpu_vendor = self.hexswap(binascii.hexlify(self.dgpu_devices[0]["vendor-id"]).decode()[:4])
-            self.dgpu_device = self.hexswap(binascii.hexlify(self.dgpu_devices[0]["device-id"]).decode()[:4])
-            print(f"- Detected dGPU: {self.dgpu_vendor}:{self.dgpu_device}")
-        except ValueError:
-            print("- No dGPU detected")
-            self.dgpu_devices = ""
+        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):
-        if self.dgpu_devices:
-            if self.dgpu_vendor == self.constants.pci_nvidia:
-                print("- Merging legacy Nvidia Kexts and Bundles")
-                self.delete_old_binaries(ModelArray.DeleteNvidiaAccel11)
-                self.add_new_binaries(ModelArray.AddNvidiaAccel11, self.constants.legacy_nvidia_path)
-            elif self.dgpu_vendor == self.constants.pci_amd_ati:
-                print("- Merging legacy AMD Kexts and Bundles")
-                self.delete_old_binaries(ModelArray.DeleteAMDAccel11)
-                self.add_new_binaries(ModelArray.AddAMDAccel11, self.constants.legacy_amd_path)
-        if self.igpu_devices:
-            if self.igpu_vendor == self.constants.pci_intel:
-                if self.igpu_device in ModelArray.IronLakepciid:
+        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:
+                if dgpu_device in PCIIDArray.nvidia_ids().tesla_ids or dgpu_device in PCIIDArray.nvidia_ids().fermi_ids:
+                    print("- Merging legacy Nvidia Tesla and Fermi 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.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:
+                #    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:
+                if dgpu_device in PCIIDArray.amd_ids().terascale_1_ids:
+                    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
+                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:
+                if igpu_device in PCIIDArray.intel_ids().iron_ids:
                     print("- Merging legacy Intel 1st 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.AddIntelGen1Accel, self.constants.legacy_intel_gen1_path)
-                elif self.igpu_device in ModelArray.SandyBridgepiciid:
+                    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)
-                    if self.model in ModelArray.LegacyGPUAMDIntelGen2:
-                        # Swap custom AppleIntelSNBGraphicsFB-AMD.kext, required to fix linking
-                        subprocess.run(f"sudo rm -R {self.mount_extensions}/AppleIntelSNBGraphicsFB.kext".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                        subprocess.run(f"sudo cp -R {self.constants.legacy_amd_path}/AMD-Link/AppleIntelSNBGraphicsFB.kext {self.mount_extensions}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-            elif self.igpu_vendor == self.constants.pci_nvidia:
-                if not self.dgpu_devices:
+                    self.added_kexts = True
+
+                # TODO: Enable below code if macOS 12 drops support
+                # 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:
+                if not dgpu_vendor:
                     # Avoid patching twice, as Nvidia iGPUs will only have Nvidia dGPUs
                     print("- Merging legacy Nvidia 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.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
-        print("- Adding HiddHack.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}/HiddHack.plist".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        subprocess.run(f"sudo chown root:wheel {self.mount_lauchd}/HiddHack.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}")
         rebuild_required = False
         # TODO: Create Backup of S*/L*/Extensions, Frameworks and PrivateFramework to easily revert changes
-        # APFS snapshotting seems to ignore System Volume changes inconcistently, would like a backup to avoid total brick
+        # APFS snapshotting seems to ignore System Volume changes inconsistently, would like a backup to avoid total brick
         # Perhaps a basic py2 script to run in recovery to restore
-        print("- Creating backup snapshot of user data (This may take some time)")
-        subprocess.run("tmutil snapshot".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
         # 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:
-            self.check_pciid()
-            if self.dgpu_devices and self.dgpu_vendor == self.constants.pci_amd_ati and self.dgpu_device in ModelArray.AMDMXMGPUs:
+        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
+                )
+            ):
                 print("- Detected Metal-based AMD GPU, skipping legacy patches")
-            elif self.dgpu_devices and self.dgpu_vendor == self.constants.pci_nvidia and self.dgpu_device in ModelArray.NVIDIAMXMGPUs:
+            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")
             else:
-                if Path(self.constants.hiddhack_path).exists():
-                    print("- Detected legacy GPU, attempting legacy acceleration patches")
-                    self.gpu_accel_patches_11()
-                else:
-                    if self.dgpu_devices:
-                        if self.dgpu_vendor == self.constants.pci_nvidia:
-                            print("- Adding Nvidia Brightness Control patches")
-                            self.add_new_binaries(ModelArray.AddNvidiaBrightness11, self.constants.legacy_nvidia_path)
-                        elif self.dgpu_vendor == self.constants.pci_amd_ati:
-                            if self.dgpu_device in ModelArray.TeraScale1pciid:
-                                print("- Adding AMD/ATI TeraScale 1 Brightness Control patches")
-                                self.add_new_binaries(ModelArray.AddAMDTeraScale1Brightness11, self.constants.legacy_amd_path)
-                            elif self.dgpu_device in ModelArray.TeraScale2pciid:
-                                print("- Adding AMD/ATI TeraScale 2 Brightness Control patches")
-                                self.add_new_binaries(ModelArray.AddAMDTeraScale2Brightness11, self.constants.legacy_amd_path)
-                            else:
-                                print("- Could not find supported Legacy AMD/ATI GPU")
-                    if self.igpu_devices:
-                        if self.igpu_vendor == self.constants.pci_intel:
-                            if self.igpu_device in ModelArray.IronLakepciid:
-                                print("- Adding Intel Ironlake Brightness Control patches")
-                                self.add_new_binaries(ModelArray.AddIntelGen1Brightness, self.constants.legacy_intel_gen1_path)
-                            elif self.igpu_device in ModelArray.SandyBridgepiciid:
-                                print("- Adding Intel Sandy Bridge Brightness Control patches")
-                                self.add_new_binaries(ModelArray.AddIntelGen2Brightness, self.constants.legacy_intel_gen2_path)
-                                if self.dgpu_devices and self.dgpu_vendor == self.constants.pci_amd_ati and self.dgpu_device in ModelArray.TeraScale2pciid:
-                                    # Swap custom AppleIntelSNBGraphicsFB-AMD.kext, required to fix linking
-                                    subprocess.run(f"sudo rm -R {self.mount_extensions}/AppleIntelSNBGraphicsFB.kext".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                                    subprocess.run(f"sudo cp -R {self.constants.legacy_amd_path}/AMD-Link/AppleIntelSNBGraphicsFB.kext {self.mount_extensions}".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-                        elif self.igpu_vendor == self.constants.pci_nvidia and not self.dgpu_devices:
-                            # Avoid patching twice, as Nvidia iGPUs will only have Nvidia dGPUs
-                            print("- Adding Nvidia Brightness Control patches")
-                            self.add_new_binaries(ModelArray.AddNvidiaBrightness11, self.constants.legacy_nvidia_path)
-                    if self.model in ModelArray.LegacyBrightness:
-                        self.add_brightness_patch()
+                print("- Detected legacy GPU, attempting legacy acceleration patches")
+                self.gpu_accel_patches_11()
                 rebuild_required = True
 
+        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("- Creating backup snapshot of user data (This may take some time)")
-        subprocess.run("tmutil snapshot".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
         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)")
-        subprocess.run(f"sudo kmutil install --volume-root {self.mount_location} --update-all".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()
-        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()
+        result = self.elevated(["kmutil", "install", "--volume-root", self.mount_location, "--update-all"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
+
+        if result.returncode != 0:
+            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.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")
+            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"):
@@ -286,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():
@@ -311,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} --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()
@@ -319,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:")
@@ -331,18 +459,19 @@ class PatchSysVolume:
             os.remove(self.constants.payload_apple_root_path_zip)
         else:
             print("- Download failed, please verify the below link works:")
-            print(self.constants.url_apple_binaries)
+            print(f"{self.constants.url_apple_binaries}{self.constants.payload_version}")
 
     def start_patch(self):
         # Check SIP
+        # self.check_files()
         if self.constants.custom_model is not None:
             print("Root Patching must be done on target machine!")
-        elif self.model in ModelArray.NoRootPatch11:
+        elif self.model in ModelArray.NoRootPatch11 and self.constants.assume_legacy is False:
             print("Root Patching not required for this machine!")
-        elif self.model not in ModelArray.SupportedSMBIOS:
+        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()
@@ -352,14 +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")
-                    print("\nPlease reboot the machine for patches to take effect")
+                    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!")
@@ -375,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()
@@ -384,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/.vuepress/config.js

@@ -98,11 +98,13 @@ module.exports = {
             collapsable: false,
             sidebarDepth: 1,
             children: [
+				'ACCEL',
 				'TROUBLESHOOTING',
 				'DEBUG',
 				'UPDATE',
 				'UNINSTALL',
 				'ICNS',
+				'WINDOWS',
             ]
         },
         {
@@ -124,6 +126,7 @@ module.exports = {
 				'TERMS',
 				'HOW',
 				'PATCHEXPLAIN',
+				'CLI',
             ]
 
         },

docs/ACCEL.md

@@ -0,0 +1,74 @@
+# Working Around Legacy Acceleration Issues
+
+* [Downloading older non-Metal Apps](#downloading-older-non-metal-apps)
+* [Unable to run Zoom](#unable-to-run-zoom)
+* [Unable to grant special permissions to apps (ie. Camera Access to Zoom)](#unable-to-grant-special-permissions-to-apps-ie-camera-access-to-zoom)
+* [Keyboard Backlight broken](#keyboard-backlight-broken)
+* [Photos and Maps Apps Heavily Distorted](#photos-and-maps-apps-heavily-distorted)
+* [Cannot press "Done" when editing a Sidebar Widget](#cannot-press-done-when-editing-a-sidebar-widget)
+* [Wake from sleep heavily distorted on AMD/ATI in macOS 11.3 and newer](#wake-from-sleep-heavily-distorted-on-amd-ati-in-macos-11-3-and-newer)
+* [Unable to achieve GPU Acceleration on 2011 15" and 17" MacBook Pros](#unable-to-achieve-gpu-acceleration-on-2011-15-and-17-macbook-pros)
+
+The below page is for users experiencing issues with their overall usage of macOS Big Sur and the Legacy Graphics Acceleration patches. Note that the following GPUs currently do not have acceleration support in Big Sur:
+
+* AMD/ATI TeraScale 2 - HD5/6000 series
+* Intel 3rd and 4th Gen - GMA series
+
+## Downloading older non-Metal Apps
+
+Many Apple apps now have direct reliance on Metal for proper functioning, however legacy builds of these apps still do work in Big Sur. See below for archive of many apps such as Pages, iMovie, GarageBand.
+
+* [Apple Apps for Non-Metal Macs](https://archive.org/details/apple-apps-for-non-metal-macs)
+
+Note: This archive assumes that you own these copies of these apps through the Mac App Store, Dortania does not condone piracy
+
+## Unable to run Zoom
+
+Currently Zoom relies partially on Metal and so needs a small binary patch. Dosdude1 has provided a nice script for this:
+
+* [Zoom Non-Metal Fix](http://dosdude1.com/catalina/zoomnonmetal-new.command.zip)
+
+## Unable to grant special permissions to apps (ie. Camera Access to Zoom)
+
+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.
+
+## Photos and Maps Apps Heavily Distorted
+
+Due to the Metal Backend, the enhanced color output of these apps seems to heavily break overall UI usage. To work around this, [users reported](https://forums.macrumors.com/threads/macos-11-big-sur-on-unsupported-macs-thread.2242172/post-29870324) forcing the color output of their monitor from Billions to Millions of colors helped greatly. Apps easily allowing this customization are [SwitchResX](https://www.madrau.com), [ResXreme](https://macdownload.informer.com/resxtreme/) and [EasyRes](http://easyresapp.com).
+
+## Cannot press "Done" when editing a Sidebar Widget
+
+To work around this, simply press Tab to hover over and press spacebar to simulate a click.
+
+## Wake from sleep heavily distorted on AMD/ATI in macOS 11.3 and newer
+
+Unfortunately a very well known issue the community is investigating, current known solution is to simply downgrade to 11.2.3 or older until a proper fix can be found.
+
+In the event Apple removes 11.2.3 from their catalogue, we've provided a mirror below:
+
+* [Install macOS 11.2.3 20D91](https://archive.org/details/install-mac-os-11.2.3-20-d-91)
+
+## Unable to achieve GPU Acceleration on 2011 15" and 17" MacBook Pros
+
+Currently OpenCore Legacy Patcher doesn't have support for the TeraScale 2 series dGPUs found in the 15" and 17" models. Currently the best way to achieve graphics acceleration is to simply disable the dGPU and force the iGPU always.
+
+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
+```
+
+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

@@ -2,20 +2,23 @@
 
 With OpenCore Legacy Patcher we recommend users go through the below table to understand what the benefits and drawbacks are compared to other patchers. There are positive and negatives to each and we feel transparency is most important when patching another users machine. There should be no grey areas where users may be mislead.
 
+* Note: [Patched Sur](https://github.com/BenSova/Patched-Sur) and [MicropatcherAutomator](https://github.com/moosethegoose2213/automator-for-barrykn-micropatcher) are iterations of [BarryKN's micropatcher](https://github.com/barrykn/big-sur-micropatcher) and therefore share many of the same benefits and limitations. Patched Sur is used for this comparison as it's the most common form of BarryKN's patcher users will find.
+
 | 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> |
-| 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</span> |
+| 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> |
+| 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> |
-| Brightness Control on Legacy GPUs | <span style="color:#30BCD5">Supported</span> | <span style="color:#30BCD5">Supported</span> |
 | Legacy GPU Acceleration | <span style="color:#30BCD5">In active development</span>, see Acceleration Progress Tracker: [Link](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108) | <span style="color:red">Currently not researching</span> |
-| WPA Wifi Support | <span style="color:#30BCD5">Native, stable</span> | <span style="color:red">Unstable</span> |
+| El Capitan-era Wifi cards | <span style="color:#30BCD5">Supported</span> | <span style="colorred">Not supported</span> |
+| WPA Wireless Support | <span style="color:#30BCD5">Supported</span> | <span style="color:red">Minority may experience issues on early 2013 and older Models</span> |
+| Personal Hotspot Support | <span style="color:#30BCD5">Native</span> | <span style="color:red">Often requires extra steps to achieve on early 2013 and older Models</span> |
 | 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> | <span style="color:red">Not available</span> |
-| El Capitan-era Wifi cards | <span style="color:#30BCD5">Supported</span> | <span style="color:red">Not supported</span> |
-| Hibernation Support | <span style="color:#30BCD5">Supports 3rd party SATA SSDs in addition to stock models</span> | <span style="color:red">Only supports stock drives</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> |

docs/BOOT.md

@@ -2,7 +2,7 @@
 
 Now we finally get to boot OpenCore!
 
-Reboot machine while holding `Option` to select the EFI Boot entry with the OpenCore icon:
+Reboot machine while holding `Option` to select the EFI Boot entry with the OpenCore icon (holding the `Control` key will make this the default boot entry):
 
 * This will be the Mac Boot Picker
 
@@ -14,9 +14,8 @@ 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)
 
-# Once installed and booting, head to [Post-Installation](./POST-INSTALL.md)
+# Once installed and booting, head to [Post-Installation](./POST-INSTALL.md)

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

@@ -0,0 +1,41 @@
+# Command Line Args
+
+With OpenCore Legacy Patcher, we include an extra binary called [OCLP-CLI](https://github.com/dortania/OpenCore-Legacy-Patcher/releases/). The purpose of this binary is to easily run our OpenCore build process for other programs to hook onto. Below is documentation on currently supported arguments.
+
+### Build Arguments
+
+* **--build**: Build OpenCore
+  * **--model xxxx**: override default model detection
+    * ex. **--model iMac11,2**
+  * **--metal_gpu xxxx**: override default GPU detection (ie. Nvidia, AMD)
+    * **--metal_gpu Nvidia**
+  * **--smbios_spoof xxxx**: set spoofing mode, defaults to Minimal if no arg provided (ie. Minimal, Moderate, Advanced)
+    * ex. **--smbios_spoof Moderate**
+  * **--verbose**: enable verbose booting
+  * **--debug_oc**: enable debug OpenCore
+  * **--debug_kext**: enable debug kexts
+  * **--skip_wifi**: skip wifi patch
+  * **--hide_picker**: hide OpenCore's picker
+  * **--disable_sip**: disables SIP
+  * **--disable_smb**: disables SecureBootModel
+  * **--vault**: enable OpenCore vaulting
+  
+Example usage:
+
+```bash
+./OCLP-CLI --build --verbose --debug_oc --debug_kext --model iMac11,2
+```
+
+Note, when building OpenCore the output folder will be next to the OCLP binary as OpenCore-RELEASE or OpenCore-DEBUG folder.
+
+### Patch System Arguments
+
+* **--patch_sys_vol**: patches root volume with detected hardware
+
+Example usage:
+
+```bash
+sudo ./OCLP-CLI --patch_sys_vol
+```
+
+Note, root volume patching needs to be run as sudo

docs/DEBUG.md

@@ -2,7 +2,7 @@
 
 For those who've hit an odd bug and unsure if it's user error or patcher, the below will tell you how to get more verbose debug information as well as logs to help [file issues with us](https://github.com/dortania/OpenCore-Legacy-Patcher/issues)
 
-* For users who are less experienced, we recommend asking on the [Unsupported Mac Discord Server](https://discord.gg/XbbWAsE) for help.
+* For users who are less experienced, we recommend asking on the [OpenCore Patcher Paradise Discord Server](https://discord.gg/rqdPgH8xSN) for help.
 
 ## Debugging yourself
 
@@ -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

@@ -4,18 +4,22 @@ OpenCore Legacy Patcher is a hobby project for us developers, and while we love
 
 The best way to support us in all honesty is to donate any old hardware you no longer need, as this allows us to have machines to test locally and push fixes much faster. While we appreciate cash donations, this makes it much more difficult for us to handle as an organization.
 
-Main hardware we'd appreciate:
+Main sections of help we'd appreciate:
 
-* Any Mac you own
+* Donating any Mac you own
   * Does require SSE4,1 CPU to test on Sierra and newer however
-  
+* 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 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, please contact us at the following email:
+If you have any legacy hardware you're willing to donate or what to buy us something, please contact us at the following email:
 
 * khronokernel@icloud.com
 
@@ -25,8 +29,7 @@ Current hardware we own:
 | :--- | :--- | :--- | :--- | :--- |
 | MacBook7,1 | Penryn | GT320M | Dhinak | N/A |
 | MacBook7,1 | Penryn | GT320M | 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 |
-
-
-<!-- | MacBookPro5,3 | Penryn | 9400M + 9600M | Dhinak | Display's partially broken | -->
-<!-- | Macmini4,1 | Penryn | GT320M | Dhinak | 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

@@ -10,26 +10,13 @@ This patcher is made of multiple external applications from different people and
   * [CPUFriend](https://github.com/acidanthera/CPUFriend/blob/master/LICENSE)
   * [RestrictEvents](https://github.com/acidanthera/RestrictEvents/blob/master/LICENSE.txt)
   * [NightShiftEnabler](https://github.com/cdf/NightShiftEnabler/blob/master/LICENSE.txt)
+  * [Innie](https://github.com/cdf/Innie/blob/master/LICENSE.txt)
+* GPL 2.0
+  * [NVMeFix](https://github.com/acidanthera/NVMeFix/blob/master/LICENSE.txt)
 * All rights reserved to respective authors
   * [AAAMouSSE](https://forums.macrumors.com/threads/mp3-1-others-sse-4-2-emulation-to-enable-amd-metal-driver.2206682/) - Syncretic
   * [telemetrap](https://forums.macrumors.com/threads/mp3-1-others-sse-4-2-emulation-to-enable-amd-metal-driver.2206682/post-28447707) - Syncretic
+  * [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,8 +20,8 @@ Regarding OS support, see below:
 
 | Support Entry | Supported OSes | Description | Comment |
 | :--- | :--- | :--- | :--- |
-| HostOS | macOS 10.9-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 |
-| TargetOS | macOS 11 | Refers to OSes that can be patched to run with OpenCore | Unofficially supports 10.4 and newer, no support provided via this patcher |
+| 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
 
@@ -30,10 +30,10 @@ Regarding OS support, see below:
 | MacBook1,1 | Mid-2006 | <span style="color:red"> NO </span>  | 32-Bit CPU limitation |
 | MacBook2,1 | Late 2006 | ^^ | 32-Bit Firmware limitation |
 | MacBook3,1 | Late 2007 | ^^ | ^^ |
-| MacBook4,1 | Early 2008 | <span style="color:#30BCD5"> YES </span> | - No GPU Acceleration in Mavericks and newer<br/>- No Keyboard and Trackpad<br/>- No USB<br/>- No Ethernet) |
-| MacBook5,1 | Late 2008 | ^^ | - No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/>- Trackpad is recognized as mouse |
-| MacBook5,2 | Early 2009 | ^^ | - No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/>- Trackpad is recognized as mouse<br/>- Brightness control partially supported |
-| MacBook6,1 | Late 2009 | ^^ | - No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/> |
+| MacBook4,1 | Early 2008 | <span style="color:#30BCD5"> YES </span> | - No GPU Acceleration in Mavericks and newer<br/>- No Keyboard and Trackpad<br/>- No USB |
+| MacBook5,1 | Late 2008 | ^^ | - GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/> |
+| MacBook5,2 | Early 2009 | ^^ | - GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/>- Trackpad is recognized as mouse<br/>- Brightness control partially supported |
+| MacBook6,1 | Late 2009 | ^^ | - GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/> |
 | MacBook7,1 | Mid-2010 | ^^ | ^^ |
 
 ### MacBook Air
@@ -41,7 +41,7 @@ Regarding OS support, see below:
 | SMBIOS | Year | Supported | Comment |
 | :--- | :--- | :--- | :--- |
 | MacBookAir1,1 | Early 2008 | <span style="color:red"> NO </span> | Requires SSE4.1 CPU |
-| MacBookAir2,1 | Late 2008 |<span style="color:#30BCD5"> YES </span> | No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
+| MacBookAir2,1 | Late 2008 |<span style="color:#30BCD5"> YES </span> | GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
 | MacBookAir3,1 | Late 2010 | ^^ | ^^ |
 | MacBookAir3,2 | ^^ | ^^ | ^^ |
 | MacBookAir4,1 | Mid-2011 | ^^ | ^^ |
@@ -58,7 +58,7 @@ Regarding OS support, see below:
 | MacBookPro2,1 | Late 2006 | ^^ | 32-Bit Firmware limitation |
 | MacBookPro2,2 | Late 2006 | ^^ | ^^ |
 | MacBookPro3,1 | Mid-2007 | ^^ | Requires SSE4.1 CPU |
-| MacBookPro4,1 | Early 2008 | <span style="color:#30BCD5"> YES </span> | No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
+| MacBookPro4,1 | Early 2008 | <span style="color:#30BCD5"> YES </span> | GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
 | MacBookPro5,1 | Late 2008 | ^^ | ^^ |
 | MacBookPro5,2 | Early 2009 | ^^ | ^^ |
 | MacBookPro5,3 | Mid-2009 | ^^ | ^^ |
@@ -81,7 +81,7 @@ Regarding OS support, see below:
 | :--- | :--- | :--- | :--- |
 | Macmini1,1 | Early 2006 | <span style="color:red"> NO </span> | 32-Bit CPU limitation |
 | Macmini2,1 | Mid-2007 | ^^ | 32-Bit Firmware limitation |
-| Macmini3,1 | Early 2009 | <span style="color:#30BCD5"> YES </span> | No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
+| Macmini3,1 | Early 2009 | <span style="color:#30BCD5"> YES </span> | GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
 | Macmini4,1 | Mid-2010 | ^^ | ^^ |
 | Macmini5,1 | Mid-2011 | ^^ | ^^ |
 | Macmini5,2 | ^^ | ^^ | ^^ |
@@ -98,10 +98,10 @@ Regarding OS support, see below:
 | iMac5,1 | Late 2006 | ^^ | 32-Bit Firmware limitation |
 | iMac5,2 | ^^ | ^^ | ^^ |
 | iMac6,1 | ^^ | ^^ | ^^ |
-| iMac7,1 | Mid-2007 | <span style="color:#30BCD5"> YES </span> | - Requires an SSE4.1 CPU Upgrade<br/>- No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/>- Brightness control partially supported on Nvidia GPUs, AMD unsupported  |
-| iMac8,1 | Early 2008 | ^^ | - No GPU Acceleration in Big Sur([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)))<br/>- Brightness control partially supported on Nvidia GPUs, AMD unsupported |
+| iMac7,1 | Mid-2007 | <span style="color:#30BCD5"> YES </span> | - Requires an [SSE4.1 CPU Upgrade](https://lowendmac.com/2018/penryn-t9300-9500-cpu-upgrades-for-the-2007-imac/)<br/>- GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108))<br/>- Brightness control partially supported on Nvidia GPUs, AMD unsupported<br/>- Stock Bluetooth 2.0 card non-functional  |
+| iMac8,1 | Early 2008 | ^^ | - GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)))<br/>- Brightness control partially supported on Nvidia GPUs, AMD unsupported |
 | iMac9,1 | Early 2009 | ^^ | ^^ |
-| iMac10,1 | Late 2009 | ^^ | GPU is socketed, [recommend upgrading to Metal GPU](https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/?post=17425857#post-17425857)  |
+| iMac10,1 | Late 2009 | ^^ | - GPU is socketed, [recommend upgrading to Metal GPU](https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/?post=17425857#post-17425857) <br/>- GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
 | iMac11,1 | ^^ | ^^ | ^^ |
 | iMac11,2 | Mid-2010 | ^^ | ^^ |
 | iMac11,3 | ^^ | ^^ | ^^ |
@@ -114,7 +114,7 @@ Regarding OS support, see below:
 | iMac14,2 | ^^ | ^^ | ^^ |
 | iMac14,3 | ^^ | ^^ | ^^ |
 
-* For iMac10,1 through iMac12,x, we highly recommend users upgrade the GPU to a Metal supported model. See here for more information: [iMac late 2009 to mid-2012 Graphics Card Upgrade Guide](https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/?post=17425857#post-17425857)
+* For iMac10,1 through iMac12,x, we highly recommend users upgrade the GPU to a Metal supported model. See here for more information: [iMac late 2009 to mid-2011 Graphics Card Upgrade Guide](https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/?post=17425857#post-17425857)
 
 ### Mac Pro
 
@@ -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 |
@@ -135,4 +134,4 @@ Regarding OS support, see below:
 | Xserve2,1 | Early 2008 | <span style="color:#30BCD5"> YES </span> | <span style="color:green"> Everything is supported as long as GPU is Metal capable </span> |
 | Xserve3,1 | Early 2009 | ^^ | ^^ |
 
-# Once you've verified your hardware is supported, head to [Download and build macOS Installers](./INSTALLER.md)
+# Once you've verified your hardware is supported, head to [Download and build macOS Installers](./INSTALLER.md)

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/POST-INSTALL.md

@@ -2,6 +2,7 @@
 
 * [Booting without USB drive](#booting-without-usb-drive)
 * [Booting seamlessly without Verbose or OpenCore Picker](#booting-seamlessly-without-verbose-or-opencore-picker)
+* [Applying Post Install Volume Patches](#applying-post-install-volume-patches)
 
 ## Booting without USB drive
 
@@ -27,9 +28,21 @@ Here you can change different patcher settings, however the main interest is:
 
 Once you've toggled them both off, build your OpenCore EFI once again and install to your desired drive. Now to show the OpenCore selector, you can simply hold down the "ESC" key while clicking on EFI boot, then you can release the "ESC" key when you see the cursor arrow at the top left.
 
-**Note**: For users who need Post-Install Volume patches for Audio support, you **must** disable the following settings in "Patcher Settings" when building and installing your new OpenCore:
+## Applying Post Install Volume Patches
+
+**Note**: For users who need Post-Install Volume patches for legacy video acceleration support, you **must** disable the following settings in "Patcher Settings" when building and installing your new OpenCore:
 
 * SIP: Disabled
 * SecureBootModel: Disabled
 
-Once set, rebuild OpenCore, install to drive and reboot. Then, Post-Install Volume patches will run just fine
+Once set, rebuild OpenCore, install to drive and reboot. Then, Post-Install Volume patches will run just fine
+
+To apply the Post-Install Volume patches [to test out the Beta Graphics Acceleration Patches system](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108), select option #3 as shown below:
+
+![](../images/root-patch.png)
+
+And go ahead to option #1 and let the OCLP patcher apply the needed legacy video patches.
+
+![](../images/root-patcher-2.png)
+
+Reboot your system and check out the now working graphics acceleration on your legacy system. This is still Beta software.

docs/START.md

@@ -5,12 +5,20 @@ This is a sophisticated boot loader used to inject and patch data in memory, ins
 * System Integrity Protection, FileVault 2, .im4m Secure Boot and Vaulting
 * Native OTA OS DELTA updates on all Macs
 * Recovery OS, Safe Mode and Single-user Mode booting
+* WPA Wifi and Personal Hotspot support
 
 While many PC users from the Hackintosh community are familiar with OpenCore, OpenCore was designed as Mac and PC agnostic ensuring both platforms can use it easily. And with OpenCore Legacy Patcher, we help automate the process making running with OpenCore that much easier.
 
-For advanced troubleshooting, we highly recommend users check out the [Unsupported Mac Discord Server](https://discord.gg/XbbWAsE) as this is generally the quickest way to get a hold of us developers and get help from the community.
+For advanced troubleshooting, we highly recommend users check out the [OpenCore Patcher Paradise Discord Server](https://discord.gg/rqdPgH8xSN) as this is generally the quickest way to get a hold of us developers and get help from the community.
 
-For those who wish to support this patcher, please see the [Supporting the Patcher page](./DONATE.md) 
+For those who wish to support this patcher, please see the [Supporting the Patcher page](./DONATE.md)
+
+## Patcher Warnings
+
+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](./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 |
@@ -42,11 +41,11 @@ To aid users in troubleshooting, we've compiled a list of users who've reported
 | MacBookPro5,5 | ^^ | ^^ | ^^ |
 | MacBookPro6,1 | ^^ | ^^ | ^^ |
 | MacBookPro6,2 | <span style="color:#30BCD5"> YES </span> | Jakeluke | - Stock model, dGPU broken <br/>- Patcher version unknown |
-| MacBookPro7,1 | No reports | N/A | N/A |
-| MacBookPro8,1 | <span style="color:#30BCD5"> YES </span> | AvaQueen | - Stock model <br/>- Patcher version 0.0.19 |
+| MacBookPro7,1 | ^^ | fussel132 | - Stock model <br/>-Patcher version v0.1.2 |
+| 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 | ^^ |
@@ -56,6 +55,7 @@ To aid users in troubleshooting, we've compiled a list of users who've reported
 | ^^ | ^^ | CyberDroid1 | - Stock model<br/>- Patcher version 0.0.16 |
 | ^^ | ^^ | woefi | - BCM94331CAX upgrade<br/>- Patcher version 0.0.13 |
 | ^^ | ^^ | whgmkeller | - Stock model<br/>- Patcher version 0.0.11 |
+| ^^ | ^^ | vinaypundith | - Patcher version 0.0.7 |
 | MacBookPro10,1 | ^^ | traviswparker | - Stock model <br/>- Patcher version 0.0.14 |
 | ^^ | ^^ | il-rollino | - Upgraded BCM94360CSAX <br/>- Patcher version 0.0.21 |
 | MacBookPro10,2 | No reports | N/A | N/A |
@@ -86,6 +86,7 @@ To aid users in troubleshooting, we've compiled a list of users who've reported
 | iMac11,1 | ^^ | internetzel | - Upgraded with RX580 mobile |
 | iMac11,2 | ^^ | MykolaG | - Stock Model<br/>- Patcher version 0.0.21 |
 | ^^ | ^^ | iMac-iPad | - Stock Model<br/>- Patcher version 0.0.21 |
+| ^^ | ^^ | vinaypundith | - Patcher version 0.0.19 |
 | iMac11,3 | ^^ | Ausdauersportler | - Upgraded with Polaris GPU<br/>- Upgraded BCM943602CDP<br/>- Patcher version 0.0.21 |
 | iMac12,1 | ^^ | shnockdu | - Upgraded with Kepler GPU<br/>- Patcher version 0.0.21 |
 | ^^ | ^^ | StephN999 | - Upgraded WX4150 GPU<br/>- Upgraded BCM94360CD<br/>- Patcher version 0.0.21 |
@@ -104,11 +105,13 @@ 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 |
 | ^^ | ^^ | Pri-est | - Patcher version 0.0.9 |
+| ^^ | ^^ | vinaypundith | - Upgraded GTX 680<br/>- Upgraded BCM94360CD<br/>- Patcher version 0.0.6 |
 | MacPro4,1 | ^^ | ^^ | - Patcher version 0.0.9 |
 | MacPro5,1 | ^^ | woefi | - Upgraded with RX 580<br/>- Patcher version 0.0.21 |
 | ^^ | ^^ | Mabrouk Oscar | - Patcher version 0.0.21 |

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,9 +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 folder
-  * [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

@@ -0,0 +1,88 @@
+# Installing UEFI Windows 10
+
+* Guide based off of [cdf's Mac Pro Thread](https://forums.macrumors.com/threads/opencore-on-the-mac-pro.2207814/)
+
+To install UEFI is actually super simple! All it requires is to boot Windows' Installer through OpenCore to force a UEFI setup. Here we'll be going a bit more step by step in the process including partitioning and such.
+
+* Note: UEFI Windows is generally quite usable for Arrendale and newer models, however machines with Penryn CPUs may experience issues
+* Recommended Models:
+  * MacBookAir4,x and newer
+  * MacBookPro8,x and newer
+  * Macmini5,x and newer
+  * iMac11,x and newer
+  * MacPro4,1 and newer
+  * Xserve3,1 and newer
+
+Once you know your model is supported, you're good to go with the rest of this guide
+
+## Disk Formatting
+
+To start off, we'll need the following:
+
+* An 8GB USB drive for the Windows Installer
+* Minimum of 30GB of free space on whatever drive you want to install Windows too
+
+First, lets format out drives as follows:
+
+### USB Drive Formatting
+
+Open Disk Utility in macOS and format the USB Drive as ExFat with MBR Scheme:
+
+![](../images/windows-mbr-format.png)
+
+### Disk Formatting
+
+Next, grab the drive you wish to install Windows on and partition it as ExFat (If formatting entire drive, ensure it's GUID Partition Table):
+
+![](../images/windows-partition-1.png)
+
+If you plan to use the same hard drive for macOS and Windows, we recommend creating a dedicated partition just for OpenCore. This lets Windows have the ESP to itself and OpenCore can stay within it's own bubble.
+
+Recommended size is 200MB and the partition format **must** be FAT32 for OpenCore to operate correctly. You will next want to install OpenCore onto the new partition, either moving from the ESP with [MountEFI](https://github.com/corpnewt/MountEFI) or rerunning the OpenCore-Patcher.app
+
+* Note: For machines with dedicated drives for Windows, having different partitions for OpenCore is not required
+* Note 2: We recommend uninstalling OpenCore from the ESP/EFI Partition when you create this new OpenCore partition to avoid confusion when selecting OpenCore builds in the Mac's boot picker
+
+![](../images/windows-partition-2.png)
+
+## Creating the Installer
+
+First up, lets grab Windows's Installer at the below link:
+
+* [Download Windows 10 Disc Image (ISO File)](https://www.microsoft.com/en-ca/software-download/windows10ISO)
+
+Next, mount the Windows 10 ISO:
+
+![](../images/windows-iso.png)
+
+The open terminal and run `rsync` on the USB drive (replace CCCOMA_X64 with the mounted ISO's name, as well as replacing W10USB with your USB drive's name):
+
+```
+rsync -r -P /Volumes/CCCOMA_X64/ /Volumes/W10USB
+```
+
+![](../images/rsync-progess.png)
+
+Command will take some time, so sit back and get some coffee. Once finished, the root of the USB drive should look as follows:
+
+* Ensure that these folders and files are on the root, otherwise the USB will not boot
+
+![](../images/windows-rsync-done.png)
+
+Once done, lets reboot into OpenCore's Menu and you'll see a new Windows' entry:
+
+* Note: Do not boot the installer outside of OpenCore as this will default back to the old MBR BIOS setup. Booting through OpenCore ensures Windows uses UEFI
+
+![](../images/oc-windows.png)
+
+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
+
+![](../images/oc-windows-done.png)
+
+## Troubleshooting
+
+### iMac12,x Bluescreen after driver installation
+
+Currently Intel's iGPU drivers for the HD 3000 series do not support UEFI booting in Windows. Recommended solution is to simply disable: [iMac 12,1 Windows 10 Boot Loop – Fix Intel Graphics issue](https://zzq.org/?p=39)

payloads/ACPI/Source/SSDT-CPBG.dsl

@@ -0,0 +1,27 @@
+/* Disable the non-existant Co-processor Bridge found on Arrendale, Lynnfield and Clarkdale Macs.
+ * IOPCIFamily in macOS 11.0 up-to 11.2 was unable to handle ACPI probing when device was not present,
+ * therefore kernel panicing the machine.
+ *
+ * This SSDT reports the device as disabled avoiding the probing.
+ * Not required for macOS 11.2 and newer, however recommended to alliviate pottential issues
+ */
+DefinitionBlock ("", "SSDT", 2, "DRTNIA", "CPBGoff", 0x00001000)
+{
+    External (_SB_.CPBG, DeviceObj)
+
+    Scope (_SB.CPBG)
+    {
+        Method (_STA, 0, NotSerialized)  // _STA: Status
+        {
+            If (_OSI ("Darwin"))
+            {
+                Store ("Disabling incompatible CPBG Device", Debug)
+                Return (Zero) // Disable only in macOS incase Windows or Linux requires
+            }
+            Else
+            {
+                Return (0x0F)
+            }
+        }
+    }
+}

payloads/ACPI/Source/SSDT-PCI.dsl

@@ -0,0 +1,165 @@
+/* Removes PCI0's 32-bit Allocation Limitation to resolve PCIe device support on Sandy and
+ * Ivy Bridge Macs, mainly applicable for Audio and eGPU support.
+ * BUF0 to BUF1 patch required to override exisiting BuffObj in DSDT.
+ *
+ * Source:
+ * https://egpu.io/forums/pc-setup/fix-dsdt-override-to-correct-error-12/
+ */
+DefinitionBlock ("", "SSDT", 2, "DRTNIA", "WinPCI", 0x00000000)
+{
+    External (_SB_.PCI0, DeviceObj)
+
+    Scope (\_SB.PCI0)
+    {
+        Store ("Injecting new BUF0 BuffObj", Debug)
+        Name (BUF0, ResourceTemplate ()
+        {
+            WordBusNumber (ResourceProducer, MinFixed, MaxFixed, PosDecode,
+                0x0000,             // Granularity
+                0x0000,             // Range Minimum
+                0x00FF,             // Range Maximum
+                0x0000,             // Translation Offset
+                0x0100,             // Length
+                ,, )
+            DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                0x00000000,         // Granularity
+                0x00000000,         // Range Minimum
+                0x00000CF7,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00000CF8,         // Length
+                ,, , TypeStatic, DenseTranslation)
+            IO (Decode16,
+                0x0CF8,             // Range Minimum
+                0x0CF8,             // Range Maximum
+                0x01,               // Alignment
+                0x08,               // Length
+                )
+            DWordIO (ResourceProducer, MinFixed, MaxFixed, PosDecode, EntireRange,
+                0x00000000,         // Granularity
+                0x00000D00,         // Range Minimum
+                0x0000FFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x0000F300,         // Length
+                ,, , TypeStatic, DenseTranslation)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000A0000,         // Range Minimum
+                0x000BFFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00020000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000C0000,         // Range Minimum
+                0x000C3FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000C4000,         // Range Minimum
+                0x000C7FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000C8000,         // Range Minimum
+                0x000CBFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000CC000,         // Range Minimum
+                0x000CFFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000D0000,         // Range Minimum
+                0x000D3FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000D4000,         // Range Minimum
+                0x000D7FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000D8000,         // Range Minimum
+                0x000DBFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000DC000,         // Range Minimum
+                0x000DFFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000E0000,         // Range Minimum
+                0x000E3FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000E4000,         // Range Minimum
+                0x000E7FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000E8000,         // Range Minimum
+                0x000EBFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000EC000,         // Range Minimum
+                0x000EFFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00004000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x000F0000,         // Range Minimum
+                0x000FFFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00010000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0x00000000,         // Range Minimum
+                0xFEAFFFFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0xFEB00000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            DWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x00000000,         // Granularity
+                0xFED40000,         // Range Minimum
+                0xFED44FFF,         // Range Maximum
+                0x00000000,         // Translation Offset
+                0x00005000,         // Length
+                ,, , AddressRangeMemory, TypeStatic)
+            QWordMemory (ResourceProducer, PosDecode, MinFixed, MaxFixed, Cacheable, ReadWrite,
+                0x0000000000000000, // Granularity
+                0x0000000C20000000, // Range Minimum,  set it to 48.5GB
+                0x0000000E0FFFFFFF, // Range Maximum,  set it to 56.25GB
+                0x0000000000000000, // Translation Offset
+                0x00000001F0000000, // Length calculated by Range Max - Range Min.
+                ,, , AddressRangeMemory, TypeStatic)
+        })
+    }
+}

payloads/Config/config.plist

@@ -23,6 +23,14 @@
 				<key>Path</key>
 				<string>SSDT-CPBG.aml</string>
 			</dict>
+			<dict>
+				<key>Enabled</key>
+				<false/>
+				<key>Comment</key>
+				<string>Patch Windows Audio support for Sandy and Ivy Bridge</string>
+				<key>Path</key>
+				<string>SSDT-PCI.aml</string>
+			</dict>
 		</array>
 		<key>Delete</key>
 		<array/>
@@ -38,7 +46,7 @@
 				<key>Count</key>
 				<integer>0</integer>
 				<key>Enabled</key>
-				<true/>
+				<false/>
 				<key>Find</key>
 				<data>WEhDMQ==</data>
 				<key>Limit</key>
@@ -68,7 +76,7 @@
 				<key>Count</key>
 				<integer>0</integer>
 				<key>Enabled</key>
-				<true/>
+				<false/>
 				<key>Find</key>
 				<data>RUhDMQ==</data>
 				<key>Limit</key>
@@ -98,7 +106,7 @@
 				<key>Count</key>
 				<integer>0</integer>
 				<key>Enabled</key>
-				<true/>
+				<false/>
 				<key>Find</key>
 				<data>RUhDMg==</data>
 				<key>Limit</key>
@@ -118,6 +126,36 @@
 				<key>TableSignature</key>
 				<data></data>
 			</dict>
+			<dict>
+				<key>Base</key>
+				<string>\_SB.PCI0</string>
+				<key>BaseSkip</key>
+				<integer>0</integer>
+				<key>Comment</key>
+				<string>BUF0 to BUF1</string>
+				<key>Count</key>
+				<integer>1</integer>
+				<key>Enabled</key>
+				<false/>
+				<key>Find</key>
+				<data>QlVGMA==</data>
+				<key>Limit</key>
+				<integer>0</integer>
+				<key>Mask</key>
+				<data></data>
+				<key>OemTableId</key>
+				<data></data>
+				<key>Replace</key>
+				<data>QlVGMQ==</data>
+				<key>ReplaceMask</key>
+				<data></data>
+				<key>Skip</key>
+				<integer>0</integer>
+				<key>TableLength</key>
+				<integer>0</integer>
+				<key>TableSignature</key>
+				<data>RFNEVA==</data>
+			</dict>
 		</array>
 		<key>Quirks</key>
 		<dict>
@@ -220,7 +258,7 @@
 				<key>MaxKernel</key>
 				<string></string>
 				<key>MinKernel</key>
-				<string>19.0.0</string>
+				<string>18.0.0</string>
 				<key>BundlePath</key>
 				<string>AppleALC.kext</string>
 				<key>ExecutablePath</key>
@@ -274,7 +312,7 @@
 				<key>MaxKernel</key>
 				<string></string>
 				<key>MinKernel</key>
-				<string>18.0.0</string>
+				<string></string>
 				<key>BundlePath</key>
 				<string>AAAMouSSE.kext</string>
 				<key>ExecutablePath</key>
@@ -534,24 +572,6 @@
 				<key>PlistPath</key>
 				<string>Contents/Info.plist</string>
 			</dict>
-			<dict>
-				<key>Arch</key>
-				<string>x86_64</string>
-				<key>Comment</key>
-				<string>VoodooHDA</string>
-				<key>Enabled</key>
-				<false/>
-				<key>MaxKernel</key>
-				<string></string>
-				<key>MinKernel</key>
-				<string>18.0.0</string>
-				<key>BundlePath</key>
-				<string>VoodooHDA.kext</string>
-				<key>ExecutablePath</key>
-				<string>Contents/MacOS/VoodooHDA</string>
-				<key>PlistPath</key>
-				<string>Contents/Info.plist</string>
-			</dict>
 			<dict>
 				<key>Arch</key>
 				<string>x86_64</string>
@@ -768,6 +788,78 @@
 				<key>PlistPath</key>
 				<string>Contents/Info.plist</string>
 			</dict>
+			<dict>
+				<key>Arch</key>
+				<string>x86_64</string>
+				<key>Comment</key>
+				<string>NVMeFix</string>
+				<key>Enabled</key>
+				<false/>
+				<key>MaxKernel</key>
+				<string></string>
+				<key>MinKernel</key>
+				<string></string>
+				<key>BundlePath</key>
+				<string>NVMeFix.kext</string>
+				<key>ExecutablePath</key>
+				<string>Contents/MacOS/NVMeFix</string>
+				<key>PlistPath</key>
+				<string>Contents/Info.plist</string>
+			</dict>
+			<dict>
+				<key>Arch</key>
+				<string>x86_64</string>
+				<key>Comment</key>
+				<string>SidecarFixup</string>
+				<key>Enabled</key>
+				<false/>
+				<key>MaxKernel</key>
+				<string></string>
+				<key>MinKernel</key>
+				<string>19.0.0</string>
+				<key>BundlePath</key>
+				<string>SidecarFixup.kext</string>
+				<key>ExecutablePath</key>
+				<string>Contents/MacOS/SidecarFixup</string>
+				<key>PlistPath</key>
+				<string>Contents/Info.plist</string>
+			</dict>
+			<dict>
+				<key>Arch</key>
+				<string>x86_64</string>
+				<key>Comment</key>
+				<string>Innie</string>
+				<key>Enabled</key>
+				<false/>
+				<key>MaxKernel</key>
+				<string></string>
+				<key>MinKernel</key>
+				<string></string>
+				<key>BundlePath</key>
+				<string>Innie.kext</string>
+				<key>ExecutablePath</key>
+				<string>Contents/MacOS/Innie</string>
+				<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/>
@@ -828,7 +920,7 @@
 				<key>Count</key>
 				<integer>1</integer>
 				<key>Enabled</key>
-				<true/>
+				<false/>
 				<key>Find</key>
 				<data>c21jLXZlcnNpb24=</data>
 				<key>Identifier</key>
@@ -880,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>
@@ -923,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>
@@ -998,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>
@@ -1014,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>
@@ -1021,7 +1119,7 @@
 				<key>RealPath</key>
 				<false/>
 				<key>TextMode</key>
-				<false/>
+				<true/>
 			</dict>
 		</array>
 	</dict>
@@ -1038,8 +1136,6 @@
 			</dict>
 			<key>4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102</key>
 			<dict>
-				<key>rtc-blacklist</key>
-				<data></data>
 				<key>OCLP-Version</key>
 				<string></string>
 			</dict>
@@ -1048,12 +1144,12 @@
 				<key>SystemAudioVolume</key>
 				<data>Rg==</data>
 				<key>boot-args</key>
-				<string>keepsyms=1 debug=0x100</string>
-				<key>run-efi-updater</key>
-				<string>No</string>
+				<string>keepsyms=1 debug=0x100 -no_compat_check -lilubetaall</string>
 				<key>csr-active-config</key>
 				<data>AAAAAA==</data>
 			</dict>
+			<key>FA4CE28D-B62F-4C99-9CC3-6815686E30F9</key>
+			<dict/>
 		</dict>
 		<key>Delete</key>
 		<dict>
@@ -1064,44 +1160,23 @@
 			</array>
 			<key>4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102</key>
 			<array>
-				<string>rtc-blacklist</string>
 				<string>OCLP-Version</string>
+				<string>revcpu</string>
+				<string>revcpuname</string>
 			</array>
 			<key>7C436110-AB2A-4BBB-A880-FE41995C9F82</key>
 			<array>
 				<string>boot-args</string>
 			</array>
+			<key>FA4CE28D-B62F-4C99-9CC3-6815686E30F9</key>
+			<array/>
 		</dict>
 		<key>LegacyEnable</key>
 		<false/>
 		<key>LegacyOverwrite</key>
 		<false/>
 		<key>LegacySchema</key>
-		<dict>
-			<key>7C436110-AB2A-4BBB-A880-FE41995C9F82</key>
-			<array>
-				<string>EFILoginHiDPI</string>
-				<string>EFIBluetoothDelay</string>
-				<string>LocationServicesEnabled</string>
-				<string>SystemAudioVolume</string>
-				<string>SystemAudioVolumeDB</string>
-				<string>SystemAudioVolumeSaved</string>
-				<string>bluetoothActiveControllerInfo</string>
-				<string>bluetoothInternalControllerInfo</string>
-				<string>flagstate</string>
-				<string>fmm-computer-name</string>
-				<string>nvda_drv</string>
-				<string>prev-lang:kbd</string>
-			</array>
-			<key>8BE4DF61-93CA-11D2-AA0D-00E098032B8C</key>
-			<array>
-				<string>Boot0080</string>
-				<string>Boot0081</string>
-				<string>Boot0082</string>
-				<string>BootNext</string>
-				<string>BootOrder</string>
-			</array>
-		</dict>
+		<dict/>
 		<key>WriteFlash</key>
 		<true/>
 	</dict>
@@ -1165,6 +1240,242 @@
 			<key>SystemUUID</key>
 			<string></string>
 		</dict>
+		<key>Memory</key>
+		<dict>
+			<key>DataWidth</key>
+			<integer>64</integer>
+			<key>ErrorCorrection</key>
+			<integer>3</integer>
+			<key>FormFactor</key>
+			<integer>9</integer>
+			<key>MaxCapacity</key>
+			<integer>137438953472</integer>
+			<key>TotalWidth</key>
+			<integer>64</integer>
+			<key>Type</key>
+			<integer>26</integer>
+			<key>TypeDetail</key>
+			<integer>128</integer>
+			<key>Devices</key>
+			<array>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 1</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA000000001</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 2</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 3</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA000000002</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 4</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 5</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA000000002</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 6</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 7</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA000000001</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 8</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 9</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 10</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 11</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+				<dict>
+					<key>AssetTag</key>
+					<string></string>
+					<key>BankLocator</key>
+					<string></string>
+					<key>DeviceLocator</key>
+					<string>Slot 12</string>
+					<key>Manufacturer</key>
+					<string>Acidanthera</string>
+					<key>PartNumber</key>
+					<string>M00001-4GB</string>
+					<key>SerialNumber</key>
+					<string>AAA00000000X</string>
+					<key>Size</key>
+					<integer>131072</integer>
+					<key>Speed</key>
+					<integer>5733</integer>
+				</dict>
+			</array>
+		</dict>
 		<key>PlatformNVRAM</key>
 		<dict>
 			<key>BID</key>
@@ -1189,7 +1500,7 @@
 			<key>BIOSVendor</key>
 			<string></string>
 			<key>BIOSVersion</key>
-			<string>9999.999.999.999.999</string>
+			<string></string>
 			<key>BoardAssetTag</key>
 			<string></string>
 			<key>BoardLocationInChassis</key>
@@ -1244,7 +1555,7 @@
 		<key>UpdateNVRAM</key>
 		<false/>
 		<key>UpdateSMBIOS</key>
-		<true/>
+		<false/>
 		<key>UpdateSMBIOSMode</key>
 		<string>Create</string>
 		<key>UseRawUuidEncoding</key>
@@ -1272,7 +1583,7 @@
 			<key>AppleEvent</key>
 			<string>Builtin</string>
 			<key>CustomDelays</key>
-			<string>Disabled</string>
+			<false/>
 			<key>KeyInitialDelay</key>
 			<integer>0</integer>
 			<key>KeySubsequentDelay</key>
@@ -1287,7 +1598,7 @@
 			<key>AudioCodec</key>
 			<integer>0</integer>
 			<key>AudioDevice</key>
-			<string>PciRoot(0x0)/Pci(0x1b,0x0)</string>
+			<string></string>
 			<key>AudioOut</key>
 			<integer>0</integer>
 			<key>AudioSupport</key>
@@ -1322,7 +1633,7 @@
 			<key>PointerSupport</key>
 			<false/>
 			<key>PointerSupportMode</key>
-			<string>ASUS</string>
+			<string></string>
 			<key>TimerResolution</key>
 			<integer>50000</integer>
 		</dict>
@@ -1337,7 +1648,7 @@
 			<key>ForceResolution</key>
 			<false/>
 			<key>GopPassThrough</key>
-			<false/>
+			<string>Disabled</string>
 			<key>IgnoreTextInGraphics</key>
 			<false/>
 			<key>ProvideConsoleGop</key>
@@ -1363,6 +1674,8 @@
 			<true/>
 			<key>AppleDebugLog</key>
 			<true/>
+			<key>AppleEg2Info</key>
+			<false/>
 			<key>AppleFramebufferInfo</key>
 			<false/>
 			<key>AppleImageConversion</key>
@@ -1396,14 +1709,20 @@
 		<dict>
 			<key>ActivateHpetSupport</key>
 			<false/>
+			<key>EnableVectorAcceleration</key>
+			<true/>
 			<key>DisableSecurityPolicy</key>
 			<false/>
 			<key>ExitBootServicesDelay</key>
 			<integer>0</integer>
+			<key>ForgeUefiSupport</key>
+			<false/>
 			<key>IgnoreInvalidFlexRatio</key>
 			<false/>
 			<key>ReleaseUsbOwnership</key>
 			<false/>
+			<key>ReloadOptionRoms</key>
+			<false/>
 			<key>RequestBootVarRouting</key>
 			<true/>
 			<key>TscSyncTimeout</key>

payloads/Kexts/Plists/AppleUSBMaps/Info.plist

@@ -764,7 +764,7 @@
 			<key>model</key>
 			<string>XXerve3,1</string>
 		</dict>
-		<key>iMac7,1</key>
+		<key>#iMac7,1</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
 			<string>com.apple.driver.AppleUSBHostMergeProperties</string>
@@ -2860,6 +2860,28 @@
 			<key>model</key>
 			<string>XacPro3,1</string>
 		</dict>
+		<key>MacPro3,1-UHC3</key>
+		<dict>
+			<key>CFBundleIdentifier</key>
+			<string>com.apple.driver.AppleUSBHostMergeProperties</string>
+			<key>IOClass</key>
+			<string>AppleUSBHostMergeProperties</string>
+			<key>IONameMatch</key>
+			<string>UHC3</string>
+			<key>IOProviderClass</key>
+			<string>AppleUSBUHCIPCI</string>
+			<key>IOProviderMergeProperties</key>
+			<dict>
+				<key>kUSBMuxEnabled</key>
+				<false/>
+				<key>port-count</key>
+				<data>AAAAAA==</data>
+				<key>ports</key>
+				<dict/>
+			</dict>
+			<key>model</key>
+			<string>MacPro3,1</string>
+		</dict>
 		<key>MacPro4,1-EHC1</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
@@ -3505,7 +3527,7 @@
 			<key>Tunnel Endpoint Device Vendor ID</key>
 			<data>AQAAAA==</data>
 		</dict>
-		<key>iMac7,1-EHC1</key>
+		<key>#iMac7,1-EHC1</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
 			<string>com.apple.driver.AppleUSBHostMergeProperties</string>
@@ -3568,7 +3590,7 @@
 			<key>model</key>
 			<string>iXac7,1</string>
 		</dict>
-		<key>iMac7,1-EHC2</key>
+		<key>#iMac7,1-EHC2</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
 			<string>com.apple.driver.AppleUSBHostMergeProperties</string>
@@ -3617,6 +3639,28 @@
 			<key>model</key>
 			<string>iXac7,1</string>
 		</dict>
+		<key>iMac7,1-UHC4</key>
+		<dict>
+			<key>CFBundleIdentifier</key>
+			<string>com.apple.driver.AppleUSBHostMergeProperties</string>
+			<key>IOClass</key>
+			<string>AppleUSBHostMergeProperties</string>
+			<key>IONameMatch</key>
+			<string>UHC4</string>
+			<key>IOProviderClass</key>
+			<string>AppleUSBUHCIPCI</string>
+			<key>IOProviderMergeProperties</key>
+			<dict>
+				<key>kUSBMuxEnabled</key>
+				<false/>
+				<key>port-count</key>
+				<data>AAAAAA==</data>
+				<key>ports</key>
+				<dict/>
+			</dict>
+			<key>model</key>
+			<string>iMac7,1</string>
+		</dict>
 		<key>iMac8,1-EHC1</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
@@ -5417,7 +5461,7 @@
 			<key>model</key>
 			<string>Xacmini4,1</string>
 		</dict>
-		<key>iMac7,1-OHC1</key>
+		<key>#iMac7,1-OHC1</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
 			<string>com.apple.driver.AppleUSBHostMergeProperties</string>
@@ -5459,7 +5503,7 @@
 			<key>model</key>
 			<string>iXac9,1</string>
 		</dict>
-		<key>iMac7,1-OHC2</key>
+		<key>#iMac7,1-OHC2</key>
 		<dict>
 			<key>CFBundleIdentifier</key>
 			<string>com.apple.driver.AppleUSBHostMergeProperties</string>