commit 3fe96bcca168b8b3ca9b9cb56f2568c338b0936d · pyrox.dev/nixpkgs

+2 -2

nixos/doc/manual/configuration.xml

···

       1195
       1195
        
       and <literal>intel</literal>).  You can also specify a driver

     

       1196
       1196
        
       manually, e.g.

     

       1197
       1197
        
       <programlisting>

     

       1198
       1198
       -
       hardware.opengl.videoDrivers = [ "r128" ];

     

       1198
       1198
       +
       services.xserver.videoDrivers = [ "r128" ];

     

       1199
       1199
        
       </programlisting>

     

       1200
       1200
        
       to enable X.org’s <literal>xf86-video-r128</literal> driver.</para>

     

       1201
       1201
        
       

     
···

       1238
       1238
        
       has better 3D performance than the X.org drivers.  It is not enabled

     

       1239
       1239
        
       by default because it’s not free software.  You can enable it as follows:

     

       1240
       1240
        
       <programlisting>

     

       1241
       1241
       -
       hardware.opengl.videoDrivers = [ "nvidia" ];

     

       1241
       1241
       +
       services.xserver.videoDrivers = [ "nvidia" ];

     

       1242
       1242
        
       </programlisting>

     

       1243
       1243
        
       You may need to reboot after enabling this driver to prevent a clash

     

       1244
       1244
        
       with other kernel modules.</para>

+24 -28

nixos/modules/hardware/opengl.nix

