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

patchsets: Implement new patch detection architecture

Browse Source 
Greatly streamlines future patch set development
This commit is contained in:
Mykola Grymalyuk
2024-09-01 21:00:05 -06:00
parent d9e91bd17e
commit a329e80082
55 changed files with 4439 additions and 2940 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1779
opencore_legacy_patcher/datasets/sys_patch_dict.py
View File

File diff suppressed because it is too large Load Diff

2
opencore_legacy_patcher/efi_builder/misc.py
View File

@@ -306,7 +306,7 @@ xw
# And MacPro4,1, MacPro5,1 and Xserve3,1 are the only post-Penryn Macs that lack an internal USB hub
# - Ref: https://techcommunity.microsoft.com/t5/microsoft-usb-blog/reasons-to-avoid-companion-controllers/ba-p/270710
#
# To be paired for sys_patch_dict.py's 'Legacy USB 1.1' patchset
# To be paired for usb11.py's 'Legacy USB 1.1' patchset
#
# Note: With macOS 14.1, injection of these kexts causes a panic.
# To avoid this, a MaxKernel is configured with XNU 23.0.0 (macOS 14.0).

54
opencore_legacy_patcher/support/validation.py
View File

@@ -19,9 +19,13 @@ from ..support import subprocess_wrapper
from ..datasets import (
example_data,
model_array,
sys_patch_dict,
os_data
)
from ..sys_patch.patchsets import (
HardwarePatchsetDetection,
PatchType,
DynamicPatchset
)
class PatcherValidation:
@@ -120,29 +124,29 @@ class PatcherValidation:
minor_kernel (int): Minor kernel version
"""
patchset = sys_patch_dict.SystemPatchDictionary(major_kernel, minor_kernel, self.constants.legacy_accel_support, self.constants.detected_os_version).patchset_dict
host_os_float = float(f"{major_kernel}.{minor_kernel}")
patchset = HardwarePatchsetDetection(self.constants, xnu_major=major_kernel, xnu_minor=minor_kernel, validation=True).patches
for patch_subject in patchset:
for patch_core in patchset[patch_subject]:
patch_os_min_float = float(f'{patchset[patch_subject][patch_core]["OS Support"]["Minimum OS Support"]["OS Major"]}.{patchset[patch_subject][patch_core]["OS Support"]["Minimum OS Support"]["OS Minor"]}')
patch_os_max_float = float(f'{patchset[patch_subject][patch_core]["OS Support"]["Maximum OS Support"]["OS Major"]}.{patchset[patch_subject][patch_core]["OS Support"]["Maximum OS Support"]["OS Minor"]}')
if (host_os_float < patch_os_min_float or host_os_float > patch_os_max_float):
continue
for install_type in ["Install", "Install Non-Root"]:
if install_type in patchset[patch_subject][patch_core]:
for install_directory in patchset[patch_subject][patch_core][install_type]:
for install_file in patchset[patch_subject][patch_core][install_type][install_directory]:
try:
if patchset[patch_subject][patch_core][install_type][install_directory][install_file] in sys_patch_dict.DynamicPatchset:
continue
except TypeError:
pass
source_file = str(self.constants.payload_local_binaries_root_path) + "/" + patchset[patch_subject][patch_core][install_type][install_directory][install_file] + install_directory + "/" + install_file
if not Path(source_file).exists():
logging.info(f"File not found: {source_file}")
raise Exception(f"Failed to find {source_file}")
if self.verify_unused_files is True:
for patch_core in patchset:
# Check if any unknown PathType is present
for install_type in patchset[patch_core]:
if install_type not in PatchType:
raise Exception(f"Unknown PatchType: {install_type}")
for install_type in [PatchType.INSTALL_SYSTEM_VOLUME, PatchType.INSTALL_DATA_VOLUME]:
if install_type in patchset[patch_core]:
for install_directory in patchset[patch_core][install_type]:
for install_file in patchset[patch_core][install_type][install_directory]:
try:
if patchset[patch_core][install_type][install_directory][install_file] in DynamicPatchset:
continue
except TypeError:
pass
source_file = str(self.constants.payload_local_binaries_root_path) + "/" + patchset[patch_core][install_type][install_directory][install_file] + install_directory + "/" + install_file
if not Path(source_file).exists():
logging.info(f"File not found: {source_file}")
raise Exception(f"Failed to find {source_file}")
if self.verify_unused_files is True:
if source_file not in self.active_patchset_files:
self.active_patchset_files.append(source_file)
logging.info(f"Validating against Darwin {major_kernel}.{minor_kernel}")
@@ -214,10 +218,10 @@ class PatcherValidation:
raise Exception("Failed to mount Universal-Binaries.dmg")
logging.info("Mounted Universal-Binaries.dmg")
atexit.register(self._unmount_dmg)
for supported_os in [os_data.os_data.big_sur, os_data.os_data.monterey, os_data.os_data.ventura, os_data.os_data.sonoma]:
for supported_os in [os_data.os_data.big_sur, os_data.os_data.monterey, os_data.os_data.ventura, os_data.os_data.sonoma, os_data.os_data.sequoia]:
for i in range(0, 10):
self._validate_root_patch_files(supported_os, i)

9
opencore_legacy_patcher/sys_patch/auto_patcher/start.py
View File

@@ -12,7 +12,6 @@ import markdown2
import subprocess
import webbrowser
from ..detections import DetectRootPatch
from ... import constants
@@ -28,6 +27,10 @@ from ...support import (
global_settings,
network_handler,
)
from ..patchsets import (
HardwarePatchsetDetection,
HardwarePatchsetValidation
)
class StartAutomaticPatching:
@@ -142,12 +145,12 @@ Please check the Github page for more information about this release."""
if utilities.check_seal() is True:
logging.info("- Detected Snapshot seal intact, detecting patches")
patches = DetectRootPatch(self.constants.computer.real_model, self.constants).detect_patch_set()
patches = HardwarePatchsetDetection(self.constants).device_properties
if not any(not patch.startswith("Settings") and not patch.startswith("Validation") and patches[patch] is True for patch in patches):
patches = {}
if patches:
logging.info("- Detected applicable patches, determining whether possible to patch")
if patches["Validation: Patching Possible"] is False:
if patches[HardwarePatchsetValidation.PATCHING_NOT_POSSIBLE] is True:
logging.info("- Cannot run patching")
return

5
opencore_legacy_patcher/sys_patch/detections/__init__.py
View File

@@ -1,5 +0,0 @@
"""
detections: Detect and generate patch sets for the host
"""
from .detect import DetectRootPatch
from .generate import GenerateRootPatchSets

843
opencore_legacy_patcher/sys_patch/detections/detect.py
View File

