commit 1ffe41b34f9bbbe3b684faeabb9f126d00f0647e · pyrox.dev/nixpkgs

+19

nixos/doc/manual/configuration/x-windows.xml

···

       73
       73
        
       

     

       74
       74
        
       </simplesect>

     

       75
       75
        
       

     

       76
       76
       +
       <simplesect><title>AMD Graphics Cards</title>

     

       77
       77
       +
       

     

       78
       78
       +
       <para>AMD provides a proprietary driver for its graphics cards that

     

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

     

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

     

       81
       81
       +
       <programlisting>

     

       82
       82
       +
       services.xserver.videoDrivers = [ "ati_unfree" ];

     

       83
       83
       +
       </programlisting>

     

       84
       84
       +
       You will need to reboot after enabling this driver to prevent a clash

     

       85
       85
       +
       with other kernel modules.</para>

     

       86
       86
       +
       

     

       87
       87
       +
       <para>On 64-bit systems, if you want full acceleration for 32-bit

     

       88
       88
       +
       programs such as Wine, you should also set the following:

     

       89
       89
       +
       <programlisting>

     

       90
       90
       +
       hardware.opengl.driSupport32Bit = true;

     

       91
       91
       +
       </programlisting>

     

       92
       92
       +
       </para>

     

       93
       93
       +
       

     

       94
       94
       +
       </simplesect>

     

       76
       95
        
       

     

       77
       96
        
       <simplesect><title>Touchpads</title>

     

       78
       97

+4 -16

nixos/modules/hardware/opengl.nix

···

       46
       46
        
             description = ''

     

       47
       47
        
               On 64-bit systems, whether to support Direct Rendering for

     

       48
       48
        
               32-bit applications (such as Wine).  This is currently only

     

       49
       49
       -
               supported for the <literal>nvidia</literal> driver and for

     

       49
       49
       +
               supported for the <literal>nvidia</literal> and 

     

       50
       50
       +
               <literal>ati_unfree</literal> drivers, as well as

     

       50
       51
        
               <literal>Mesa</literal>.

     

       51
       52
        
             '';

     

       52
       53
        
           };

     
···

       104
       105
        
           environment.sessionVariables.LD_LIBRARY_PATH =

     

       105
       106
        
             [ "/run/opengl-driver/lib" "/run/opengl-driver-32/lib" ];

     

       106
       107
        
       

     

       107
       107
       -
           # FIXME: move this into card-specific modules.

     

       108
       108
       -
           hardware.opengl.package = mkDefault

     

       109
       109
       -
             (if elem "ati_unfree" videoDrivers then

     

       110
       110
       -
               kernelPackages.ati_drivers_x11

     

       111
       111
       -
             else

     

       112
       112
       -
               makePackage pkgs);

     

       113
       113
       -
       

     

       108
       108
       +
           hardware.opengl.package = mkDefault (makePackage pkgs);

     

       114
       109
        
           hardware.opengl.package32 = mkDefault (makePackage pkgs_i686);

     

       115
       110
        
       

     

       116
       116
       -
           boot.extraModulePackages =

     

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

     

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

     

       119
       119
       -
       

     

       120
       120
       -
           environment.etc =

     

       121
       121
       -
             optionalAttrs (elem "ati_unfree" videoDrivers) {

     

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

     

       123
       123
       -
             };

     

       111
       111
       +
           boot.extraModulePackages = optional (elem "virtualbox" videoDrivers) kernelPackages.virtualboxGuestAdditions;

     

       124
       112
        
         };

     

       125
       113
        
       }

+37

nixos/modules/hardware/video/ati.nix

