{
  inputs =
    {
      nixpkgs.url = "github:nixos/nixpkgs/nixos-23.11";

      get-flake.url = "github:ursi/get-flake";

      disko.inputs.nixpkgs.follows = "nixpkgs";

      mobile-nixos.url = "github:NixOS/mobile-nixos";
      mobile-nixos.flake = false;

      # see https://github.com/jhovold/linux/wiki/X13s for status updates
      linux_x13s.url = "github:jhovold/linux/wip/sc8280xp-v6.7";
      linux_x13s.flake = false;

      brainwart_x13s-nixos = {
        url = "github:BrainWart/x13s-nixos/flake";
        flake = false;
      };

      acamcstephens_stop-export = {
        flake = false;
        url = "git+https://codeberg.org/adamcstephens/stop-export.git";
      };


      alsa-ucm-conf = {
        flake = false;
        url = "github:alsa-project/alsa-ucm-conf/e87dde51d68950537f92af955ad0633437cc419a";
      };
    };

  outputs =
    { self
    , get-flake
    , nixpkgs
    , ...
    }:
    let
      targetPlatform = "aarch64-linux";
      buildPlatform = "x86_64-linux";
      nodeName = "steveej-x13s-rmvbl";

      mkNixosConfiguration = { extraModules ? [ ], ... } @ attrs:
        nixpkgs.lib.nixosSystem (
          nixpkgs.lib.attrsets.recursiveUpdate
            attrs
            {
              specialArgs = (import ./default.nix {
                system = targetPlatform;
                inherit nodeName;

                repoFlake = get-flake ../../../..;
                nodeFlake = self;
              }).meta.nodeSpecialArgs.${nodeName};

              modules =
                [
                  self.nixosModules.hardware-x13s

                  ./configuration.nix

                  # flake registry
                  {
                    nix.registry.nixpkgs.flake = nixpkgs;
                  }
                ]
                ++ extraModules;
            }
        );
    in
    {
      nixosConfigurations = {
        native = mkNixosConfiguration {
          system = targetPlatform;
        };

        cross = mkNixosConfiguration {
          extraModules = [
            {
              nixpkgs.buildPlatform.system = buildPlatform;
              nixpkgs.hostPlatform.system = targetPlatform;
            }
          ];
        };
      };

      nixosModules.hardware-x13s = { pkgs, config, lib, options, ... }:
        let
          # TODO: introduce options for these
          kernelPdMapper = true;
        in
        {
          config =
            let
              inherit (config.boot.loader) efi;
              kp = [
                {
                  name = "x13s-cfg";
                  patch = null;
                  extraStructuredConfig = with lib.kernel; {
                    EFI_ARMSTUB_DTB_LOADER = lib.mkForce yes;
                    OF_OVERLAY = lib.mkForce yes;
                    BTRFS_FS = lib.mkForce yes;
                    BTRFS_FS_POSIX_ACL = lib.mkForce yes;
                    MEDIA_CONTROLLER = lib.mkForce yes;
                    SND_USB_AUDIO_USE_MEDIA_CONTROLLER = lib.mkForce yes;
                    SND_USB = lib.mkForce yes;
                    SND_USB_AUDIO = lib.mkForce module;
                    USB_XHCI_PCI = lib.mkForce module;
                    NO_HZ_FULL = lib.mkForce yes;
                    HZ_100 = lib.mkForce yes;
                    HZ_250 = lib.mkForce no;
                    DRM_AMDGPU = lib.mkForce no;
                    DRM_NOUVEAU = lib.mkForce no;
                    QCOM_TSENS = lib.mkForce yes;
                    NVMEM_QCOM_QFPROM = lib.mkForce yes;
                    ARM_QCOM_CPUFREQ_NVMEM = lib.mkForce yes;
                  } // lib.optionalAttrs kernelPdMapper {
                    QCOM_PD_MAPPER = lib.mkForce yes;
                    QRTR = lib.mkForce yes;
                  };
                }
              ];

              # We can't quite move to mainline linux
              linux_x13s_pkg = { buildLinux, ... } @ args:
                buildLinux (args // rec {
                  version = "6.7.0";
                  modDirVersion = lib.versions.pad 3 version;
                  extraMeta.branch = lib.versions.majorMinor version;

                  src = self.inputs.linux_x13s;
                  kernelPatches = (args.kernelPatches or [ ]) ++ kp;
                } // (args.argsOverride or { }));

              # we add additional configuration on top of te normal configuration above
              # using the extraStructuredConfig option on the kernel patch
              linux_x13s = pkgs.callPackage linux_x13s_pkg {
                defconfig = "johan_defconfig";
              };

              linuxPackages_x13s = pkgs.linuxPackagesFor linux_x13s;
              dtb = "${linuxPackages_x13s.kernel}/dtbs/qcom/sc8280xp-lenovo-thinkpad-x13s.dtb";

              dtbName = "x13s63rc4.dtb";

              x13_firmware = { stdenvNoCC, fetchFromGitHub }:
                stdenvNoCC.mkDerivation {
                  pname = "x13s-extra-firmware";
                  version = "1.0.0";

                  src = fetchFromGitHub {
                    owner = "ironrobin";
                    repo = "x13s-alarm";
                    rev = "efa51c3b519f75b3983aef67855b1561d9828771";
                    sha256 = "sha256-weETbWXz9aL2pDQDKk7fkb1ecQH0qrhUYDs2E5EiJcI=";
                  };

                  dontFixup = true;
                  dontBuild = true;

                  installPhase = ''
                    mkdir -p $out/lib/firmware/qcom/sc8280xp/LENOVO/21BX
                    cp x13s-firmware/qcvss8280.mbn $out/lib/firmware/qcom/sc8280xp/LENOVO/21BX/
                  '';
                };

            in
            {
              nixpkgs.overlays = [
                (final: prev:
                  {
                    qrtr = final.callPackage "${self.inputs.acamcstephens_stop-export}/hardware/x13s/qrtr/qrtr.nix" { };
                    pd-mapper = final.callPackage "${self.inputs.acamcstephens_stop-export}/hardware/x13s/qrtr/pd-mapper.nix" {
                      inherit (final) qrtr;
                    };

                    x13s_alsa-ucm-conf = prev.alsa-ucm-conf.overrideAttrs (prev: {
                      src = self.inputs.alsa-ucm-conf;
                    });
                  }
                )
              ];

              boot = {
                loader.systemd-boot.enable = true;
                loader.systemd-boot.extraFiles = {
                  "${dtbName}" = dtb;
                };
                loader.efi.canTouchEfiVariables = false;
                loader.efi.efiSysMountPoint = "/boot";

                blacklistedKernelModules = [ "wwan" ];

                kernelPackages = linuxPackages_x13s;

                kernelParams = [
                  "dtb=${dtbName}"

                  "boot.shell_on_fail"

                  # jhovold recommended
                  "efi=noruntime"
                  "clk_ignore_unused"
                  "pd_ignore_unused"
                  "arm64.nopauth"

                  # blacklist graphics in initrd so the firmware can load from disk
                  "rd.driver.blacklist=msm"
                ];

                initrd = {
                  includeDefaultModules = false;
                  availableKernelModules = [
                    "i2c_hid"
                    "i2c_hid_of"
                    "i2c_qcom_geni"
                    "leds_qcom_lpg"
                    "pwm_bl"
                    "qrtr"
                    "pmic_glink_altmode"
                    "gpio_sbu_mux"
                    "phy_qcom_qmp_combo"
                    "panel-edp"
                    "msm"
                    "phy_qcom_edp"
                    "i2c-core"
                    "i2c-hid"
                    "i2c-hid-of"
                    "i2c-qcom-geni"
                    "pcie-qcom"
                    "phy-qcom-qmp-combo"
                    "phy-qcom-qmp-pcie"
                    "phy-qcom-qmp-usb"
                    "phy-qcom-snps-femto-v2"
                    "phy-qcom-usb-hs"
                    "nvme"

                    "usbcore"
                    "xhci_hcd"
                    "usbhid"
                    "usb_storage"
                    # "xhci_pci"
                    "uas"
                  ];
                };
              };


              # default is performance
              powerManagement.cpuFreqGovernor = "ondemand";

              hardware.enableAllFirmware = true;
              hardware.firmware = [
                pkgs.linux-firmware

                (pkgs.callPackage x13_firmware { })
                (pkgs.callPackage "${self.inputs.brainwart_x13s-nixos}/pkgs/x13s-firmware.nix" { })
              ];

              systemd.services.pd-mapper = {
                wantedBy = [ "multi-user.target" ];

                serviceConfig = {
                  ExecStart = "${lib.getExe pkgs.pd-mapper}";
                  Restart = "always";
                };
              };

              # bind mount over existing alsa-ucm-conf
              # this is just config, but is in the critical path for lots of packages
              # systemd.services.x13s-alsa-conf = {
              #   wantedBy = [ "multi-user.target" ];

              #   serviceConfig = {
              #     Type = "oneshot";
              #     RemainAfterExit = true;

              #     ExecStart = "${pkgs.util-linux.mount}/bin/mount -o bind ${pkgs.x13s_alsa-ucm-conf}/share/alsa ${pkgs.alsa-ucm-conf}/share/alsa";
              #     ExecStop = "${pkgs.util-linux.mount}/bin/umount ${pkgs.alsa-ucm-conf}/share/alsa";
              #   };
              # };

              systemd.services.bluetooth = {
                serviceConfig = {
                  # disabled because btmgmt call hangs
                  # ExecStartPre = [
                  #   ""
                  #   "${pkgs.util-linux}/bin/rfkill block bluetooth"
                  #   "${pkgs.bluez5-experimental}/bin/btmgmt public-addr ${cfg.bluetoothMac}"
                  #   "${pkgs.util-linux}/bin/rfkill unblock bluetooth"
                  # ];
                  RestartSec = 5;
                  Restart = "on-failure";
                };
              };
            };
        };
    };
}