@@ -1,843 +0,0 @@
"""
detect.py: Hardware Detection Logic for Root Patching
"""
import logging
import plistlib
import py_sip_xnu
import packaging.version
from pathlib import Path
from ... import constants
from ...detections import (
amfi_detect,
device_probe
)
from ...support import (
kdk_handler,
network_handler,
utilities
)
from ...datasets import (
cpu_data,
model_array,
os_data,
sip_data,
smbios_data
)
class DetectRootPatch:
"""
Library for querying root volume patches applicable for booted system
"""
def __init__(self, model: str, global_constants: constants.Constants,
os_major: int = None, os_minor: int = None,
os_build: str = None, os_version: str = None
) -> None:
self.model: str = model
self.constants: constants.Constants = global_constants
if os_major is None:
os_major = self.constants.detected_os
if os_minor is None:
os_minor = self.constants.detected_os_minor
if os_build is None:
os_build = self.constants.detected_os_build
if os_version is None:
os_version = self.constants.detected_os_version
self.os_major: int = os_major
self.os_minor: int = os_minor
self.os_build: str = os_build
self.os_version: str = os_version
self.computer = self.constants.computer
# GPU Patch Detection
self.nvidia_tesla = False
self.kepler_gpu = False
self.nvidia_web = False
self.amd_ts1 = False
self.amd_ts2 = False
self.iron_gpu = False
self.sandy_gpu = False
self.ivy_gpu = False
self.haswell_gpu = False
self.broadwell_gpu = False
self.skylake_gpu = False
self.legacy_gcn = False
self.legacy_gcn_v2 = False
self.legacy_polaris = False
self.legacy_vega = False
# Misc Patch Detection
self.brightness_legacy = False
self.legacy_audio = False
self.legacy_wifi = False
self.modern_wifi = False
self.legacy_gmux = False
self.legacy_keyboard_backlight = False
self.legacy_uhci_ohci = False
self.legacy_pcie_webcam = False
self.legacy_t1_chip = False
# Patch Requirements
self.amfi_must_disable = False
self.amfi_shim_bins = False
self.supports_metal = False
self.needs_nv_web_checks = False
self.requires_root_kc = False
# Validation Checks
self.sip_enabled = False
self.sbm_enabled = False
self.amfi_enabled = False
self.fv_enabled = False
self.dosdude_patched = False
self.missing_kdk = False
self.has_network = False
self.unsupported_os = False
self.missing_whatever_green = False
self.missing_nv_web_nvram = False
self.missing_nv_web_opengl = False
self.missing_nv_compat = False
def _detect_gpus(self):
"""
Query GPUs and set flags for applicable patches
"""
gpus = self.constants.computer.gpus
non_metal_os = os_data.os_data.catalina
for i, gpu in enumerate(gpus):
if gpu.class_code and gpu.class_code != 0xFFFFFFFF:
logging.info(f"Found GPU ({i}): {utilities.friendly_hex(gpu.vendor_id)}:{utilities.friendly_hex(gpu.device_id)}")
if gpu.arch in [device_probe.NVIDIA.Archs.Tesla] and self.constants.force_nv_web is False:
if self.os_major > non_metal_os:
self.nvidia_tesla = True
self.amfi_must_disable = True
if os_data.os_data.ventura in self.constants.legacy_accel_support:
self.amfi_shim_bins = True
self.legacy_keyboard_backlight = self._check_legacy_keyboard_backlight()
self.requires_root_kc = True
elif gpu.arch == device_probe.NVIDIA.Archs.Kepler and self.constants.force_nv_web is False:
if self.os_major > os_data.os_data.big_sur:
# Kepler drivers were dropped with Beta 7
# 12.0 Beta 5: 21.0.0 - 21A5304g
# 12.0 Beta 6: 21.1.0 - 21A5506j
# 12.0 Beta 7: 21.1.0 - 21A5522h
if (
self.os_major >= os_data.os_data.ventura or
(
"21A5506j" not in self.os_build and
self.os_major == os_data.os_data.monterey and
self.os_minor > 0
)
):
self.kepler_gpu = True
self.supports_metal = True
if self.os_major >= os_data.os_data.ventura:
self.amfi_must_disable = True
if (self.os_major == os_data.os_data.ventura and self.os_minor >= 4) or self.os_major > os_data.os_data.ventura:
self.amfi_shim_bins = True
elif gpu.arch in [
device_probe.NVIDIA.Archs.Fermi,
device_probe.NVIDIA.Archs.Kepler,
device_probe.NVIDIA.Archs.Maxwell,
device_probe.NVIDIA.Archs.Pascal,
]:
if self.os_major > os_data.os_data.mojave:
self.nvidia_web = True
self.amfi_must_disable = True
if os_data.os_data.ventura in self.constants.legacy_accel_support:
self.amfi_shim_bins = True
self.needs_nv_web_checks = True
self.requires_root_kc = True
elif gpu.arch == device_probe.AMD.Archs.TeraScale_1:
if self.os_major > non_metal_os:
self.amd_ts1 = True
self.amfi_must_disable = True
if os_data.os_data.ventura in self.constants.legacy_accel_support:
self.amfi_shim_bins = True
self.requires_root_kc = True
elif gpu.arch == device_probe.AMD.Archs.TeraScale_2:
if self.os_major > non_metal_os:
self.amd_ts2 = True
self.amfi_must_disable = True
if os_data.os_data.ventura in self.constants.legacy_accel_support:
self.amfi_shim_bins = True
self.requires_root_kc = True
elif gpu.arch in [
device_probe.AMD.Archs.Legacy_GCN_7000,
device_probe.AMD.Archs.Legacy_GCN_8000,
device_probe.AMD.Archs.Legacy_GCN_9000,
device_probe.AMD.Archs.Polaris,
]:
if self.os_major > os_data.os_data.monterey:
if self.constants.computer.rosetta_active is True:
continue
if gpu.arch == device_probe.AMD.Archs.Polaris:
# Check if host supports AVX2.0
# If not, enable legacy GCN patch
# MacBookPro13,3 does include an unsupported framebuffer, thus we'll patch to ensure
# full compatibility (namely power states, etc)
# Reference: https://github.com/dortania/bugtracker/issues/292
# TODO: Probe framebuffer families further
# Sonoma note: MacBookPro14,3 has the same issue...
# iMac18,2/3 is partially affected, however currently it seems the generic framebuffer
# is sufficient. Only MacBookPro14,3 needs this for dGPU handling
if self.model not in ["MacBookPro13,3", "MacBookPro14,3"]:
if "AVX2" in self.constants.computer.cpu.leafs:
continue
self.legacy_polaris = True
else:
if self.model == "MacBookPro13,3":
self.legacy_gcn = True
elif self.model == "MacBookPro14,3":
if self.os_major < os_data.os_data.sonoma:
continue
self.legacy_gcn_v2 = True
else:
self.legacy_gcn = True
self.supports_metal = True
self.requires_root_kc = True
self.amfi_must_disable = True
elif gpu.arch == device_probe.AMD.Archs.Vega:
if self.os_major > os_data.os_data.monterey:
if "AVX2" in self.constants.computer.cpu.leafs:
continue
self.legacy_vega = True
self.supports_metal = True
self.requires_root_kc = True
self.amfi_must_disable = True
elif gpu.arch == device_probe.Intel.Archs.Iron_Lake:
if self.os_major > non_metal_os:
self.iron_gpu = True
self.amfi_must_disable = True
if os_data.os_data.ventura in self.constants.legacy_accel_support:
self.amfi_shim_bins = True
self.legacy_keyboard_backlight = self._check_legacy_keyboard_backlight()
self.requires_root_kc = True
elif gpu.arch == device_probe.Intel.Archs.Sandy_Bridge:
if self.os_major > non_metal_os:
self.sandy_gpu = True
self.amfi_must_disable = True
if os_data.os_data.ventura in self.constants.legacy_accel_support:
self.amfi_shim_bins = True
self.legacy_keyboard_backlight = self._check_legacy_keyboard_backlight()
self.requires_root_kc = True
elif gpu.arch == device_probe.Intel.Archs.Ivy_Bridge:
if self.os_major > os_data.os_data.big_sur:
self.ivy_gpu = True
if self.os_major >= os_data.os_data.ventura:
self.amfi_must_disable = True
if (self.os_major == os_data.os_data.ventura and self.os_minor >= 4) or self.os_major > os_data.os_data.ventura:
self.amfi_shim_bins = True
self.supports_metal = True
elif gpu.arch == device_probe.Intel.Archs.Haswell:
if self.os_major > os_data.os_data.monterey:
self.haswell_gpu = True
self.amfi_must_disable = True
if (self.os_major == os_data.os_data.ventura and self.os_minor >= 4) or self.os_major > os_data.os_data.ventura:
self.amfi_shim_bins = True
self.supports_metal = True
elif gpu.arch == device_probe.Intel.Archs.Broadwell:
if self.os_major > os_data.os_data.monterey:
self.broadwell_gpu = True
self.amfi_must_disable = True
self.supports_metal = True
elif gpu.arch == device_probe.Intel.Archs.Skylake:
if self.os_major > os_data.os_data.monterey:
self.skylake_gpu = True
self.amfi_must_disable = True
self.supports_metal = True
if self.supports_metal is True:
# Avoid patching Metal and non-Metal GPUs if both present, prioritize Metal GPU
# Main concerns are for iMac12,x with Sandy iGPU and Kepler dGPU
self.nvidia_tesla = False
self.nvidia_web = False
self.amd_ts1 = False
self.amd_ts2 = False
self.iron_gpu = False
self.sandy_gpu = False
self.legacy_keyboard_backlight = False
if self.legacy_gcn is True or self.legacy_gcn_v2 is True:
# We can only support one or the other due to the nature of relying
# on portions of the native AMD stack for Polaris and Vega
# Thus we'll prioritize legacy GCN due to being the internal card
# ex. MacPro6,1 and MacBookPro11,5 with eGPUs
self.legacy_polaris = False
self.legacy_vega = False
if self.os_major <= os_data.os_data.monterey:
# Always assume Root KC requirement on Monterey and older
self.requires_root_kc = True
else:
if self.requires_root_kc is True:
self.missing_kdk = not self._check_kdk()
def _check_networking_support(self):
"""
Query for network requirement, ex. KDK downloading
On macOS Ventura, networking support is required to download KDKs.
However for machines such as BCM94322, BCM94328 and Atheros chipsets,
users may only have wifi as their only supported network interface.
Thus we'll allow for KDK-less installs for these machines on first run.
On subsequent runs, we'll require networking to be enabled.
"""
# Increase OS check if modern wifi is detected
if self.os_major < (os_data.os_data.ventura if self.legacy_wifi is True else os_data.os_data.sonoma):
return
if self.legacy_wifi is False and self.modern_wifi is False:
return
if self.requires_root_kc is False:
return
if self.missing_kdk is False:
return
if self.has_network is True:
return
# Verify whether OCLP already installed network patches to the root volume
# If so, require networking to be enabled (user just needs to connect to wifi)
oclp_patch_path = "/System/Library/CoreServices/OpenCore-Legacy-Patcher.plist"
if Path(oclp_patch_path).exists():
oclp_plist = plistlib.load(open(oclp_patch_path, "rb"))
if "Legacy Wireless" in oclp_plist or "Modern Wireless" in oclp_plist:
return
# Due to the reliance of KDKs for most older patches, we'll allow KDK-less
# installs for Legacy Wifi patches and remove others
self.missing_kdk = False
self.requires_root_kc = False
# Reset patches needing KDK
self.nvidia_tesla = False
self.nvidia_web = False
self.amd_ts1 = False
self.amd_ts2 = False
self.iron_gpu = False
self.sandy_gpu = False
self.legacy_gcn = False
self.legacy_gcn_v2 = False
self.legacy_polaris = False
self.legacy_vega = False
self.brightness_legacy = False
self.legacy_audio = False
self.legacy_gmux = False
self.legacy_keyboard_backlight = False
# Currently all graphics patches require a KDK
if self.os_major >= os_data.os_data.sonoma:
self.kepler_gpu = False
self.ivy_gpu = False
self.haswell_gpu = False
self.broadwell_gpu = False
self.skylake_gpu = False
def _check_dgpu_status(self):
"""
Query whether system has an active dGPU
"""
dgpu = self.constants.computer.dgpu
if dgpu:
if dgpu.class_code and dgpu.class_code == 0xFFFFFFFF:
# If dGPU is disabled via class-codes, assume demuxed
return False
return True
return False
def _detect_demux(self):
"""
Query whether system has been demuxed (ex. MacBookPro8,2, disabled dGPU)
"""
# If GFX0 is missing, assume machine was demuxed
# -wegnoegpu would also trigger this, so ensure arg is not present
if not "-wegnoegpu" in (utilities.get_nvram("boot-args", decode=True) or ""):
igpu = self.constants.computer.igpu
dgpu = self._check_dgpu_status()
if igpu and not dgpu:
return True
return False
def _check_legacy_keyboard_backlight(self):
"""
Query whether system has a legacy keyboard backlight
Returns:
bool: True if legacy keyboard backlight, False otherwise
"""
# iMac12,x+ have an 'ACPI0008' device, but it's not a keyboard backlight
# Best to assume laptops will have a keyboard backlight
if self.model.startswith("MacBook"):
return self.constants.computer.ambient_light_sensor
return False
def _check_nv_web_nvram(self):
"""
Query for Nvidia Web Driver property: nvda_drv_vrl or nvda_drv
Returns:
bool: True if property is present, False otherwise
"""
nv_on = utilities.get_nvram("boot-args", decode=True)
if nv_on:
if "nvda_drv_vrl=" in nv_on:
return True
nv_on = utilities.get_nvram("nvda_drv")
if nv_on:
return True
return False
def _check_nv_web_opengl(self):
"""
Query for Nvidia Web Driver property: ngfxgl
Verify Web Drivers will run in OpenGL mode
Returns:
bool: True if property is present, False otherwise
"""
nv_on = utilities.get_nvram("boot-args", decode=True)
if nv_on:
if "ngfxgl=" in nv_on:
return True
for gpu in self.constants.computer.gpus:
if isinstance(gpu, device_probe.NVIDIA):
if gpu.disable_metal is True:
return True
return False
def _check_nv_compat(self):
"""
Query for Nvidia Web Driver property: ngfxcompat
Verify Web Drivers will skip NVDAStartupWeb compatibility check
Returns:
bool: True if property is present, False otherwise
"""
nv_on = utilities.get_nvram("boot-args", decode=True)
if nv_on:
if "ngfxcompat=" in nv_on:
return True
for gpu in self.constants.computer.gpus:
if isinstance(gpu, device_probe.NVIDIA):
if gpu.force_compatible is True:
return True
return False
def _check_whatevergreen(self):
"""
Query whether WhateverGreen.kext is loaded
Returns:
bool: True if loaded, False otherwise
"""
return utilities.check_kext_loaded("as.vit9696.WhateverGreen")
def _check_os_compat(self) -> bool:
"""
Base check to ensure patcher is compatible with host OS
"""
min_os = os_data.os_data.big_sur
max_os = os_data.os_data.sequoia
if self.os_major < min_os or self.os_major > max_os:
return False
return True
def _check_kdk(self):
"""
Query whether Kernel Debug Kit is installed
Returns:
bool: True if installed, False otherwise
"""
return kdk_handler.KernelDebugKitObject(self.constants, self.os_build, self.os_version, passive=True).kdk_already_installed
def _check_sip(self):
"""
Query System Integrity checks required for patching
Returns:
tuple: (list, str, str) of SIP values, SIP hex, SIP error message
"""
if self.os_major > os_data.os_data.catalina:
if self.nvidia_web is True:
sip = sip_data.system_integrity_protection.root_patch_sip_big_sur_3rd_part_kexts
sip_hex = "0xA03"
sip_value = (
f"For Hackintoshes, please set csr-active-config to '030A0000' ({sip_hex})\nFor non-OpenCore Macs, please run 'csrutil disable' and \n'csrutil authenticated-root disable' in RecoveryOS"
)
elif self.os_major >= os_data.os_data.ventura:
sip = sip_data.system_integrity_protection.root_patch_sip_ventura
sip_hex = "0x803"
sip_value = (
f"For Hackintoshes, please set csr-active-config to '03080000' ({sip_hex})\nFor non-OpenCore Macs, please run 'csrutil disable' and \n'csrutil authenticated-root disable' in RecoveryOS"
)
else:
sip = sip_data.system_integrity_protection.root_patch_sip_big_sur
sip_hex = "0x802"
sip_value = (
f"For Hackintoshes, please set csr-active-config to '02080000' ({sip_hex})\nFor non-OpenCore Macs, please run 'csrutil disable' and \n'csrutil authenticated-root disable' in RecoveryOS"
)
else:
sip = sip_data.system_integrity_protection.root_patch_sip_mojave
sip_hex = "0x603"
sip_value = f"For Hackintoshes, please set csr-active-config to '03060000' ({sip_hex})\nFor non-OpenCore Macs, please run 'csrutil disable' in RecoveryOS"
return (sip, sip_value, sip_hex)
def _check_uhci_ohci(self):
"""
Query whether host has UHCI/OHCI controllers, and requires USB 1.1 patches
Returns:
bool: True if UHCI/OHCI patches required, False otherwise
"""
if self.os_major < os_data.os_data.ventura:
return False
# If we're on a hackintosh, check for UHCI/OHCI controllers
if self.constants.host_is_hackintosh is True:
for controller in self.constants.computer.usb_controllers:
if (
isinstance(controller, device_probe.UHCIController) or
isinstance(controller, device_probe.OHCIController)
):
return True
return False
if self.model not in smbios_data.smbios_dictionary:
return False
# If we're on a Mac, check for Penryn or older
# This is due to Apple implementing an internal USB hub on post-Penryn (excluding MacPro4,1, MacPro5,1 and Xserve3,1)
# Ref: https://techcommunity.microsoft.com/t5/microsoft-usb-blog/reasons-to-avoid-companion-controllers/ba-p/270710
if (
smbios_data.smbios_dictionary[self.model]["CPU Generation"] <= cpu_data.CPUGen.penryn.value or \
self.model in ["MacPro4,1", "MacPro5,1", "Xserve3,1"]
):
return True
return False
# Entry point for patch set detection
def detect_patch_set(self):
"""
Query patch sets required for host
Returns:
dict: Dictionary of patch sets
"""
self.has_network = network_handler.NetworkUtilities().verify_network_connection()
if self.os_major >= os_data.os_data.sonoma:
self.legacy_pcie_webcam = self.constants.computer.pcie_webcam
self.legacy_t1_chip = self.constants.computer.t1_chip
if self.legacy_t1_chip is True:
self.amfi_must_disable = True
if self._check_uhci_ohci() is True:
self.legacy_uhci_ohci = True
self.requires_root_kc = True
if self.model in model_array.LegacyBrightness:
if self.os_major > os_data.os_data.catalina:
self.brightness_legacy = True
if self.model in ["iMac7,1", "iMac8,1"] or (self.model in model_array.LegacyAudio and utilities.check_kext_loaded("as.vit9696.AppleALC") is False):
# Special hack for systems with botched GOPs
# TL;DR: No Boot Screen breaks Lilu, therefore breaking audio
if self.os_major > os_data.os_data.catalina:
self.legacy_audio = True
if (
isinstance(self.constants.computer.wifi, device_probe.Broadcom)
and self.constants.computer.wifi.chipset in [device_probe.Broadcom.Chipsets.AirPortBrcm4331, device_probe.Broadcom.Chipsets.AirPortBrcm43224]
) or (isinstance(self.constants.computer.wifi, device_probe.Atheros) and self.constants.computer.wifi.chipset == device_probe.Atheros.Chipsets.AirPortAtheros40):
if self.os_major > os_data.os_data.big_sur:
self.legacy_wifi = True
if self.os_major >= os_data.os_data.ventura:
# Due to extracted frameworks for IO80211.framework and co, check library validation
self.amfi_must_disable = True
if self.os_major > os_data.os_data.ventura:
self.amfi_shim_bins = True
if (
isinstance(self.constants.computer.wifi, device_probe.Broadcom)
and self.constants.computer.wifi.chipset in [
device_probe.Broadcom.Chipsets.AirPortBrcm4360,
device_probe.Broadcom.Chipsets.AirportBrcmNIC,
# We don't officially support this chipset, however we'll throw a bone to hackintosh users
device_probe.Broadcom.Chipsets.AirPortBrcmNICThirdParty,
]):
if self.os_major > os_data.os_data.ventura:
self.modern_wifi = True
self.amfi_shim_bins = True
# if self.model in ["MacBookPro5,1", "MacBookPro5,2", "MacBookPro5,3", "MacBookPro8,2", "MacBookPro8,3"]:
if self.model in ["MacBookPro8,2", "MacBookPro8,3"]:
# Sierra uses a legacy GMUX control method needed for dGPU switching on MacBookPro5,x
# Same method is also used for demuxed machines
# Note that MacBookPro5,x machines are extremely unstable with this patch set, so disabled until investigated further
# Ref: https://github.com/dortania/OpenCore-Legacy-Patcher/files/7360909/KP-b10-030.txt
if self.os_major > os_data.os_data.high_sierra:
if self.model in ["MacBookPro8,2", "MacBookPro8,3"]:
# Ref: https://doslabelectronics.com/Demux.html
if self._detect_demux() is True:
self.legacy_gmux = True
else:
self.legacy_gmux = True
self._detect_gpus()
# This must be performed last, as it may override previous decisions
# Namely, whether we allow patches requiring KDKs
self._check_networking_support()
self.root_patch_dict = {
"Graphics: Nvidia Tesla": self.nvidia_tesla,
"Graphics: Nvidia Kepler": self.kepler_gpu,
"Graphics: Nvidia Web Drivers": self.nvidia_web,
"Graphics: AMD TeraScale 1": self.amd_ts1,
"Graphics: AMD TeraScale 2": self.amd_ts2,
"Graphics: AMD Legacy GCN": self.legacy_gcn,
"Graphics: AMD Legacy GCN (2017)": self.legacy_gcn_v2,
"Graphics: AMD Legacy Polaris": self.legacy_polaris,
"Graphics: AMD Legacy Vega": self.legacy_vega,
"Graphics: Intel Ironlake": self.iron_gpu,
"Graphics: Intel Sandy Bridge": self.sandy_gpu,
"Graphics: Intel Ivy Bridge": self.ivy_gpu,
"Graphics: Intel Haswell": self.haswell_gpu,
"Graphics: Intel Broadwell": self.broadwell_gpu,
"Graphics: Intel Skylake": self.skylake_gpu,
"Brightness: Legacy Backlight Control": self.brightness_legacy,
"Audio: Legacy Realtek": self.legacy_audio,
"Networking: Legacy Wireless": self.legacy_wifi,
"Networking: Modern Wireless": self.modern_wifi,
"Miscellaneous: Legacy GMUX": self.legacy_gmux,
"Miscellaneous: Legacy Keyboard Backlight": self.legacy_keyboard_backlight,
"Miscellaneous: Legacy USB 1.1": self.legacy_uhci_ohci,
"Miscellaneous: PCIe FaceTime Camera": self.legacy_pcie_webcam,
"Miscellaneous: T1 Security Chip": self.legacy_t1_chip,
"Settings: Requires AMFI exemption": self.amfi_must_disable,
"Settings: Supports Auxiliary Cache": not self.requires_root_kc,
"Settings: Kernel Debug Kit missing": self.missing_kdk if self.os_major >= os_data.os_data.ventura.value else False,
"Settings: MetallibSupportPkg missing": self.os_major >= os_data.os_data.sequoia.value and any([self.kepler_gpu, self.ivy_gpu, self.haswell_gpu]),
"Validation: Patching Possible": self.verify_patch_allowed(),
"Validation: Unpatching Possible": self._verify_unpatch_allowed(),
f"Validation: Unsupported Host OS": self.unsupported_os,
f"Validation: SIP is enabled (Required: {self._check_sip()[2]} or higher)": self.sip_enabled,
f"Validation: Currently Booted SIP: ({hex(py_sip_xnu.SipXnu().get_sip_status().value)})": self.sip_enabled,
"Validation: SecureBootModel is enabled": self.sbm_enabled,
f"Validation: {'AMFI' if self.constants.host_is_hackintosh is True or self._get_amfi_level_needed() > 2 else 'Library Validation'} is enabled": self.amfi_enabled if self.amfi_must_disable is True else False,
"Validation: FileVault is enabled": self.fv_enabled,
"Validation: System is dosdude1 patched": self.dosdude_patched,
"Validation: WhateverGreen.kext missing": self.missing_whatever_green if self.nvidia_web is True else False,
"Validation: Force OpenGL property missing": self.missing_nv_web_opengl if self.nvidia_web is True else False,
"Validation: Force compat property missing": self.missing_nv_compat if self.nvidia_web is True else False,
"Validation: nvda_drv(_vrl) variable missing": self.missing_nv_web_nvram if self.nvidia_web is True else False,
"Validation: Network Connection Required": (not self.has_network) if (self.requires_root_kc and self.missing_kdk and self.os_major >= os_data.os_data.ventura.value) else False,
f"Validation: Graphics Patches unavailable for macOS Sequoia": not self._can_patch_3802(),
}
return self.root_patch_dict
def _get_amfi_level_needed(self):
"""
Query the AMFI level needed for the patcher to work
Returns:
int: AMFI level needed
"""
if self.amfi_must_disable is False:
return amfi_detect.AmfiConfigDetectLevel.NO_CHECK
if self.os_major < os_data.os_data.big_sur:
return amfi_detect.AmfiConfigDetectLevel.NO_CHECK
amfipass_version = utilities.check_kext_loaded("com.dhinakg.AMFIPass")
if amfipass_version:
if packaging.version.parse(amfipass_version) >= packaging.version.parse(self.constants.amfipass_compatibility_version):
# If AMFIPass is loaded, our binaries will work
return amfi_detect.AmfiConfigDetectLevel.NO_CHECK
if self.os_major >= os_data.os_data.ventura:
if self.amfi_shim_bins is True:
# Currently we require AMFI outright disabled
# in Ventura to work with shim'd binaries
return amfi_detect.AmfiConfigDetectLevel.ALLOW_ALL
return amfi_detect.AmfiConfigDetectLevel.LIBRARY_VALIDATION
def _can_patch_3802(self) -> bool:
"""
3802 patches are currently very broken in Sequoia
Only allow patching if
"""
# Check if any 3802 patches are needed
if self.constants.detected_os < os_data.os_data.sequoia:
return True
if any([self.kepler_gpu, self.ivy_gpu, self.haswell_gpu]):
if Path("~/.dortania_developer").expanduser().exists():
return True
return False
return True
def verify_patch_allowed(self, print_errors: bool = False):
"""
Validate that the patcher can be run
Parameters:
print_errors (bool): Print errors to console
Returns:
bool: True if patching is allowed, False otherwise
"""
sip_dict = self._check_sip()
sip = sip_dict[0]
sip_value = sip_dict[1]
self.sip_enabled, self.sbm_enabled, self.fv_enabled, self.dosdude_patched = utilities.patching_status(sip, self.os_major)
self.amfi_enabled = not amfi_detect.AmfiConfigurationDetection().check_config(self._get_amfi_level_needed())
self.unsupported_os = not self._check_os_compat()
if self.nvidia_web is True:
self.missing_nv_web_nvram = not self._check_nv_web_nvram()
self.missing_nv_web_opengl = not self._check_nv_web_opengl()
self.missing_nv_compat = not self._check_nv_compat()
self.missing_whatever_green = not self._check_whatevergreen()
if print_errors is True:
if self.sip_enabled is True:
logging.info("\nCannot patch! Please disable System Integrity Protection (SIP).")
logging.info("Disable SIP in Patcher Settings and Rebuild OpenCore\n")
logging.info("Ensure the following bits are set for csr-active-config:")
logging.info("\n".join(sip))
logging.info(sip_value)
if self.sbm_enabled is True:
logging.info("\nCannot patch! Please disable Apple Secure Boot.")
logging.info("Disable SecureBootModel in Patcher Settings and Rebuild OpenCore")
logging.info("For Hackintoshes, set SecureBootModel to Disabled")
if self.fv_enabled is True:
logging.info("\nCannot patch! Please disable FileVault.")
logging.info("For OCLP Macs, please rebuild your config with 0.2.5 or newer")
logging.info("For others, Go to System Preferences -> Security and disable FileVault")
if self.amfi_enabled is True and self.amfi_must_disable is True:
logging.info("\nCannot patch! Please disable AMFI.")
logging.info("For Hackintoshes, please add amfi_get_out_of_my_way=1 to boot-args")
if self.dosdude_patched is True:
logging.info("\nCannot patch! Detected machine has already been patched by another patcher")
logging.info("Please ensure your install is either clean or patched with OpenCore Legacy Patcher")
if self.nvidia_web is True:
if self.missing_nv_web_opengl is True:
logging.info("\nCannot patch! Force OpenGL property missing")
logging.info("Please ensure ngfxgl=1 is set in boot-args")
if self.missing_nv_compat is True:
logging.info("\nCannot patch! Force Nvidia compatibility property missing")
logging.info("Please ensure ngfxcompat=1 is set in boot-args")
if self.missing_nv_web_nvram is True:
logging.info("\nCannot patch! nvda_drv(_vrl) variable missing")
logging.info("Please ensure nvda_drv_vrl=1 is set in boot-args")
if self.missing_whatever_green is True:
logging.info("\nCannot patch! WhateverGreen.kext missing")
logging.info("Please ensure WhateverGreen.kext is installed")
if (not self.has_network) if (self.requires_root_kc and self.missing_kdk and self.os_major >= os_data.os_data.ventura.value) else False:
logging.info("\nCannot patch! Network Connection Required")
logging.info("Please ensure you have an active internet connection")
if self.unsupported_os is True:
logging.info("\nCannot patch! Unsupported Host OS")
logging.info("Please ensure you are running a patcher-supported OS")
if any(
[
# General patch checks
self.sip_enabled, self.sbm_enabled, self.fv_enabled, self.dosdude_patched, self.unsupported_os,
# non-Metal specific
self.amfi_enabled if self.amfi_must_disable is True else False,
# Web Driver specific
self.missing_nv_web_nvram if self.nvidia_web is True else False,
self.missing_nv_web_opengl if self.nvidia_web is True else False,
self.missing_nv_compat if self.nvidia_web is True else False,
self.missing_whatever_green if self.nvidia_web is True else False,
# KDK specific
(not self.has_network) if (self.requires_root_kc and self.missing_kdk and self.os_major >= os_data.os_data.ventura.value) else False,
# 3802 specific
not self._can_patch_3802()
]
):
return False
return True
def _verify_unpatch_allowed(self):
"""
Validate that the unpatcher can be run
Preconditions:
Must be called after verify_patch_allowed()
Returns:
bool: True if unpatching is allowed, False otherwise
"""
return not self.sip_enabled

215
opencore_legacy_patcher/sys_patch/detections/generate.py
View File