···

       1
       1
       +
       # This module provides the proprietary ATI X11 / OpenGL drivers.

     

       2
       2
       +
       

     

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

     

       4
       4
       +
       

     

       5
       5
       +
       with lib;

     

       6
       6
       +
       

     

       7
       7
       +
       let

     

       8
       8
       +
       

     

       9
       9
       +
         drivers = config.services.xserver.videoDrivers;

     

       10
       10
       +
       

     

       11
       11
       +
         enabled = elem "ati_unfree" drivers;

     

       12
       12
       +
       

     

       13
       13
       +
         ati_x11 = config.boot.kernelPackages.ati_drivers_x11;

     

       14
       14
       +
       

     

       15
       15
       +
       in

     

       16
       16
       +
       

     

       17
       17
       +
       {

     

       18
       18
       +
       

     

       19
       19
       +
         config = mkIf enabled {

     

       20
       20
       +
       

     

       21
       21
       +
           services.xserver.drivers = singleton

     

       22
       22
       +
             { name = "fglrx"; modules = [ ati_x11 ]; libPath = [ "${ati_x11}/lib" ]; };

     

       23
       23
       +
       

     

       24
       24
       +
           hardware.opengl.package = ati_x11;

     

       25
       25
       +
           hardware.opengl.package32 = pkgs_i686.linuxPackages.ati_drivers_x11.override { libsOnly = true; kernel = null; };

     

       26
       26
       +
       

     

       27
       27
       +
           environment.systemPackages = [ ati_x11 ];

     

       28
       28
       +
       

     

       29
       29
       +
           boot.extraModulePackages = [ ati_x11 ];

     

       30
       30
       +
       

     

       31
       31
       +
           boot.blacklistedKernelModules = [ "radeon" ];

     

       32
       32
       +
       

     

       33
       33
       +
           environment.etc."ati".source = "${ati_x11}/etc/ati";

     

       34
       34
       +
       

     

       35
       35
       +
         };

     

       36
       36
       +
       

     

       37
       37
       +
       }

nixos/modules/module-list.nix

···

       38
       38
        
         ./hardware/pcmcia.nix

     

       39
       39
        
         ./hardware/video/bumblebee.nix

     

       40
       40
        
         ./hardware/video/nvidia.nix

     

       41
       41
       +
         ./hardware/video/ati.nix

     

       41
       42
        
         ./installer/tools/nixos-checkout.nix

     

       42
       43
        
         ./installer/tools/tools.nix

     

       43
       44
        
         ./misc/assertions.nix

+1 -5

nixos/modules/services/x11/xserver.nix

···

       13
       13
        
       

     

       14
       14
        
         # Map video driver names to driver packages. FIXME: move into card-specific modules.

     

       15
       15
        
         knownVideoDrivers = {

     

       16
       16
       -
           ati_unfree   = { modules = [ kernelPackages.ati_drivers_x11 ]; driverName = "fglrx"; };

     

       17
       16
        
           nouveau       = { modules = [ pkgs.xf86_video_nouveau ]; };

     

       18
       17
        
           unichrome    = { modules = [ pkgs.xorgVideoUnichrome ]; };

     

       19
       18
        
           virtualbox   = { modules = [ kernelPackages.virtualboxGuestAdditions ]; driverName = "vboxvideo"; };

     
···

       444
       443
        
               pkgs.xterm

     

       445
       444
        
               pkgs.xdg_utils

     

       446
       445
        
             ]

     

       447
       447
       -
             ++ optional (elem "virtualbox" cfg.videoDrivers) xorg.xrefresh

     

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

     

       446
       446
       +
             ++ optional (elem "virtualbox" cfg.videoDrivers) xorg.xrefresh;

     

       449
       447
        
       

     

       450
       448
        
           environment.pathsToLink =

     

       451
       449
        
             [ "/etc/xdg" "/share/xdg" "/share/applications" "/share/icons" "/share/pixmaps" ];

     
···

       465
       463
        
                   XORG_DRI_DRIVER_PATH = "/run/opengl-driver/lib/dri"; # !!! Depends on the driver selected at runtime.

     

       466
       464
        
                   LD_LIBRARY_PATH = concatStringsSep ":" (

     

       467
       465
        
                     [ "${xorg.libX11}/lib" "${xorg.libXext}/lib" ]

     

       468
       468
       -
                     ++ optionals (elem "ati_unfree" cfg.videoDrivers)

     

       469
       469
       -
                       [ "${kernelPackages.ati_drivers_x11}/lib" "${kernelPackages.ati_drivers_x11}/X11R6/lib64/modules/linux" ]

     

       470
       466
        
                     ++ concatLists (catAttrs "libPath" cfg.drivers));

     

       471
       467
        
                 } // cfg.displayManager.job.environment;

     

       472
       468

+142 -97

pkgs/os-specific/linux/ati-drivers/builder.sh