···

       1
       1
       -
       { config, pkgs, pkgs_i686, ... }:

     

       1
       1
       +
       { config, lib, pkgs, pkgs_i686, ... }:

     

       2
       2
       +
       

     

       3
       3
       +
       with lib;

     

       4
       4
       +
       

     

       2
       5
        
       let

     

       3
       3
       -
         inherit (pkgs.lib) mkOption types mkIf optional optionals elem optionalString optionalAttrs;

     

       4
       6
        
       

     

       5
       7
        
         cfg = config.hardware.opengl;

     

       6
       8
        
       

     

       7
       9
        
         kernelPackages = config.boot.kernelPackages;

     

       8
       8
       -
       in {

     

       10
       10
       +
       

     

       11
       11
       +
         videoDrivers = config.services.xserver.videoDrivers;

     

       12
       12
       +
       

     

       13
       13
       +
       in

     

       14
       14
       +
       

     

       15
       15
       +
       {

     

       9
       16
        
         options = {

     

       10
       17
        
           hardware.opengl.enable = mkOption {

     

       11
       11
       -
             description = "Whether this configuration requires opengl.";

     

       18
       18
       +
             description = "Whether this configuration requires OpenGL.";

     

       12
       19
        
             type = types.bool;

     

       13
       20
        
             default = false;

     

       14
       21
        
             internal = true;

     
···

       45
       52
        
             '';

     

       46
       53
        
           };

     

       47
       54
        
       

     

       48
       48
       -
       

     

       49
       49
       -
           hardware.opengl.videoDrivers = mkOption {

     

       50
       50
       -
             type = types.listOf types.str;

     

       51
       51
       -
             # !!! We'd like "nv" here, but it segfaults the X server.

     

       52
       52
       -
             default = [ "ati" "cirrus" "intel" "vesa" "vmware" ];

     

       53
       53
       -
             example = [ "vesa" ];

     

       54
       54
       -
             description = ''

     

       55
       55
       -
               The names of the opengl video drivers the configuration

     

       56
       56
       -
               supports. They will be tried in order until one that

     

       57
       57
       -
               supports your card is found.

     

       58
       58
       -
             '';

     

       59
       59
       -
           };

     

       60
       55
        
         };

     

       61
       56
        
       

     

       62
       57
        
         config = mkIf cfg.enable {

     
···

       71
       66
        
             ${optionalString (pkgs.stdenv.isi686) "ln -sf opengl-driver /run/opengl-driver-32"}

     

       72
       67
        
           ''

     

       73
       68
        
             #TODO:  The OpenGL driver should depend on what's detected at runtime.

     

       74
       74
       -
            +( if elem "nvidia" cfg.videoDrivers then

     

       69
       69
       +
            +( if elem "nvidia" videoDrivers then

     

       75
       70
        
                 ''

     

       76
       71
        
                   ln -sf ${kernelPackages.nvidia_x11} /run/opengl-driver

     

       77
       72
        
                   ${optionalString cfg.driSupport32Bit

     

       78
       73
        
                     "ln -sf ${pkgs_i686.linuxPackages.nvidia_x11.override { libsOnly = true; kernel = null; } } /run/opengl-driver-32"}

     

       79
       74
        
                 ''

     

       80
       80
       -
               else if elem "nvidiaLegacy173" cfg.videoDrivers then

     

       75
       75
       +
               else if elem "nvidiaLegacy173" videoDrivers then

     

       81
       76
        
                 "ln -sf ${kernelPackages.nvidia_x11_legacy173} /run/opengl-driver"

     

       82
       82
       -
               else if elem "nvidiaLegacy304" cfg.videoDrivers then

     

       77
       77
       +
               else if elem "nvidiaLegacy304" videoDrivers then

     

       83
       78
        
                 ''

     

       84
       79
        
                   ln -sf ${kernelPackages.nvidia_x11_legacy304} /run/opengl-driver

     

       85
       80
        
                   ${optionalString cfg.driSupport32Bit

     

       86
       81
        
                     "ln -sf ${pkgs_i686.linuxPackages.nvidia_x11_legacy304.override { libsOnly = true; kernel = null; } } /run/opengl-driver-32"}

     

       87
       82
        
                 ''

     

       88
       88
       -
               else if elem "ati_unfree" cfg.videoDrivers then

     

       83
       83
       +
               else if elem "ati_unfree" videoDrivers then

     

       89
       84
        
                 "ln -sf ${kernelPackages.ati_drivers_x11} /run/opengl-driver"

     

       90
       85
        
               else

     

       91
       86
        
                 let

     
···

       109
       104
        
             [ "/run/opengl-driver/lib" "/run/opengl-driver-32/lib" ];

     

       110
       105
        
       

     

       111
       106
        
           boot.extraModulePackages =

     

       112
       112
       -
             optional (elem "nvidia" cfg.videoDrivers) kernelPackages.nvidia_x11 ++

     

       113
       113
       -
             optional (elem "nvidiaLegacy173" cfg.videoDrivers) kernelPackages.nvidia_x11_legacy173 ++

     

       114
       114
       -
             optional (elem "nvidiaLegacy304" cfg.videoDrivers) kernelPackages.nvidia_x11_legacy304 ++

     

       115
       115
       -
             optional (elem "virtualbox" cfg.videoDrivers) kernelPackages.virtualboxGuestAdditions ++

     

       116
       116
       -
             optional (elem "ati_unfree" cfg.videoDrivers) kernelPackages.ati_drivers_x11;

     

       107
       107
       +
             optional (elem "nvidia" videoDrivers) kernelPackages.nvidia_x11 ++

     

       108
       108
       +
             optional (elem "nvidiaLegacy173" videoDrivers) kernelPackages.nvidia_x11_legacy173 ++

     

       109
       109
       +
             optional (elem "nvidiaLegacy304" videoDrivers) kernelPackages.nvidia_x11_legacy304 ++

     

       110
       110
       +
             optional (elem "virtualbox" videoDrivers) kernelPackages.virtualboxGuestAdditions ++

     

       111
       111
       +
             optional (elem "ati_unfree" videoDrivers) kernelPackages.ati_drivers_x11;

     

       117
       112
        
       

     

       118
       113
        
           boot.blacklistedKernelModules =

     

       119
       119
       -
             optionals (elem "nvidia" cfg.videoDrivers) [ "nouveau" "nvidiafb" ];

     

       114
       114
       +
             optionals (elem "nvidia" videoDrivers) [ "nouveau" "nvidiafb" ];

     

       120
       115
        
       

     

       121
       121
       -
           environment.etc =  (optionalAttrs (elem "ati_unfree" cfg.videoDrivers) {

     

       116
       116
       +
           environment.etc =

     

       117
       117
       +
             (optionalAttrs (elem "ati_unfree" videoDrivers) {

     

       122
       118
        
               "ati".source = "${kernelPackages.ati_drivers_x11}/etc/ati";

     

       123
       119
        
             })

     

       124
       124
       -
             // (optionalAttrs (elem "nvidia" cfg.videoDrivers) {

     

       120
       120
       +
             // (optionalAttrs (elem "nvidia" videoDrivers) {

     

       125
       121
        
               "OpenCL/vendors/nvidia.icd".source = "${kernelPackages.nvidia_x11}/lib/vendors/nvidia.icd";

     

       126
       122
        
             });

     

       127
       123
        
         };

+2 -1

nixos/modules/installer/cd-dvd/system-tarball-sheevaplug.nix

···

       138
       138
        
         };

     

       139
       139
        
       

     

       140
       140
        
         # Setting vesa, we don't get the nvidia driver, which can't work in arm.

     

       141
       141
       -
         hardware.opengl.videoDrivers = [ "vesa" ];

     

       141
       141
       +
         services.xserver.videoDrivers = [ "vesa" ];

     

       142
       142
       +
       

     

       142
       143
        
         services.nixosManual.enable = false;

     

       143
       144
        
       

     

       144
       145
        
         # Include the firmware for various wireless cards.

+1 -1

nixos/modules/installer/tools/nixos-generate-config.pl

···

       165
       165
        
           pciCheck $path;

     

       166
       166
        
       }

     

       167
       167
        
       

     

       168
       168
       -
       push @attrs, "hardware.opengl.videoDrivers = [ \"$videoDriver\" ];" if $videoDriver;

     

       168
       168
       +
       push @attrs, "services.xserver.videoDrivers = [ \"$videoDriver\" ];" if $videoDriver;

     

       169
       169
        
       

     

       170
       170
        
       

     

       171
       171
        
       # Idem for USB devices.

+1 -1

nixos/modules/installer/virtualbox-demo.nix

···

       15
       15
        
       

     

       16
       16
        
         # Add some more video drivers to give X11 a shot at working in

     

       17
       17
        
         # VMware and QEMU.

     

       18
       18
       -
         hardware.opengl.videoDrivers = mkOverride 40 [ "virtualbox" "vmware" "cirrus" "vesa" ];

     

       18
       18
       +
         services.xserver.videoDrivers = mkOverride 40 [ "virtualbox" "vmware" "cirrus" "vesa" ];

     

       19
       19
        
       }

+1 -1

nixos/modules/rename.nix

···

       121
       121
        
       ++ obsolete [ "services" "xserver" "driSupport" ] [ "hardware" "opengl" "driSupport" ]

     

       122
       122
        
       ++ obsolete [ "services" "xserver" "driSupport32Bit" ] [ "hardware" "opengl" "driSupport32Bit" ]

     

       123
       123
        
       ++ obsolete [ "services" "xserver" "s3tcSupport" ] [ "hardware" "opengl" "s3tcSupport" ]

     

       124
       124
       -
       ++ obsolete [ "services" "xserver" "videoDrivers" ] [ "hardware" "opengl" "videoDrivers" ]

     

       124
       124
       +
       ++ obsolete [ "hardware" "opengl" "videoDrivers" ] [ "services" "xserver" "videoDrivers" ]

     

       125
       125
        
       

     

       126
       126
        
       ++ obsolete [ "services" "mysql55" ] [ "services" "mysql" ]

     

       127
       127

+1 -1

nixos/modules/services/x11/terminal-server.nix

···

       27
       27
        
         config = {

     

       28
       28
        
       

     

       29
       29
        
           services.xserver.enable = true;

     

       30
       30
       -
           hardware.opengl.videoDrivers = [];

     

       30
       30
       +
           services.xserver.videoDrivers = [];

     

       31
       31
        
       

     

       32
       32
        
           # Enable KDM.  Any display manager will do as long as it supports XDMCP.

     

       33
       33
        
           services.xserver.displayManager.kdm.enable = true;

+15 -3

nixos/modules/services/x11/xserver.nix

···

       24
       24
        
           intel-testing = { modules = with pkgs.xorg; [ xf86videointel-testing glamoregl ]; driverName = "intel"; };

     

       25
       25
        
         };

     

       26
       26
        
       

     

       27
       27
       -
         driverNames = config.hardware.opengl.videoDrivers;

     

       27
       27
       +
         driverNames = cfg.videoDrivers;

     

       28
       28
        
       

     

       29
       29
        
         needsAcpid =

     

       30
       30
        
            (elem "nvidia" driverNames) ||

     
···

       181
       181
        
               '';

     

       182
       182
        
             };

     

       183
       183
        
       

     

       184
       184
       +
             videoDrivers = mkOption {

     

       185
       185
       +
               type = types.listOf types.str;

     

       186
       186
       +
               # !!! We'd like "nv" here, but it segfaults the X server.

     

       187
       187
       +
               default = [ "ati" "cirrus" "intel" "vesa" "vmware" ];

     

       188
       188
       +
               example = [ "vesa" ];

     

       189
       189
       +
               description = ''

     

       190
       190
       +
                 The names of the video drivers the configuration

     

       191
       191
       +
                 supports. They will be tried in order until one that

     

       192
       192
       +
                 supports your card is found.

     

       193
       193
       +
               '';

     

       194
       194
       +
             };

     

       195
       195
       +
       

     

       184
       196
        
             videoDriver = mkOption {

     

       185
       197
        
               type = types.nullOr types.str;

     

       186
       198
        
               default = null;

     
···

       188
       200
        
               description = ''

     

       189
       201
        
                 The name of the video driver for your graphics card.  This

     

       190
       202
        
                 option is obsolete; please set the

     

       191
       191
       -
                 <option>hardware.opengl.videoDrivers</option> instead.

     

       203
       203
       +
                 <option>services.xserver.videoDrivers</option> instead.

     

       192
       204
        
               '';

     

       193
       205
        
             };

     

       194
       206
        
       

     