@@ -1,215 +0,0 @@
"""
generate.py: Class for generating patch sets for the current host
"""
import logging
from ... import constants
from ...datasets import sys_patch_dict
from ...support import utilities
from ...detections import device_probe
class GenerateRootPatchSets:
"""
Library for generating patch sets for the current host
Parameters:
model (str): Model identifier
global_constants (constants.Constants): Global constants object
hardware_details (dict): Dictionary of hardware details generated by detect_patch_set()
Usage:
>>> from resources.sys_patch import sys_patch_generate
>>> patchset = sys_patch_generate.GenerateRootPatches("iMac7,1", self.constants, self.hardware_details).patchset
"""
def __init__(self, model: str, global_constants: constants.Constants, hardware_details: dict) -> None:
self.model: str = model
self.constants: constants.Constants = global_constants
self.hardware_details: dict = hardware_details
self.patchset: dict = self._generate_patchset()
def _generate_patchset(self) -> dict:
"""
Generate Patchset dictionary for the current system
Returns:
dict: Dictionary of patches to be applied from sys_patch_dict.py
"""
all_hardware_patchset: dict = sys_patch_dict.SystemPatchDictionary(self.constants.detected_os, self.constants.detected_os_minor, self.constants.legacy_accel_support, self.constants.detected_os_version).patchset_dict
required_patches: dict = {}
utilities.cls()
logging.info("The following patches will be applied:")
if self.hardware_details["Graphics: Intel Ironlake"] is True:
required_patches.update({"Non-Metal Common": all_hardware_patchset["Graphics"]["Non-Metal Common"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"Intel Ironlake": all_hardware_patchset["Graphics"]["Intel Ironlake"]})
if self.hardware_details["Graphics: Intel Sandy Bridge"] is True:
required_patches.update({"Non-Metal Common": all_hardware_patchset["Graphics"]["Non-Metal Common"]})
required_patches.update({"High Sierra GVA": all_hardware_patchset["Graphics"]["High Sierra GVA"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"Intel Sandy Bridge": all_hardware_patchset["Graphics"]["Intel Sandy Bridge"]})
# Patchset breaks Display Profiles, don't install if primary GPU is AMD. Give users option to disable patch in settings to restore Display Profiles
if self.constants.computer.real_model not in ["Macmini5,2", "iMac12,1", "iMac12,2"]:
required_patches.update({"Revert Non-Metal ColorSync Workaround": all_hardware_patchset["Graphics"]["Revert Non-Metal ColorSync Workaround"]})
if self.hardware_details["Graphics: Intel Ivy Bridge"] is True:
required_patches.update({"Metal 3802 Common": all_hardware_patchset["Graphics"]["Metal 3802 Common"]})
required_patches.update({"Metal 3802 Common Extended": all_hardware_patchset["Graphics"]["Metal 3802 Common Extended"]})
required_patches.update({"Metal 3802 .metallibs": all_hardware_patchset["Graphics"]["Metal 3802 .metallibs"]})
required_patches.update({"Catalina GVA": all_hardware_patchset["Graphics"]["Catalina GVA"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
required_patches.update({"Big Sur OpenCL": all_hardware_patchset["Graphics"]["Big Sur OpenCL"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"Intel Ivy Bridge": all_hardware_patchset["Graphics"]["Intel Ivy Bridge"]})
if self.hardware_details["Graphics: Intel Haswell"] is True:
required_patches.update({"Metal 3802 Common": all_hardware_patchset["Graphics"]["Metal 3802 Common"]})
required_patches.update({"Metal 3802 Common Extended": all_hardware_patchset["Graphics"]["Metal 3802 Common Extended"]})
required_patches.update({"Metal 3802 .metallibs": all_hardware_patchset["Graphics"]["Metal 3802 .metallibs"]})
required_patches.update({"Monterey GVA": all_hardware_patchset["Graphics"]["Monterey GVA"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
required_patches.update({"Intel Haswell": all_hardware_patchset["Graphics"]["Intel Haswell"]})
if self.hardware_details["Graphics: Intel Broadwell"] is True:
required_patches.update({"Monterey GVA": all_hardware_patchset["Graphics"]["Monterey GVA"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
required_patches.update({"Intel Broadwell": all_hardware_patchset["Graphics"]["Intel Broadwell"]})
if self.hardware_details["Graphics: Intel Skylake"] is True:
required_patches.update({"Revert GVA Downgrade": all_hardware_patchset["Graphics"]["Revert GVA Downgrade"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
required_patches.update({"Intel Skylake": all_hardware_patchset["Graphics"]["Intel Skylake"]})
if self.hardware_details["Graphics: Nvidia Tesla"] is True:
required_patches.update({"Non-Metal Common": all_hardware_patchset["Graphics"]["Non-Metal Common"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"Nvidia Tesla": all_hardware_patchset["Graphics"]["Nvidia Tesla"]})
if self.hardware_details["Graphics: Nvidia Web Drivers"] is True:
required_patches.update({"Non-Metal Common": all_hardware_patchset["Graphics"]["Non-Metal Common"]})
required_patches.update({"Non-Metal IOAccelerator Common": all_hardware_patchset["Graphics"]["Non-Metal IOAccelerator Common"]})
required_patches.update({"Non-Metal CoreDisplay Common": all_hardware_patchset["Graphics"]["Non-Metal CoreDisplay Common"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"Nvidia Web Drivers": all_hardware_patchset["Graphics"]["Nvidia Web Drivers"]})
required_patches.update({"Non-Metal Enforcement": all_hardware_patchset["Graphics"]["Non-Metal Enforcement"]})
if self.hardware_details["Graphics: Nvidia Kepler"] is True:
required_patches.update({"Metal 3802 Common": all_hardware_patchset["Graphics"]["Metal 3802 Common"]})
required_patches.update({"Metal 3802 Common Extended": all_hardware_patchset["Graphics"]["Metal 3802 Common Extended"]})
required_patches.update({"Metal 3802 .metallibs": all_hardware_patchset["Graphics"]["Metal 3802 .metallibs"]})
required_patches.update({"Catalina GVA": all_hardware_patchset["Graphics"]["Catalina GVA"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
required_patches.update({"Big Sur OpenCL": all_hardware_patchset["Graphics"]["Big Sur OpenCL"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"Nvidia Kepler": all_hardware_patchset["Graphics"]["Nvidia Kepler"]})
for gpu in self.constants.computer.gpus:
# Handle mixed GPU situations (ie. MacBookPro11,3: Haswell iGPU + Kepler dGPU)
if gpu.arch == device_probe.Intel.Archs.Haswell:
if "Catalina GVA" in required_patches:
del(required_patches["Catalina GVA"])
break
if self.hardware_details["Graphics: AMD TeraScale 1"] is True:
required_patches.update({"Non-Metal Common": all_hardware_patchset["Graphics"]["Non-Metal Common"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"AMD TeraScale Common": all_hardware_patchset["Graphics"]["AMD TeraScale Common"]})
required_patches.update({"AMD TeraScale 1": all_hardware_patchset["Graphics"]["AMD TeraScale 1"]})
if self.hardware_details["Graphics: AMD TeraScale 2"] is True:
required_patches.update({"Non-Metal Common": all_hardware_patchset["Graphics"]["Non-Metal Common"]})
required_patches.update({"Non-Metal IOAccelerator Common": all_hardware_patchset["Graphics"]["Non-Metal IOAccelerator Common"]})
required_patches.update({"WebKit Monterey Common": all_hardware_patchset["Graphics"]["WebKit Monterey Common"]})
required_patches.update({"AMD TeraScale Common": all_hardware_patchset["Graphics"]["AMD TeraScale Common"]})
required_patches.update({"AMD TeraScale 2": all_hardware_patchset["Graphics"]["AMD TeraScale 2"]})
if self.constants.allow_ts2_accel is False or self.constants.detected_os not in self.constants.legacy_accel_support:
# TeraScale 2 MacBooks with faulty GPUs are highly prone to crashing with AMDRadeonX3000 attached
# Additionally, AMDRadeonX3000 requires IOAccelerator downgrade which is not installed without 'Non-Metal IOAccelerator Common'
del(required_patches["AMD TeraScale 2"]["Install"]["/System/Library/Extensions"]["AMDRadeonX3000.kext"])
if self.hardware_details["Graphics: AMD Legacy GCN"] is True or self.hardware_details["Graphics: AMD Legacy Polaris"] is True:
if self.hardware_details["Graphics: Intel Skylake"] is False:
# GVA downgrade not required if Skylake is present
required_patches.update({"Monterey GVA": all_hardware_patchset["Graphics"]["Monterey GVA"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
if self.hardware_details["Graphics: AMD Legacy GCN"] is True:
required_patches.update({"AMD Legacy GCN": all_hardware_patchset["Graphics"]["AMD Legacy GCN"]})
else:
required_patches.update({"AMD Legacy Polaris": all_hardware_patchset["Graphics"]["AMD Legacy Polaris"]})
required_patches.update({"Revert GVA Downgrade": all_hardware_patchset["Graphics"]["Revert GVA Downgrade"]})
if "AVX2" not in self.constants.computer.cpu.leafs:
required_patches.update({"AMD OpenCL": all_hardware_patchset["Graphics"]["AMD OpenCL"]})
if self.hardware_details["Graphics: AMD Legacy GCN (2017)"] is True:
required_patches.update({"AMD Legacy GCN v2": all_hardware_patchset["Graphics"]["AMD Legacy GCN v2"]})
if self.hardware_details["Graphics: AMD Legacy Vega"] is True:
required_patches.update({"Monterey GVA": all_hardware_patchset["Graphics"]["Monterey GVA"]})
required_patches.update({"Monterey OpenCL": all_hardware_patchset["Graphics"]["Monterey OpenCL"]})
required_patches.update({"AMD Legacy Vega": all_hardware_patchset["Graphics"]["AMD Legacy Vega"]})
required_patches.update({"AMD OpenCL": all_hardware_patchset["Graphics"]["AMD OpenCL"]})
if self.hardware_details["Graphics: AMD Legacy GCN"] is True:
required_patches.update({"AMD Legacy Vega Extended": all_hardware_patchset["Graphics"]["AMD Legacy Vega Extended"]})
else:
required_patches.update({"Revert GVA Downgrade": all_hardware_patchset["Graphics"]["Revert GVA Downgrade"]})
if self.hardware_details["Brightness: Legacy Backlight Control"] is True:
required_patches.update({"Legacy Backlight Control": all_hardware_patchset["Brightness"]["Legacy Backlight Control"]})
if self.hardware_details["Audio: Legacy Realtek"] is True:
if self.model in ["iMac7,1", "iMac8,1"]:
required_patches.update({"Legacy Realtek": all_hardware_patchset["Audio"]["Legacy Realtek"]})
else:
required_patches.update({"Legacy Non-GOP": all_hardware_patchset["Audio"]["Legacy Non-GOP"]})
if self.hardware_details["Networking: Legacy Wireless"] is True:
required_patches.update({"Legacy Wireless": all_hardware_patchset["Networking"]["Legacy Wireless"]})
required_patches.update({"Legacy Wireless Extended": all_hardware_patchset["Networking"]["Legacy Wireless Extended"]})
if self.hardware_details["Networking: Modern Wireless"] is True:
required_patches.update({"Legacy Wireless": all_hardware_patchset["Networking"]["Modern Wireless"]})
if self.hardware_details["Miscellaneous: Legacy GMUX"] is True:
required_patches.update({"Legacy GMUX": all_hardware_patchset["Miscellaneous"]["Legacy GMUX"]})
if self.hardware_details["Miscellaneous: Legacy Keyboard Backlight"] is True:
required_patches.update({"Legacy Keyboard Backlight": all_hardware_patchset["Miscellaneous"]["Legacy Keyboard Backlight"]})
if self.hardware_details["Miscellaneous: Legacy USB 1.1"] is True:
required_patches.update({"Legacy USB 1.1": all_hardware_patchset["Miscellaneous"]["Legacy USB 1.1"]})
required_patches.update({"Legacy USB 1.1 Extended": all_hardware_patchset["Miscellaneous"]["Legacy USB 1.1 Extended"]})
if self.hardware_details["Miscellaneous: PCIe FaceTime Camera"] is True:
required_patches.update({"PCIe FaceTime Camera": all_hardware_patchset["Miscellaneous"]["PCIe FaceTime Camera"]})
if self.hardware_details["Miscellaneous: T1 Security Chip"] is True:
required_patches.update({"T1 Security Chip": all_hardware_patchset["Miscellaneous"]["T1 Security Chip"]})
if required_patches:
host_os_float = float(f"{self.constants.detected_os}.{self.constants.detected_os_minor}")
# Prioritize Monterey GVA patches
if "Catalina GVA" in required_patches and "Monterey GVA" in required_patches:
del(required_patches["Catalina GVA"])
for patch_name in list(required_patches):
patch_os_min_float = float(f'{required_patches[patch_name]["OS Support"]["Minimum OS Support"]["OS Major"]}.{required_patches[patch_name]["OS Support"]["Minimum OS Support"]["OS Minor"]}')
patch_os_max_float = float(f'{required_patches[patch_name]["OS Support"]["Maximum OS Support"]["OS Major"]}.{required_patches[patch_name]["OS Support"]["Maximum OS Support"]["OS Minor"]}')
if (host_os_float < patch_os_min_float or host_os_float > patch_os_max_float):
del(required_patches[patch_name])
else:
if required_patches[patch_name]["Display Name"]:
logging.info(f"- {required_patches[patch_name]['Display Name']}")
else:
logging.info("- No patch sets found for booted model")
return required_patches

4
opencore_legacy_patcher/sys_patch/kernelcache/kernel_collection/support.py
View File

@@ -8,6 +8,8 @@ import plistlib
from pathlib import Path
from datetime import datetime
from ...patchsets import PatchType
from ....datasets import os_data
from ....support import subprocess_wrapper
@@ -127,7 +129,7 @@ class KernelCacheSupport:
for key in oclp_plist_data:
if isinstance(oclp_plist_data[key], (bool, int)):
continue
for install_type in ["Install", "Install Non-Root"]:
for install_type in [PatchType.INSTALL_SYSTEM_VOLUME, PatchType.INSTALL_DATA_VOLUME]:
if install_type not in oclp_plist_data[key]:
continue
for location in oclp_plist_data[key][install_type]:

6
opencore_legacy_patcher/sys_patch/patchsets/__init__.py Normal file
View File

@@ -0,0 +1,6 @@
"""
patchsets module
"""
from .base import PatchType, DynamicPatchset
from .detect import HardwarePatchsetDetection, HardwarePatchsetSettings, HardwarePatchsetValidation

33
opencore_legacy_patcher/sys_patch/patchsets/base.py Normal file
View File

@@ -0,0 +1,33 @@
"""
base.py: Base class for all patch sets
"""
from enum import StrEnum
class PatchType(StrEnum):
"""
Type of patch
"""
INSTALL_SYSTEM_VOLUME = "Install System Volume"
INSTALL_DATA_VOLUME = "Install Data Volume"
REMOVE_SYSTEM_VOLUME = "Remove System Volume"
REMOVE_DATA_VOLUME = "Remove Data Volume"
EXECUTE = "Execute"
class DynamicPatchset(StrEnum):
MetallibSupportPkg = "MetallibSupportPkg"
class BasePatchset:
def __init__(self) -> None:
# XNU Kernel versions
self.macOS_12_0_B7: float = 21.1
self.macOS_12_4: float = 21.5
self.macOS_12_5: float = 21.6
self.macOS_13_3: float = 22.4
self.macOS_14_1: float = 23.1
self.macOS_14_2: float = 23.2
self.macOS_14_4: float = 23.4

468
opencore_legacy_patcher/sys_patch/patchsets/detect.py Normal file
View File

@@ -0,0 +1,468 @@
"""
detect.py: Detects patches for a given system
"""
import logging
import plistlib
import subprocess
import py_sip_xnu
import packaging.version
from enum import StrEnum
from pathlib import Path
from functools import cache
from .hardware.base import BaseHardware
from .hardware.graphics import (
intel_iron_lake,
intel_sandy_bridge,
intel_ivy_bridge,
intel_haswell,
intel_broadwell,
intel_skylake,
nvidia_tesla,
nvidia_kepler,
nvidia_webdriver,
amd_terascale_1,
amd_terascale_2,
amd_legacy_gcn,
amd_polaris,
amd_vega,
)
from .hardware.networking import (
legacy_wireless,
modern_wireless,
)
from .hardware.misc import (
display_backlight,
gmux,
keyboard_backlight,
legacy_audio,
pcie_webcam,
t1_security,
usb11,
)
from ... import constants
from ...datasets import sip_data
from ...datasets.os_data import os_data
from ...support import (
network_handler,
utilities,
kdk_handler,
metallib_handler
)
from ...detections import (
amfi_detect,
device_probe
)
class HardwarePatchsetSettings(StrEnum):
"""
Enum for patch settings
"""
KERNEL_DEBUG_KIT_REQUIRED = "Settings: Kernel Debug Kit required"
KERNEL_DEBUG_KIT_MISSING = "Settings: Kernel Debug Kit missing"
METALLIB_SUPPORT_PKG_REQUIRED = "Settings: MetallibSupportPkg.pkg required"
METALLIB_SUPPORT_PKG_MISSING = "Settings: MetallibSupportPkg.pkg missing"
class HardwarePatchsetValidation(StrEnum):
"""
Enum for validation settings
"""
UNSUPPORTED_HOST_OS = "Validation: Unsupported Host OS"
MISSING_NETWORK_CONNECTION = "Validation: Missing Network Connection"
FILEVAULT_ENABLED = "Validation: FileVault is enabled"
SIP_ENABLED = "Validation: System Integrity Protection is enabled"
SECURE_BOOT_MODEL_ENABLED = "Validation: SecureBootModel is enabled"
AMFI_ENABLED = "Validation: AMFI is enabled"
WHATEVERGREEN_MISSING = "Validation: WhateverGreen.kext missing"
FORCE_OPENGL_MISSING = "Validation: Force OpenGL property missing"
FORCE_COMPAT_MISSING = "Validation: Force compat property missing"
NVDA_DRV_MISSING = "Validation: nvda_drv(_vrl) variable missing"
HELL_SPAWN_GPU_PRESENT = "Validation: Graphics Patches unavailable for macOS Sequoia"
PATCHING_NOT_POSSIBLE = "Validation: Patching not possible"
UNPATCHING_NOT_POSSIBLE = "Validation: Unpatching not possible"
class HardwarePatchsetDetection:
def __init__(self, constants: constants.Constants,
xnu_major: int = None, xnu_minor: int = None,
os_build: str = None, os_version: str = None,
validation: bool = False # Whether to run validation checks
) -> None:
self._constants = constants
self._xnu_major = xnu_major or self._constants.detected_os
self._xnu_minor = xnu_minor or self._constants.detected_os_minor
self._os_build = os_build or self._constants.detected_os_build
self._os_version = os_version or self._constants.detected_os_version
self._validation = validation
self._hardware_variants = [
intel_iron_lake.IntelIronLake,
intel_sandy_bridge.IntelSandyBridge,
intel_ivy_bridge.IntelIvyBridge,
intel_haswell.IntelHaswell,
intel_broadwell.IntelBroadwell,
intel_skylake.IntelSkylake,
nvidia_tesla.NvidiaTesla,
nvidia_kepler.NvidiaKepler,
nvidia_webdriver.NvidiaWebDriver,
amd_terascale_1.AMDTeraScale1,
amd_terascale_2.AMDTeraScale2,
amd_legacy_gcn.AMDLegacyGCN,
amd_polaris.AMDPolaris,
amd_vega.AMDVega,
legacy_wireless.LegacyWireless,
modern_wireless.ModernWireless,
display_backlight.DisplayBacklight,
gmux.GraphicsMultiplexer,
keyboard_backlight.KeyboardBacklight,
legacy_audio.LegacyAudio,
pcie_webcam.PCIeFaceTimeCamera,
t1_security.T1SecurityChip,
usb11.USB11Controller,
]
self.device_properties = None
self.patches = None
self.can_patch = False
self.can_unpatch = False
self._detect()
def _validation_check_unsupported_host_os(self) -> bool:
"""
Determine if host OS is unsupported
"""
_min_os = os_data.big_sur.value
_max_os = os_data.sequoia.value
if self._xnu_major < _min_os or self._xnu_major > _max_os:
return True
return False
@cache
def _validation_check_missing_network_connection(self) -> bool:
"""
Determine if network connection is present
"""
return network_handler.NetworkUtilities().verify_network_connection() is False
@cache
def _validation_check_filevault_is_enabled(self) -> bool:
"""
Determine if FileVault is enabled
"""
# macOS 11.0 introduced a FileVault check for root patching
if self._xnu_major < os_data.big_sur.value:
return False
# OpenCore Legacy Patcher exposes whether it patched APFS.kext to allow for FileVault
nvram = utilities.get_nvram("OCLP-Settings", "4D1FDA02-38C7-4A6A-9CC6-4BCCA8B30102", decode=True)
if nvram:
if "-allow_fv" in nvram:
return False
return "FileVault is Off" not in subprocess.run(["/usr/bin/fdesetup", "status"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT).stdout.decode()
def _validation_check_system_integrity_protection_enabled(self, configs: list[str]) -> bool:
"""
Determine if System Integrity Protection is enabled
"""
return utilities.csr_decode(configs)
def _validation_check_secure_boot_model_enabled(self) -> bool:
"""
Determine if SecureBootModel is enabled
"""
return utilities.check_secure_boot_level()
def _validation_check_amfi_enabled(self, level: amfi_detect.AmfiConfigDetectLevel) -> bool:
"""
Determine if AMFI is enabled
"""
return not amfi_detect.AmfiConfigurationDetection().check_config(self._override_amfi_level(level))
def _validation_check_whatevergreen_missing(self) -> bool:
"""
Determine if WhateverGreen.kext is missing
"""
return utilities.check_kext_loaded("as.vit9696.WhateverGreen") is False
@cache
def _validation_check_force_opengl_missing(self) -> bool:
"""
Determine if Force OpenGL property is missing
"""
nv_on = utilities.get_nvram("boot-args", decode=True)
if nv_on:
if "ngfxgl=" in nv_on:
return True
for gpu in self._constants.computer.gpus:
if isinstance(gpu, device_probe.NVIDIA):
if gpu.disable_metal is True:
return True
return False
def _validation_check_force_compat_missing(self) -> bool:
"""
Determine if Force compat property is missing
"""
nv_on = utilities.get_nvram("boot-args", decode=True)
if nv_on:
if "ngfxcompat=" in nv_on:
return True
for gpu in self._constants.computer.gpus:
if isinstance(gpu, device_probe.NVIDIA):
if gpu.force_compatible is True:
return True
return False
def _validation_check_nvda_drv_missing(self) -> bool:
"""
Determine if nvda_drv(_vrl) variable is missing
"""
nv_on = utilities.get_nvram("boot-args", decode=True)
if nv_on:
if "nvda_drv_vrl=" in nv_on:
return True
nv_on = utilities.get_nvram("nvda_drv")
if nv_on:
return True
return False
@cache
def _override_amfi_level(self, level: amfi_detect.AmfiConfigDetectLevel) -> amfi_detect.AmfiConfigDetectLevel:
"""
Override level required based on whether AMFIPass is loaded
"""
amfipass_version = utilities.check_kext_loaded("com.dhinakg.AMFIPass")
if amfipass_version:
if packaging.version.parse(amfipass_version) >= packaging.version.parse(self._constants.amfipass_compatibility_version):
# If AMFIPass is loaded, our binaries will work
return amfi_detect.AmfiConfigDetectLevel.NO_CHECK
return level
def _dortania_internal_check(self) -> None:
"""
Determine whether to unlock Dortania Developer mode
"""
return Path("~/.dortania_developer").expanduser().exists()
def _already_has_networking_patches(self) -> bool:
"""
Check if network patches are already applied
"""
oclp_patch_path = "/System/Library/CoreServices/OpenCore-Legacy-Patcher.plist"
if not Path(oclp_patch_path).exists():
return False
try:
oclp_plist = plistlib.load(open(oclp_patch_path, "rb"))
except Exception as e:
return False
if "Legacy Wireless" in oclp_plist or "Modern Wireless" in oclp_plist:
return True
return False
def _is_cached_kernel_debug_kit_present(self) -> bool:
"""
Check if Kernel Debug Kit is present
"""
return kdk_handler.KernelDebugKitObject(self._constants, self._os_build, self._os_version).kdk_already_installed
def _is_cached_metallib_support_pkg_present(self) -> bool:
"""
Check if MetallibSupportPkg is present
"""
return metallib_handler.MetalLibraryObject(self._constants, self._os_build, self._os_version).metallib_already_installed
def _can_patch(self, requirements: dict, ignore_keys: list[str] = []) -> bool:
"""
Check if patching is possible
"""
for key, value in requirements.items():
if key in ignore_keys:
continue
if not key.startswith("Validation:"):
continue
if value is True:
return False
return True
def _convert_required_sip_config_to_int(self, configs: list[str]) -> int:
"""
Convert required SIP configurations to integer
"""
value = 0
for config in configs:
if config in sip_data.system_integrity_protection.csr_values_extended:
value += sip_data.system_integrity_protection.csr_values_extended[config]["value"]
return value
def _detect(self) -> None:
"""
Detect patches for a given system
"""
device_properties = {}
patches = {}
requires_metallib_support_pkg = False
missing_metallib_support_pkg = False
requires_kernel_debug_kit = False
missing_kernel_debug_kit = False
has_nvidia_web_drivers = False
has_3802_gpu = False
highest_amfi_level = amfi_detect.AmfiConfigDetectLevel.NO_CHECK
required_sip_configs = []
for hardware in self._hardware_variants:
item: BaseHardware = hardware(
xnu_major = self._xnu_major,
xnu_minor = self._xnu_minor,
os_build = self._os_build,
global_constants = self._constants
)
# During validation, don't skip missing items
# This is to ensure we can validate all files
if self._validation is False:
if item.present() is False: # Skip if not present
continue
if item.native_os() is True: # Skip if native OS
continue
device_properties[item.name()] = True
if item.name() == "Graphics: Nvidia Web Drivers":
has_nvidia_web_drivers = True
if item.name() in ["Graphics: Nvidia Kepler", "Graphics: Intel Ivy Bridge", "Graphics: Intel Haswell"]:
has_3802_gpu = True
for config in item.required_system_integrity_protection_configurations():
if config not in required_sip_configs:
required_sip_configs.append(config)
if item.requires_metallib_support_pkg() is True:
requires_metallib_support_pkg = True
if item.requires_kernel_debug_kit() is True:
requires_kernel_debug_kit = True
if item.required_amfi_level() > highest_amfi_level:
highest_amfi_level = item.required_amfi_level()
patches.update(item.patches())
if requires_metallib_support_pkg is True:
missing_metallib_support_pkg = not self._is_cached_metallib_support_pkg_present()
if requires_kernel_debug_kit is True:
missing_kernel_debug_kit = not self._is_cached_kernel_debug_kit_present()
requirements = {
HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED: requires_kernel_debug_kit,
HardwarePatchsetSettings.KERNEL_DEBUG_KIT_MISSING: missing_kernel_debug_kit,
HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_REQUIRED: requires_metallib_support_pkg,
HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_MISSING: missing_metallib_support_pkg,
HardwarePatchsetValidation.UNSUPPORTED_HOST_OS: self._validation_check_unsupported_host_os(),
HardwarePatchsetValidation.MISSING_NETWORK_CONNECTION: self._validation_check_missing_network_connection() if any([missing_metallib_support_pkg, missing_kernel_debug_kit]) else False,
HardwarePatchsetValidation.FILEVAULT_ENABLED: self._validation_check_filevault_is_enabled(),
HardwarePatchsetValidation.SIP_ENABLED: self._validation_check_system_integrity_protection_enabled(required_sip_configs),
HardwarePatchsetValidation.SECURE_BOOT_MODEL_ENABLED: self._validation_check_secure_boot_model_enabled(),
HardwarePatchsetValidation.AMFI_ENABLED: self._validation_check_amfi_enabled(highest_amfi_level),
HardwarePatchsetValidation.WHATEVERGREEN_MISSING: self._validation_check_whatevergreen_missing() if has_nvidia_web_drivers is True else False,
HardwarePatchsetValidation.FORCE_OPENGL_MISSING: self._validation_check_force_opengl_missing() if has_nvidia_web_drivers is True else False,
HardwarePatchsetValidation.FORCE_COMPAT_MISSING: self._validation_check_force_compat_missing() if has_nvidia_web_drivers is True else False,
HardwarePatchsetValidation.NVDA_DRV_MISSING: self._validation_check_nvda_drv_missing() if has_nvidia_web_drivers is True else False,
HardwarePatchsetValidation.HELL_SPAWN_GPU_PRESENT: has_3802_gpu and not self._dortania_internal_check(),
}
_cant_patch = False
_cant_unpatch = requirements[HardwarePatchsetValidation.SIP_ENABLED]
if requirements[HardwarePatchsetValidation.SIP_ENABLED] is True:
current_sip_status = hex(py_sip_xnu.SipXnu().get_sip_status().value)
expected_sip_status = hex(self._convert_required_sip_config_to_int(required_sip_configs))
sip_string = f"Validation: Booted SIP: {current_sip_status} vs expected: {expected_sip_status}"
index = list(requirements.keys()).index(HardwarePatchsetValidation.SIP_ENABLED)
requirements = dict(list(requirements.items())[:index+1] + [(sip_string, True)] + list(requirements.items())[index+1:])
# If MISSING_NETWORK_CONNECTION is enabled, see whether 'Networking: Legacy Wireless' or 'Networking: Modern Wireless' is present
# If so, remove other patches and set PATCHING_NOT_POSSIBLE to True
if requirements[HardwarePatchsetValidation.MISSING_NETWORK_CONNECTION] is True:
if self._can_patch(requirements, ignore_keys=[HardwarePatchsetValidation.MISSING_NETWORK_CONNECTION]) is True:
logging.info("Network connection missing, checking whether network patches are applicable")
if self._already_has_networking_patches() is True:
logging.info("Network patches are already applied, requiring network connection")
else:
if "Networking: Legacy Wireless" in device_properties or "Networking: Modern Wireless" in device_properties:
logging.info("Network patches are applicable, removing other patches")
for key in list(device_properties.keys()):
if key.startswith("Networking:"):
continue
device_properties.pop(key, None)
requirements[HardwarePatchsetValidation.MISSING_NETWORK_CONNECTION] = False
requirements[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED] = False
requirements[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_MISSING] = False
requirements[HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_REQUIRED] = False
requirements[HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_MISSING] = False
_cant_patch = not self._can_patch(requirements)
requirements[HardwarePatchsetValidation.PATCHING_NOT_POSSIBLE] = _cant_patch
requirements[HardwarePatchsetValidation.UNPATCHING_NOT_POSSIBLE] = _cant_unpatch
self.can_patch = not _cant_patch
self.can_unpatch = not _cant_unpatch
device_properties.update(requirements)
self.device_properties = device_properties
self.patches = patches
def detailed_errors(self) -> None:
"""
Print out detailed errors
"""
logging.error("- Breakdown:")
for key, value in self.device_properties.items():
if not key.startswith("Validation:"):
continue
if key in ["Validation: Patching not possible", "Validation: Unpatching not possible"]:
continue
if value is False:
continue
logging.error(f" - {key.replace('Validation: ', '')}")

150
opencore_legacy_patcher/sys_patch/patchsets/hardware/base.py Normal file
View File

@@ -0,0 +1,150 @@
"""
base.py: Base class for hardware patch set detection
"""
from enum import StrEnum
from ..base import BasePatchset
from ....constants import Constants
from ....datasets.os_data import os_data
from ....datasets.sip_data import system_integrity_protection
from ....detections.amfi_detect import AmfiConfigDetectLevel
from ....detections import device_probe
class HardwareVariant(StrEnum):
"""
Hardware variant for patch set
"""
GRAPHICS: str = "Graphics"
NETWORKING: str = "Networking"
AUDIO: str = "Audio"
MISCELLANEOUS: str = "Miscellaneous"
class BaseHardware(BasePatchset):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__()
self._xnu_major = xnu_major
self._xnu_minor = xnu_minor
self._os_build = os_build
self._constants = global_constants
self._computer = global_constants.computer
self._xnu_float = float(f"{self._xnu_major}.{self._xnu_minor}")
def name(self) -> str:
"""
Name of the patch set
"""
raise NotImplementedError
def present(self) -> bool:
"""
Whether the hardware is present in the system
"""
raise NotImplementedError
def native_os(self) -> bool:
"""
Is on native OS
"""
raise NotImplementedError
def hardware_variant(self) -> HardwareVariant:
"""
What hardware variant is this patch set for
"""
raise NotImplementedError
def required_amfi_level(self) -> AmfiConfigDetectLevel:
"""
What level of AMFI configuration is required for this patch set
Currently defaulted to AMFI needing to be disabled
"""
return AmfiConfigDetectLevel.ALLOW_ALL
def requires_primary_kernel_cache(self) -> bool:
"""
Whether patch set requires access to the primary kernel cache
ex. Boot/System Kernel Collection on Big Sur and newer
"""
return False
def requires_kernel_debug_kit(self) -> bool:
"""
Whether patch set requires access to the Kernel Debug Kit
"""
return False
def requires_metallib_support_pkg(self) -> bool:
"""
Whether patch set requires access to the MetallibSupportPkg PKG
"""
return False
def required_system_integrity_protection_configurations(self) -> list[str]:
"""
List of required SIP configurations for the patch set
"""
if self._xnu_major >= os_data.ventura.value:
return system_integrity_protection.root_patch_sip_ventura
if self._xnu_major >= os_data.big_sur.value:
return system_integrity_protection.root_patch_sip_big_sur
return system_integrity_protection.root_patch_sip_mojave
def patches(self) -> dict:
"""
Dictionary of patches
"""
raise NotImplementedError
def _is_gpu_architecture_present(self, gpu_architectures: list[device_probe.GPU]) -> bool:
"""
Check if a GPU architecture is present
"""
for gpu in self._computer.gpus:
if not gpu.class_code:
continue
if not gpu.arch:
continue
if gpu.class_code == 0xFFFFFFFF:
continue
if gpu.arch in gpu_architectures:
return True
return False
def _resolve_monterey_framebuffers(self) -> str:
"""
Resolve patchset directory for framebuffers last supported in Monterey:
- AppleIntelBDWGraphics.kext
- AppleIntelBDWGraphicsFramebuffer.kext
- AppleIntelFramebufferAzul.kext
- AppleIntelHD5000Graphics.kext
- AppleIntelSKLGraphics.kext
- AppleIntelSKLGraphicsFramebuffer.kext
- AMDRadeonX4000.kext
- AMDRadeonX5000.kext
"""
if self._xnu_major < os_data.sonoma.value:
return "12.5"
if self._xnu_float < self.macOS_14_4:
return "12.5-23"
return "12.5-23.4"

116
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/amd_legacy_gcn.py Normal file
View File

@@ -0,0 +1,116 @@
"""
amd_legacy_gcn.py: AMD Legacy GCN detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.monterey_gva import MontereyGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from ...shared_patches.amd_opencl import AMDOpenCL
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class AMDLegacyGCN(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: AMD Legacy GCN"
def present(self) -> bool:
"""
Targeting AMD Legacy GCN GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.AMD.Archs.Legacy_GCN_7000,
device_probe.AMD.Archs.Legacy_GCN_8000,
device_probe.AMD.Archs.Legacy_GCN_9000
]
) and self._computer.rosetta_active is False # Rosetta 2 mimics an AMD R9 270X
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"AMD Legacy GCN": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMD7000Controller.kext": "12.5",
"AMD8000Controller.kext": "12.5",
"AMD9000Controller.kext": "12.5",
"AMD9500Controller.kext": "12.5",
"AMD10000Controller.kext": "12.5",
"AMDRadeonX4000.kext": self._resolve_monterey_framebuffers(),
"AMDRadeonX4000HWServices.kext": "12.5",
"AMDFramebuffer.kext": "12.5" if self._xnu_float < self.macOS_13_3 else "12.5-GCN",
"AMDSupport.kext": "12.5",
"AMDRadeonVADriver.bundle": "12.5",
"AMDRadeonVADriver2.bundle": "12.5",
"AMDRadeonX4000GLDriver.bundle": "12.5",
"AMDMTLBronzeDriver.bundle": "12.5" if self._xnu_major < os_data.sequoia else "12.5-24",
"AMDShared.bundle": "12.5",
},
},
},
}
def patches(self) -> dict:
"""
Patches for AMD Legacy GCN GPUs
"""
if self.native_os() is True:
return {}
_base = {}
if self._is_gpu_architecture_present(gpu_architectures=[device_probe.Intel.Archs.Skylake]) is False:
# Monterey GVA is not required for Intel Skylake iGPUs
_base.update({
**MontereyGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
})
_base.update({
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**AMDOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**self._model_specific_patches(),
})
return _base

139
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/amd_polaris.py Normal file
View File

@@ -0,0 +1,139 @@
"""
amd_polaris.py: AMD Polaris detection
"""
from .amd_legacy_gcn import AMDLegacyGCN
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.monterey_gva import MontereyGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from ...shared_patches.amd_opencl import AMDOpenCL
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class AMDPolaris(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: AMD Polaris"
def present(self) -> bool:
"""
Targeting AMD Polaris GPUs with CPUs lacking AVX2.0 or missing Framebuffer patches (ie. MacBookPro13,3 and MacBookPro14,3)
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.AMD.Archs.Polaris
]
) and ("AVX2" not in self._computer.cpu.leafs or self._computer.real_model in ["MacBookPro13,3", "MacBookPro14,3"])
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
# For MacBookPro13,3 missing framebuffers (ex. 'ATY,Berbice')
if self._computer.real_model in ["MacBookPro13,3"]:
# Since dropped at the same time, we can use the same patches
return AMDLegacyGCN(self._xnu_major, self._xnu_minor, self._os_build, self._constants)._model_specific_patches()
# For MacBookPro14,3 (and other AMD dGPUs that no longer function in Sonoma)
# iMac18,2/3 still function with the generic framebuffer, however if issues arise
# we'll downgrade them as well.
if self._computer.real_model in ["MacBookPro14,3"]:
if self._xnu_major < os_data.sonoma.value:
return {}
return {
"AMD Legacy Polaris (2017)": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMD9500Controller.kext": "13.5.2",
"AMD10000Controller.kext": "13.5.2",
"AMDFramebuffer.kext": "13.5.2",
"AMDSupport.kext": "13.5.2",
},
},
},
}
# Assuming non-AVX2.0 CPUs
# Note missing framebuffers are not restored (ex. 'ATY,Berbice')
return {
"AMD Legacy Polaris": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMDRadeonX4000.kext": self._resolve_monterey_framebuffers(),
"AMDRadeonX4000HWServices.kext": "12.5",
"AMDRadeonVADriver2.bundle": "12.5",
"AMDRadeonX4000GLDriver.bundle": "12.5",
"AMDMTLBronzeDriver.bundle": "12.5" if self._xnu_major < os_data.sequoia else "12.5-24",
"AMDShared.bundle": "12.5",
},
},
},
}
def patches(self) -> dict:
"""
Patches for AMD Polaris GPUs
"""
if self.native_os() is True:
return {}
# Minimal amount of patches required for 2017 Polaris
if self._computer.real_model in ["MacBookPro14,3"]:
return self._model_specific_patches()
_base = {
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**self._model_specific_patches(),
}
if "AVX2" not in self._computer.cpu.leafs:
_base.update({
**AMDOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
})
if self._is_gpu_architecture_present(gpu_architectures=[device_probe.Intel.Archs.Skylake]) is False:
# Monterey GVA is not required for Intel Skylake iGPUs
_base.update({
**MontereyGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
})
return _base

105
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/amd_terascale_1.py Normal file
View File

@@ -0,0 +1,105 @@
"""
amd_terascale_1.py: AMD TeraScale 1 detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.non_metal import NonMetal
from ...shared_patches.monterey_webkit import MontereyWebKit
from ...shared_patches.amd_terascale import AMDTeraScale
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class AMDTeraScale1(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: AMD TeraScale 1"
def present(self) -> bool:
"""
Targeting AMD TeraScale GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.AMD.Archs.TeraScale_1
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major < os_data.mojave.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"AMD TeraScale 1": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMD2400Controller.kext": "10.13.6",
"AMD2600Controller.kext": "10.13.6",
"AMD3800Controller.kext": "10.13.6",
"AMD4600Controller.kext": "10.13.6",
"AMD4800Controller.kext": "10.13.6",
"ATIRadeonX2000.kext": "10.13.6" if self._xnu_major < os_data.ventura else "10.13.6 TS1",
"ATIRadeonX2000GA.plugin": "10.13.6",
"ATIRadeonX2000GLDriver.bundle": "10.13.6",
"ATIRadeonX2000VADriver.bundle": "10.13.6",
},
},
},
}
def patches(self) -> dict:
"""
Patches for AMD TeraScale 1 GPUs
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {
**AMDTeraScale(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches()
}
return {
**NonMetal(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**AMDTeraScale(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

110
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/amd_terascale_2.py Normal file
View File

@@ -0,0 +1,110 @@
"""
amd_terascale_2.py: AMD TeraScale 2 detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.non_metal import NonMetal
from ...shared_patches.non_metal_ioaccel import NonMetalIOAccelerator
from ...shared_patches.monterey_webkit import MontereyWebKit
from ...shared_patches.amd_terascale import AMDTeraScale
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class AMDTeraScale2(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: AMD TeraScale 2"
def present(self) -> bool:
"""
Targeting AMD TeraScale GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.AMD.Archs.TeraScale_2
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major < os_data.mojave.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
_base = {
"AMD TeraScale 2": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMD5000Controller.kext": "10.13.6",
"AMD6000Controller.kext": "10.13.6",
"AMDRadeonVADriver.bundle": "10.13.6",
"AMDRadeonVADriver2.bundle": "10.13.6",
"AMDRadeonX3000.kext": "10.13.6",
"AMDRadeonX3000GLDriver.bundle": "10.13.6",
},
},
},
}
# TeraScale 2 MacBooks with faulty GPUs are highly prone to crashing with AMDRadeonX3000 attached
if self._constants.allow_ts2_accel is False and self._constants.host_is_hackintosh is False:
_base["AMD TeraScale 2"][PatchType.INSTALL_SYSTEM_VOLUME]["/System/Library/Extensions"].pop("AMDRadeonX3000.kext")
return _base
def patches(self) -> dict:
"""
Patches for AMD TeraScale 2 GPUs
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {
**AMDTeraScale(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches()
}
return {
**NonMetal(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**NonMetalIOAccelerator(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**AMDTeraScale(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

123
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/amd_vega.py Normal file
View File

@@ -0,0 +1,123 @@
"""
amd_vega.py: AMD Vega detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.monterey_gva import MontereyGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from ...shared_patches.amd_opencl import AMDOpenCL
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class AMDVega(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: AMD Vega"
def present(self) -> bool:
"""
Targeting AMD Vega GPUs with CPUs lacking AVX2.0
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.AMD.Archs.Vega
]
) and "AVX2" not in self._computer.cpu.leafs
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"AMD Legacy Vega": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMDRadeonX5000.kext": self._resolve_monterey_framebuffers(),
"AMDRadeonVADriver2.bundle": "12.5",
"AMDRadeonX5000GLDriver.bundle": "12.5",
"AMDRadeonX5000MTLDriver.bundle": "12.5" if self._xnu_major < os_data.sequoia else "12.5-24",
"AMDRadeonX5000Shared.bundle": "12.5",
"AMDShared.bundle": "12.5",
},
},
},
}
def _model_specific_patches_extended(self) -> dict:
"""
Support mixed legacy and modern AMD GPUs
Specifically systems using AMD GCN 1-3 and Vega (ex. MacPro6,1 with eGPU)
Assume 'AMD Legacy GCN' patchset is installed alongside this
"""
if self._is_gpu_architecture_present([
device_probe.AMD.Archs.Legacy_GCN_7000,
device_probe.AMD.Archs.Legacy_GCN_8000,
device_probe.AMD.Archs.Legacy_GCN_9000
]) is False:
return {}
return {
"AMD Legacy Vega Extended": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMDRadeonX5000HWServices.kext": "12.5",
},
},
},
}
def patches(self) -> dict:
"""
Patches for AMD Vega GPUs
"""
if self.native_os() is True:
return {}
return {
**MontereyGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**AMDOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**self._model_specific_patches(),
**self._model_specific_patches_extended(),
}

87
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/intel_broadwell.py Normal file
View File

@@ -0,0 +1,87 @@
"""
intel_broadwell.py: Intel Broadwell detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.monterey_gva import MontereyGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class IntelBroadwell(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Intel Broadwell"
def present(self) -> bool:
"""
Targeting Intel Broadwell GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Broadwell
]
)
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Intel Broadwell": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleIntelBDWGraphics.kext": self._resolve_monterey_framebuffers(),
"AppleIntelBDWGraphicsFramebuffer.kext": self._resolve_monterey_framebuffers(),
"AppleIntelBDWGraphicsGLDriver.bundle": "12.5",
"AppleIntelBDWGraphicsMTLDriver.bundle": "12.5-22" if self._xnu_major < os_data.sequoia else "12.5-24",
"AppleIntelBDWGraphicsVADriver.bundle": "12.5",
"AppleIntelBDWGraphicsVAME.bundle": "12.5",
"AppleIntelGraphicsShared.bundle": "12.5",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Intel Broadwell iGPUs
"""
if self.native_os() is True:
return {}
return {
**MontereyGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**self._model_specific_patches(),
}

98
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/intel_haswell.py Normal file
View File

@@ -0,0 +1,98 @@
"""
intel_haswell.py: Intel Haswell detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.metal_3802 import LegacyMetal3802
from ...shared_patches.monterey_gva import MontereyGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class IntelHaswell(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Intel Haswell"
def present(self) -> bool:
"""
Targeting Intel Haswell GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Haswell
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_metallib_support_pkg(self) -> bool:
"""
New compiler format introduced in macOS 15, Sequoia
"""
return self._xnu_major >= os_data.sequoia.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Intel Haswell": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleIntelFramebufferAzul.kext": self._resolve_monterey_framebuffers(),
"AppleIntelHD5000Graphics.kext": self._resolve_monterey_framebuffers(),
"AppleIntelHD5000GraphicsGLDriver.bundle": "12.5",
"AppleIntelHD5000GraphicsMTLDriver.bundle": "12.5",
"AppleIntelHD5000GraphicsVADriver.bundle": "12.5",
"AppleIntelHSWVA.bundle": "12.5",
"AppleIntelGraphicsShared.bundle": "12.5",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Intel Haswell iGPUs
"""
if self.native_os() is True:
return {}
return {
**LegacyMetal3802(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**self._model_specific_patches(),
}

96
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/intel_iron_lake.py Normal file
View File

@@ -0,0 +1,96 @@
"""
intel_iron_lake.py: Intel Iron Lake detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.non_metal import NonMetal
from ...shared_patches.monterey_webkit import MontereyWebKit
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class IntelIronLake(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Intel Iron Lake"
def present(self) -> bool:
"""
Targeting Intel Iron Lake GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Iron_Lake
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major < os_data.mojave.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Intel Iron Lake": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleIntelHDGraphics.kext": "10.13.6",
"AppleIntelHDGraphicsFB.kext": "10.13.6",
"AppleIntelHDGraphicsGA.plugin": "10.13.6",
"AppleIntelHDGraphicsGLDriver.bundle": "10.13.6",
"AppleIntelHDGraphicsVADriver.bundle": "10.13.6",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Intel Iron Lake iGPUs
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {**self._model_specific_patches()}
return {
**NonMetal(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

114
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/intel_ivy_bridge.py Normal file
View File

@@ -0,0 +1,114 @@
"""
intel_ivy_bridge.py: Intel Ivy Bridge detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.metal_3802 import LegacyMetal3802
from ...shared_patches.big_sur_gva import BigSurGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from ...shared_patches.big_sur_opencl import BigSurOpenCL
from ...shared_patches.monterey_webkit import MontereyWebKit
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class IntelIvyBridge(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Intel Ivy Bridge"
def present(self) -> bool:
"""
Targeting Intel Ivy Bridge GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Ivy_Bridge
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 12, Monterey
"""
return self._xnu_major < os_data.monterey.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_metallib_support_pkg(self) -> bool:
"""
New compiler format introduced in macOS 15, Sequoia
"""
return self._xnu_major >= os_data.sequoia.value
def _resolve_ivy_bridge_framebuffers(self) -> str:
"""
Resolve patchset directory for Ivy Bridge framebuffers:
- AppleIntelFramebufferCapri.kext
- AppleIntelHD4000Graphics.kext
"""
if self._xnu_major < os_data.sonoma:
return "11.7.10"
if self._xnu_float < self.macOS_14_4:
return "11.7.10-23"
return "11.7.10-23.4"
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Intel Ivy Bridge": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleIntelHD4000GraphicsGLDriver.bundle": "11.7.10",
"AppleIntelHD4000GraphicsMTLDriver.bundle": "11.7.10" if self._xnu_major < os_data.ventura else "11.7.10-22",
"AppleIntelHD4000GraphicsVADriver.bundle": "11.7.10",
"AppleIntelFramebufferCapri.kext": self._resolve_ivy_bridge_framebuffers(),
"AppleIntelHD4000Graphics.kext": self._resolve_ivy_bridge_framebuffers(),
"AppleIntelIVBVA.bundle": "11.7.10",
"AppleIntelGraphicsShared.bundle": "11.7.10", # libIGIL-Metal.dylib pulled from 11.0 Beta 6
},
},
},
}
def patches(self) -> dict:
"""
Patches for Intel Ivy Bridge iGPUs
"""
if self.native_os() is True:
return {}
return {
**LegacyMetal3802(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**BigSurGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**BigSurOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

101
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/intel_sandy_bridge.py Normal file
View File

@@ -0,0 +1,101 @@
"""
intel_sandy_bridge.py: Intel Sandy Bridge detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.non_metal import NonMetal
from ...shared_patches.monterey_webkit import MontereyWebKit
from ...shared_patches.high_sierra_gva import HighSierraGVA
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class IntelSandyBridge(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Intel Sandy Bridge"
def present(self) -> bool:
"""
Targeting Intel Sandy Bridge GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Sandy_Bridge
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major < os_data.mojave.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Requires replacing a number of kexts in the BootKC
"""
if self._xnu_major >= os_data.ventura.value:
return True
return False
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Intel Sandy Bridge": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleIntelHD3000Graphics.kext": "10.13.6",
"AppleIntelHD3000GraphicsGA.plugin": "10.13.6",
"AppleIntelHD3000GraphicsGLDriver.bundle": "10.13.6",
"AppleIntelHD3000GraphicsVADriver.bundle": "10.13.6",
"AppleIntelSNBGraphicsFB.kext": "10.13.6",
"AppleIntelSNBVA.bundle": "10.13.6",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Intel Sandy Bridge GPUs
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {**self._model_specific_patches()}
return {
**NonMetal(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**HighSierraGVA(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

86
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/intel_skylake.py Normal file
View File

@@ -0,0 +1,86 @@
"""
intel_skylake.py: Intel Skylake detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.monterey_opencl import MontereyOpenCL
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class IntelSkylake(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Intel Skylake"
def present(self) -> bool:
"""
Targeting Intel Skylake GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Skylake
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Intel Skylake": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleIntelSKLGraphics.kext": self._resolve_monterey_framebuffers(),
"AppleIntelSKLGraphicsFramebuffer.kext": self._resolve_monterey_framebuffers(),
"AppleIntelSKLGraphicsGLDriver.bundle": "12.5",
"AppleIntelSKLGraphicsMTLDriver.bundle": "12.5" if self._xnu_major < os_data.sequoia else "12.5-24",
"AppleIntelSKLGraphicsVADriver.bundle": "12.5",
"AppleIntelSKLGraphicsVAME.bundle": "12.5",
"AppleIntelGraphicsShared.bundle": "12.5",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Intel Skylake iGPUs
"""
if self.native_os() is True:
return {}
return {
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**self._model_specific_patches(),
}

130
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/nvidia_kepler.py Normal file
View File

@@ -0,0 +1,130 @@
"""
nvidia_kepler.py: Nvidia Kepler detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.metal_3802 import LegacyMetal3802
from ...shared_patches.big_sur_gva import BigSurGVA
from ...shared_patches.monterey_opencl import MontereyOpenCL
from ...shared_patches.big_sur_opencl import BigSurOpenCL
from ...shared_patches.monterey_webkit import MontereyWebKit
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class NvidiaKepler(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Nvidia Kepler"
def present(self) -> bool:
"""
Targeting Nvidia Kepler GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.NVIDIA.Archs.Kepler
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 12.0 Beta 7, Monterey
"""
if self._xnu_major < os_data.monterey:
return True
if self._xnu_major == os_data.monterey:
if self._xnu_minor > 0:
return True
if self._os_build != "21A5522h": # 12.0 Beta 7
return True
return False
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_metallib_support_pkg(self) -> bool:
"""
New compiler format introduced in macOS 15, Sequoia
"""
return self._xnu_major >= os_data.sequoia.value
def _resolve_kepler_geforce_framebuffers(self) -> str:
"""
Resolve patchset directory for GeForce.kext
"""
if self._xnu_major < os_data.sonoma:
return "12.0 Beta 6"
if self._xnu_float < self.macOS_14_4:
return "12.0 Beta 6-23"
return "12.0 Beta 6-23.4"
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Nvidia Kepler": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"GeForce.kext": self._resolve_kepler_geforce_framebuffers(),
"NVDAGF100Hal.kext": "12.0 Beta 6",
"NVDAGK100Hal.kext": "12.0 Beta 6",
"NVDAResman.kext": "12.0 Beta 6",
"NVDAStartup.kext": "12.0 Beta 6",
"GeForceAIRPlugin.bundle": "11.0 Beta 3",
"GeForceGLDriver.bundle": "11.0 Beta 3",
"GeForceMTLDriver.bundle": "11.0 Beta 3" if self._xnu_major <= os_data.monterey else f"11.0 Beta 3-22",
"GeForceVADriver.bundle": "12.0 Beta 6",
},
"/System/Library/Frameworks": {
# XNU 21.6 (macOS 12.5)
**({ "Metal.framework": "12.5 Beta 2"} if (self._xnu_float >= self.macOS_12_5 and self._xnu_major < os_data.ventura) else {}),
},
"/System/Library/PrivateFrameworks": {
"GPUCompiler.framework": "11.6",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Nvidia Kepler GPUs
"""
if self.native_os() is True:
return {}
return {
**LegacyMetal3802(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**BigSurGVA(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**BigSurOpenCL(self._xnu_major, self._xnu_minor, self._constants.detected_os_version).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

99
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/nvidia_tesla.py Normal file
View File

@@ -0,0 +1,99 @@
"""
nvidia_tesla.py: Nvidia Tesla detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.non_metal import NonMetal
from ...shared_patches.monterey_webkit import MontereyWebKit
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class NvidiaTesla(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Nvidia Tesla"
def present(self) -> bool:
"""
Targeting Nvidia Tesla GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.NVIDIA.Archs.Tesla
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Nvidia Tesla": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"GeForceGA.bundle": "10.13.6",
"GeForceTesla.kext": "10.13.6",
"GeForceTeslaGLDriver.bundle": "10.13.6",
"GeForceTeslaVADriver.bundle": "10.13.6",
"NVDANV50HalTesla.kext": "10.13.6",
"NVDAResmanTesla.kext": "10.13.6",
# Apple dropped NVDAStartup in 12.0 Beta 7 (XNU 21.1)
**({ "NVDAStartup.kext": "12.0 Beta 6" } if self._xnu_float >= self.macOS_12_0_B7 else {})
},
},
},
}
def patches(self) -> dict:
"""
Patches for Nvidia Tesla GPUs
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {**self._model_specific_patches()}
return {
**NonMetal(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
}

155
opencore_legacy_patcher/sys_patch/patchsets/hardware/graphics/nvidia_webdriver.py Normal file
View File

@@ -0,0 +1,155 @@
"""
nvidia_webdriver.py: Nvidia Web Driver detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from ...shared_patches.non_metal import NonMetal
from ...shared_patches.monterey_webkit import MontereyWebKit
from ...shared_patches.non_metal_ioaccel import NonMetalIOAccelerator
from ...shared_patches.non_metal_coredisplay import NonMetalCoreDisplay
from ...shared_patches.non_metal_enforcement import NonMetalEnforcement
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
from .....datasets.sip_data import system_integrity_protection
class NvidiaWebDriver(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Nvidia Web Drivers"
def present(self) -> bool:
"""
Targeting Nvidia Fermi, Maxwell, Pascal GPUs
"""
return self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.NVIDIA.Archs.Fermi,
device_probe.NVIDIA.Archs.Maxwell,
device_probe.NVIDIA.Archs.Pascal,
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major < os_data.mojave.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.GRAPHICS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def required_system_integrity_protection_configurations(self) -> list[str]:
"""
List of required SIP configurations for the patch set
"""
return system_integrity_protection.root_patch_sip_big_sur_3rd_part_kexts
def _model_specific_patches(self) -> dict:
"""
Model specific patches
"""
return {
"Nvidia Web Drivers": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"GeForceAIRPluginWeb.bundle": "WebDriver-387.10.10.10.40.140",
"GeForceGLDriverWeb.bundle": "WebDriver-387.10.10.10.40.140",
"GeForceMTLDriverWeb.bundle": "WebDriver-387.10.10.10.40.140",
"GeForceVADriverWeb.bundle": "WebDriver-387.10.10.10.40.140",
# Tesla-only files
"GeForceTeslaGAWeb.bundle": "WebDriver-387.10.10.10.40.140",
"GeForceTeslaGLDriverWeb.bundle": "WebDriver-387.10.10.10.40.140",
"GeForceTeslaVADriverWeb.bundle": "WebDriver-387.10.10.10.40.140",
},
"/System/Library/PrivateFrameworks": {
# Restore OpenCL by adding missing compiler files
**({ "GPUCompiler.framework": "11.6"} if self._xnu_major >= os_data.monterey else {}),
},
},
PatchType.INSTALL_DATA_VOLUME: {
"/Library/Extensions": {
"GeForceWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAGF100HalWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAGK100HalWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAGM100HalWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAGP100HalWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAResmanWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAStartupWeb.kext": "WebDriver-387.10.10.10.40.140",
# Tesla-only files
"GeForceTeslaWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDANV50HalTeslaWeb.kext": "WebDriver-387.10.10.10.40.140",
"NVDAResmanTeslaWeb.kext": "WebDriver-387.10.10.10.40.140",
},
# Disabled due to issues with Pref pane stripping 'nvda_drv' NVRAM
# variables
# "/Library/PreferencePanes": {
# "NVIDIA Driver Manager.prefPane": "WebDriver-387.10.10.10.40.140",
# },
# "/Library/LaunchAgents": {
# "com.nvidia.nvagent.plist": "WebDriver-387.10.10.10.40.140",
# },
# "/Library/LaunchDaemons": {
# "com.nvidia.nvroothelper.plist": "WebDriver-387.10.10.10.40.140",
# },
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions": [
# Due to how late the Auxiliary cache loads, NVDAStartup will match first and then the Web Driver kexts.
# This has no effect for Maxwell and Pascal, however for development purposes, Tesla and Kepler are partially supported.
"NVDAStartup.kext",
],
},
},
}
def patches(self) -> dict:
"""
Patches for Nvidia Web Drivers
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {**self._model_specific_patches()}
return {
**NonMetal(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**NonMetalIOAccelerator(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**NonMetalCoreDisplay(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**MontereyWebKit(self._xnu_major, self._xnu_minor, self._os_build).patches(),
**self._model_specific_patches(),
**NonMetalEnforcement(self._xnu_major, self._xnu_minor, self._os_build).patches(),
}

84
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/display_backlight.py Normal file
View File

@@ -0,0 +1,84 @@
"""
display_backlight.py: Legacy Backlight Control detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....datasets.os_data import os_data
class DisplayBacklight(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Legacy Backlight Control"
def present(self) -> bool:
"""
Targeting Legacy Backlight Controllers
"""
return self._computer.real_model in [
"MacBook5,2",
"iMac7,1",
"iMac8,1",
"iMac9,1",
]
def native_os(self) -> bool:
"""
Dropped support with macOS 10.13, High Sierra
"""
return self._xnu_major < os_data.high_sierra.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def patches(self) -> dict:
"""
Patches for Legacy Backlight Control
"""
if self.native_os() is True:
return {}
return {
"Legacy Backlight Control": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleBacklight.kext": "10.12.6",
"AppleBacklightExpert.kext": "10.12.6",
},
"/System/Library/PrivateFrameworks": {
"DisplayServices.framework": "10.12.6",
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions/AppleGraphicsControl.kext/Contents/PlugIns": [
"AGDCBacklightControl.kext",
],
},
},
}

116
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/gmux.py Normal file
View File

@@ -0,0 +1,116 @@
"""
gmux.py: Legacy GMUX detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....support import utilities
from .....datasets.os_data import os_data
class GraphicsMultiplexer(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Legacy GMUX"
def _check_dgpu_status(self) -> bool:
"""
Query whether system has an active dGPU
"""
dgpu = self._computer.dgpu
if dgpu:
if dgpu.class_code and dgpu.class_code == 0xFFFFFFFF:
# If dGPU is disabled via class-codes, assume demuxed
return False
return True
return False
def _detect_demux(self) -> bool:
"""
Query whether system has been demuxed (ex. MacBookPro8,2, disabled dGPU)
"""
# If GFX0 is missing, assume machine was demuxed
# -wegnoegpu would also trigger this, so ensure arg is not present
if not "-wegnoegpu" in (utilities.get_nvram("boot-args", decode=True) or ""):
igpu = self._constants.computer.igpu
dgpu = self._check_dgpu_status()
if igpu and not dgpu:
return True
return False
def present(self) -> bool:
"""
Targeting Legacy GMUX Controllers
Ref: https://doslabelectronics.com/Demux.html
Sierra uses a legacy GMUX control method needed for dGPU switching on MacBookPro5,x
Same method is also used for demuxed machines
Note that MacBookPro5,x machines are extremely unstable with this patch set, so disabled until investigated further
Ref: https://github.com/dortania/OpenCore-Legacy-Patcher/files/7360909/KP-b10-030.txt
"""
return self._computer.real_model in ["MacBookPro8,2", "MacBookPro8,3"] and self._detect_demux()
def native_os(self) -> bool:
"""
Dropped support with macOS 10.13, High Sierra
"""
return self._xnu_major < os_data.sierra.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def patches(self) -> dict:
"""
Patches for Legacy Backlight Control
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {}
return {
"Legacy GMUX": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions/AppleGraphicsControl.kext/Contents/PlugIns": {
"AppleMuxControl.kext": "10.12.6",
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions": [
"AppleBacklight.kext",
],
"/System/Library/Extensions/AppleGraphicsControl.kext/Contents/PlugIns": [
"AGDCBacklightControl.kext",
"AppleMuxControl.kext",
],
},
},
}

91
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/keyboard_backlight.py Normal file
View File

@@ -0,0 +1,91 @@
"""
keyboard_backlight.py: Legacy Keyboard Backlight detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class KeyboardBacklight(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Legacy Keyboard Backlight"
def present(self) -> bool:
"""
Targeting Legacy Keyboard Backlight (ie. non-Metal Macs)
"""
return self._computer.real_model.startswith("MacBook") and self._is_gpu_architecture_present(
gpu_architectures=[
device_probe.Intel.Archs.Iron_Lake,
device_probe.Intel.Archs.Sandy_Bridge,
device_probe.AMD.Archs.TeraScale_1,
device_probe.AMD.Archs.TeraScale_2,
device_probe.NVIDIA.Archs.Tesla,
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 11, Big Sur
"""
return self._xnu_major < os_data.big_sur.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def requires_kernel_debug_kit(self) -> bool:
"""
Apple no longer provides standalone kexts in the base OS
"""
return self._xnu_major >= os_data.ventura.value
def patches(self) -> dict:
"""
Patches for Legacy Backlight Control
"""
if self.native_os() is True:
return {}
if self._xnu_major not in self._constants.legacy_accel_support:
return {}
return {
"Legacy Backlight Control": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleBacklight.kext": "10.12.6",
"AppleBacklightExpert.kext": "10.12.6",
},
"/System/Library/PrivateFrameworks": {
"DisplayServices.framework": "10.12.6",
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions/AppleGraphicsControl.kext/Contents/PlugIns": [
"AGDCBacklightControl.kext",
],
},
},
}

136
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/legacy_audio.py Normal file
View File

@@ -0,0 +1,136 @@
"""
legacy_audio.py: Legacy Audio detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....support import utilities
from .....datasets.os_data import os_data
class LegacyAudio(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Legacy Audio"
def present(self) -> bool:
"""
Targeting Realtek Audio and machines without AppleALC
"""
return self._computer.real_model in ["iMac7,1", "iMac8,1"] or (
self._computer.real_model in ["MacBook5,1",
"MacBook5,2",
"MacBook6,1",
"MacBook7,1",
"MacBookAir2,1",
"MacBookAir3,1",
"MacBookAir3,2",
"MacBookAir4,1",
"MacBookAir4,2",
"MacBookPro4,1",
"MacBookPro5,1",
"MacBookPro5,2",
"MacBookPro5,3",
"MacBookPro5,4",
"MacBookPro5,5",
"MacBookPro6,1",
"MacBookPro6,2",
"MacBookPro7,1",
"MacBookPro8,1",
"MacBookPro8,2",
"MacBookPro8,3",
"Macmini3,1",
"Macmini4,1",
"Macmini5,1",
"Macmini5,2",
"Macmini5,3",
"iMac9,1",
"iMac10,1",
"iMac11,1",
"iMac11,2",
"iMac11,3",
"iMac12,1",
"iMac12,2",
"MacPro3,1"
] and utilities.check_kext_loaded("as.vit9696.AppleALC") is False)
def native_os(self) -> bool:
"""
- iMac7,1 and iMac8,1 last supported in macOS 10.11, El Capitan
- All other models pre-2012 models last supported in macOS 10.13, High Sierra
"""
if self._computer.real_model in ["iMac7,1", "iMac8,1"]:
return self._xnu_major < os_data.sierra.value
return self._xnu_major < os_data.mojave.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def _missing_gop_patches(self) -> dict:
"""
Patches for graphics cards with missing GOP (ie. breaking AppleALC functionality)
"""
return {
"Legacy Non-GOP": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleHDA.kext": "10.13.6",
},
},
},
}
def _realtek_audio_patches(self) -> dict:
"""
Patches for Realtek Audio
"""
return {
"Legacy Realtek": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AppleHDA.kext": "10.11.6",
"IOAudioFamily.kext": "10.11.6",
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions": [
"AppleVirtIO.kext",
"AppleVirtualGraphics.kext",
"AppleVirtualPlatform.kext",
"ApplePVPanic.kext",
"AppleVirtIOStorage.kext",
],
},
},
}
def patches(self) -> dict:
"""
Patches for legacy audio
"""
if self.native_os() is True:
return {}
if self._computer.real_model in ["iMac7,1", "iMac8,1"]:
return self._realtek_audio_patches()
return self._missing_gop_patches()

66
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/pcie_webcam.py Normal file
View File

@@ -0,0 +1,66 @@
"""
pci_webcam.py: PCIe FaceTime Camera detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....datasets.os_data import os_data
class PCIeFaceTimeCamera(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: PCIe FaceTime Camera"
def present(self) -> bool:
"""
Targeting PCIe FaceTime Cameras
"""
return self._computer.pcie_webcam
def native_os(self) -> bool:
"""
Dropped support with macOS 14 Developer Beta 1 (23A5257q)
"""
return self._xnu_major < os_data.sonoma.value or self._os_build == "23A5257q"
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def patches(self) -> dict:
"""
Patches for PCIe FaceTime Camera
"""
if self.native_os() is True:
return {}
return {
"PCIe FaceTime Camera": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks/CoreMediaIO.framework/Versions/A/Resources": {
"AppleCamera.plugin": "14.0 Beta 1"
},
"/System/Library/LaunchDaemons": {
"com.apple.cmio.AppleCameraAssistant.plist": "14.0 Beta 1"
},
},
},
}

90
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/t1_security.py Normal file
View File

@@ -0,0 +1,90 @@
"""
t1_security.py: T1 Security Chip detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....datasets.os_data import os_data
class T1SecurityChip(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: T1 Security Chip"
def present(self) -> bool:
"""
Targeting T1 Security Chip
"""
return self._computer.t1_chip
def native_os(self) -> bool:
"""
Dropped support with macOS 14, Sonoma
"""
return self._xnu_major < os_data.sonoma.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def patches(self) -> dict:
"""
Patches for T1 Security Chip
"""
if self.native_os() is True:
return {}
return {
"T1 Security Chip": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"LocalAuthentication.framework": f"13.6-{self._xnu_major}" # Required for Password Authentication (SharedUtils.framework)
},
"/System/Library/PrivateFrameworks": {
"EmbeddedOSInstall.framework": "13.6", # Required for biometrickitd
**({ "NearField.framework": "14.5" } if self._xnu_major >= os_data.sequoia else {}),
},
# Required for Apple Pay
"/usr/lib": {
"libNFC_Comet.dylib": "13.6",
"libNFC_HAL.dylib": "13.6",
"libnfshared.dylib": "13.6",
"libnfshared.dylibOld.dylib": "13.6",
"libnfstorage.dylib": "13.6",
"libnfrestore.dylib": "13.6",
"libPN548_API.dylib": "13.6"
},
"/usr/libexec": {
"biometrickitd": "13.6", # Required for Touch ID
"nfcd": "13.6", # Required for Apple Pay
"nfrestore_service": "13.6", # Required for Apple Pay
},
"/usr/standalone/firmware/nfrestore/firmware/fw": {
"PN549_FW_02_01_5A_rev88207.bin": "13.6",
"SN100V_FW_A3_01_01_81_rev127208.bin": "13.6",
"SN200V_FW_B1_02_01_86_rev127266.bin": "13.6",
"SN300V_FW_B0_02_01_22_rev129172.bin": "13.6",
}
},
},
}

125
opencore_legacy_patcher/sys_patch/patchsets/hardware/misc/usb11.py Normal file
View File

@@ -0,0 +1,125 @@
"""
usb11.py: Legacy USB 1.1 Controller detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
from .....datasets import smbios_data, cpu_data
class USB11Controller(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Legacy USB 1.1"
def present(self) -> bool:
"""
Targeting UHCI/OHCI controllers
"""
# If we're on a hackintosh, check for UHCI/OHCI controllers
if self._constants.host_is_hackintosh is True:
for controller in self._computer.usb_controllers:
if (
isinstance(controller, device_probe.UHCIController) or
isinstance(controller, device_probe.OHCIController)
):
return True
return False
if self._computer.real_model not in smbios_data.smbios_dictionary:
return False
# If we're on a Mac, check for Penryn or older
# This is due to Apple implementing an internal USB hub on post-Penryn (excluding MacPro4,1, MacPro5,1 and Xserve3,1)
# Ref: https://techcommunity.microsoft.com/t5/microsoft-usb-blog/reasons-to-avoid-companion-controllers/ba-p/270710
if (
smbios_data.smbios_dictionary[self._computer.real_model]["CPU Generation"] <= cpu_data.CPUGen.penryn.value or \
self._computer.real_model in ["MacPro4,1", "MacPro5,1", "Xserve3,1"]
):
return True
return False
def native_os(self) -> bool:
"""
Dropped support with macOS 13, Ventura
"""
return self._xnu_major < os_data.ventura.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.MISCELLANEOUS
def _base_patches(self) -> dict:
"""
Base patches for USB 1.1 Controller
"""
return {
"Legacy USB 1.1": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"IOUSBHostFamily.kext": "12.6.2" if self._xnu_float < self.macOS_14_4 else "12.6.2-23.4",
},
},
},
}
def _extended_patches(self) -> dict:
"""
Extended patches for USB 1.1 Controller
"""
if self._xnu_float < self.macOS_14_1:
return {}
return {
# Injection of UHCI/OHCI causes a panic on 14.1+
"Legacy USB 1.1 Extended": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions/IOUSBHostFamily.kext/Contents/PlugIns": {
"AppleUSBOHCI.kext": "12.6.2-USB",
"AppleUSBOHCIPCI.kext": "12.6.2-USB",
"AppleUSBUHCI.kext": "12.6.2-USB",
"AppleUSBUHCIPCI.kext": "12.6.2-USB",
},
"/System/Library/Extensions": {
**({ "AppleUSBAudio.kext": "14.5" } if self._xnu_major >= os_data.sequoia else {}),
**({ "AppleUSBCDC.kext": "14.5" } if self._xnu_major >= os_data.sequoia else {}),
},
},
},
}
def patches(self) -> dict:
"""
Patches for USB 1.1 Controller
"""
if self.native_os() is True:
return {}
return {
**self._base_patches(),
**self._extended_patches(),
}

147
opencore_legacy_patcher/sys_patch/patchsets/hardware/networking/legacy_wireless.py Normal file
View File

@@ -0,0 +1,147 @@
"""
legacy_wireless.py: Legacy Wireless detection
"""
import packaging.version
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class LegacyWireless(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Legacy Wireless"
def present(self) -> bool:
"""
Targeting Legacy Wireless
"""
if (
isinstance(self._computer.wifi, device_probe.Broadcom)
and self._computer.wifi.chipset in [device_probe.Broadcom.Chipsets.AirPortBrcm4331, device_probe.Broadcom.Chipsets.AirPortBrcm43224]
):
return True
if (
isinstance(self._computer.wifi, device_probe.Atheros)
and self._computer.wifi.chipset == device_probe.Atheros.Chipsets.AirPortAtheros40
):
return True
return False
def native_os(self) -> bool:
"""
Dropped support with macOS 12, Monterey
"""
return self._xnu_major < os_data.monterey.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.NETWORKING
def _affected_by_cve_2024_23227(self) -> bool:
"""
CVE-2024-23227 broke our airportd patches for 12.7.4, 13.6.5 and 14.4
Note that since the XNU version's security patch level is not increment
"""
if self._xnu_major > os_data.sonoma:
return True
marketing_version = self._constants.detected_os_version
parsed_version = packaging.version.parse(marketing_version)
if marketing_version.startswith("12"):
return parsed_version >= packaging.version.parse("12.7.4")
if marketing_version.startswith("13"):
return parsed_version >= packaging.version.parse("13.6.5")
if marketing_version.startswith("14"):
return parsed_version >= packaging.version.parse("14.4")
return False
def _base_patch(self) -> dict:
"""
Base patches for Legacy Wireless
"""
return {
"Legacy Wireless": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/usr/libexec": {
"airportd": "11.7.10" if self._affected_by_cve_2024_23227 is False else "11.7.10-Sandbox",
},
"/System/Library/CoreServices": {
"WiFiAgent.app": "11.7.10",
},
},
PatchType.INSTALL_DATA_VOLUME: {
"/Library/Application Support/SkyLightPlugins": {
**({ "CoreWLAN.dylib": "SkyLightPlugins" } if self._xnu_major == os_data.monterey else {}),
**({ "CoreWLAN.txt": "SkyLightPlugins" } if self._xnu_major == os_data.monterey else {}),
},
},
},
}
def _extended_patch(self) -> dict:
"""
Extended patches for Legacy Wireless
"""
if self._xnu_major < os_data.ventura:
return {}
return {
"Legacy Wireless Extended": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/usr/libexec": {
"wps": "12.7.2",
"wifip2pd": "12.7.2",
},
"/System/Library/Frameworks": {
"CoreWLAN.framework": "12.7.2",
},
"/System/Library/PrivateFrameworks": {
"CoreWiFi.framework": "12.7.2",
"IO80211.framework": "12.7.2",
"WiFiPeerToPeer.framework": "12.7.2",
},
},
},
}
def patches(self) -> dict:
"""
Patches for Legacy Wireless
"""
if self.native_os() is True:
return {}
return {
**self._base_patch(),
**self._extended_patch(),
}

83
opencore_legacy_patcher/sys_patch/patchsets/hardware/networking/modern_wireless.py Normal file
View File

@@ -0,0 +1,83 @@
"""
modern_wireless.py: Modern Wireless detection
"""
from ..base import BaseHardware, HardwareVariant
from ...base import PatchType
from .....constants import Constants
from .....detections import device_probe
from .....datasets.os_data import os_data
class ModernWireless(BaseHardware):
def __init__(self, xnu_major, xnu_minor, os_build, global_constants: Constants) -> None:
super().__init__(xnu_major, xnu_minor, os_build, global_constants)
def name(self) -> str:
"""
Display name for end users
"""
return f"{self.hardware_variant()}: Modern Wireless"
def present(self) -> bool:
"""
Targeting Modern Wireless
"""
return isinstance(self._computer.wifi, device_probe.Broadcom) and (
self._computer.wifi.chipset in [
device_probe.Broadcom.Chipsets.AirPortBrcm4360,
device_probe.Broadcom.Chipsets.AirportBrcmNIC,
# We don't officially support this chipset, however we'll throw a bone to hackintosh users
device_probe.Broadcom.Chipsets.AirPortBrcmNICThirdParty,
]
)
def native_os(self) -> bool:
"""
Dropped support with macOS 14, Sonoma
"""
return self._xnu_major < os_data.sonoma.value
def hardware_variant(self) -> HardwareVariant:
"""
Type of hardware variant
"""
return HardwareVariant.NETWORKING
def patches(self) -> dict:
"""
Patches for Modern Wireless
"""
if self.native_os() is True:
return {}
return {
"Modern Wireless": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/usr/libexec": {
"airportd": "13.6.5",
"wifip2pd": "13.6.5",
},
"/System/Library/Frameworks": {
"CoreWLAN.framework": f"13.6.5-{self._xnu_major}",
},
"/System/Library/PrivateFrameworks": {
"CoreWiFi.framework": f"13.6.5-{self._xnu_major}",
"IO80211.framework": f"13.6.5-{self._xnu_major}",
"WiFiPeerToPeer.framework": f"13.6.5-{self._xnu_major}",
},
"/System/Library/CoreServices": {
**({ "WiFiAgent.app": "14.5" } if self._xnu_major >= os_data.sequoia else {}),
},
},
},
}

