add current state I use of

https://github.com/nix-community/nixos-apple-silicon

zeta/apple-silicon-support/default.nix

@@ -0,0 +1,7 @@
+{ ... }:
+
+{
+  imports = [
+    ./modules/default.nix
+  ];
+}

zeta/apple-silicon-support/modules/boot-m1n1/default.nix

@@ -0,0 +1,55 @@
+{ config, pkgs, lib, ... }:
+let
+  pkgs' = config.hardware.asahi.pkgs;
+
+  bootM1n1 = pkgs'.m1n1.override {
+    isRelease = true;
+    withTools = false;
+    customLogo = config.boot.m1n1CustomLogo;
+  };
+
+  bootUBoot = pkgs'.uboot-asahi.override {
+    m1n1 = bootM1n1;
+  };
+
+  bootFiles = {
+    "m1n1/boot.bin" = pkgs.runCommand "boot.bin" {} ''
+      cat ${bootM1n1}/build/m1n1.bin > $out
+      cat ${config.boot.kernelPackages.kernel}/dtbs/apple/*.dtb >> $out
+      cat ${bootUBoot}/u-boot-nodtb.bin.gz >> $out
+      if [ -n "${config.boot.m1n1ExtraOptions}" ]; then
+        echo '${config.boot.m1n1ExtraOptions}' >> $out
+      fi
+    '';
+  };
+in {
+  config = lib.mkIf config.hardware.asahi.enable {
+    # install m1n1 with the boot loader
+    boot.loader.grub.extraFiles = bootFiles;
+    boot.loader.systemd-boot.extraFiles = bootFiles;
+
+    # ensure the installer has m1n1 in the image
+    system.extraDependencies = lib.mkForce [ bootM1n1 bootUBoot ];
+    system.build.m1n1 = bootFiles."m1n1/boot.bin";
+  };
+
+  options.boot = {
+    m1n1ExtraOptions = lib.mkOption {
+      type = lib.types.str;
+      default = "";
+      description = ''
+        Append extra options to the m1n1 boot binary. Might be useful for fixing
+        display problems on Mac minis.
+        https://github.com/AsahiLinux/m1n1/issues/159
+      '';
+    };
+
+    m1n1CustomLogo = lib.mkOption {
+      type = lib.types.nullOr lib.types.path;
+      default = null;
+      description = ''
+        Custom logo to build into m1n1. The path must point to a 256x256 PNG.
+      '';
+    };
+  };
+}

zeta/apple-silicon-support/modules/default.nix

@@ -0,0 +1,92 @@
+{ config, pkgs, lib, ... }:
+{
+  imports = [
+    ./kernel
+    ./mesa
+    ./peripheral-firmware
+    ./boot-m1n1
+    ./sound
+  ];
+
+  config = let
+      cfg = config.hardware.asahi;
+    in lib.mkIf cfg.enable {
+      nixpkgs.overlays = lib.mkBefore [ cfg.overlay ];
+
+      # patch systemd-boot to boot in Apple Silicon UEFI environment.
+      # This regression only appeared in systemd 256.7.
+      # see https://github.com/NixOS/nixpkgs/pull/355290
+      # and https://github.com/systemd/systemd/issues/35026
+      systemd.package = let
+        systemdBroken = (pkgs.systemd.version == "256.7");
+
+        systemdPatched = pkgs.systemd.overrideAttrs (old: {
+          patches = let
+            oldPatches = (old.patches or []);
+            # not sure why there are non-paths in there but oh well
+            patchNames = (builtins.map (p: if ((builtins.typeOf p) == "path") then builtins.baseNameOf p else "") oldPatches);
+            fixName = "0019-Revert-boot-Make-initrd_prepare-semantically-equival.patch";
+            alreadyPatched = builtins.elem fixName patchNames;
+          in oldPatches ++ lib.optionals (!alreadyPatched) [
+            (pkgs.fetchpatch {
+              url = "https://raw.githubusercontent.com/NixOS/nixpkgs/125e99477b0ac0a54b7cddc6c5a704821a3074c7/pkgs/os-specific/linux/systemd/${fixName}";
+              hash = "sha256-UW3DZiaykQUUNcGA5UFxN+/wgNSW3ufxDDCZ7emD16o=";
+            })
+          ];
+        });
+      in if systemdBroken then systemdPatched else pkgs.systemd;
+
+      hardware.asahi.pkgs =
+        if cfg.pkgsSystem != "aarch64-linux"
+        then
+          import (pkgs.path) {
+            crossSystem.system = "aarch64-linux";
+            localSystem.system = cfg.pkgsSystem;
+            overlays = [ cfg.overlay ];
+          }
+        else pkgs;
+    };
+
+  options.hardware.asahi = {
+    enable = lib.mkOption {
+      type = lib.types.bool;
+      default = true;
+      description = ''
+        Enable the basic Asahi Linux components, such as kernel and boot setup.
+      '';
+    };
+
+    pkgsSystem = lib.mkOption {
+      type = lib.types.str;
+      default = "aarch64-linux";
+      description = ''
+        System architecture that should be used to build the major Asahi
+        packages, if not the default aarch64-linux. This allows installing from
+        a cross-built ISO without rebuilding them during installation.
+      '';
+    };
+
+    pkgs = lib.mkOption {
+      type = lib.types.raw;
+      description = ''
+        Package set used to build the major Asahi packages. Defaults to the
+        ambient set if not cross-built, otherwise re-imports the ambient set
+        with the system defined by `hardware.asahi.pkgsSystem`.
+      '';
+    };
+
+    overlay = lib.mkOption {
+      type = lib.mkOptionType {
+        name = "nixpkgs-overlay";
+        description = "nixpkgs overlay";
+        check = lib.isFunction;
+        merge = lib.mergeOneOption;
+      };
+      default = import ../packages/overlay.nix;
+      defaultText = "overlay provided with the module";
+      description = ''
+        The nixpkgs overlay for asahi packages.
+      '';
+    };
+  };
+}

zeta/apple-silicon-support/modules/kernel/default.nix

@@ -0,0 +1,106 @@
+# the Asahi Linux kernel and options that must go along with it
+
+{ config, pkgs, lib, ... }:
+{
+  config = lib.mkIf config.hardware.asahi.enable {
+    boot.kernelPackages = let
+      pkgs' = config.hardware.asahi.pkgs;
+    in
+      pkgs'.linux-asahi.override {
+        _kernelPatches = config.boot.kernelPatches;
+        withRust = config.hardware.asahi.withRust;
+      };
+
+    # we definitely want to use CONFIG_ENERGY_MODEL, and
+    # schedutil is a prerequisite for using it
+    # source: https://www.kernel.org/doc/html/latest/scheduler/sched-energy.html
+    powerManagement.cpuFreqGovernor = lib.mkOverride 800 "schedutil";
+
+    boot.initrd.includeDefaultModules = false;
+    boot.initrd.availableKernelModules = [
+      # list of initrd modules stolen from
+      # https://github.com/AsahiLinux/asahi-scripts/blob/f461f080a1d2575ae4b82879b5624360db3cff8c/initcpio/install/asahi
+      "apple-mailbox"
+      "nvme_apple"
+      "pinctrl-apple-gpio"
+      "macsmc"
+      "macsmc-rtkit"
+      "i2c-pasemi-platform"
+      "tps6598x"
+      "apple-dart"
+      "dwc3"
+      "dwc3-of-simple"
+      "xhci-pci"
+      "pcie-apple"
+      "gpio_macsmc"
+      "phy-apple-atc"
+      "nvmem_apple_efuses"
+      "spi-apple"
+      "spi-hid-apple"
+      "spi-hid-apple-of"
+      "rtc-macsmc"
+      "simple-mfd-spmi"
+      "spmi-apple-controller"
+      "nvmem_spmi_mfd"
+      "apple-dockchannel"
+      "dockchannel-hid"
+      "apple-rtkit-helper"
+
+      # additional stuff necessary to boot off USB for the installer
+      # and if the initrd (i.e. stage 1) goes wrong
+      "usb-storage"
+      "xhci-plat-hcd"
+      "usbhid"
+      "hid_generic"
+    ];
+
+    boot.kernelParams = [
+      "earlycon"
+      "console=tty0"
+      "boot.shell_on_fail"
+      # Apple's SSDs are slow (~dozens of ms) at processing flush requests which
+      # slows down programs that make a lot of fsync calls. This parameter sets
+      # a delay in ms before actually flushing so that such requests can be
+      # coalesced. Be warned that increasing this parameter above zero (default
+      # is 1000) has the potential, though admittedly unlikely, risk of
+      # UNBOUNDED data corruption in case of power loss!!!! Don't even think
+      # about it on desktops!!
+      "nvme_apple.flush_interval=0"
+    ];
+
+    # U-Boot does not support EFI variables
+    boot.loader.efi.canTouchEfiVariables = lib.mkForce false;
+
+    # U-Boot does not support switching console mode
+    boot.loader.systemd-boot.consoleMode = "0";
+
+    # GRUB has to be installed as removable if the user chooses to use it
+    boot.loader.grub = lib.mkDefault {
+      efiSupport = true;
+      efiInstallAsRemovable = true;
+      device = "nodev";
+    };
+
+    # autosuspend was enabled as safe for the PCI SD card reader
+    # "Genesys Logic, Inc GL9755 SD Host Controller [17a0:9755] (rev 01)"
+    # by recent systemd versions, but this has a "negative interaction"
+    # with our kernel/SoC and causes random boot hangs. disable it!
+    services.udev.extraHwdb = ''
+      pci:v000017A0d00009755*
+        ID_AUTOSUSPEND=0
+    '';
+  };
+
+  imports = [
+    (lib.mkRemovedOptionModule [ "hardware" "asahi" "addEdgeKernelConfig" ]
+      "All edge kernel config options are now the default.")
+  ];
+
+  options.hardware.asahi.withRust = lib.mkOption {
+    type = lib.types.bool;
+    default = false;
+    description = ''
+      Build the Asahi Linux kernel with Rust support.
+    '';
+  };
+}

zeta/apple-silicon-support/modules/mesa/default.nix

@@ -0,0 +1,53 @@
+{ options, config, pkgs, lib, ... }:
+{
+  config = let
+    isMode = mode: (config.hardware.asahi.useExperimentalGPUDriver
+        && config.hardware.asahi.experimentalGPUInstallMode == mode);
+  in lib.mkIf config.hardware.asahi.enable (lib.mkMerge [
+    {
+      # required for proper DRM setup even without GPU driver
+      services.xserver.config = ''
+        Section "OutputClass"
+            Identifier "appledrm"
+            MatchDriver "apple"
+            Driver "modesetting"
+            Option "PrimaryGPU" "true"
+        EndSection
+      '';
+    }
+    (lib.mkIf config.hardware.asahi.useExperimentalGPUDriver {
+      # install the Asahi Mesa version
+      hardware.graphics.package = config.hardware.asahi.pkgs.mesa-asahi-edge;
+      # required for in-kernel GPU driver
+      hardware.asahi.withRust = true;
+    })
+  ]);
+
+  options.hardware.asahi.useExperimentalGPUDriver = lib.mkOption {
+    type = lib.types.bool;
+    default = false;
+    description = ''
+      Use the experimental Asahi Mesa GPU driver.
+
+      Do not report issues using this driver under NixOS to the Asahi project.
+    '';
+  };
+
+  # hopefully no longer used, should be deprecated eventually
+  options.hardware.asahi.experimentalGPUInstallMode = lib.mkOption {
+    type = lib.types.enum [ "driver" "replace" "overlay" ];
+    default = "replace";
+    description = ''
+      Mode to use to install the experimental GPU driver into the system.
+
+      driver: install only as a driver, do not replace system Mesa.
+        Causes issues with certain programs like Plasma Wayland.
+
+      replace (default): use replaceRuntimeDependencies to replace system Mesa with Asahi Mesa.
+        Does not work in pure evaluation context (i.e. in flakes by default).
+
+      overlay: overlay system Mesa with Asahi Mesa
+        Requires rebuilding the world.
+    '';
+  };
+}

zeta/apple-silicon-support/modules/peripheral-firmware/default.nix

@@ -0,0 +1,69 @@
+{ config, pkgs, lib, ... }:
+{
+  config = lib.mkIf config.hardware.asahi.enable {
+    assertions = lib.mkIf config.hardware.asahi.extractPeripheralFirmware [
+      { assertion = config.hardware.asahi.peripheralFirmwareDirectory != null;
+        message = ''
+          Asahi peripheral firmware extraction is enabled but the firmware
+          location appears incorrect.
+        '';
+      }
+    ];
+
+    hardware.firmware = let
+      pkgs' = config.hardware.asahi.pkgs;
+    in
+      lib.mkIf ((config.hardware.asahi.peripheralFirmwareDirectory != null)
+          && config.hardware.asahi.extractPeripheralFirmware) [
+        (pkgs.stdenv.mkDerivation {
+          name = "asahi-peripheral-firmware";
+
+          nativeBuildInputs = [ pkgs'.asahi-fwextract pkgs.cpio ];
+
+          buildCommand = ''
+            mkdir extracted
+            asahi-fwextract ${config.hardware.asahi.peripheralFirmwareDirectory} extracted
+
+            mkdir -p $out/lib/firmware
+            cat extracted/firmware.cpio | cpio -id --quiet --no-absolute-filenames
+            mv vendorfw/* $out/lib/firmware
+          '';
+        })
+      ];
+  };
+
+  options.hardware.asahi = {
+    extractPeripheralFirmware = lib.mkOption {
+      type = lib.types.bool;
+      default = true;
+      description = ''
+        Automatically extract the non-free non-redistributable peripheral
+        firmware necessary for features like Wi-Fi.
+      '';
+    };
+
+    peripheralFirmwareDirectory = lib.mkOption {
+      type = lib.types.nullOr lib.types.path;
+
+      default = lib.findFirst (path: builtins.pathExists (path + "/all_firmware.tar.gz")) null
+        [
+          # path when the system is operating normally
+          /boot/asahi
+          # path when the system is mounted in the installer
+          /mnt/boot/asahi
+        ];
+
+      description = ''
+        Path to the directory containing the non-free non-redistributable
+        peripheral firmware necessary for features like Wi-Fi. Ordinarily, this
+        will automatically point to the appropriate location on the ESP. Flake
+        users and those interested in maximum purity will want to copy those
+        files elsewhere and specify this manually.
+
+        Currently, this consists of the files `all-firmware.tar.gz` and
+        `kernelcache*`. The official Asahi Linux installer places these files
+        in the `asahi` directory of the EFI system partition when creating it.
+      '';
+    };
+  };
+}

zeta/apple-silicon-support/modules/sound/default.nix

@@ -0,0 +1,49 @@
+{ config, options, pkgs, lib, ... }:
+
+{
+  options.hardware.asahi = {
+    setupAsahiSound = lib.mkOption {
+      type = lib.types.bool;
+      default = config.hardware.asahi.enable;
+      description = ''
+        Set up the Asahi DSP components so that the speakers and headphone jack
+        work properly and safely.
+      '';
+    };
+  };
+
+  config = let
+    cfg = config.hardware.asahi;
+  in lib.mkIf (cfg.setupAsahiSound && cfg.enable) (lib.mkMerge [
+    {
+      # can't be used by Asahi sound infrastructure
+      services.pulseaudio.enable = false;
+      # enable pipewire to run real-time and avoid audible glitches
+      security.rtkit.enable = true;
+      # set up pipewire with the supported capabilities (instead of pulseaudio)
+      # and asahi-audio configs and plugins
+      services.pipewire = {
+        enable = true;
+        alsa.enable = true;
+        pulse.enable = true;
+
+        configPackages = [ pkgs.asahi-audio ];
+
+        wireplumber = {
+          enable = true;
+
+          configPackages = [ pkgs.asahi-audio ];
+        };
+      };
+
+      # set up enivronment so that UCM configs are used as well
+      environment.variables.ALSA_CONFIG_UCM2 = "${pkgs.alsa-ucm-conf-asahi}/share/alsa/ucm2";
+      systemd.user.services.pipewire.environment.ALSA_CONFIG_UCM2 = config.environment.variables.ALSA_CONFIG_UCM2;
+      systemd.user.services.wireplumber.environment.ALSA_CONFIG_UCM2 = config.environment.variables.ALSA_CONFIG_UCM2;
+
+      # enable speakersafetyd to protect speakers
+      systemd.packages = [ pkgs.speakersafetyd ];
+      services.udev.packages = [ pkgs.speakersafetyd ];
+    }
+  ]);
+}

zeta/apple-silicon-support/packages/alsa-ucm-conf-asahi/default.nix

@@ -0,0 +1,22 @@
+{ lib
+, fetchFromGitHub
+, alsa-ucm-conf
+}:
+
+(alsa-ucm-conf.overrideAttrs (oldAttrs: let
+  versionAsahi = "8";
+
+  srcAsahi = fetchFromGitHub {
+    # tracking: https://src.fedoraproject.org/rpms/alsa-ucm-asahi
+    owner = "AsahiLinux";
+    repo = "alsa-ucm-conf-asahi";
+    rev = "v${versionAsahi}";
+    hash = "sha256-FPrAzscc1ICSCQSqULaGLqG4UCq8GZU9XLV7TUSBBRM=";
+  };
+in {
+  name = "${oldAttrs.pname}-${oldAttrs.version}-asahi-${versionAsahi}";
+
+  postInstall = oldAttrs.postInstall or "" + ''
+    cp -r ${srcAsahi}/ucm2 $out/share/alsa
+  '';
+}))

zeta/apple-silicon-support/packages/asahi-audio/default.nix

@@ -0,0 +1,46 @@
+{ stdenv
+, lib
+, fetchFromGitHub
+, lsp-plugins
+, bankstown-lv2
+, triforce-lv2
+}:
+
+stdenv.mkDerivation rec {
+  pname = "asahi-audio";
+  # tracking: https://src.fedoraproject.org/rpms/asahi-audio
+  version = "3.3";
+
+  src = fetchFromGitHub {
+    owner = "AsahiLinux";
+    repo = "asahi-audio";
+    rev = "v${version}";
+    hash = "sha256-p0M1pPxov+wSLT2F4G6y5NZpCXzbjZkzle+75zQ4xxU=";
+  };
+
+  preBuild = ''
+    export PREFIX=$out
+
+    readarray -t configs < <(\
+          find . \
+                -name '*.conf' -or \
+                -name '*.json' -or \
+                -name '*.lua'
+    )
+
+    substituteInPlace "''${configs[@]}" --replace \
+          "/usr/share/asahi-audio" \
+          "$out/asahi-audio"
+  '';
+
+  postInstall = ''
+    # no need to link the asahi-audio dir globally
+    mv $out/share/asahi-audio $out
+  '';
+
+  passthru.requiredLv2Packages = [
+    lsp-plugins
+    bankstown-lv2
+    triforce-lv2
+  ];
+}

zeta/apple-silicon-support/packages/asahi-fwextract/default.nix

@@ -0,0 +1,32 @@
+{ lib
+, python3
+, fetchFromGitHub
+, gzip
+, gnutar
+, lzfse
+}:
+
+python3.pkgs.buildPythonApplication rec {
+  pname = "asahi-fwextract";
+  version = "0.7.8";
+
+  # tracking version: https://packages.fedoraproject.org/pkgs/asahi-installer/python3-asahi_firmware/
+  src = fetchFromGitHub {
+    owner = "AsahiLinux";
+    repo = "asahi-installer";
+    rev = "v${version}";
+    hash = "sha256-UmgHWKIRbcg9PK44YPPM4tyuEDC0+ANKO3Mzc4N9RHo=";
+  };
+
+  postPatch = ''
+    substituteInPlace asahi_firmware/img4.py \
+      --replace 'liblzfse.so' '${lzfse}/lib/liblzfse.so'
+    substituteInPlace asahi_firmware/update.py \
+      --replace '"tar"' '"${gnutar}/bin/tar"' \
+      --replace '"xf"' '"-x", "-I", "${gzip}/bin/gzip", "-f"'
+  '';
+
+  nativeBuildInputs = [ python3.pkgs.setuptools ];
+
+  doCheck = false;
+}

zeta/apple-silicon-support/packages/linux-asahi/default.nix

@@ -0,0 +1,104 @@
+{ lib
+, callPackage
+, writeText
+, linuxPackagesFor
+, withRust ? true
+, _kernelPatches ? [ ]
+}:
+
+let
+  i = builtins.elemAt;
+
+  # parse <OPT> [ymn]|foo style configuration as found in a patch's extraConfig
+  # into a list of k, v tuples
+  parseExtraConfig = config:
+    let
+      lines =
+        builtins.filter (s: s != "") (lib.strings.splitString "\n" config);
+      parseLine = line: let
+        t = lib.strings.splitString " " line;
+        join = l: builtins.foldl' (a: b: "${a} ${b}")
+          (builtins.head l) (builtins.tail l);
+        v = if (builtins.length t) > 2 then join (builtins.tail t) else (i t 1);
+      in [ "CONFIG_${i t 0}" v ];
+    in map parseLine lines;
+
+  # parse <OPT>=lib.kernel.(yes|module|no)|lib.kernel.freeform "foo"
+  # style configuration as found in a patch's extraStructuredConfig into
+  # a list of k, v tuples
+  parseExtraStructuredConfig = config: lib.attrsets.mapAttrsToList
+    (k: v: [ "CONFIG_${k}" (v.tristate or v.freeform) ] ) config;
+
+  parsePatchConfig = { extraConfig ? "", extraStructuredConfig ? {}, ... }:
+    (parseExtraConfig extraConfig) ++
+    (parseExtraStructuredConfig extraStructuredConfig);
+
+  # parse CONFIG_<OPT>=[ymn]|"foo" style configuration as found in a config file
+  # into a list of k, v tuples
+  parseConfig = config:
+    let
+      parseLine = builtins.match ''(CONFIG_[[:upper:][:digit:]_]+)=(([ymn])|"([^"]*)")'';
+      # get either the [ymn] option or the "foo" option; whichever matched
+      t = l: let v = (i l 2); in [ (i l 0) (if v != null then v else (i l 3)) ];
+      lines = lib.strings.splitString "\n" config;
+    in map t (builtins.filter (l: l != null) (map parseLine lines));
+
+  origConfigfile = ./config;
+
+  linux-asahi-pkg = { stdenv, lib, fetchFromGitHub, fetchpatch, linuxKernel,
+      rustc, rust-bindgen, ... } @ args:
+    let
+      origConfigText = builtins.readFile origConfigfile;
+
+      # extraConfig from all patches in order
+      extraConfig =
+        lib.fold (patch: ex: ex ++ (parsePatchConfig patch)) [] _kernelPatches
+        ++ (lib.optional withRust [ "CONFIG_RUST" "y" ]);
+      # config file text for above
+      extraConfigText = let
+        text = k: v: if (v == "y") || (v == "m") || (v == "n")
+          then "${k}=${v}" else ''${k}="${v}"'';
+      in (map (t: text (i t 0) (i t 1)) extraConfig);
+
+      # final config as a text file path
+      configfile = if extraConfig == [] then origConfigfile else
+        writeText "config" ''
+          ${origConfigText}
+
+          # Patches
+          ${lib.strings.concatStringsSep "\n" extraConfigText}
+        '';
+      # final config as an attrset
+      configAttrs = let
+        makePair = t: lib.nameValuePair (i t 0) (i t 1);
+        configList = (parseConfig origConfigText) ++ extraConfig;
+      in builtins.listToAttrs (map makePair (lib.lists.reverseList configList));
+
+      # used to fix issues when nixpkgs gets ahead of the kernel
+      rustAtLeast = version: withRust && (lib.versionAtLeast rustc.version version);
+      bindgenAtLeast = version: withRust && (lib.versionAtLeast rust-bindgen.unwrapped.version version);
+    in
+    linuxKernel.manualConfig rec {
+      inherit stdenv lib;
+
+      version = "6.14.8-asahi";
+      modDirVersion = version;
+      extraMeta.branch = "6.14";
+
+      src = fetchFromGitHub {
+        # tracking: https://github.com/AsahiLinux/linux/tree/asahi-wip (w/ fedora verification)
+        owner = "AsahiLinux";
+        repo = "linux";
+        rev = "asahi-6.14.8-1";
+        hash = "sha256-JrWVw1FiF9LYMiOPm0QI0bg/CrZAMSSVcs4AWNDIH3Q=";
+      };
+
+      kernelPatches = [
+      ] ++ _kernelPatches;
+
+      inherit configfile;
+      config = configAttrs;
+    };
+
+  linux-asahi = (callPackage linux-asahi-pkg { });
+in lib.recurseIntoAttrs (linuxPackagesFor linux-asahi)

zeta/apple-silicon-support/packages/m1n1/default.nix

@@ -0,0 +1,110 @@
+{ stdenv
+, buildPackages
+, lib
+, fetchFromGitHub
+, python3
+, dtc
+, imagemagick
+, isRelease ? false
+, withTools ? true
+, withChainloading ? false
+, customLogo ? null
+}:
+
+let
+  pyenv = python3.withPackages (p: with p; [
+    construct
+    pyserial
+  ]);
+
+  stdenvOpts = {
+    targetPlatform.system = "aarch64-none-elf";
+    targetPlatform.rust.rustcTarget = "${stdenv.hostPlatform.parsed.cpu.name}-unknown-none-softfloat";
+    targetPlatform.rust.rustcTargetSpec = "${stdenv.hostPlatform.parsed.cpu.name}-unknown-none-softfloat";
+  };
+  rust = buildPackages.rust.override {
+    stdenv = lib.recursiveUpdate buildPackages.stdenv stdenvOpts;
+  };
+  rustPackages = rust.packages.stable.overrideScope (f: p: {
+    rustc-unwrapped = p.rustc-unwrapped.override {
+      stdenv = lib.recursiveUpdate p.rustc-unwrapped.stdenv stdenvOpts;
+    };
+  });
+  rustPlatform = buildPackages.makeRustPlatform rustPackages;
+
+in stdenv.mkDerivation rec {
+  pname = "m1n1";
+  version = "1.4.21";
+
+  src = fetchFromGitHub {
+    # tracking: https://src.fedoraproject.org/rpms/m1n1
+    owner = "AsahiLinux";
+    repo = "m1n1";
+    rev = "v${version}";
+    hash = "sha256-PEjTaSwcsV8PzM9a3rDWMYXGX9FlrM0oeElrP5HYRPg=";
+    fetchSubmodules = true;
+  };
+  cargoVendorDir = ".";
+
+  makeFlags = [ "ARCH=${stdenv.cc.targetPrefix}" ]
+    ++ lib.optional isRelease "RELEASE=1"
+    ++ lib.optional withChainloading "CHAINLOADING=1";
+
+  nativeBuildInputs = [
+    dtc
+  ] ++ lib.optionals withChainloading [rustPackages.rustc rustPackages.cargo rustPlatform.cargoSetupHook]
+    ++ lib.optional (customLogo != null) imagemagick;
+
+  postPatch = ''
+    substituteInPlace proxyclient/m1n1/asm.py \
+      --replace 'aarch64-linux-gnu-' 'aarch64-unknown-linux-gnu-' \
+      --replace 'TOOLCHAIN = ""' 'TOOLCHAIN = "'$out'/toolchain-bin/"'
+  '';
+
+  preConfigure = lib.optionalString (customLogo != null) ''
+    pushd data &>/dev/null
+    ln -fs ${customLogo} bootlogo_256.png
+    if [[ "$(magick identify bootlogo_256.png)" != 'bootlogo_256.png PNG 256x256'* ]]; then
+      echo "Custom logo is not a 256x256 PNG"
+      exit 1
+    fi
+
+    rm bootlogo_128.png
+    convert bootlogo_256.png -resize 128x128 bootlogo_128.png
+    patchShebangs --build ./makelogo.sh
+    ./makelogo.sh
+    popd &>/dev/null
+  '';
+
+  installPhase = ''
+    runHook preInstall
+
+    mkdir -p $out/build
+    cp build/m1n1.bin $out/build
+  '' + (lib.optionalString withTools ''
+    mkdir -p $out/{bin,script,toolchain-bin}
+    cp -r proxyclient $out/script
+    cp -r tools $out/script
+
+    for toolpath in $out/script/proxyclient/tools/*.py; do
+      tool=$(basename $toolpath .py)
+      script=$out/bin/m1n1-$tool
+      cat > $script <<EOF
+#!/bin/sh
+${pyenv}/bin/python $toolpath "\$@"
+EOF
+      chmod +x $script
+    done
+
+    GCC=${buildPackages.gcc}
+    BINUTILS=${buildPackages.binutils-unwrapped}
+
+    ln -s $GCC/bin/${stdenv.cc.targetPrefix}gcc $out/toolchain-bin/
+    ln -s $GCC/bin/${stdenv.cc.targetPrefix}ld $out/toolchain-bin/
+    ln -s $BINUTILS/bin/${stdenv.cc.targetPrefix}objcopy $out/toolchain-bin/
+    ln -s $BINUTILS/bin/${stdenv.cc.targetPrefix}objdump $out/toolchain-bin/
+    ln -s $GCC/bin/${stdenv.cc.targetPrefix}nm $out/toolchain-bin/
+  '') + ''
+    runHook postInstall
+  '';
+}

zeta/apple-silicon-support/packages/mesa-asahi-edge/default.nix

@@ -0,0 +1,48 @@
+{ lib
+, fetchFromGitLab
+, mesa
+}:
+
+(mesa.override {
+  galliumDrivers = [ "softpipe" "llvmpipe" "asahi" ];
+  vulkanDrivers = [ "swrast" "asahi" ];
+}).overrideAttrs (oldAttrs: {
+  version = "25.1.0-asahi";
+  src = fetchFromGitLab {
+    # tracking: https://pagure.io/fedora-asahi/mesa/commits/asahi
+    domain = "gitlab.freedesktop.org";
+    owner = "asahi";
+    repo = "mesa";
+    tag = "asahi-20250425";
+    hash = "sha256-3c3uewzKv5wL9BRwaVL4E3FnyA04veQwAPxfHiL7wII=";
+  };
+
+  mesonFlags =
+    let
+      badFlags = [
+        "-Dinstall-mesa-clc"
+        "-Dgallium-nine"
+        "-Dtools"
+      ];
+      isBadFlagList = f: builtins.map (b: lib.hasPrefix b f) badFlags;
+      isGoodFlag = f: !(builtins.foldl' (x: y: x || y) false (isBadFlagList f));
+    in
+    (builtins.filter isGoodFlag oldAttrs.mesonFlags) ++ [
+      # we do not build any graphics drivers these features can be enabled for
+      "-Dgallium-va=disabled"
+      "-Dgallium-vdpau=disabled"
+      "-Dgallium-xa=disabled"
+      "-Dtools=asahi"
+    ];
+
+  # replace patches with ones tweaked slightly to apply to this version
+  patches = [
+    ./opencl.patch
+  ];
+
+  postInstall = (oldAttrs.postInstall or "") + ''
+    # we don't build anything to go in this output but it needs to exist
+    touch $spirv2dxil
+    touch $cross_tools
+  '';
+})

zeta/apple-silicon-support/packages/mesa-asahi-edge/opencl.patch

@@ -0,0 +1,54 @@
+diff --git a/meson.build b/meson.build
+index 07991a6..4c875b9 100644
+--- a/meson.build
++++ b/meson.build
+@@ -1900,7 +1900,7 @@ endif
+
+ dep_clang = null_dep
+ if with_clc or with_gallium_clover
+-  llvm_libdir = dep_llvm.get_variable(cmake : 'LLVM_LIBRARY_DIR', configtool: 'libdir')
++  llvm_libdir = get_option('clang-libdir')
+
+   dep_clang = cpp.find_library('clang-cpp', dirs : llvm_libdir, required : false)
+
+diff --git a/meson.options b/meson.options
+index 84e0f20..38ea92c 100644
+--- a/meson.options
++++ b/meson.options
+@@ -795,3 +795,10 @@ option(
+   value : false,
+   description : 'Install the drivers internal shader compilers (if needed for cross builds).'
+ )
++
++option(
++  'clang-libdir',
++  type : 'string',
++  value : '',
++  description : 'Locations to search for clang libraries.'
++)
+diff --git a/src/gallium/targets/opencl/meson.build b/src/gallium/targets/opencl/meson.build
+index ab2c835..a59e88e 100644
+--- a/src/gallium/targets/opencl/meson.build
++++ b/src/gallium/targets/opencl/meson.build
+@@ -56,7 +56,7 @@ if with_opencl_icd
+     configuration : _config,
+     input : 'mesa.icd.in',
+     output : 'mesa.icd',
+-    install : true,
++    install : false,
+     install_tag : 'runtime',
+     install_dir : join_paths(get_option('sysconfdir'), 'OpenCL', 'vendors'),
+   )
+diff --git a/src/gallium/targets/rusticl/meson.build b/src/gallium/targets/rusticl/meson.build
+index 2b214ad..7f91939 100644
+--- a/src/gallium/targets/rusticl/meson.build
++++ b/src/gallium/targets/rusticl/meson.build
+@@ -64,7 +64,7 @@ configure_file(
+   configuration : _config,
+   input : 'rusticl.icd.in',
+   output : 'rusticl.icd',
+-  install : true,
++  install : false,
+   install_tag : 'runtime',
+   install_dir : join_paths(get_option('sysconfdir'), 'OpenCL', 'vendors'),
+ )

zeta/apple-silicon-support/packages/overlay.nix

@@ -0,0 +1,9 @@
+final: prev: {
+  linux-asahi = final.callPackage ./linux-asahi { };
+  m1n1 = final.callPackage ./m1n1 { };
+  uboot-asahi = final.callPackage ./uboot-asahi { };
+  asahi-fwextract = final.callPackage ./asahi-fwextract { };
+  mesa-asahi-edge = final.callPackage ./mesa-asahi-edge { };
+  alsa-ucm-conf-asahi = final.callPackage ./alsa-ucm-conf-asahi { inherit (prev) alsa-ucm-conf; };
+  asahi-audio = final.callPackage ./asahi-audio { };
+}

zeta/apple-silicon-support/packages/uboot-asahi/default.nix

@@ -0,0 +1,44 @@
+{ lib
+, fetchFromGitHub
+, buildUBoot
+, m1n1
+}:
+
+(buildUBoot rec {
+  src = fetchFromGitHub {
+    # tracking: https://pagure.io/fedora-asahi/uboot-tools/commits/main
+    owner = "AsahiLinux";
+    repo = "u-boot";
+    rev = "asahi-v2025.04-1";
+    hash = "sha256-/z37qj26AqsyEBsFT6UEN3GjG6KVsoJOoUB4s9BRDbE=";
+  };
+  version = "2025.04-1-asahi";
+
+  defconfig = "apple_m1_defconfig";
+  extraMeta.platforms = [ "aarch64-linux" ];
+  filesToInstall = [
+    "u-boot-nodtb.bin.gz"
+    "m1n1-u-boot.bin"
+  ];
+  extraConfig = ''
+    CONFIG_IDENT_STRING=" ${version}"
+    CONFIG_VIDEO_FONT_4X6=n
+    CONFIG_VIDEO_FONT_8X16=n
+    CONFIG_VIDEO_FONT_SUN12X22=n
+    CONFIG_VIDEO_FONT_16X32=y
+    CONFIG_CMD_BOOTMENU=y
+  '';
+}).overrideAttrs (o: {
+  # nixos's downstream patches are not applicable
+  patches = [ 
+  ];
+
+  # DTC= flag somehow breaks DTC compilation so we remove it
+  makeFlags = builtins.filter (s: (!(lib.strings.hasPrefix "DTC=" s))) o.makeFlags;
+
+  preInstall = ''
+    # compress so that m1n1 knows U-Boot's size and can find things after it
+    gzip -n u-boot-nodtb.bin
+    cat ${m1n1}/build/m1n1.bin arch/arm/dts/t[68]*.dtb u-boot-nodtb.bin.gz > m1n1-u-boot.bin
+  '';
+})