Fix audio support on iMac7,1 and iMac8,1

Fix NVMe properties applying with OC installed
Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/212
2026-04-15 21:28:55 +10:00 · 2021-05-11 10:52:56 -06:00 · 2021-05-11 10:44:23 -06:00 · 2021-05-10 17:55:13 -06:00 · 2021-05-10 10:30:07 -06:00 · 2021-05-10 09:18:28 -06:00
26 changed files with 1612 additions and 481 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -8,6 +8,7 @@ OCLP-GUI.command
 /dist
 /.vscode
 __pycache__/
+*.kext
 *.py[cod]
 *$py.class
 /docs/.vuepress/dist
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,23 @@
 # OpenCore Legacy Patcher changelog

+## 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
--- a/OCLP-CLI.command
+++ b/OCLP-CLI.command
@@ -12,7 +12,7 @@ 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, Utilities, CliMenu, DeviceProbe


 class OpenCoreLegacyPatcher():
@@ -30,20 +30,14 @@ class OpenCoreLegacyPatcher():
        if self.current_model in ModelArray.NoAPFSsupport:
            self.constants.serial_settings = "Moderate"
        if self.current_model in ModelArray.LegacyGPU:
-            try:
-                dgpu_devices = plistlib.loads(subprocess.run("ioreg -r -n GFX0 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-                dgpu_vendor = self.hexswap(binascii.hexlify(dgpu_devices[0]["vendor-id"]).decode()[:4])
-                dgpu_device = self.hexswap(binascii.hexlify(dgpu_devices[0]["device-id"]).decode()[:4])
-            except ValueError:
-                dgpu_vendor = ""
-                dgpu_device = ""
-
-            if (dgpu_vendor == self.constants.pci_amd_ati and dgpu_device in ModelArray.AMDMXMGPUs) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in ModelArray.NVIDIAMXMGPUs):
-                self.constants.sip_status = True
-                self.constants.secure_status = True
-            else:
-                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:
@@ -59,6 +53,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
--- a/OpenCore-Patcher.command
+++ b/OpenCore-Patcher.command
@@ -10,7 +10,7 @@ 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():
@@ -27,15 +27,9 @@ class OpenCoreLegacyPatcher():
        if self.current_model in ModelArray.NoAPFSsupport:
            self.constants.serial_settings = "Moderate"
        if self.current_model in ModelArray.LegacyGPU:
-            try:
-                dgpu_devices = plistlib.loads(subprocess.run("ioreg -r -n GFX0 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
-                dgpu_vendor = self.hexswap(binascii.hexlify(dgpu_devices[0]["vendor-id"]).decode()[:4])
-                dgpu_device = self.hexswap(binascii.hexlify(dgpu_devices[0]["device-id"]).decode()[:4])
-            except ValueError:
-                dgpu_vendor = ""
-                dgpu_device = ""
+            dgpu_vendor,dgpu_device,dgpu_acpi = DeviceProbe.pci_probe().gpu_probe("GFX0")

-            if (dgpu_vendor == self.constants.pci_amd_ati and dgpu_device in ModelArray.AMDMXMGPUs) or (dgpu_vendor == self.constants.pci_nvidia and dgpu_device in ModelArray.NVIDIAMXMGPUs):
+            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:
@@ -55,6 +49,15 @@ class OpenCoreLegacyPatcher():
            print(f"True Model: {true_model}")
            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]
+
    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]
@@ -100,17 +103,35 @@ 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"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 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"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\t{self.constants.boot_efi}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).bootstrap_setting],
-                [f"Set Acceleration Patches:\t\t{self.constants.legacy_acceleration_patch}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).accel_setting],
-                [f"Assume Legacy GPU:\t\t\t{self.constants.assume_legacy}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).force_accel_setting],
-                [f"Allow OpenCore on native Models:\t{self.constants.allow_oc_everywhere}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).allow_native_models],
+                [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"Set Custom name {self.constants.custom_cpu_model_value}", CliMenu.MenuOptions(self.constants.custom_model or self.current_model, self.constants).custom_cpu],
            ]

            for option in options:
@@ -128,7 +149,7 @@ 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()
@@ -139,6 +160,7 @@ system_profiler SPHardwareDataType | grep 'Model Identifier'
  - 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
--- a/README.md
+++ b/README.md
@@ -2,60 +2,55 @@

 <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/)
-  * You can still boot BootCamp outside of OpenCore just like before however!
-* 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 [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:
+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:
+## Credits

-* [How to debug with OpenCore](https://dortania.github.io/OpenCore-Legacy-Patcher/DEBUG.html)
-
-## 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
+* [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
+* [vit9696](https://github.com/vit9696)
+  * Endless amount of help troubleshooting, determining fixes and writing patches
+* [mario_bros_tech](https://github.com/mariobrostech) and the rest of the Unsupported Mac Discord
+  * Catalyst that started OpenCore Legacy Patcher
+* MacRumors and Unsupported Mac Communities
+  * Endless testing, reporting issues
+* Apple
+  * for macOS and many of the kexts, frameworks and other binaries we reimplemented into newer OSes
--- a/Resources/Build.py
+++ b/Resources/Build.py
@@ -15,7 +15,7 @@ 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):
@@ -44,33 +44,6 @@ class BuildOpenCore:
        hex_str = "".join(["".join(x) for x in hex_rev])
        return hex_str.upper()

-    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_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}")
-                self.config["#Revision"]["Hardware-iGPU"] = f"{self.constants.igpu_vendor}:{self.constants.igpu_device}"
-        except ValueError:
-            if print_status is True:
-                print("- No iGPU detected")
-            self.constants.igpu_devices = ""
-            self.config["#Revision"]["Hardware-iGPU"] = "No iGPU detected"
-
-        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_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}")
-                self.config["#Revision"]["Hardware-GFX0"] = f"{self.constants.dgpu_vendor}:{self.constants.dgpu_device}"
-        except ValueError:
-            if print_status is True:
-                print("- No dGPU detected")
-            self.constants.dgpu_devices = ""
-            self.config["#Revision"]["Hardware-GFX0"] = "No dGPU detected"
-
    def build_efi(self):
        Utilities.cls()
        print(f"Building Configuration for model: {self.model}")
@@ -113,13 +86,13 @@ class BuildOpenCore:
            ("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 and self.constants.allow_oc_everywhere is False and self.constants.serial_settings == "Moderate"),
+            ("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 != "iMac7,1" and self.constants.allow_oc_everywhere is False),
+            ("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),
@@ -137,38 +110,63 @@ class BuildOpenCore:
            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 = self.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
+                    storage_device = self.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"]
-            nvme_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 nvme_devices:
                    nvme_vendor = self.hexswap(binascii.hexlify(i["vendor-id"]).decode()[:4])
                    nvme_device = self.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):
-                        #print("- Converting variable")
-                        binascii.unhexlify(nvme_aspm)
-                        nvme_aspm = self.hexswap(nvme_aspm)
-                        nvme_aspm = int(nvme_aspm, 16)
-
+                        nvme_aspm = int.from_bytes(nvme_aspm, byteorder='little')
                    nvme_aspm = (nvme_aspm & (~3)) | 2
-
-                    print(f'- Found 3rd Party NVMe SSD ({x}): {nvme_vendor}:{nvme_device}')
+                    #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 = [line.strip().split("= ", 1)[1] for line in nvme_path_gfx.split("\n") if f'{nvme_vendor}:{nvme_device}'.lower() in line.strip()][0]
-                        nvme_path_parent = "/".join(nvme_path.split("/")[:-1])
+                        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}")
-                        #print(f"- Found NVMe({x}) Parent at {nvme_path_parent}")
-                        self.config["DeviceProperties"]["Add"][nvme_path] = {"pci-aspm-default": nvme_aspm}
+                        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:
-                        print(f"- Failed to find Device path for NVMe {x}")
                        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"
@@ -176,22 +174,20 @@ class BuildOpenCore:
                        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")
+                print("- No 3rd Party NVMe drive found(V)")
            except IndexError:
-                print("- No 3rd Party NVMe drive found")
+                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:
-                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:
@@ -213,49 +209,31 @@ 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")]
-            try:
-                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:
-                    if wifi_ioname in ["pci14e4,4353", "pci14e4,4331"]:
-                        print(f"- Detected Wifi Card: {wifi_ioname}")
-                        self.config["#Revision"]["Hardware-Wifi"] = f"{wifi_ioname}"
-                    else:
-                        print(f"- Detected Wifi Card: {wifi_vendor}:{wifi_device}")
-                        self.config["#Revision"]["Hardware-Wifi"] = f"{wifi_vendor}:{wifi_device}"
-            except IndexError:
-                wifi_devices = ""
-
+        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:
                # This works around OCLP spoofing the Wifi card and therefore unable to actually detect the correct device
-                if wifi_device in ModelArray.BCM4360Wifi and wifi_ioname not in ["pci14e4,4353", "pci14e4,4331"]:
+                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 ModelArray.BCM94331Wifi:
+                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:
@@ -334,12 +312,18 @@ class BuildOpenCore:
        # AGPM Patch
        if self.model in ModelArray.DualGPUPatch:
            print("- Adding dual GPU patch")
+            if not self.constants.custom_model:
+                gfx0_path: str = subprocess.run([self.constants.gfxutil_path] + f"-f GFX0".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+                if gfx0_path == "":
+                    gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
+            else:
+                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"]["PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"] = {"agdpmod": "pikera", "shikigva": 256}
+                self.config["DeviceProperties"]["Add"][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"]["PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"] = {"agdpmod": "pikera"}
+                self.config["DeviceProperties"]["Add"][gfx0_path] = {"agdpmod": "vit9696"}

        # HiDPI OpenCanopy and FileVault
        if self.model in ModelArray.HiDPIpicker:
@@ -364,12 +348,12 @@ class BuildOpenCore:
                    print(f"- Found GFX0 device at {self.gfx0_path}")
                except IndexError:
                    print("- Failed to find GFX0 Device path, falling back on known logic")
-                    if self.model == ["iMac11,1", "iMac11,3"]:
+                    if self.model in ["iMac11,1", "iMac11,3"]:
                        self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
                    else:
                        self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
            else:
-                if self.model == ["iMac11,1", "iMac11,3"]:
+                if self.model in ["iMac11,1", "iMac11,3"]:
                    self.gfx0_path = "PciRoot(0x0)/Pci(0x3,0x0)/Pci(0x0,0x0)"
                else:
                    self.gfx0_path = "PciRoot(0x0)/Pci(0x1,0x0)/Pci(0x0,0x0)"
@@ -421,14 +405,16 @@ class BuildOpenCore:
                nvidia_patch(self, self.gfx0_path)
            else:
                print("- Failed to find vendor")
-        elif not self.constants.custom_model:
-            self.check_pciid(True)
-            if self.constants.dgpu_vendor == self.constants.pci_amd_ati and self.constants.dgpu_device in ModelArray.AMDMXMGPUs:
-                backlight_path_detection(self)
-                amd_patch(self, self.gfx0_path)
-            elif self.constants.dgpu_vendor == self.constants.pci_nvidia and self.constants.dgpu_device in ModelArray.NVIDIAMXMGPUs:
-                backlight_path_detection(self)
-                nvidia_patch(self, self.gfx0_path)
+        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())
@@ -535,7 +521,15 @@ class BuildOpenCore:
            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
@@ -592,6 +586,8 @@ class BuildOpenCore:

        # Setup menu
        def minimal_serial_patch(self):
+            if self.constants.custom_cpu_model == 0 or self.constants.custom_cpu_model == 1:
+                self.config["PlatformInfo"]["PlatformNVRAM"]["ProcessorType"] = 1537
            self.config["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
@@ -600,6 +596,8 @@ class BuildOpenCore:
            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
@@ -609,6 +607,8 @@ class BuildOpenCore:
            self.config["PlatformInfo"]["Generic"]["SystemProductName"] = self.spoofed_model

        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"
@@ -634,6 +634,12 @@ class BuildOpenCore:
            self.spoofed_model = self.model
            minimal_serial_patch(self)

+        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
+
        # 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")
@@ -656,9 +662,8 @@ class BuildOpenCore:

                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"))
@@ -671,10 +676,6 @@ class BuildOpenCore:
            plistlib.dump(cpu_config, Path(new_cpu_ls).open("wb"), sort_keys=True)


-
-
-
-
        if self.model == "MacBookPro9,1":
            new_agdp_ls = Path(self.constants.agdp_contents_folder) / Path("Info.plist")
            new_agpm_ls = Path(self.constants.agpm_contents_folder) / Path("Info.plist")
--- a/Resources/CliMenu.py
+++ b/Resources/CliMenu.py
@@ -269,34 +269,6 @@ Recommend only disabling if absolutely required.
        else:
            print("Invalid option")

-    def accel_setting(self):
-        Utilities.cls()
-        Utilities.header(["Enable Beta Acceleration Patches"])
-        print("""Enables OCLP's experimental GPU Acceleration Patches
-Note these are still in beta and we highly recommend users
-not run them daily or expect stable performance.
-
-Currently the following are supported:
-
- Nvidia:  Tesla and Fermi (8000-500)
- AMD/ATI: TeraScale 1 (2000-4000)
- Intel:   Ironlake and Sandy Bridge
-
-For reliability, please consider running macOS Catalina or
-older via Dosdude1's patchers
-
-Note: These patches may break Big Sur booting, please have any
-important data backed up in case of emergencies
-        """)
-        change_menu = input("Enable Beta Acceleration Patches(y/n): ")
-        if change_menu in {"y", "Y", "yes", "Yes"}:
-            self.constants.legacy_acceleration_patch = True
-        elif change_menu in {"n", "N", "no", "No"}:
-            self.constants.legacy_acceleration_patch = False
-        else:
-            print("Invalid option")
-
-
    def force_accel_setting(self):
        Utilities.cls()
        Utilities.header(["Assume Legacy GPU"])
@@ -329,4 +301,85 @@ power usage.
            self.constants.allow_oc_everywhere = False
            self.constants.serial_settings = "Minimal"
        else:
-            print("Invalid option")
+            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")
--- a/Resources/Constants.py
+++ b/Resources/Constants.py
@@ -9,7 +9,7 @@ from pathlib import Path

 class Constants:
    def __init__(self):
-        self.patcher_version = "0.1.2"
+        self.patcher_version = "0.1.3"
        self.opencore_commit = "65cc81b - 05-03-2021"
        self.opencore_version = "0.6.9"
        self.lilu_version = "1.5.3"
@@ -25,7 +25,7 @@ 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.applealc_version = "1.6.1"
        self.restrictevents_version = "1.0.1"
        self.restrictevents_mbp_version = "1.0.1"
        self.piixata_version = "1.0.0"
@@ -37,7 +37,8 @@ class Constants:
        self.hibernationfixup = "1.3.9"
        self.nvmefix_version = "1.0.7"
        self.sidecarfixup_version = "1.0.0"
-        self.payload_version = "0.0.4"
+        self.innie_version = "1.3.0"
+        self.payload_version = "0.0.6"

        # Get resource path
        self.current_path = Path(__file__).parent.parent.resolve()
@@ -47,10 +48,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
@@ -75,6 +72,11 @@ class Constants:
        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

        # OS Versions
        self.tiger = 8
@@ -99,7 +101,6 @@ class Constants:
        self.pci_atheros = "168C"
        self.pci_apple = "106B"

-
        # Class Codes
        # https://pci-ids.ucw.cz/read/PD
        self.classcode_sata = "01060100"
@@ -190,6 +191,8 @@ class Constants:
    @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")
@@ -301,6 +304,8 @@ class Constants:
    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")
--- a/Resources/DeviceProbe.py
+++ b/Resources/DeviceProbe.py
@@ -0,0 +1,96 @@
+# Probe devices, return device entries
+# Copyright (C) 2021 Mykola Grymalyuk
+from __future__ import print_function
+
+import binascii
+import plistlib
+import shutil
+import subprocess
+import uuid
+import os
+import sys
+import platform
+from pathlib import Path
+
+from Resources import Constants, ModelArray, Utilities
+
+class pci_probe:
+    def __init__(self):
+        self.constants = Constants.Constants()
+
+    def hexswap(self, input_hex: str):
+        hex_pairs = [input_hex[i:i + 2] for i in range(0, len(input_hex), 2)]
+        hex_rev = hex_pairs[::-1]
+        hex_str = "".join(["".join(x) for x in hex_rev])
+        return hex_str.upper()
+
+    # Converts given device IDs to DeviceProperty pathing, requires ACPI pathing as DeviceProperties shouldn't be used otherwise
+    def deviceproperty_probe(self, vendor_id, device_id, acpi_path):
+        gfxutil_output: str = subprocess.run([self.constants.gfxutil_path] + f"-v".split(), stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
+        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("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 = self.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
+            device_id = self.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}")
+            return "", "", ""
+
+    def wifi_probe(self):
+        try:
+            devices = plistlib.loads(subprocess.run("ioreg -r -n ARPT -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+        except ValueError:
+            devices = plistlib.loads(subprocess.run("ioreg -c IOPCIDevice -r -d2 -a".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode())
+        try:
+            devices = [i for i in devices if i["class-code"] == binascii.unhexlify(self.constants.classcode_wifi)]
+            vendor_id = self.hexswap(binascii.hexlify(devices[0]["vendor-id"]).decode()[:4])
+            device_id = self.hexswap(binascii.hexlify(devices[0]["device-id"]).decode()[:4])
+            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")
+            return "", "", "", ""
--- a/Resources/ModelArray.py
+++ b/Resources/ModelArray.py
@@ -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",
@@ -697,6 +697,10 @@ ControllerTypes = [
    "-XHC1",
    "-OHC1",
    "-OHC2",
+    "-UHC1",
+    "-UHC2",
+    "-UHC3",
+    "-UHC4",
    "-InternalHub-EHC1",
    "-InternalHub-EHC1-InternalHub",
    "-InternalHub-EHC2",
@@ -714,76 +718,6 @@ upgradableMXMGPUs = [
    "Dortania1,1"
 ]

-# Reference: https://forums.macrumors.com/threads/2011-imac-graphics-card-upgrade.1596614/
-NVIDIAMXMGPUs = [
-    "0FF6",  # Quadro K1100M
-    "0FFB",  # Quadro K2000M
-    "0FFC",  # Quadro K1000M
-    "1198",  # GTX 880M
-    "1199",  # GTX 870M
-    "119A",  # GTX 860M
-    "119E",  # GTX 780M
-    "119F",  # GTX 880M
-    "11A9",  # GTX 870M
-    "11B6",  # Quadro K3100M
-    "11B7",  # Quadro K4100M
-    "11B8",  # Quadro K5100M
-    "11BC",  # Quadro K5000M
-    "11BD",  # Quadro K4000M
-    "11BE",  # Quadro K3000M
-    "11E1",  # GTX 765M
-    "11E2",  # GTX 765M
-    "11E0",  # GTX 770M
-    "11FC",  # Quadro K2100M
-    "12B9",  # Quadro K610M
-]
-
-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",
@@ -965,11 +899,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",
@@ -985,7 +919,6 @@ DeleteAMDAccel11 = [
    "AppleIntelFramebufferCapri.kext",
    "AppleParavirtGPU.kext",
    "GeForce.kext",
-    "IOAcceleratorFamily2.kext",
    "IOGPUFamily.kext",
 ]

@@ -1000,16 +933,16 @@ AddNvidiaAccel11 = [
 ]

 AddNvidiaKeplerAccel11 = [
-	"GeForce.kext",
-	"GeForceAIRPlugin.bundle",
-	"GeForceGLDriver.bundle",
-	"GeForceMTLDriver.bundle",
-	"GeForceVADriver.bundle",
-	"NVDAGF100Hal.kext",
-	"NVDAGK100Hal.kext",
-	"NVDAResman.kext",
-	"NVDAStartup.kext",
-	"NVSMU.kext",
+    "GeForce.kext",
+    "GeForceAIRPlugin.bundle",
+    "GeForceGLDriver.bundle",
+    "GeForceMTLDriver.bundle",
+    "GeForceVADriver.bundle",
+    "NVDAGF100Hal.kext",
+    "NVDAGK100Hal.kext",
+    "NVDAResman.kext",
+    "NVDAStartup.kext",
+    "NVSMU.kext",
 ]

 AddAMDAccel11 = [
@@ -1025,25 +958,14 @@ 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",
-]
-
-AddAMDTeraScale2Brightness11 = [
-    "AMD5000Controller.kext",
-    "AMD6000Controller.kext",
-    "AMDLegacyFramebuffer.kext",
-    "AMDLegacySupport.kext",
-    "AMDRadeonX3000.kext",
-    "AMDRadeonX3000GLDriver.bundle",
-    "IOAcceleratorFamily2.kext"
 ]

 AddIntelGen1Accel = [
@@ -1052,7 +974,6 @@ AddIntelGen1Accel = [
    "AppleIntelHDGraphicsGA.plugin",
    "AppleIntelHDGraphicsGLDriver.bundle",
    "AppleIntelHDGraphicsVADriver.bundle",
-    "IOSurface.kext",
 ]

 AddIntelGen2Accel = [
@@ -1062,15 +983,25 @@ AddIntelGen2Accel = [
    "AppleIntelHD3000GraphicsVADriver.bundle",
    "AppleIntelSNBGraphicsFB.kext",
    "AppleIntelSNBVA.bundle",
-    "IOSurface.kext",
 ]

 AddIntelGen3Accel = [
-	"AppleIntelFramebufferCapri.kext",
-	"AppleIntelHD4000Graphics.kext",
-	"AppleIntelHD4000GraphicsGLDriver.bundle",
-	"AppleIntelHD4000GraphicsMTLDriver.bundle",
-	"AppleIntelHD4000GraphicsVADriver.bundle",
+    "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 = [
@@ -1083,97 +1014,6 @@ AddBrightness = [
 ]

 AddVolumeControl = [
+    "AppleHDA.kext",
    "IOAudioFamily.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",
-]
-
-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",
-]
-
-IronLakepciid = [
-    "0044",
-    "0046",
-]
-
-SandyBridgepiciid = [
-    "0106",
-    "0601",
-    "0116",
-    "0102",
-    "0126",
-]
-
-IvyBridgepciid = [
-	"0152",
-	"0156",
-	"0162",
-	"0166",
-]
-
--- a/Resources/PCIIDArray.py
+++ b/Resources/PCIIDArray.py
@@ -0,0 +1,732 @@
+# 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 = [
+        # 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]
+        "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]
+        "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]
+        "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]
+        "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]
+        # G200
+        "05E0", # G200 [GTX 295]
+        "05E1", # G200 [GTX 280]
+        "05E2", # G200 [GTX 260]
+        "05E3", # G200 [GTX 285]
+        "05E6", # G200 [GTX 275]
+        "05E7", # G200 [C1060]
+        "05E9", # G200 [CX]
+        "05EA", # G200 [GTX 260]
+        "05EB", # G200 [GTX 295]
+        "05ED", # G200 [FX 5800]
+        "05EE", # G200 [FX 4800]
+        "05EF", # G200 [FX 3800]
+        # 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]
+        # 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]
+        "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]
+        "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]
+        "107D", # GF119 [NVS 310]
+        # GF117
+        "1140", # GF117 [GT 620M]
+    ]
+
+    kepler_ids = [
+        # GK104
+        "1180", # GK104 [GTX 680]
+        "1183", # GK104 [GTX 660 Ti]
+        "1185", # GK104 [GTX 660]
+        "1188", # GK104 [GTX 690]
+        "1189", # GK104 [GTX 670]
+        "1198", # GTX 880M
+        "1199", # GK104 [GTX 870M]
+        "119A", # GTX 860M
+        "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
+        "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]
+        "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]
+        "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]
+        "0FE0", # GK107 [GTX 660M]
+        "0FE9", # GK107 [GT 750M Mac Edition]
+        "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
+        "1003", # GK110 [GTX Titan LE]
+        "1004", # GK110 [GTX 780]
+        "1005", # GK110 [GTX Titan]
+        "101F", # GK110 [TEslA K20]
+        "1020", # GK110 [TEslA K2]
+        "1021", # GK110 [TEslA K2m]
+        "1022", # GK110 [TEslA K20C]
+        "1026", # GK110 [TEslA K20s]
+        "1028", # GK110 [TEslA K20m]
+        # GK208
+        "1280", # GK208 [GT 635]
+        "1282", # GK208 [GT 640 REv. 2]
+        "1284", # GK208 [GT 630 REv. 2]
+        "1290", # GK208 [GT 730M]
+        "1291", # GK208 [GT 735M]
+        "1292", # GK208 [GT 740M]
+        "1293", # GK208 [GT 730M]
+        "1294", # GK208 [GT 740M]
+        "1295", # GK208 [710M]
+        "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", # BCM94328
+        "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
+    ]
--- a/Resources/SysPatch.py
+++ b/Resources/SysPatch.py
@@ -18,7 +18,7 @@ import os
 from pathlib import Path
 from datetime import date

-from Resources import Constants, ModelArray, Utilities
+from Resources import Constants, ModelArray, PCIIDArray, Utilities, DeviceProbe


 class PatchSysVolume:
@@ -121,69 +121,51 @@ class PatchSysVolume:
        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])
-            try:
-                self.nvidia_arch = self.dgpu_devices[0]["NVArch"]
-            except KeyError:
-                self.nvidia_arch = ""
-            print(f"- Detected dGPU: {self.dgpu_vendor}:{self.dgpu_device}")
-        except ValueError:
-            print("- No dGPU detected")
-            self.dgpu_devices = ""
-
    def gpu_accel_patches_11(self):
-        if self.dgpu_devices:
-            if self.dgpu_vendor == self.constants.pci_nvidia:
-                if self.nvidia_arch == self.constants.arch_kepler and self.constants.assume_legacy is True 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)
-                else:
+        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)
-            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:
+                # 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)
+        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:
+                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()

-                # Code for when Ivy Bridge binares are presumably removed from macOS 12, code currently
-                #elif self.igpu_device in ModelArray.IvyBridgepciid:
+                # 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 self.igpu_vendor == self.constants.pci_nvidia:
-                if not self.dgpu_devices:
+            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)

        # Frameworks
@@ -222,19 +204,19 @@ class PatchSysVolume:
        subprocess.run(f"sudo find {self.constants.payload_apple_root_path} -name '.DS_Store' -delete".split(), stdout=subprocess.PIPE).stdout.decode().strip().encode()

        if self.model in ModelArray.LegacyGPU or self.constants.assume_legacy is True:
-            self.check_pciid()
-            if self.dgpu_devices and self.dgpu_vendor == self.constants.pci_amd_ati and self.dgpu_device in ModelArray.AMDMXMGPUs:
+            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:
                print("- Detected legacy GPU, attempting legacy acceleration patches")
                self.gpu_accel_patches_11()
                rebuild_required = True

-        #if self.model == "iMac7,1":
-        #    print("- Fixing Volume Control Support")
-        #    self.add_new_binaries(ModelArray.AddVolumeControl, self.constants.audio_path)
+        if self.model in ["iMac7,1", "iMac8,1"]:
+            print("- Fixing Volume Control Support")
+            self.add_new_binaries(ModelArray.AddVolumeControl, self.constants.audio_path)

        if rebuild_required is True:
            self.rebuild_snapshot()
@@ -334,6 +316,7 @@ class PatchSysVolume:

    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 and self.constants.assume_legacy is False:
--- a/docs/.vuepress/config.js
+++ b/docs/.vuepress/config.js
@@ -98,6 +98,7 @@ module.exports = {
            collapsable: false,
            sidebarDepth: 1,
            children: [
+				'ACCEL',
 				'TROUBLESHOOTING',
 				'DEBUG',
 				'UPDATE',
--- a/docs/ACCEL.md
+++ b/docs/ACCEL.md
@@ -0,0 +1,65 @@
+# 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.
+
+## 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.
--- a/docs/BENIFITS.md
+++ b/docs/BENIFITS.md
@@ -2,21 +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> |
+| 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</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> | 
 | 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 and Personal Hotspot 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> |
-| Sidecar Support | <span style="color:#30BCD5">Supports any Mac with Metal Intel iGPU</span> | <span style="color:red">Not supported at all</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> |
--- a/docs/DONATE.md
+++ b/docs/DONATE.md
@@ -4,12 +4,14 @@ 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
-* Any spare SATA SSDs
+* Donating any spare SATA SSDs
  * Having extra SSDs on hand allows us to quickly and easily test specific builds of macOS without having to wipe drives and reinstall as much
+* Aiding by buying items in our Amazon Wishlist
+  * Currently we have a few members within Dortania testing so we recommend messaging the email listed below to see which member at the time would something purchased the most 
  
 Additionally, hardware info dumps are greatly beneficial for us to determine what patches a machine might need:

@@ -17,7 +19,7 @@ Additionally, hardware info dumps are greatly beneficial for us to determine wha
  * `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

-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

--- a/docs/LICENSE.md
+++ b/docs/LICENSE.md
@@ -10,9 +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:
--- a/docs/MODELS.md
+++ b/docs/MODELS.md
@@ -98,7 +98,7 @@ 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/>- 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  |
+| 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) <br/>- GPU Acceleration in Public Beta, see current issues ([#108](https://github.com/dortania/OpenCore-Legacy-Patcher/issues/108)) |
--- a/docs/START.md
+++ b/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 [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](). Legacy MBR Based installs won't show up in OpenCore

 ## How do I get started?

--- a/docs/TESTED.md
+++ b/docs/TESTED.md
@@ -42,8 +42,8 @@ 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 |
--- a/docs/WINDOWS.md
+++ b/docs/WINDOWS.md
@@ -79,4 +79,10 @@ From there, install Windows as normal and you'll get a new BootCamp entry in Ope

 * 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)
+![](../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)
--- a/payloads/Config/config.plist
+++ b/payloads/Config/config.plist
@@ -824,6 +824,24 @@
 				<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>
 		</array>
 		<key>Block</key>
 		<array/>
@@ -1096,10 +1114,6 @@
 			<dict>
 				<key>OCLP-Version</key>
 				<string></string>
-				<key>revcpu</key>
-				<string></string>
-				<key>revcpuname</key>
-				<string></string>
 			</dict>
 			<key>7C436110-AB2A-4BBB-A880-FE41995C9F82</key>
 			<dict>
@@ -1202,6 +1216,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>
--- a/payloads/Kexts/Acidanthera/AppleALC-v1.6.0.zip
+++ b/payloads/Kexts/Acidanthera/AppleALC-v1.6.0.zip
--- a/payloads/Kexts/Acidanthera/AppleALC-v1.6.1.zip
+++ b/payloads/Kexts/Acidanthera/AppleALC-v1.6.1.zip
--- a/payloads/Kexts/Misc/Innie-v1.3.0.zip
+++ b/payloads/Kexts/Misc/Innie-v1.3.0.zip
--- a/payloads/Kexts/Plists/AppleUSBMaps/Info.plist
+++ b/payloads/Kexts/Plists/AppleUSBMaps/Info.plist
@@ -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>
@@ -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>
Author	SHA1	Message	Date
Mykola Grymalyuk	e5fd984daf	Fix audio support on iMac7,1 and iMac8,1	2021-05-11 10:52:56 -06:00
Mykola Grymalyuk	0a0a59feea	Fix NVMe properties applying with OC installed Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/212	2021-05-11 10:44:23 -06:00
Mykola Grymalyuk	75200e9c8d	Remove unused setting	2021-05-10 17:55:13 -06:00
Mykola Grymalyuk	83d4cc5a16	Work-around BT2.0 panic Based on StarPlayrX’s BigMac patch	2021-05-10 10:30:07 -06:00
Mykola Grymalyuk	faecdc3b0c	Add misc info	2021-05-10 09:18:28 -06:00
Mykola Grymalyuk	0fe230e56b	Fix typo	2021-05-10 08:55:29 -06:00
Mykola Grymalyuk	6f13247151	Add accel issues docs	2021-05-10 08:53:57 -06:00
Mykola Grymalyuk	24a8249a60	Update docs	2021-05-09 17:38:52 -06:00
Mykola Grymalyuk	7df345d286	Fix USB mapping witout CPUFriend	2021-05-09 10:29:52 -06:00
Mykola Grymalyuk	7c0088e0ff	Merge pull request #208 from dortania/accel-testing Import dosdude1 patches	2021-05-09 08:08:38 -06:00
Mykola Grymalyuk	204cf5beea	Increment Apple binaries	2021-05-09 08:07:57 -06:00
Mykola Grymalyuk	04b69f4288	Fix typo	2021-05-08 22:25:28 -06:00
Mykola Grymalyuk	b4ef000fc0	Import dosdude1 patches	2021-05-08 22:24:05 -06:00
Mykola Grymalyuk	78038b9607	Add partial TeraScale 2 support	2021-05-08 22:04:33 -06:00
Mykola Grymalyuk	a458b68f2b	Merge pull request #207 from dortania/pci-id Revamp PCI ID handling	2021-05-08 21:39:21 -06:00
Mykola Grymalyuk	1509dffa1c	Fix iMac7,1 audio support Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/191	2021-05-08 21:38:36 -06:00
Mykola Grymalyuk	e274137503	Fix codesigning crashes	2021-05-08 20:52:26 -06:00
Mykola Grymalyuk	97bfb9f730	Clean up SysPatch code	2021-05-08 20:33:10 -06:00
Mykola Grymalyuk	b1f8b80e83	Fix typo	2021-05-08 20:18:30 -06:00
Mykola Grymalyuk	f0a339b0f7	Rework PCI ID storage	2021-05-08 20:14:51 -06:00
Mykola Grymalyuk	6bb5c2e74e	Update donate.md	2021-05-08 18:07:50 -06:00
Mykola Grymalyuk	5f1b732e12	Heavily expand Graphics ID list	2021-05-08 17:35:26 -06:00
Mykola Grymalyuk	2a9f94ac99	Add user-configurable CPUFriend Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/199	2021-05-08 14:04:01 -06:00
Mykola Grymalyuk	9b89b62219	Add device ID comments	2021-05-08 12:51:03 -06:00
Mykola Grymalyuk	315be87f31	Fix table	2021-05-08 12:35:26 -06:00
Mykola Grymalyuk	0613ad9bc3	Merge pull request #196 from fussel132/patch-1 Adding successful report of MacBookPro7,1	2021-05-08 12:34:25 -06:00
Mykola Grymalyuk	0ff6977bb7	Add iMac12,x troubleshooting	2021-05-08 12:29:19 -06:00
Mykola Grymalyuk	025d03e7e8	Fix crashing	2021-05-07 14:56:32 -06:00
Mykola Grymalyuk	a4efb1ecd5	Fix DevicePath handling Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/195	2021-05-07 08:23:12 -06:00
Mykola Grymalyuk	7340539742	Fix iMac display output support Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/190	2021-05-07 07:54:37 -06:00
Mykola Grymalyuk	377fdc8de1	Fix crashing on Nvidia iGPUs	2021-05-05 15:32:51 -06:00
Fussel132	36a68ca147	Adding successful report of MacBookPro7,1 Tried out Big Sur 11.3 on MacBookPro7,1 with OpenCore patcher version v0.1.2, working fine (with graphics acceleration). Not working: Keyboard backlight and graphical issues with sliders in control center.	2021-05-05 23:11:25 +02:00
Mykola Grymalyuk	922f207da7	Add better debug during Root Patch	2021-05-05 12:38:20 -06:00
Mykola Grymalyuk	ec4d1d4471	Fix crash	2021-05-05 12:34:23 -06:00
Mykola Grymalyuk	057b8739d3	Refactor Device Probing	2021-05-05 12:28:24 -06:00
Dhinak G	332376030e	Fix typo in storage device detection Fixes #192	2021-05-05 08:19:58 -04:00
Mykola Grymalyuk	302cfb3bef	Add built-in to party PCI drives	2021-05-04 22:24:14 -06:00
Mykola Grymalyuk	0cb70d896d	Fix iMac9,1 audio support	2021-05-04 21:03:11 -06:00
Mykola Grymalyuk	f5c511366e	Fix NightShift disabling on Minimal SMBIOS configs	2021-05-04 14:07:50 -06:00
Mykola Grymalyuk	79a2f49739	Fix integer	2021-05-04 00:13:05 -06:00
Mykola Grymalyuk	d6b5b65183	Avoid having too fast RAM	2021-05-04 00:11:30 -06:00
Mykola Grymalyuk	89444bc4bc	Fix input handling	2021-05-04 00:03:49 -06:00
Mykola Grymalyuk	2435a7e651	Fix typo	2021-05-03 23:56:48 -06:00
Mykola Grymalyuk	1957e70cfd	Fix CPU Renaming on non-i5 models	2021-05-03 23:49:43 -06:00
Mykola Grymalyuk	aba21bca43	Fix crash	2021-05-03 21:33:05 -06:00
Mykola Grymalyuk	ccc9549fc4	Fix typo	2021-05-03 21:24:30 -06:00
Mykola Grymalyuk	07bd8fa33f	Support custom CPU names in About This Mac	2021-05-03 21:12:01 -06:00
Mykola Grymalyuk	85e0761460	Fix MacBookPro5,4 audio Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/185	2021-05-03 12:44:11 -06:00
Mykola Grymalyuk	5bca1a0ad6	Add Innie Support Closes https://github.com/dortania/OpenCore-Legacy-Patcher/issues/187	2021-05-03 12:28:47 -06:00