41
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/amd_opencl.py Normal file
View File

@@ -0,0 +1,41 @@
"""
amd_opencl.py: AMD OpenCL patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class AMDOpenCL(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major >= os_data.ventura.value
def patches(self) -> dict:
"""
In Ventura, Apple added AVX2.0 code to AMD's OpenCL/GL compilers
"""
if self._os_requires_patches() is False:
return {}
return {
"AMD OpenCL": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"OpenCL.framework": "12.5 non-AVX2.0",
"OpenGL.framework": "12.5 non-AVX2.0",
},
},
},
}

53
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/amd_terascale.py Normal file
View File

@@ -0,0 +1,53 @@
"""
amd_terascale.py: AMD TeraScale patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class AMDTeraScale(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major >= os_data.mojave.value
def patches(self) -> dict:
"""
Shared patches between TeraScale 1 and 2
"""
if self._os_requires_patches() is False:
return {}
return {
"AMD TeraScale Common": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"AMDFramebuffer.kext": "10.13.6",
"AMDLegacyFramebuffer.kext": "10.13.6",
"AMDLegacySupport.kext": "10.13.6",
"AMDShared.bundle": "10.13.6",
"AMDSupport.kext": "10.13.6",
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions": [
"AMD7000Controller.kext",
"AMD8000Controller.kext",
"AMD9000Controller.kext",
"AMD9500Controller.kext",
"AMD10000Controller.kext",
],
},
},
}