···

       8
       8
        
       

     

       9
       9
        
       # custom unpack:

     

       10
       10
        
       unzip $src

     

       11
       11
       -
       run_file=$(echo amd-catalyst-*)

     

       11
       11
       +
       run_file=$(echo fglrx-*/amd-driver-installer-*)

     

       12
       12
        
       sh $run_file --extract .

     

       13
       13
        
       

     

       14
       14
        
       eval "$patchPhase"

     

       15
       15
        
       

     

       16
       16
       -
       kernelVersion=$(cd ${kernel}/lib/modules && ls)

     

       17
       17
       -
       kernelBuild=$(echo ${kernel}/lib/modules/$kernelVersion/build)

     

       18
       18
       -
       linuxsources=$(echo ${kernel}/lib/modules/$kernelVersion/source)

     

       16
       16
       +
       case "$system" in

     

       17
       17
       +
         x86_64-linux)

     

       18
       18
       +
           arch=x86_64

     

       19
       19
       +
           lib_arch=lib64

     

       20
       20
       +
           DIR_DEPENDING_ON_XORG_VERSION=xpic_64a

     

       21
       21
       +
         ;;

     

       22
       22
       +
         i686-linux)

     

       23
       23
       +
           arch=x86

     

       24
       24
       +
           lib_arch=lib

     

       25
       25
       +
           DIR_DEPENDING_ON_XORG_VERSION=xpic

     

       26
       26
       +
         ;;

     

       27
       27
       +
         *) exit 1;;

     

       28
       28
       +
       esac

     

       19
       29
        
       

     

       30
       30
       +
       # Handle/Build the kernel module.

     

       31
       31
       +
       if test -z "$libsOnly"; then

     

       20
       32
        
       

     

       21
       21
       -
       # note: maybe the .config file should be used to determine this ?

     

       22
       22
       -
       # current kbuild infrastructure allows using CONFIG_* defines

     

       23
       23
       -
       # but ati sources don't use them yet..

     

       24
       24
       -
       # copy paste from make.sh

     

       25
       25
       -
       setSMP(){

     

       33
       33
       +
         kernelVersion=$(cd ${kernel}/lib/modules && ls)

     

       34
       34
       +
         kernelBuild=$(echo ${kernel}/lib/modules/$kernelVersion/build)

     

       35
       35
       +
         linuxsources=$(echo ${kernel}/lib/modules/$kernelVersion/source)

     

       26
       36
        
       

     

       27
       27
       -
         linuxincludes=$kernelBuild/include

     

       37
       37
       +
         # note: maybe the .config file should be used to determine this ?

     

       38
       38
       +
         # current kbuild infrastructure allows using CONFIG_* defines

     

       39
       39
       +
         # but ati sources don't use them yet..

     

       40
       40
       +
         # copy paste from make.sh

     

       41
       41
       +
         setSMP(){

     

       28
       42
        
       

     

       29
       29
       -
         # copied and stripped. source: make.sh:

     

       43
       43
       +
           linuxincludes=$kernelBuild/include

     

       30
       44
        
       

     

       31
       31
       -
         # 3

     

       32
       32
       -
         # linux/autoconf.h may contain this: #define CONFIG_SMP 1

     

       45
       45
       +
           # copied and stripped. source: make.sh:

     

       46
       46
       +
           # 3

     

       47
       47
       +
           # linux/autoconf.h may contain this: #define CONFIG_SMP 1

     

       33
       48
        
       

     

       34
       34
       -
         # Before 2.6.33 autoconf.h is under linux/.

     

       35
       35
       -
         # For 2.6.33 and later autoconf.h is under generated/.

     

       36
       36
       -
         if [ -f $linuxincludes/generated/autoconf.h ]; then

     

       37
       37
       -
             autoconf_h=$linuxincludes/generated/autoconf.h

     

       38
       38
       -
         else

     

       39
       39
       -
             autoconf_h=$linuxincludes/linux/autoconf.h

     

       40
       40
       -
         fi

     

       41
       41
       -
         src_file=$autoconf_h

     

       49
       49
       +
           # Before 2.6.33 autoconf.h is under linux/.

     

       50
       50
       +
           # For 2.6.33 and later autoconf.h is under generated/.

     

       51
       51
       +
           if [ -f $linuxincludes/generated/autoconf.h ]; then

     

       52
       52
       +
               autoconf_h=$linuxincludes/generated/autoconf.h

     

       53
       53
       +
           else

     

       54
       54
       +
               autoconf_h=$linuxincludes/linux/autoconf.h

     

       55
       55
       +
           fi

     

       56
       56
       +
           src_file=$autoconf_h

     

       42
       57
        
       

     

       43
       43
       -
         [ -e $src_file ] || die "$src_file not found"

     

       58
       58
       +
           [ -e $src_file ] || die "$src_file not found"

     

       44
       59
        
       

     

       45
       45
       -
         if [ `cat $src_file | grep "#undef" | grep "CONFIG_SMP" -c` = 0 ]; then

     

       46
       46
       -
           SMP=`cat $src_file | grep CONFIG_SMP | cut -d' ' -f3`

     

       47
       47
       -
           echo "file $src_file says: SMP=$SMP"

     

       48
       48
       -
         fi

     

       60
       60
       +
           if [ `cat $src_file | grep "#undef" | grep "CONFIG_SMP" -c` = 0 ]; then

     

       61
       61
       +
             SMP=`cat $src_file | grep CONFIG_SMP | cut -d' ' -f3`

     

       62
       62
       +
             echo "file $src_file says: SMP=$SMP"

     

       63
       63
       +
           fi

     

       49
       64
        
       

     

       50
       50
       -
         if [ "$SMP" = 0 ]; then

     

       51
       51
       -
           echo "assuming default: SMP=$SMP"

     

       52
       52
       -
         fi

     

       65
       65
       +
           if [ "$SMP" = 0 ]; then

     

       66
       66
       +
             echo "assuming default: SMP=$SMP"

     

       67
       67
       +
           fi

     

       53
       68
        
       

     

       54
       54
       -
         # act on final result

     

       55
       55
       -
         if [ ! "$SMP" = 0 ]; then

     

       56
       56
       -
           smp="-SMP"

     

       57
       57
       -
           def_smp=-D__SMP__

     

       58
       58
       -
         fi

     

       69
       69
       +
           # act on final result

     

       70
       70
       +
           if [ ! "$SMP" = 0 ]; then

     

       71
       71
       +
             smp="-SMP"

     

       72
       72
       +
             def_smp=-D__SMP__

     

       73
       73
       +
           fi

     

       59
       74
        
       

     

       60
       60
       -
       }

     

       75
       75
       +
         }

     

       61
       76
        
       

     

       62
       62
       -
       setModVersions(){

     

       63
       63
       -
         ! grep CONFIG_MODVERSIONS=y $kernel/config ||

     

       64
       64
       -
         def_modversions="-DMODVERSIONS"

     

       65
       65
       -
         # make.sh contains much more code to determine this whether its enabled

     

       66
       66
       -
       }

     

       77
       77
       +
         setModVersions(){

     

       78
       78
       +
           ! grep CONFIG_MODVERSIONS=y $kernelBuild/.config ||

     

       79
       79
       +
           def_modversions="-DMODVERSIONS"

     

       80
       80
       +
           # make.sh contains much more code to determine this whether its enabled

     

       81
       81
       +
         }

     

       67
       82
        
       

     

       68
       68
       -
       # ==============================================================

     

       69
       69
       -
       # resolve if we are building for a kernel with a fix for CVE-2010-3081

     

       70
       70
       -
       # On kernels with the fix, use arch_compat_alloc_user_space instead

     

       71
       71
       -
       # of compat_alloc_user_space since the latter is GPL-only

     

       83
       83
       +
         # ==============================================================

     

       84
       84
       +
         # resolve if we are building for a kernel with a fix for CVE-2010-3081

     

       85
       85
       +
         # On kernels with the fix, use arch_compat_alloc_user_space instead

     

       86
       86
       +
         # of compat_alloc_user_space since the latter is GPL-only

     

       72
       87
        
       

     

       73
       73
       -
       COMPAT_ALLOC_USER_SPACE=arch_compat_alloc_user_space

     

       88
       88
       +
         COMPAT_ALLOC_USER_SPACE=arch_compat_alloc_user_space

     

       74
       89
        
       

     

       75
       75
       -
       for src_file in \

     

       90
       90
       +
         for src_file in \

     

       76
       91
        
           $kernelBuild/arch/x86/include/asm/compat.h \

     

       77
       92
        
           $linuxsources/arch/x86/include/asm/compat.h \

     

       78
       93
        
           $kernelBuild/include/asm-x86_64/compat.h \

     

       79
       94
        
           $linuxsources/include/asm-x86_64/compat.h \

     

       80
       95
        
           $kernelBuild/include/asm/compat.h;

     

       81
       81
       -
       do

     

       82
       82
       -
         if [ -e $src_file ];

     

       83
       83
       -
         then

     

       84
       84
       -
           break

     

       85
       85
       -
         fi

     

       86
       86
       -
       done

     

       87
       87
       -
       if [ ! -e $src_file ];

     

       88
       88
       -
       then

     

       89
       89
       -
         echo "Warning: x86 compat.h not found in kernel headers"        

     

       90
       90
       -
         echo "neither arch/x86/include/asm/compat.h nor include/asm-x86_64/compat.h" 

     

       91
       91
       -
         echo "could be found in $kernelBuild or $linuxsources"            

     

       92
       92
       -
         echo ""                                                          

     

       93
       93
       -
       else

     

       94
       94
       -
         if [ `cat $src_file | grep -c arch_compat_alloc_user_space` -gt 0 ]

     

       95
       95
       -
         then

     

       96
       96
       -
           COMPAT_ALLOC_USER_SPACE=arch_compat_alloc_user_space

     

       96
       96
       +
         do

     

       97
       97
       +
           if [ -e $src_file ];

     

       98
       98
       +
           then

     

       99
       99
       +
             break

     

       100
       100
       +
           fi

     

       101
       101
       +
         done

     

       102
       102
       +
         if [ ! -e $src_file ];

     

       103
       103
       +
           then

     

       104
       104
       +
           echo "Warning: x86 compat.h not found in kernel headers"

     

       105
       105
       +
           echo "neither arch/x86/include/asm/compat.h nor include/asm-x86_64/compat.h"

     

       106
       106
       +
           echo "could be found in $kernelBuild or $linuxsources"

     

       107
       107
       +
           echo ""

     

       108
       108
       +
         else

     

       109
       109
       +
           if [ `cat $src_file | grep -c arch_compat_alloc_user_space` -gt 0 ]

     

       110
       110
       +
           then

     

       111
       111
       +
             COMPAT_ALLOC_USER_SPACE=arch_compat_alloc_user_space

     

       112
       112
       +
           fi

     

       113
       113
       +
           echo "file $src_file says: COMPAT_ALLOC_USER_SPACE=$COMPAT_ALLOC_USER_SPACE"

     

       97
       114
        
         fi

     

       98
       98
       -
         echo "file $src_file says: COMPAT_ALLOC_USER_SPACE=$COMPAT_ALLOC_USER_SPACE" 

     

       99
       99
       -
       fi

     

       100
       115
        
       

     

       116
       116
       +
         # make.sh contains some code figuring out whether to use these or not..

     

       117
       117
       +
         PAGE_ATTR_FIX=0

     

       118
       118
       +
         setSMP

     

       119
       119
       +
         setModVersions

     

       120
       120
       +
         CC=gcc

     

       121
       121
       +
         MODULE=fglrx

     

       122
       122
       +
         LIBIP_PREFIX=$TMP/arch/$arch/lib/modules/fglrx/build_mod

     

       123
       123
       +
         [ -d $LIBIP_PREFIX ]

     

       124
       124
       +
         GCC_MAJOR="`gcc --version | grep -o -e ") ." | head -1 | cut -d " " -f 2`"

     

       101
       125
        
       

     

       102
       102
       -
       # make.sh contains some code figuring out whether to use these or not..

     

       103
       103
       -
       PAGE_ATTR_FIX=0

     

       104
       104
       -
       setSMP

     

       105
       105
       -
       setModVersions

     

       106
       106
       -
       CC=gcc

     

       107
       107
       -
       MODULE=fglrx

     

       108
       108
       -
       case "$system" in

     

       109
       109
       -
         x86_64-linux)

     

       110
       110
       -
           arch=x86_64

     

       111
       111
       -
           lib_arch=lib64

     

       112
       112
       -
         ;;

     

       113
       113
       -
         i686-linux)

     

       114
       114
       -
           arch=x86

     

       115
       115
       -
           lib_arch=lib

     

       116
       116
       -
         ;;

     

       117
       117
       -
         *) exit 1;;

     

       118
       118
       -
       esac

     

       119
       119
       -
       LIBIP_PREFIX=$TMP/arch/$arch/lib/modules/fglrx/build_mod

     

       120
       120
       -
       [ -d $LIBIP_PREFIX ]

     

       121
       121
       -
       GCC_MAJOR="`gcc --version | grep -o -e ") ." | head -1 | cut -d " " -f 2`"

     

       126
       126
       +
         { # build .ko module

     

       127
       127
       +
           cd ./common/lib/modules/fglrx/build_mod/2.6.x

     

       128
       128
       +
           echo .lib${MODULE}_ip.a.GCC${GCC_MAJOR}.cmd

     

       129
       129
       +
           echo 'This is a dummy file created to suppress this warning: could not find /lib/modules/fglrx/build_mod/2.6.x/.libfglrx_ip.a.GCC4.cmd for /lib/modules/fglrx/build_mod/2.6.x/libfglrx_ip.a.GCC4' > lib${MODULE}_ip.a.GCC${GCC_MAJOR}.cmd

     

       122
       130
        
       

     

       123
       123
       -
       { # build .ko module

     

       124
       124
       -
         cd ./common/lib/modules/fglrx/build_mod/2.6.x

     

       125
       125
       -
         echo .lib${MODULE}_ip.a.GCC${GCC_MAJOR}.cmd

     

       126
       126
       -
         echo 'This is a dummy file created to suppress this warning: could not find /lib/modules/fglrx/build_mod/2.6.x/.libfglrx_ip.a.GCC4.cmd for /lib/modules/fglrx/build_mod/2.6.x/libfglrx_ip.a.GCC4' > lib${MODULE}_ip.a.GCC${GCC_MAJOR}.cmd

     

       131
       131
       +
           sed -i -e "s@COMPAT_ALLOC_USER_SPACE@$COMPAT_ALLOC_USER_SPACE@" ../kcl_ioctl.c

     

       127
       132
        
       

     

       128
       128
       -
         sed -i -e "s@COMPAT_ALLOC_USER_SPACE@$COMPAT_ALLOC_USER_SPACE@" ../kcl_ioctl.c

     

       129
       129
       -
       

     

       130
       130
       -
         make CC=${CC} \

     

       133
       133
       +
           make CC=${CC} \

     

       131
       134
        
             LIBIP_PREFIX=$(echo "$LIBIP_PREFIX" | sed -e 's|^\([^/]\)|../\1|') \

     

       132
       135
        
             MODFLAGS="-DMODULE -DATI -DFGL -DPAGE_ATTR_FIX=$PAGE_ATTR_FIX -DCOMPAT_ALLOC_USER_SPACE=$COMPAT_ALLOC_USER_SPACE $def_smp $def_modversions" \

     

       133
       136
        
             KVER=$kernelVersion \

     
···

       135
       138
        
             PAGE_ATTR_FIX=$PAGE_ATTR_FIX \

     

       136
       139
        
             -j4

     

       137
       140
        
       

     

       138
       138
       -
         cd $TMP

     

       139
       139
       -
       }

     

       141
       141
       +
           cd $TMP

     

       142
       142
       +
         }

     

       143
       143
       +
       

     

       144
       144
       +
       fi

     

       140
       145
        
       

     

       141
       146
        
       { # install

     

       142
       147
        
       

     
···

       152
       157
        
         # what are those files used for?

     

       153
       158
        
         cp -r common/etc $out

     

       154
       159
        
       

     

       155
       155
       -
         DIR_DEPENDING_ON_XORG_VERSION=xpic_64a

     

       156
       160
        
         cp -r $DIR_DEPENDING_ON_XORG_VERSION/usr/X11R6/$lib_arch/* $out/lib/xorg

     

       157
       161
        
       

     

       158
       158
       -
         t=$out/lib/modules/${kernelVersion}/kernel/drivers/misc

     

       159
       159
       -
         mkdir -p $t

     

       162
       162
       +
         # install kernel module

     

       163
       163
       +
         if test -z "$libsOnly"; then

     

       164
       164
       +
           t=$out/lib/modules/${kernelVersion}/kernel/drivers/misc

     

       165
       165
       +
           mkdir -p $t

     

       160
       166
        
       

     

       161
       161
       -
         cp ./common/lib/modules/fglrx/build_mod/2.6.x/fglrx.ko $t

     

       167
       167
       +
           cp ./common/lib/modules/fglrx/build_mod/2.6.x/fglrx.ko $t

     

       168
       168
       +
         fi

     

       162
       169
        
       

     

       163
       170
        
         # should this be installed at all?

     

       164
       171
        
         # its used by the example fglrx_gamma only

     
···

       181
       188
        
         # make xorg use the ati version

     

       182
       189
        
         ln -s $out/lib/xorg/modules/extensions/{fglrx/fglrx-libglx.so,libglx.so}

     

       183
       190
        
       

     

       191
       191
       +
         # Correct some paths that are hardcoded into binary libs.

     

       192
       192
       +
         if [ "$arch" ==  "x86_64" ]; then

     

       193
       193
       +
           for lib in \

     

       194
       194
       +
             lib/xorg/modules/extensions/fglrx/fglrx-libglx.so \

     

       195
       195
       +
             lib/xorg/modules/glesx.so \

     

       196
       196
       +
             lib/dri/fglrx_dri.so \

     

       197
       197
       +
             lib/fglrx_dri.so \

     

       198
       198
       +
             lib/fglrx-libGL.so.1.2

     

       199
       199
       +
           do

     

       200
       200
       +
             oldPaths="/usr/X11R6/lib/modules/dri"

     

       201
       201
       +
             newPaths="/run/opengl-driver/lib/dri"

     

       202
       202
       +
             sed -i -e "s|$oldPaths|$newPaths|" $out/$lib

     

       203
       203
       +
           done

     

       204
       204
       +
         else

     

       205
       205
       +
           oldPaths="/usr/X11R6/lib32/modules/dri\x00/usr/lib32/dri"

     

       206
       206
       +
           newPaths="/run/opengl-driver-32/lib/dri\x00/dev/null/dri"

     

       207
       207
       +
           sed -i -e "s|$oldPaths|$newPaths|" \

     

       208
       208
       +
             $out/lib/xorg/modules/extensions/fglrx/fglrx-libglx.so

     

       209
       209
       +
       

     

       210
       210
       +
           for lib in \

     

       211
       211
       +
             lib/dri/fglrx_dri.so \

     

       212
       212
       +
             lib/fglrx_dri.so \

     

       213
       213
       +
             lib/xorg/modules/glesx.so

     

       214
       214
       +
           do

     

       215
       215
       +
             oldPaths="/usr/X11R6/lib32/modules/dri/"

     

       216
       216
       +
             newPaths="/run/opengl-driver-32/lib/dri"

     

       217
       217
       +
             sed -i -e "s|$oldPaths|$newPaths|" $out/$lib

     

       218
       218
       +
           done

     

       219
       219
       +
       

     

       220
       220
       +
           oldPaths="/usr/X11R6/lib32/modules/dri\x00"

     

       221
       221
       +
           newPaths="/run/opengl-driver-32/lib/dri"

     

       222
       222
       +
           sed -i -e "s|$oldPaths|$newPaths|" $out/lib/fglrx-libGL.so.1.2

     

       223
       223
       +
         fi

     

       224
       224
       +
       

     

       184
       225
        
         # libstdc++ and gcc are needed by some libs

     

       185
       226
        
         patchelf --set-rpath $gcc/$lib_arch $out/lib/libatiadlxx.so

     

       186
       227
        
       }

     

       228
       228
       +
       

     

       229
       229
       +
       if test -z "$libsOnly"; then

     

       187
       230
        
       

     

       188
       231
        
       { # build samples

     

       189
       232
        
         mkdir -p $out/bin

     
···

       228
       271
        
         rm -fr $out/lib/modules/fglrx # don't think those .a files are needed. They cause failure of the mod

     

       229
       272
        
       

     

       230
       273
        
       }

     

       274
       274
       +
       

     

       275
       275
       +
       fi

     

       231
       276
        
       

     

       232
       277
        
       for p in $extraDRIlibs; do

     

       233
       278
        
         for lib in $p/lib/*.so*; do

+15 -17

pkgs/os-specific/linux/ati-drivers/default.nix

···

       1
       1
       -
       { stdenv, fetchurl, kernel, xlibs, which, imake

     

       1
       1
       +
       { stdenv, fetchurl, kernel ? null, xlibs, which, imake

     

       2
       2
        
       , mesa # for fgl_glxgears

     

       3
       3
        
       , libXxf86vm, xf86vidmodeproto # for fglrx_gamma

     

       4
       4
        
       , xorg, makeWrapper, glibc, patchelf

     

       5
       5
        
       , unzip

     

       6
       6
       +
       , # Whether to build the libraries only (i.e. not the kernel module or

     

       7
       7
       +
         # driver utils). Used to support 32-bit binaries on 64-bit

     

       8
       8
       +
         # Linux.

     

       9
       9
       +
         libsOnly ? false

     

       6
       10
        
       }:

     

       11
       11
       +
       

     

       12
       12
       +
       assert (!libsOnly) -> kernel != null;

     

       7
       13
        
       

     

       8
       14
        
       # If you want to use a different Xorg version probably

     

       9
       15
        
       # DIR_DEPENDING_ON_XORG_VERSION in builder.sh has to be adopted (?)

     
···

       21
       27
        
       # There is one issue left:

     

       22
       28
        
       # /usr/lib/dri/fglrx_dri.so must point to /run/opengl-driver/lib/fglrx_dri.so

     

       23
       29
        
       

     

       24
       24
       -
       # You eventually have to blacklist radeon module (?)

     

       25
       25
       -
       

     

       26
       26
       -
       assert stdenv.system == "x86_64-linux";

     

       30
       30
       +
       with stdenv.lib;

     

       27
       31
        
       

     

       28
       32
        
       stdenv.mkDerivation {

     

       29
       29
       -
         name = "ati-drivers-13.12-${kernel.version}";

     

       33
       33
       +
         name = "ati-drivers-14.4" + (optionalString (!libsOnly) "-${kernel.version}");

     

       30
       34
        
       

     

       31
       35
        
         builder = ./builder.sh;

     

       32
       36
        
       

     
···

       34
       38
        
         gcc = stdenv.gcc.gcc;

     

       35
       39
        
       

     

       36
       40
        
         src = fetchurl {

     

       37
       37
       -
           url = http://www2.ati.com/drivers/linux/amd-catalyst-13.12-linux-x86.x86_64.zip;

     

       38
       38
       -
           sha256 = "1c3fn328340by4qn99dgfj8c2q34fxdb2alcak0vnyc6bw7l5sms";

     

       41
       41
       +
           url = http://www2.ati.com/drivers/linux/amd-catalyst-14-4-rev2-linux-x86-x86-64-may6.zip;

     

       42
       42
       +
           sha256 = "1xbhn55yifis9b0lzb3s03hc1bcq8jmy7l96m4x8d842n7ji7qlk";

     

       39
       43
        
           curlOpts = "--referer http://support.amd.com/en-us/download/desktop?os=Linux%20x86_64";

     

       40
       44
        
         };

     

       41
       45
        
       

     
···

       51
       55
        
             mesa

     

       52
       56
        
           ];

     

       53
       57
        
       

     

       54
       54
       -
         kernel = kernel.dev;

     

       58
       58
       +
         inherit libsOnly;

     

       59
       59
       +
       

     

       60
       60
       +
         kernel = if libsOnly then null else kernel.dev;

     

       55
       61
        
       

     

       56
       62
        
         inherit glibc /* glibc only used for setting interpreter */;

     

       57
       63
        
       

     
···

       75
       81
        
           homepage = http://support.amd.com/us/gpudownload/Pages/index.aspx;

     

       76
       82
        
           license = licenses.unfree;

     

       77
       83
        
           maintainers = with maintainers; [marcweber offline];

     

       78
       78
       -
           platforms = [ "x86_64-linux" ];

     

       84
       84
       +
           platforms = platforms.linux;

     

       79
       85
        
           hydraPlatforms = [];

     

       80
       86
        
         };

     

       81
       81
       -
       

     

       82
       82
       -
         # moved assertions here because the name is evaluated when the NixOS manual is generated

     

       83
       83
       -
         # Don't make that fail - fail lazily when a users tries to build this derivation only

     

       84
       84
       -
         dummy =

     

       85
       85
       -
           # assert xorg.xorgserver.name == "xorg-server-1.7.5";

     

       86
       86
       -
           assert stdenv.system == "x86_64-linux"; # i686-linux should work as well - however I didn't test it.

     

       87
       87
       -
           null;

     

       88
       88
       -
       

     

       89
       87
        
       }

