287 lines
10 KiB
Nix
287 lines
10 KiB
Nix
{
|
|
# # Nvidia informations.
|
|
# Version of the system kernel module. Let it to null to enable auto-detection.
|
|
nvidiaVersion ? null
|
|
, # Hash of the Nvidia driver .run file. null is fine, but fixing a value here
|
|
# will be more reproducible and more efficient.
|
|
nvidiaHash ? null
|
|
, # Alternatively, you can pass a path that points to a nvidia version file
|
|
# and let nixGL extract the version from it. That file must be a copy of
|
|
# /proc/driver/nvidia/version. Nix doesn't like zero-sized files (see
|
|
# https://github.com/NixOS/nix/issues/3539 ).
|
|
nvidiaVersionFile ? null
|
|
, # Enable 32 bits driver
|
|
# This is one by default, you can switch it to off if you want to reduce a
|
|
# bit the size of nixGL closure.
|
|
enable32bits ? true
|
|
, writeTextFile
|
|
, shellcheck
|
|
, pcre
|
|
, runCommand
|
|
, linuxPackages
|
|
, fetchurl
|
|
, lib
|
|
, runtimeShell
|
|
, bumblebee
|
|
, libglvnd
|
|
, vulkan-validation-layers
|
|
, mesa
|
|
, libvdpau-va-gl
|
|
, intel-media-driver
|
|
, vaapiIntel
|
|
, pkgsi686Linux
|
|
, driversi686Linux
|
|
, zlib
|
|
, libdrm
|
|
, xorg
|
|
, wayland
|
|
, gcc
|
|
}:
|
|
|
|
let
|
|
writeExecutable = { name, text }:
|
|
writeTextFile {
|
|
inherit name text;
|
|
|
|
executable = true;
|
|
destination = "/bin/${name}";
|
|
|
|
checkPhase = ''
|
|
${shellcheck}/bin/shellcheck "$out/bin/${name}"
|
|
|
|
# Check that all the files listed in the output binary exists
|
|
for i in $(${pcre}/bin/pcregrep -o0 '/nix/store/.*?/[^ ":]+' $out/bin/${name})
|
|
do
|
|
ls $i > /dev/null || (echo "File $i, referenced in $out/bin/${name} does not exists."; exit -1)
|
|
done
|
|
'';
|
|
};
|
|
top = rec {
|
|
/*
|
|
It contains the builder for different nvidia configuration, parametrized by
|
|
the version of the driver and sha256 sum of the driver installer file.
|
|
*/
|
|
nvidiaPackages = { version }:
|
|
let
|
|
nvidiaDrivers = (linuxPackages.nvidia_x11.override { }).overrideAttrs
|
|
(oldAttrs: {
|
|
pname = "nvidia";
|
|
name = "nvidia-x11-${version}-nixGL";
|
|
inherit version;
|
|
src =
|
|
let
|
|
url =
|
|
"https://download.nvidia.com/XFree86/Linux-x86_64/${version}/NVIDIA-Linux-x86_64-${version}.run";
|
|
in
|
|
fetchurl { inherit url sha256; };
|
|
useGLVND = true;
|
|
});
|
|
in
|
|
{
|
|
inherit nvidiaDrivers;
|
|
nvidiaLibsOnly = nvidiaDrivers.override {
|
|
libsOnly = true;
|
|
kernel = null;
|
|
};
|
|
|
|
nixGLNvidiaBumblebee = writeExecutable {
|
|
name = "nixGLNvidiaBumblebee-${version}";
|
|
text = ''
|
|
#!${runtimeShell}
|
|
export LD_LIBRARY_PATH=${
|
|
lib.makeLibraryPath [ nvidiaDrivers ]
|
|
}"''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
|
|
${
|
|
bumblebee.override {
|
|
nvidia_x11 = nvidiaDrivers;
|
|
nvidia_x11_i686 = nvidiaDrivers.lib32;
|
|
}
|
|
}/bin/optirun --ldpath ${
|
|
lib.makeLibraryPath ([ libglvnd nvidiaDrivers ]
|
|
++ lib.optionals enable32bits [
|
|
nvidiaDrivers.lib32
|
|
pkgsi686Linux.libglvnd
|
|
])
|
|
} "$@"
|
|
'';
|
|
};
|
|
|
|
# TODO: 32bit version? Not tested.
|
|
nixNvidiaWrapper = api:
|
|
writeExecutable {
|
|
name = "nix${api}Nvidia-${version}";
|
|
text = ''
|
|
#!${runtimeShell}
|
|
${lib.optionalString (api == "Vulkan")
|
|
"export VK_LAYER_PATH=${vulkan-validation-layers}/share/vulkan/explicit_layer.d"}
|
|
NVIDIA_JSON=(${nvidiaLibsOnly}/share/glvnd/egl_vendor.d/*nvidia.json)
|
|
${lib.optionalString enable32bits "NVIDIA_JSON32=(${nvidiaLibsOnly.lib32}/share/glvnd/egl_vendor.d/*nvidia.json)"}
|
|
|
|
${''export __EGL_VENDOR_LIBRARY_FILENAMES=''${NVIDIA_JSON[*]}${
|
|
lib.optionalString enable32bits
|
|
'':''${NVIDIA_JSON32[*]}''
|
|
}"''${__EGL_VENDOR_LIBRARY_FILENAMES:+:$__EGL_VENDOR_LIBRARY_FILENAMES}"''
|
|
}
|
|
|
|
${
|
|
lib.optionalString (api == "Vulkan")
|
|
''export VK_ICD_FILENAMES=${nvidiaLibsOnly}/share/vulkan/icd.d/nvidia_icd.json${
|
|
lib.optionalString enable32bits
|
|
":${nvidiaLibsOnly.lib32}/share/vulkan/icd.d/nvidia_icd.json"
|
|
}"''${VK_ICD_FILENAMES:+:$VK_ICD_FILENAMES}"''
|
|
}
|
|
export LD_LIBRARY_PATH=${
|
|
lib.makeLibraryPath ([ libglvnd nvidiaLibsOnly ]
|
|
++ lib.optional (api == "Vulkan") vulkan-validation-layers
|
|
++ lib.optionals enable32bits [
|
|
nvidiaLibsOnly.lib32
|
|
pkgsi686Linux.libglvnd
|
|
])
|
|
}"''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
|
|
exec "$@"
|
|
'';
|
|
};
|
|
|
|
# TODO: 32bit version? Not tested.
|
|
nixGLNvidia = nixNvidiaWrapper "GL";
|
|
|
|
# TODO: 32bit version? Not tested.
|
|
nixVulkanNvidia = nixNvidiaWrapper "Vulkan";
|
|
};
|
|
|
|
nixGLIntel = writeExecutable {
|
|
name = "nixGLIntel";
|
|
# add the 32 bits drivers if needed
|
|
text =
|
|
let
|
|
mesa-drivers = [ mesa.drivers ]
|
|
++ lib.optional enable32bits pkgsi686Linux.mesa.drivers;
|
|
intel-driver = [ intel-media-driver vaapiIntel ]
|
|
# Note: intel-media-driver is disabled for i686 until https://github.com/NixOS/nixpkgs/issues/140471 is fixed
|
|
++ lib.optionals enable32bits [ /* pkgsi686Linux.intel-media-driver */ driversi686Linux.vaapiIntel ];
|
|
libvdpau = [ libvdpau-va-gl ]
|
|
++ lib.optional enable32bits pkgsi686Linux.libvdpau-va-gl;
|
|
glxindirect = runCommand "mesa_glxindirect" { } (
|
|
''
|
|
mkdir -p $out/lib
|
|
ln -s ${mesa.drivers}/lib/libGLX_mesa.so.0 $out/lib/libGLX_indirect.so.0
|
|
''
|
|
);
|
|
in
|
|
''
|
|
#!${runtimeShell}
|
|
export LIBGL_DRIVERS_PATH=${lib.makeSearchPathOutput "lib" "lib/dri" mesa-drivers}
|
|
export LIBVA_DRIVERS_PATH=${lib.makeSearchPathOutput "out" "lib/dri" intel-driver}
|
|
${''export __EGL_VENDOR_LIBRARY_FILENAMES=${mesa.drivers}/share/glvnd/egl_vendor.d/50_mesa.json${
|
|
lib.optionalString enable32bits
|
|
":${pkgsi686Linux.mesa.drivers}/share/glvnd/egl_vendor.d/50_mesa.json"
|
|
}"''${__EGL_VENDOR_LIBRARY_FILENAMES:+:$__EGL_VENDOR_LIBRARY_FILENAMES}"''
|
|
}
|
|
export LD_LIBRARY_PATH=${lib.makeLibraryPath mesa-drivers}:${lib.makeSearchPathOutput "lib" "lib/vdpau" libvdpau}:${glxindirect}/lib:${lib.makeLibraryPath [libglvnd]}"''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
|
|
exec "$@"
|
|
'';
|
|
};
|
|
|
|
nixVulkanIntel = writeExecutable {
|
|
name = "nixVulkanIntel";
|
|
text =
|
|
let
|
|
# generate a file with the listing of all the icd files
|
|
icd = runCommand "mesa_icd" { } (
|
|
# 64 bits icd
|
|
''
|
|
ls ${mesa.drivers}/share/vulkan/icd.d/*.json > f
|
|
''
|
|
# 32 bits ones
|
|
+ lib.optionalString enable32bits ''
|
|
ls ${pkgsi686Linux.mesa.drivers}/share/vulkan/icd.d/*.json >> f
|
|
''
|
|
# concat everything as a one line string with ":" as seperator
|
|
+ ''cat f | xargs | sed "s/ /:/g" > $out''
|
|
);
|
|
in
|
|
''
|
|
#!${runtimeShell}
|
|
if [ -n "$LD_LIBRARY_PATH" ]; then
|
|
echo "Warning, nixVulkanIntel overwriting existing LD_LIBRARY_PATH" 1>&2
|
|
fi
|
|
export VK_LAYER_PATH=${vulkan-validation-layers}/share/vulkan/explicit_layer.d
|
|
ICDS=$(cat ${icd})
|
|
export VK_ICD_FILENAMES=$ICDS"''${VK_ICD_FILENAMES:+:$VK_ICD_FILENAMES}"
|
|
export LD_LIBRARY_PATH=${
|
|
lib.makeLibraryPath [
|
|
zlib
|
|
libdrm
|
|
xorg.libX11
|
|
xorg.libxcb
|
|
xorg.libxshmfence
|
|
wayland
|
|
gcc.cc
|
|
]
|
|
}"''${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
|
|
exec "$@"
|
|
'';
|
|
};
|
|
|
|
nixGLCommon = nixGL:
|
|
runCommand "nixGL" { } ''
|
|
mkdir -p "$out/bin"
|
|
# star because nixGLNvidia... have version prefixed name
|
|
cp ${nixGL}/bin/* "$out/bin/nixGL";
|
|
'';
|
|
|
|
auto =
|
|
let
|
|
_nvidiaVersionFile =
|
|
if nvidiaVersionFile != null then
|
|
nvidiaVersionFile
|
|
else
|
|
# HACK: Get the version from /proc. It turns out that /proc is mounted
|
|
# inside of the build sandbox and varies from machine to machine.
|
|
#
|
|
# builtins.readFile is not able to read /proc files. See
|
|
# https://github.com/NixOS/nix/issues/3539.
|
|
runCommand "impure-nvidia-version-file"
|
|
{
|
|
# To avoid sharing the build result over time or between machine,
|
|
# Add an impure parameter to force the rebuild on each access.
|
|
# time = builtins.currentTime;
|
|
preferLocalBuild = true;
|
|
allowSubstitutes = false;
|
|
} "cp /proc/driver/nvidia/version $out 2> /dev/null || touch $out";
|
|
|
|
# The nvidia version. Either fixed by the `nvidiaVersion` argument, or
|
|
# auto-detected. Auto-detection is impure.
|
|
nvidiaVersionAuto =
|
|
if nvidiaVersion != null then
|
|
nvidiaVersion
|
|
else
|
|
# Get if from the nvidiaVersionFile
|
|
let
|
|
data = builtins.readFile _nvidiaVersionFile;
|
|
versionMatch = builtins.match ".*Module ([0-9.]+) .*" data;
|
|
in
|
|
if versionMatch != null then builtins.head versionMatch else null;
|
|
|
|
autoNvidia = nvidiaPackages { version = nvidiaVersionAuto; };
|
|
in
|
|
rec {
|
|
# The output derivation contains nixGL which point either to
|
|
# nixGLNvidia or nixGLIntel using an heuristic.
|
|
nixGLDefault =
|
|
if nvidiaVersionAuto != null then
|
|
nixGLCommon autoNvidia.nixGLNvidia
|
|
else
|
|
nixGLCommon nixGLIntel;
|
|
} // autoNvidia;
|
|
};
|
|
in
|
|
top // (if nvidiaVersion != null then
|
|
top.nvidiaPackages
|
|
{
|
|
version = nvidiaVersion;
|
|
sha256 = nvidiaHash;
|
|
}
|
|
else
|
|
{ })
|