30
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/base.py Normal file
View File

@@ -0,0 +1,30 @@
"""
base.py: Base class for shared patch sets
"""
from ..base import BasePatchset
class BaseSharedPatchSet(BasePatchset):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__()
self._xnu_major = xnu_major
self._xnu_minor = xnu_minor
self._marketing_version = marketing_version
self._xnu_float = float(f"{self._xnu_major}.{self._xnu_minor}")
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires patches
"""
raise NotImplementedError
def patches(self) -> dict:
"""
Dictionary of patches
"""
raise NotImplementedError

42
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/big_sur_gva.py Normal file
View File

@@ -0,0 +1,42 @@
"""
big_sur_gva.py: Big Sur GVA patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class BigSurGVA(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major >= os_data.monterey.value
def patches(self) -> dict:
"""
For GPUs last natively supported in Catalina/Big Sur
Restores DRM support for these GPUs
"""
if self._os_requires_patches() is False:
return {}
return {
"Big Sur GVA": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/PrivateFrameworks": {
"AppleGVA.framework": "11.7.10",
"AppleGVACore.framework": "11.7.10",
},
},
},
}

40
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/big_sur_opencl.py Normal file
View File

@@ -0,0 +1,40 @@
"""
big_sur_opencl.py: Big Sur OpenCL patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class BigSurOpenCL(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major >= os_data.monterey.value
def patches(self) -> dict:
"""
For graphics cards dropped in Monterey
"""
if self._os_requires_patches() is False:
return {}
return {
"Big Sur OpenCL": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"OpenCL.framework": "11.6",
},
},
},
}

43
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/high_sierra_gva.py Normal file
View File

@@ -0,0 +1,43 @@
"""
high_sierra_gva.py: High Sierra GVA patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class HighSierraGVA(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Dropped support with macOS 11.0, Big Sur
"""
return self._xnu_major >= os_data.big_sur.value
def patches(self) -> dict:
"""
For GPUs last natively supported in High Sierra/Catalina
"""
if self._os_requires_patches() is False:
return {}
return {
# For GPUs last natively supported in High Sierra/Catalina
# Restores DRM support
"High Sierra GVA": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/PrivateFrameworks": {
"AppleGVA.framework": "10.13.6",
"AppleGVACore.framework": "10.15.7",
},
},
},
}

477
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/metal_3802.py Normal file
View File

@@ -0,0 +1,477 @@
"""
metal_3802.py: Metal 3802 patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType, DynamicPatchset
from ....datasets.os_data import os_data
class LegacyMetal3802(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major >= os_data.ventura.value
def _patches_metal_3802_common(self) -> dict:
"""
Intel Ivy Bridge, Haswell and Nvidia Kepler are Metal 3802-based GPUs
Due to this, we need to re-add 3802 compiler support to the Metal stack
"""
if self._os_requires_patches() is False:
return {}
return {
"Metal 3802 Common": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"Metal.framework": "12.5-3802-22" if self._xnu_major < os_data.sonoma else "12.5-3802-23",
},
"/System/Library/PrivateFrameworks": {
"MTLCompiler.framework": "12.7.6-3802",
"GPUCompiler.framework": "12.7.6-3802",
},
"/System/Library/Sandbox/Profiles": {
"com.apple.mtlcompilerservice.sb": "12.5-3802",
}
}
}
}
def _patches_metal_3802_common_extended(self) -> dict:
"""
Support for 3802 GPUs were broken with 13.3+
Downgrades 31001 stack to 13.2.1, however nukes AMFI support
"""
if self._xnu_float < self.macOS_13_3:
return {}
return {
"Metal 3802 Common Extended": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"Metal.framework": f"13.2.1-{self._xnu_major}",
**({ "CoreImage.framework": "14.0 Beta 3" if self._xnu_major < os_data.sequoia.value else "14.0 Beta 3-24"} if self._xnu_major >= os_data.sonoma.value else {}),
},
"/System/Library/PrivateFrameworks": {
**({ "MTLCompiler.framework": "13.2.1" } if self._xnu_major == os_data.ventura.value else {}),
**({ "GPUCompiler.framework": "13.2.1" } if self._xnu_major == os_data.ventura.value else {}),
"RenderBox.framework": "13.2.1-3802" if self._xnu_major == os_data.ventura.value else "14.0-3802",
# More issues for 3802, now with 14.2 Beta 2+...
# If there is a god, they clearly despise us and legacy Macs.
**({ "MTLCompiler.framework": "14.2 Beta 1" } if self._xnu_float >= self.macOS_14_2 else {}),
**({ "GPUCompiler.framework": "14.2 Beta 1" } if self._xnu_float >= self.macOS_14_2 else {}),
},
}
}
}
def _patches_metal_3802_metallibs(self) -> dict:
"""
With macOS Sequoia, a new .metallib compiler format was introduced (V27)
Thus we need to patch all .metallib files to support 3802 GPUs using MetallibSupportPkg
Reference:
https://github.com/dortania/MetallibSupportPkg
"""
if self._xnu_major < os_data.sequoia.value:
return {}
return {
"Metal 3802 .metallibs": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSCore.framework/Versions/A/Resources": {
"default.metallib": "14.6.1",
},
"/System/Library/Frameworks/MLCompute.framework/Versions/A/Resources": {
"default.metallib": "14.6.1"
},
"/System/Library/PrivateFrameworks/CoreUI.framework/Versions/A/Resources": {
"default.metallib": "14.6.1",
},
"/System/Library/Frameworks/CoreImage.framework/Versions/A": {
"CoreImage.metallib": "14.6.1",
},
"/System/Library/Frameworks/CoreImage.framework/Versions/A/Resources": {
"default.metallib": "14.6.1",
"ci_filters.metallib": "14.6.1",
"ci_stdlib_stitchable_h.metallib": "14.6.1",
"ci_stdlib_stitchable.metallib": "14.6.1",
"CIPortraitBlurStitchableV3.metallib": "14.6.1",
"CIPortraitBlurStitchableV2.metallib": "14.6.1",
"ci_stdlib_h.metallib": "14.6.1",
"ci_filters_stitchable.metallib": "14.6.1",
"CIPortraitBlurV2.metallib": "14.6.1",
"CIPortraitBlurV3.metallib": "14.6.1",
"ci_stdlib.metallib": "14.6.1",
},
"/System/iOSSupport/System/Library/PrivateFrameworks/VFX.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/VisionKitInternal.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/TSReading.framework/Versions/A/Resources": {
"TSDDefaultMetalLibrary.metallib": DynamicPatchset.MetallibSupportPkg,
"KeynoteMetalLibrary.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/WeatherUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"ForegroundEffectShaders.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/AvatarKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/Tungsten.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/TextInputUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/ActivityRingsUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/ChatKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/WeatherMaps.framework/Versions/A/Resources": {
"WeatherMapsMetalLib.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/HomeAccessoryControlUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/PassKitUIFoundation.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/PrivateFrameworks/MediaCoreUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/Frameworks/ARKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/Frameworks/SpriteKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/Frameworks/PencilKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/Frameworks/SwiftUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/iOSSupport/System/Library/Frameworks/SceneKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Video/Plug-Ins/AppleGVAHEVCEncoder.bundle/Contents/Resources": {
"AppleGVAHEVCFrameStatistics.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Video/Plug-Ins/AV1DecoderSW.bundle/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Video/Plug-Ins/AppleAVEEncoder.bundle/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/CoreServices/MTLReplayer.app/Contents/Frameworks/MTLReplayController.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/CoreImage/CIPassThrough.cifilter/Contents/Resources": {
"CIPassThrough.ci.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/CoreImage/PortraitFilters.cifilter/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"portrait_filters.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/ScreenCaptureKitMetal/ScreenCaptureKitMetal.bundle/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/ExtensionKit/Extensions/Monterey.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/ExtensionKit/Extensions/Drift.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/ExtensionKit/Extensions/WallpaperMacintoshExtension.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/ExtensionKit/Extensions/WallpaperSequoiaExtension.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/SetupAssistantSupportUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/GESS.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VFX.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VisionCore.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/CMImaging.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/CoreRE.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/HDRProcessing.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/AvatarKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/SkyLight.framework/Versions/A/Resources": {
"SkyLightShaders.air64.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/RenderBox.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/AppleISPEmulator.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/NeutrinoCore.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Tungsten.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/ImageHarmonizationKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VideoProcessing.framework/Versions/A/PlugIns/Codecs/VCPRealtimeEncoder.bundle/Contents/Resources": {
"ProcessAccelerate.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VideoProcessing.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"ProcessAccelerate.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Portrait.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VisualGeneration.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"NonMaxLineSuppress.ci.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/AccelerateGPU.framework": {
"GPUBLAS.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/AccelerateGPU.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/ShaderGraph.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Hydra.framework/Plugins/HydraQLThumbnailExtension.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Hydra.framework/Plugins/HydraQLPreviewExtension.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Hydra.framework/Versions/C/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/SiriUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/TextRecognition.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Leonardo.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VectorKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/VectorKit.framework/Versions/A/Resources/metal_libraries": {
"AlloyCommonLibrary.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/GPUToolsCapture.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/PhotoImaging.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/MetalTools.framework/Versions/A/Resources": {
"MTLLegacySVICBSupport.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLGPUDebugICBSupport.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLGPUDebugAccelerationStructureSupport.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLDebugShaders.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLLegacySVAccelerationStructureSupport.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/AppleDepth.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Human.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/CorePhotogrammetry.framework/Versions/A/Resources": {
"ComputerVision_Tess_Kernels.metallib": DynamicPatchset.MetallibSupportPkg,
"Photogrammetry_Matching_Kernels.metallib": DynamicPatchset.MetallibSupportPkg,
"Photogrammetry_Texturing_Kernels.metallib": DynamicPatchset.MetallibSupportPkg,
"Photogrammetry_MVS_Kernels.metallib": DynamicPatchset.MetallibSupportPkg,
"Photogrammetry_Meshing_Kernels.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/HumanUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Quagga.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/Espresso.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/CMPhoto.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/MediaAnalysis.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/AltruisticBodyPoseKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/PhotosUICore.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/MusicUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/FRC.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/H13ISPServices.framework/Versions/A/Resources": {
"CalibrateRgbIr.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/SiriUICore.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/PassKitUIFoundation.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/H16ISPServices.framework/Versions/A/Resources": {
"CalibrateRgbIr.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/CoreOCModules.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/PhotosensitivityProcessing.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/PrivateFrameworks/MediaCoreUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/Metal.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLMeshShaderEmulator.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLBVHBuilder.metallib": DynamicPatchset.MetallibSupportPkg,
"MTLECBE.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/QuartzCore.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/CoreMediaIO.framework/Versions/A/Resources/ACD.plugin/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSFunctions.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSRayIntersector.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSNeuralNetwork.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSNDArray.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSImage.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalPerformanceShaders.framework/Versions/A/Frameworks/MPSMatrix.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/MetalFX.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/ParavirtualizedGraphics.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/ImageIO.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/SpriteKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/PencilKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/CoreDisplay.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/SwiftUICore.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/SwiftUI.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/Vision.framework/Versions/A/Resources": {
"ImageFilters.metallib": DynamicPatchset.MetallibSupportPkg,
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/StickerKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/VideoToolbox.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/Frameworks/SceneKit.framework/Versions/A/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Library/VideoProcessors/CCPortrait.bundle/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"CoreImageKernels_only.ci.metallib": DynamicPatchset.MetallibSupportPkg,
"CoreImageKernels.ci.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Applications/Music.app/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Applications/Chess.app/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Applications/Freeform.app/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
"coreimage.metallib": DynamicPatchset.MetallibSupportPkg,
},
"/System/Applications/Freeform.app/Contents/Extensions/USDRendererExtension.appex/Contents/Resources": {
"default.metallib": DynamicPatchset.MetallibSupportPkg,
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/PrivateFrameworks/RenderBox.framework/Versions/A/Resources": [
# For some reason Ivy Bridge can't tell the metallib lacks AIR64 support, and errors out
"archive.metallib",
],
},
}
}
def patches(self) -> dict:
"""
Dictionary of patches
"""
return {
**self._patches_metal_3802_common(),
**self._patches_metal_3802_common_extended(),
**self._patches_metal_3802_metallibs(),
}

42
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/monterey_gva.py Normal file
View File

@@ -0,0 +1,42 @@
"""
monterey_gva.py: Monterey GVA patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class MontereyGVA(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major >= os_data.ventura.value
def patches(self) -> dict:
"""
For GPUs last natively supported in Monterey
Restores DRM support
"""
if self._os_requires_patches() is False:
return {}
return {
"Monterey GVA": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/PrivateFrameworks": {
"AppleGVA.framework": "12.5",
"AppleGVACore.framework": "12.5",
},
},
},
}

40
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/monterey_opencl.py Normal file
View File

@@ -0,0 +1,40 @@
"""
monterey_opencl.py: Monterey OpenCL patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class MontereyOpenCL(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major >= os_data.ventura.value
def patches(self) -> dict:
"""
For graphics cards dropped in Ventura
"""
if self._os_requires_patches() is False:
return {}
return {
"Monterey OpenCL": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"OpenCL.framework": "12.5",
},
},
},
}

47
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/monterey_webkit.py Normal file
View File

@@ -0,0 +1,47 @@
"""
monterey_opencl.py: Monterey OpenCL patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class MontereyWebKit(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Check if the current OS requires
"""
return self._xnu_major == os_data.monterey.value
def patches(self) -> dict:
"""
Monterey has a WebKit sandboxing issue where many UI elements fail to render
This patch simple replaces the sandbox profile with one supporting our GPUs
Note: Neither Big Sur nor Ventura have this issue
"""
if self._os_requires_patches() is False:
return {}
return {
"WebKit Monterey Common": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"WebKit.framework": "11.6"
},
},
PatchType.INSTALL_DATA_VOLUME: {
"/Library/Apple/System/Library/StagedFrameworks/Safari": {
"WebKit.framework": "11.6"
},
},
},
}

98
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/non_metal.py Normal file
View File

@@ -0,0 +1,98 @@
"""
non_metal.py: Non-Metal patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class NonMetal(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major >= os_data.mojave.value
def patches(self) -> dict:
"""
General non-Metal GPU patches
"""
if self._os_requires_patches() is False:
return {}
return {
"Non-Metal Common": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"IOSurface.kext": "10.15.7",
},
"/System/Library/Frameworks": {
"OpenGL.framework": "10.14.3",
"CoreDisplay.framework": f"10.14.4-{self._xnu_major}",
"IOSurface.framework": f"10.15.7-{self._xnu_major}",
"QuartzCore.framework": f"10.15.7-{self._xnu_major}",
},
"/System/Library/PrivateFrameworks": {
"GPUSupport.framework": "10.14.3",
"SkyLight.framework": f"10.14.6-{self._xnu_major}",
**({"FaceCore.framework": f"13.5"} if self._xnu_major >= os_data.sonoma else {}),
},
"/System/Applications": {
**({ "Photo Booth.app": "11.7.9"} if self._xnu_major >= os_data.monterey else {}),
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions": [
"AMDRadeonX4000.kext",
"AMDRadeonX4000HWServices.kext",
"AMDRadeonX5000.kext",
"AMDRadeonX5000HWServices.kext",
"AMDRadeonX6000.kext",
"AMDRadeonX6000Framebuffer.kext",
"AMDRadeonX6000HWServices.kext",
"AppleIntelBDWGraphics.kext",
"AppleIntelBDWGraphicsFramebuffer.kext",
"AppleIntelCFLGraphicsFramebuffer.kext",
"AppleIntelHD4000Graphics.kext",
"AppleIntelHD5000Graphics.kext",
"AppleIntelICLGraphics.kext",
"AppleIntelICLLPGraphicsFramebuffer.kext",
"AppleIntelKBLGraphics.kext",
"AppleIntelKBLGraphicsFramebuffer.kext",
"AppleIntelSKLGraphics.kext",
"AppleIntelSKLGraphicsFramebuffer.kext",
"AppleIntelFramebufferAzul.kext",
"AppleIntelFramebufferCapri.kext",
"AppleParavirtGPU.kext",
"GeForce.kext",
"IOAcceleratorFamily2.kext",
"IOGPUFamily.kext",
"AppleAfterburner.kext",
],
},
PatchType.INSTALL_DATA_VOLUME: {
"/Library/Application Support/SkyLightPlugins": {
**({ "DropboxHack.dylib": "SkyLightPlugins" } if self._xnu_major >= os_data.monterey else {}),
**({ "DropboxHack.txt": "SkyLightPlugins" } if self._xnu_major >= os_data.monterey else {}),
},
},
PatchType.EXECUTE: {
# 'When Space Allows' option introduced in 12.4 (XNU 21.5)
**({"/usr/bin/defaults write /Library/Preferences/.GlobalPreferences.plist ShowDate -int 1": True } if self._xnu_float >= self.macOS_12_4 else {}),
"/usr/bin/defaults write /Library/Preferences/.GlobalPreferences.plist InternalDebugUseGPUProcessForCanvasRenderingEnabled -bool false": True,
"/usr/bin/defaults write /Library/Preferences/.GlobalPreferences.plist WebKitExperimentalUseGPUProcessForCanvasRenderingEnabled -bool false": True,
**({"/usr/bin/defaults write /Library/Preferences/.GlobalPreferences.plist WebKitPreferences.acceleratedDrawingEnabled -bool false": True} if self._xnu_major >= os_data.sonoma else {}),
**({"/usr/bin/defaults write /Library/Preferences/.GlobalPreferences.plist NSEnableAppKitMenus -bool false": True} if self._xnu_major >= os_data.sonoma else {}),
**({"/usr/bin/defaults write /Library/Preferences/.GlobalPreferences.plist NSZoomButtonShowMenu -bool false": True} if self._xnu_major >= os_data.sonoma else {}),
},
},
}

40
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/non_metal_coredisplay.py Normal file
View File

@@ -0,0 +1,40 @@
"""
non_metal_coredisplay.py: Non-Metal CoreDisplay patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class NonMetalCoreDisplay(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major >= os_data.mojave.value
def patches(self) -> dict:
"""
Nvidia Web Drivers require an older build of CoreDisplay
"""
if self._os_requires_patches() is False:
return {}
return {
"Non-Metal CoreDisplay Common": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Frameworks": {
"CoreDisplay.framework": f"10.13.6-{self._xnu_major}",
},
},
},
}