···

       386
       398
        
       

     

       387
       399
        
         config = mkIf cfg.enable {

     

       388
       400
        
           hardware.opengl.enable = true;

     

       389
       389
       -
           hardware.opengl.videoDrivers = mkIf (cfg.videoDriver != null) [ cfg.videoDriver ];

     

       401
       401
       +
           services.xserver.videoDrivers = mkIf (cfg.videoDriver != null) [ cfg.videoDriver ];

     

       390
       402
        
       

     

       391
       403
        
           assertions =

     

       392
       404
        
             [ { assertion = !(config.programs.ssh.startAgent && cfg.startGnuPGAgent);

+1 -1

nixos/modules/virtualisation/qemu-vm.nix

···

       386
       386
        
       

     

       387
       387
        
           # When building a regular system configuration, override whatever

     

       388
       388
        
           # video driver the host uses.

     

       389
       389
       -
           hardware.opengl.videoDrivers = mkVMOverride [ "vesa" ];

     

       389
       389
       +
           services.xserver.videoDrivers = mkVMOverride [ "vesa" ];

     

       390
       390
        
           services.xserver.defaultDepth = mkVMOverride 0;

     

       391
       391
        
           services.xserver.resolutions = mkVMOverride [ { x = 1024; y = 768; } ];

     

       392
       392
        
           services.xserver.monitorSection =

+1 -1

nixos/modules/virtualisation/virtualbox-guest.nix

···

       54
       54
        
               serviceConfig.ExecStart = "@${kernel.virtualboxGuestAdditions}/sbin/VBoxService VBoxService --foreground";

     

       55
       55
        
             };

     

       56
       56
        
       

     

       57
       57
       -
           hardware.opengl.videoDrivers = mkOverride 50 [ "virtualbox" ];

     

       57
       57
       +
           services.xserver.videoDrivers = mkOverride 50 [ "virtualbox" ];

     

       58
       58
        
       

     

       59
       59
        
           services.xserver.config =

     

       60
       60
        
             ''