-18

pkgs/os-specific/linux/ati-drivers/gentoo-patches.patch

···

       31
       31
        
       +# endif

     

       32
       32
        
        #endif

     

       33
       33
        
        }

     

       34
       34
       -
        

     

       35
       35
       -
       

     

       36
       36
       -
       diff -urN a/common/lib/modules/fglrx/build_mod/kcl_acpi.c common/lib/modules/fglrx/build_mod/kcl_acpi.c

     

       37
       37
       -
       --- a/common/lib/modules/fglrx/build_mod/kcl_acpi.c	2013-12-27 13:32:34.734832283 +0100

     

       38
       38
       -
       +++ b/common/lib/modules/fglrx/build_mod/kcl_acpi.c	2013-12-27 13:33:31.849831765 +0100

     

       39
       39
       -
       @@ -1002,7 +1002,11 @@

     

       40
       40
       -
        #endif

     

       41
       41
       -
            {

     

       42
       42
       -
                return KCL_ACPI_ERROR;

     

       43
       43
       -
       -    }    

     

       44
       44
       -
       +    }

     

       45
       45
       -
       +#if LINUX_VERSION_CODE >= KERNEL_VERSION(3,9,1)

     

       46
       46
       -
       +    ((acpi_tbl_table_handler)handler)(hdr);

     

       47
       47
       -
       +#else

     

       48
       48
       -
            ((acpi_table_handler)handler)(hdr);

     

       49
       49
       -
       +#endif

     

       50
       50
       -
            return KCL_ACPI_OK;

     

       51
       51
       -
        }