44
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/non_metal_enforcement.py Normal file
View File

@@ -0,0 +1,44 @@
"""
non_metal_enforcement.py: Non-Metal Enforcement patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class NonMetalEnforcement(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major >= os_data.mojave.value
def patches(self) -> dict:
"""
Forces Metal kexts from High Sierra to run in the fallback non-Metal mode
Verified functional with HD4000 and Iris Plus 655
Only used for internal development purposes, not suitable for end users
Note: Metal kexts in High Sierra rely on IOAccelerator, thus 'Non-Metal IOAccelerator Common'
is needed for proper linking
"""
if self._os_requires_patches() is False:
return {}
return {
"Non-Metal Enforcement": {
PatchType.EXECUTE: {
"/usr/bin/defaults write /Library/Preferences/com.apple.CoreDisplay useMetal -boolean no": True,
"/usr/bin/defaults write /Library/Preferences/com.apple.CoreDisplay useIOP -boolean no": True,
},
},
}

55
opencore_legacy_patcher/sys_patch/patchsets/shared_patches/non_metal_ioaccel.py Normal file
View File

@@ -0,0 +1,55 @@
"""
non_metal_ioaccel.py: Non-Metal IOAccelerator patches
"""
from .base import BaseSharedPatchSet
from ..base import PatchType
from ....datasets.os_data import os_data
class NonMetalIOAccelerator(BaseSharedPatchSet):
def __init__(self, xnu_major: int, xnu_minor: int, marketing_version: str) -> None:
super().__init__(xnu_major, xnu_minor, marketing_version)
def _os_requires_patches(self) -> bool:
"""
Dropped support with macOS 10.14, Mojave
"""
return self._xnu_major >= os_data.mojave.value
def patches(self) -> dict:
"""
TeraScale 2 and Nvidia Web Drivers broke in Mojave due to mismatched structs in
the IOAccelerator stack
"""
if self._os_requires_patches() is False:
return {}
return {
"Non-Metal IOAccelerator Common": {
PatchType.INSTALL_SYSTEM_VOLUME: {
"/System/Library/Extensions": {
"IOAcceleratorFamily2.kext": "10.13.6",
"IOSurface.kext": "10.14.6",
},
"/System/Library/Frameworks": {
"IOSurface.framework": f"10.14.6-{self._xnu_major}",
"OpenCL.framework": "10.13.6",
},
"/System/Library/PrivateFrameworks": {
"GPUSupport.framework": "10.13.6",
"IOAccelerator.framework": f"10.13.6-{self._xnu_major}",
},
},
PatchType.REMOVE_SYSTEM_VOLUME: {
"/System/Library/Extensions": [
"AppleCameraInterface.kext"
],
},
},
}

54
opencore_legacy_patcher/sys_patch/sys_patch.py
View File

@@ -58,20 +58,24 @@ from .. import constants
from ..volume import generate_copy_arguments
from ..datasets import (
os_data,
sys_patch_dict
os_data
)
from ..support import (
utilities,
subprocess_wrapper,
metallib_handler
)
from .patchsets import (
HardwarePatchsetDetection,
HardwarePatchsetSettings,
PatchType,
DynamicPatchset
)
from . import (
sys_patch_helpers,
kernelcache
)
from .auto_patcher import InstallAutomaticPatchingServices
from .detections import DetectRootPatch, GenerateRootPatchSets
class PatchSysVolume:
@@ -90,11 +94,11 @@ class PatchSysVolume:
# GUI will detect hardware patches before starting PatchSysVolume()
# However the TUI will not, so allow for data to be passed in manually avoiding multiple calls
if hardware_details is None:
hardware_details = DetectRootPatch(self.computer.real_model, self.constants).detect_patch_set()
hardware_details = HardwarePatchsetDetection(self.constants).device_properties
self.hardware_details = hardware_details
self._init_pathing()
self.skip_root_kmutil_requirement = self.hardware_details["Settings: Supports Auxiliary Cache"]
self.skip_root_kmutil_requirement = not self.hardware_details[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED] if self.constants.detected_os >= os_data.os_data.ventura else False
self.mount_obj = RootVolumeMount(self.constants.detected_os)
@@ -315,7 +319,7 @@ class PatchSysVolume:
Write patchset information to Root Volume
Parameters:
patchset (dict): Patchset information (generated by GenerateRootPatchSets)
patchset (dict): Patchset information (generated by HardwarePatchsetDetection)
"""
destination_path = f"{self.mount_location}/System/Library/CoreServices"
@@ -337,7 +341,7 @@ class PatchSysVolume:
if self.patch_set_dictionary != {}:
self._execute_patchset(self.patch_set_dictionary)
else:
self._execute_patchset(GenerateRootPatchSets(self.computer.real_model, self.constants, self.hardware_details).patchset)
self._execute_patchset(HardwarePatchsetDetection(self.constants).patches)
if self.constants.wxpython_variant is True and self.constants.detected_os >= os_data.os_data.big_sur:
needs_daemon = False
@@ -353,7 +357,7 @@ class PatchSysVolume:
Executes provided patchset
Parameters:
required_patches (dict): Patchset to execute (generated by sys_patch_generate.GenerateRootPatchSets)
required_patches (dict): Patchset to execute (generated by HardwarePatchsetDetection)
"""
kc_support_obj = kernelcache.KernelCacheSupport(
@@ -366,19 +370,19 @@ class PatchSysVolume:
required_patches = self._preflight_checks(required_patches, source_files_path)
for patch in required_patches:
logging.info("- Installing Patchset: " + patch)
for method_remove in ["Remove", "Remove Non-Root"]:
for method_remove in [PatchType.REMOVE_SYSTEM_VOLUME, PatchType.REMOVE_DATA_VOLUME]:
if method_remove in required_patches[patch]:
for remove_patch_directory in required_patches[patch][method_remove]:
logging.info("- Remove Files at: " + remove_patch_directory)
for remove_patch_file in required_patches[patch][method_remove][remove_patch_directory]:
if method_remove == "Remove":
if method_remove == PatchType.REMOVE_SYSTEM_VOLUME:
destination_folder_path = str(self.mount_location) + remove_patch_directory
else:
destination_folder_path = str(self.mount_location_data) + remove_patch_directory
remove_file(destination_folder_path, remove_patch_file)
for method_install in ["Install", "Install Non-Root"]:
for method_install in [PatchType.INSTALL_SYSTEM_VOLUME, PatchType.INSTALL_DATA_VOLUME]:
if method_install not in required_patches[patch]:
continue
@@ -390,7 +394,7 @@ class PatchSysVolume:
if not required_patches[patch][method_install][install_patch_directory][install_file].startswith("/"):
source_folder_path = source_files_path + "/" + source_folder_path
if method_install == "Install":
if method_install == PatchType.INSTALL_SYSTEM_VOLUME:
destination_folder_path = str(self.mount_location) + install_patch_directory
else:
if install_patch_directory == "/Library/Extensions":
@@ -416,11 +420,11 @@ class PatchSysVolume:
install_new_file(source_folder_path, destination_folder_path, install_file)
if "Processes" in required_patches[patch]:
for process in required_patches[patch]["Processes"]:
if PatchType.EXECUTE in required_patches[patch]:
for process in required_patches[patch][PatchType.EXECUTE]:
# Some processes need sudo, however we cannot directly call sudo in some scenarios
# Instead, call elevated funtion if string's boolean is True
if required_patches[patch]["Processes"][process] is True:
if required_patches[patch][PatchType.EXECUTE][process] is True:
logging.info(f"- Running Process as Root:\n{process}")
subprocess_wrapper.run_as_root_and_verify(process.split(" "), stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
else:
@@ -466,11 +470,11 @@ class PatchSysVolume:
@cache
def _resolve_dynamic_patchset(self, variant: sys_patch_dict.DynamicPatchset) -> str:
def _resolve_dynamic_patchset(self, variant: DynamicPatchset) -> str:
"""
Resolves dynamic patchset to a path
"""
if variant == sys_patch_dict.DynamicPatchset.MetallibSupportPkg:
if variant == DynamicPatchset.MetallibSupportPkg:
return self._resolve_metallib_support_pkg()
raise Exception(f"Unknown Dynamic Patchset: {variant}")
@@ -481,7 +485,7 @@ class PatchSysVolume:
Runs preflight checks before patching
Parameters:
required_patches (dict): Patchset dictionary (from sys_patch_generate.GenerateRootPatchSets)
required_patches (dict): Patchset dictionary (from HardwarePatchsetDetection)
source_files_path (Path): Path to the source files (PatcherSupportPkg)
Returns:
@@ -492,13 +496,13 @@ class PatchSysVolume:
for patch in required_patches:
# Check if all files are present
for method_type in ["Install", "Install Non-Root"]:
for method_type in [PatchType.INSTALL_SYSTEM_VOLUME, PatchType.INSTALL_DATA_VOLUME]:
if method_type not in required_patches[patch]:
continue
for install_patch_directory in required_patches[patch][method_type]:
for install_file in required_patches[patch][method_type][install_patch_directory]:
try:
if required_patches[patch][method_type][install_patch_directory][install_file] in sys_patch_dict.DynamicPatchset:
if required_patches[patch][method_type][install_patch_directory][install_file] in DynamicPatchset:
required_patches[patch][method_type][install_patch_directory][install_file] = self._resolve_dynamic_patchset(required_patches[patch][method_type][install_patch_directory][install_file])
except TypeError:
pass
@@ -544,15 +548,17 @@ class PatchSysVolume:
logging.info("- Starting Patch Process")
logging.info(f"- Determining Required Patch set for Darwin {self.constants.detected_os}")
self.patch_set_dictionary = GenerateRootPatchSets(self.computer.real_model, self.constants, self.hardware_details).patchset
patchset_obj = HardwarePatchsetDetection(self.constants)
self.patch_set_dictionary = patchset_obj.patches
if self.patch_set_dictionary == {}:
logging.info("- No Root Patches required for your machine!")
return
logging.info("- Verifying whether Root Patching possible")
if DetectRootPatch(self.computer.real_model, self.constants).verify_patch_allowed(print_errors=not self.constants.wxpython_variant) is False:
if patchset_obj.can_patch is False:
logging.error("- Cannot continue with patching!!!")
patchset_obj.detailed_errors()
return
logging.info("- Patcher is capable of patching")
@@ -579,8 +585,10 @@ class PatchSysVolume:
"""
logging.info("- Starting Unpatch Process")
if DetectRootPatch(self.computer.real_model, self.constants).verify_patch_allowed(print_errors=True) is False:
patchset_obj = HardwarePatchsetDetection(self.constants)
if patchset_obj.can_unpatch is False:
logging.error("- Cannot continue with unpatching!!!")
patchset_obj.detailed_errors()
return
if self._mount_root_vol() is False:

2
opencore_legacy_patcher/sys_patch/sys_patch_helpers.py
View File

@@ -82,7 +82,7 @@ class SysPatchHelpers:
Generate patchset file for user reference
Parameters:
patchset (dict): Dictionary of patchset, see detect.py and sys_patch_dict.py
patchset (dict): Dictionary of patchset, sys_patch/patchsets
file_name (str): Name of the file to write to
kdk_used (Path): Path to the KDK used, if any

136
opencore_legacy_patcher/wx_gui/gui_cache_os_update.py
View File

@@ -12,9 +12,11 @@ import threading
from pathlib import Path
from .. import constants
from ..support import kdk_handler, utilities
from ..support import kdk_handler, utilities, metallib_handler
from ..wx_gui import gui_support, gui_download
from ..sys_patch.patchsets import HardwarePatchsetDetection, HardwarePatchsetSettings
class OSUpdateFrame(wx.Frame):
"""
@@ -40,29 +42,68 @@ class OSUpdateFrame(wx.Frame):
logging.info(f"Staged update found: {os_data[0]} ({os_data[1]})")
self.os_data = os_data
# Check if we need to patch the system volume
results = HardwarePatchsetDetection(
constants=self.constants,
xnu_major=int(self.os_data[1][:2]),
xnu_minor=0, # We can't determine this from the build number
os_build=self.os_data[1],
os_version=self.os_data[0],
).device_properties
if results[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED] is True:
logging.info("KDK required")
if results[HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_REQUIRED] is True:
# TODO: Download MetalLibSupportPkg
logging.info("MetallibSupportPkg required")
if not any([results[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED], results[HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_REQUIRED]]):
logging.info("No additional resources required")
self._exit()
self._generate_ui()
self.kdk_obj: kdk_handler.KernelDebugKitObject = None
def _kdk_thread_spawn():
self.kdk_obj = kdk_handler.KernelDebugKitObject(self.constants, self.os_data[1], self.os_data[0], passive=True, check_backups_only=True)
kdk_thread = threading.Thread(target=_kdk_thread_spawn)
kdk_thread.start()
while kdk_thread.is_alive():
wx.Yield()
self.metallib_obj: metallib_handler.MetalLibraryObject = None
def _metallib_thread_spawn():
self.metallib_obj = metallib_handler.MetalLibraryObject(self.constants, self.os_data[1], self.os_data[0])
if self.kdk_obj.success is False:
if results[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED] is True:
kdk_thread = threading.Thread(target=_kdk_thread_spawn)
kdk_thread.start()
while kdk_thread.is_alive():
wx.Yield()
if results[HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_REQUIRED] is True:
metallib_thread = threading.Thread(target=_metallib_thread_spawn)
metallib_thread.start()
while metallib_thread.is_alive():
wx.Yield()
download_objects = {
# Name: xxx
# download_obj: xxx
}
if self.kdk_obj:
if self.kdk_obj.success is True:
result = self.kdk_obj.retrieve_download()
if result is not None:
download_objects[f"KDK Build {self.kdk_obj.kdk_url_build}"] = result
if self.metallib_obj:
if self.metallib_obj.success is True:
result = self.metallib_obj.retrieve_download()
if result is not None:
download_objects[f"Metallib Build {self.metallib_obj.metallib_url_build}"] = result
if len(download_objects) == 0:
self._exit()
kdk_download_obj = self.kdk_obj.retrieve_download()
if not kdk_download_obj:
# KDK is already downloaded
# Return false since we didn't display anything
self._exit()
self.kdk_download_obj = kdk_download_obj
self.frame.Show()
self.did_cancel = -1
@@ -76,20 +117,34 @@ class OSUpdateFrame(wx.Frame):
if self.did_cancel == -1:
time.sleep(1)
gui_download.DownloadFrame(
self,
title=self.title,
global_constants=self.constants,
download_obj=kdk_download_obj,
item_name=f"KDK Build {self.kdk_obj.kdk_url_build}"
)
if kdk_download_obj.download_complete is False:
self._exit()
for item in download_objects:
name = item
download_obj = download_objects[item]
self.download_obj = download_obj
gui_download.DownloadFrame(
self,
title=self.title,
global_constants=self.constants,
download_obj=download_obj,
item_name=name
)
if download_obj.download_complete is True:
if item.startswith("KDK"):
self._handle_kdk(self.kdk_obj)
if item.startswith("Metallib"):
self._handle_metallib(self.metallib_obj)
self._exit()
def _handle_kdk(self, kdk_obj: kdk_handler.KernelDebugKitObject) -> None:
"""
Handle KDK installation
"""
logging.info("KDK download complete, validating with hdiutil")
self.kdk_checksum_result = False
def _validate_kdk_checksum_thread():
self.kdk_checksum_result = self.kdk_obj.validate_kdk_checksum()
self.kdk_checksum_result = kdk_obj.validate_kdk_checksum()
kdk_checksum_thread = threading.Thread(target=_validate_kdk_checksum_thread)
kdk_checksum_thread.start()
@@ -99,15 +154,16 @@ class OSUpdateFrame(wx.Frame):
if self.kdk_checksum_result is False:
logging.error("KDK checksum validation failed")
logging.error(self.kdk_obj.error_msg)
logging.error(kdk_obj.error_msg)
self._exit()
logging.info("KDK checksum validation passed")
logging.info("Mounting KDK")
if not Path(self.constants.kdk_download_path).exists():
logging.error("KDK download path does not exist")
self._exit()
return
self.kdk_install_result = False
def _install_kdk_thread():
@@ -121,10 +177,31 @@ class OSUpdateFrame(wx.Frame):
if self.kdk_install_result is False:
logging.info("Failed to install KDK")
self._exit()
return
logging.info("KDK installed successfully")
self._exit()
def _handle_metallib(self, metallib_obj: metallib_handler.MetalLibraryObject) -> None:
"""
Handle Metallib installation
"""
self.metallib_install_result = False
def _install_metallib_thread():
self.metallib_install_result = metallib_obj.install_metallib()
metallib_install_thread = threading.Thread(target=_install_metallib_thread)
metallib_install_thread.start()
while metallib_install_thread.is_alive():
wx.Yield()
if self.metallib_install_result is False:
logging.info("Failed to install Metallib")
return
logging.info("Metallib installed successfully")
def _generate_ui(self) -> None:
@@ -179,7 +256,8 @@ class OSUpdateFrame(wx.Frame):
result = dlg.ShowModal()
if result == wx.ID_NO:
logging.info("User cancelled OS caching")
self.kdk_download_obj.stop()
if hasattr(self, "download_obj"):
self.download_obj.stop()
self.did_cancel = 1
else:
self.did_cancel = 0

4
opencore_legacy_patcher/wx_gui/gui_entry.py
View File

@@ -12,7 +12,7 @@ from Cocoa import NSApp, NSApplication
from .. import constants
from ..sys_patch.detections import DetectRootPatch
from ..sys_patch.patchsets import HardwarePatchsetDetection
from ..wx_gui import (
gui_cache_os_update,
@@ -64,7 +64,7 @@ class EntryPoint:
if "--gui_patch" in sys.argv or "--gui_unpatch" in sys.argv or start_patching is True :
entry = gui_sys_patch_start.SysPatchStartFrame
patches = DetectRootPatch(self.constants.computer.real_model, self.constants).detect_patch_set()
patches = HardwarePatchsetDetection(constants=self.constants).device_properties
logging.info(f"Entry point set: {entry.__name__}")

16
opencore_legacy_patcher/wx_gui/gui_sys_patch_display.py
View File

@@ -11,7 +11,7 @@ from pathlib import Path
from .. import constants
from ..sys_patch.detections import DetectRootPatch
from ..sys_patch.patchsets import HardwarePatchsetDetection, HardwarePatchsetValidation
from ..wx_gui import (
gui_main_menu,
@@ -86,7 +86,7 @@ class SysPatchDisplayFrame(wx.Frame):
patches: dict = {}
def _fetch_patches(self) -> None:
nonlocal patches
patches = DetectRootPatch(self.constants.computer.real_model, self.constants).detect_patch_set()
patches = HardwarePatchsetDetection(constants=self.constants).device_properties
thread = threading.Thread(target=_fetch_patches, args=(self,))
thread.start()
@@ -106,7 +106,7 @@ class SysPatchDisplayFrame(wx.Frame):
available_label.Centre(wx.HORIZONTAL)
can_unpatch: bool = patches["Validation: Unpatching Possible"]
can_unpatch: bool = patches[HardwarePatchsetValidation.UNPATCHING_NOT_POSSIBLE]
if not any(not patch.startswith("Settings") and not patch.startswith("Validation") and patches[patch] is True for patch in patches):
logging.info("No applicable patches available")
@@ -152,7 +152,7 @@ class SysPatchDisplayFrame(wx.Frame):
patch_label.SetLabel(patch_label.GetLabel().replace("-", ""))
patch_label.Centre(wx.HORIZONTAL)
if patches["Validation: Patching Possible"] is False:
if patches[HardwarePatchsetValidation.PATCHING_NOT_POSSIBLE] is True:
# Cannot patch due to the following reasons:
patch_label = wx.StaticText(frame, label="Cannot patch due to the following reasons:", pos=(-1, patch_label.GetPosition()[1] + 25))
patch_label.SetFont(gui_support.font_factory(13, wx.FONTWEIGHT_BOLD))
@@ -164,7 +164,7 @@ class SysPatchDisplayFrame(wx.Frame):
continue
if patches[patch] is False:
continue
if patch == "Validation: Unpatching Possible":
if patch in [HardwarePatchsetValidation.PATCHING_NOT_POSSIBLE, HardwarePatchsetValidation.UNPATCHING_NOT_POSSIBLE]:
continue
if len(patch) > len(longest_patch):
@@ -180,7 +180,7 @@ class SysPatchDisplayFrame(wx.Frame):
continue
if patches[patch] is False:
continue
if patch == "Validation: Unpatching Possible":
if patch in [HardwarePatchsetValidation.PATCHING_NOT_POSSIBLE, HardwarePatchsetValidation.UNPATCHING_NOT_POSSIBLE]:
continue
patch_label = wx.StaticText(frame, label=f"- {patch.split('Validation: ')[1]}", pos=(anchor.GetPosition()[0], anchor.GetPosition()[1] + i))
@@ -231,7 +231,7 @@ class SysPatchDisplayFrame(wx.Frame):
start_button.Disable()
else:
self.available_patches = True
if patches["Validation: Patching Possible"] is False:
if patches[HardwarePatchsetValidation.PATCHING_NOT_POSSIBLE] is True:
start_button.Disable()
elif no_new_patches is False:
start_button.SetDefault()
@@ -320,7 +320,7 @@ class SysPatchDisplayFrame(wx.Frame):
for patch in patches:
if (not patch.startswith("Settings") and not patch.startswith("Validation") and patches[patch] is True):
# Patches should share the same name as the plist key
# See sys_patch_dict.py for more info
# See sys_patch/patchsets/base.py for more info
patch_installed = False
for key in oclp_plist_data:
if isinstance(oclp_plist_data[key], (bool, int)):

10
opencore_legacy_patcher/wx_gui/gui_sys_patch_start.py
View File

@@ -30,7 +30,7 @@ from ..wx_gui import (
gui_download,
)
from ..sys_patch.detections import DetectRootPatch
from ..sys_patch.patchsets import HardwarePatchsetDetection, HardwarePatchsetSettings
@@ -54,7 +54,7 @@ class SysPatchStartFrame(wx.Frame):
self.Centre()
if self.patches == {}:
self.patches = DetectRootPatch(self.constants.computer.real_model, self.constants).detect_patch_set()
self.patches = HardwarePatchsetDetection(constants=self.constants).device_properties
def _kdk_download(self, frame: wx.Frame = None) -> bool:
@@ -315,11 +315,11 @@ class SysPatchStartFrame(wx.Frame):
while gui_support.PayloadMount(self.constants, self).is_unpack_finished() is False:
wx.Yield()
if self.patches["Settings: Kernel Debug Kit missing"] is True:
if self.patches[HardwarePatchsetSettings.KERNEL_DEBUG_KIT_REQUIRED] is True:
if self._kdk_download(self) is False:
sys.exit(1)
if self.patches["Settings: MetallibSupportPkg missing"] is True:
if self.patches[HardwarePatchsetSettings.METALLIB_SUPPORT_PKG_REQUIRED] is True:
if self._metallib_download(self) is False:
sys.exit(1)
@@ -459,7 +459,7 @@ class SysPatchStartFrame(wx.Frame):
for patch in patches:
if (not patch.startswith("Settings") and not patch.startswith("Validation") and patches[patch] is True):
# Patches should share the same name as the plist key
# See sys_patch_dict.py for more info
# See sys_patch/patchsets/base.py for more info
patch_installed = False
for key in oclp_plist_data:
if isinstance(oclp_plist_data[key], (bool, int)):