Installer les pilotes ATI

Article écrit et wikisé par Sébastien KALT.

Ce document explique comment installer une carte Gigabyte MAYA II Radeon 9700pro sous Debian Sarge.

Il s'inspire fortement du document de Flavio Stanchina pour la partie concernant la création des paquets Debian.

Il vous faut le support AGP pour que les pilotes puissent marcher correctement. Vous pouvez soit utiliser le module du noyau, soit utiliser le support interne aux pilotes ATI. Si les deux marchent, faites des essais pour voir si l'une des méthodes est plus performante que l'autre.

Vous avez juste besoin du support AGP si vous souhaitez utiliser le pilote agpgart du noyau. L'idéal est de le compiler en module pour avoir le choix entre l'utiliser ou ne pas l'utiliser, telle est la question …

Pour les noyaux 2.6.xx il y a deux modules à compiler : agpgart et le module spécifique à votre carte mère (via-agp, nvidia-agp, …)

Voici un tableau qui reprend les options affectant le pilote fglrx, si vous rencontrez des problèmes essayez de compiler votre noyau avec ces options :

Un fois votre noyau compilé et installé, on va charger le module AGP et vérifier que tout se passe bien :

# modprobe -k via-agp
Linux agpgart interface v0.100 (c) Dave Jones
agpgart: Detected VIA KT400/KT400A/KT600 chipset
agpgart: Maximum main memory to use for agp memory: 439M
agpgart: AGP aperture is 256M @ 0xe0000000

Pour que le module se charge automatiquement au démarrage de votre machine, il faut rajouter dans votre fichier /etc/modules :

# driver port AGP
# pour 2.6.x
via-agp

Deux méthodes permettent d'arriver au même résultat:

• récupérer les pilotes sur le site ATI et les compiler,
• récupérer les scripts de Flavio Stanchina et compiler des paquets Debian.

Personnellement je trouve la deuxième méthode plus propre, mais chacun est maître de sa machine !

Quoi que vous choisissiez, il y a quelques paquets à avoir sur sa machine :

# apt-get install debhelper libqt3-mt-dev xlibs-dev fakeroot rpm wget

Vous aurez besoin des pilotes fournis par ATI. Normalement ils sont disponibles sur leur site. Sinon essayez ce site (les pilotes sont communs à toutes les cartes ATI, y compris les FireGL). Au 30 octobre 2005, la dernière version disponible est la 8.18.6, et les notes de version sont disponibles sur le site ATI (ils n'autorisent plus de lien pointant directement vers la page, je vous laisse chercher …).

Pour une Debian Sarge, il faut récupérer la version pour XFree 4.3.0. Comme vous pouvez le voir, l'archive fournie est au format rpm, ce qui n'est pas très utile sur une Debian. Il faut donc bidouiller un peu pour faire l'installation. Créez un répertoire radeon et mettez-y le fichier (pour la suite, x.x.x = 8.18.6) :

$ cd /usr/local/src
$ mkdir radeon
$ cd radeon
$ wget http://www2.ati.com/drivers/linux/fglrx-4.3.0-x.x.x.i386.rpm

Pour cela il faut utiliser rpm2cpio (si ce n'est pas déjà fait, installez le paquet “rpm” : apt-get install rpm) :

$ rpm2cpio fglrx-4.3.0-x.x.x.i386.rpm | cpio -i --make-directories

Maintenant il va falloir compiler le module ATI spécifique.

Les modules sont dans le répertoire lib/modules/fglrx/. Pour les recompiler on va commencer par copier le répertoire dans /lib/modules/ :

# cp -r lib/modules/fglrx /lib/modules
$ cd /lib/modules/fglrx/build_mod
# sh make.sh

Les modules compilés sont placés dans /lib/modules/fglrx/.

$ cd ..
# ./make_install.sh
- creating symlink
- recreating module dependency list
- trying a sample load of the kernel module
Warning: loading /lib/modules/2.4.20/kernel/drivers/char/drm/fglrx.o will taint the kernel: non-GPL license - Proprietary. (C) 2002 - ATI Technologies, Starnberg, GERMANY
[fglrx] Maximum main memory to use for locked dma buffers: 432 MBytes.
ACPI: PCI interrupt 0000:01:00.0[A] -> GSI 16 (level, low) -> IRQ 16
[fglrx] module loaded - fglrx 3.14.1 [Sep 27 2004] on minor 0
[fglrx] module unloaded - fglrx 3.14.1 [Sep 27 2004] on minor 0
done.

Et voilà, les modules sont installés. N'oubliez pas de recommencer à chaque fois que vous compilez un nouveau noyau.

Maintenant il faut installer les pilotes nécessaires pour XFree :

# cd /usr/local/src/radeon/usr/X11R6
# cp -a lib/modules/* /usr/X11R6/lib/
# mv /usr/X11R6/lib/libGL.so.1.2 /usr/X11R6/lib/OLD.libGL.SO.1.2
# cp lib/libGL.so.1.2 /usr/X11R6/lib
# cp bin/* /usr/X11R6/bin

Cette dernière commande copie quelques utilitaires, comme fglrxconfig pour générer votre fichier XF86Config-4. Il est déconseillé de l'utiliser (cf section configuration).

Au 30 octobre 2005, les scripts fournis par Flavio Stanchina vont empaqueter les pilotes ATI version 8.18.6. Vous pouvez empaqueter une version différente des pilotes en utilisant une variable d'environnement lors de l'invocation de debian/rules. Cette option n'a pas beaucoup été testée, elle est donc réservée aux utilisateurs qui savent ce qu'ils font !

Le script détecte la version de XFree86 présente sur votre machine, et il téléchargera automatiquement le pilote ATI correspondant. Vous pouvez demander une version de pilote différente, mais cette manipulation n'est pas documentée, à réserver donc aux pros qui trouveront d'eux-même.

Voici les deux fichiers à télécharger :

• fglrx-installer_8.18.6-1.dsc (850 octets)
• fglrx-installer_8.18.6-1.tar.gz (36 515 octets)

On va placer ces fichiers dans un répertoire radeon, puis on va les dépaqueter (x.x.xx-x = 8.18.6-1):

$ mkdir /usr/local/src/radeon
$ cd /usr/local/src/radeon
$ wget http://xoomer.virgilio.it/flavio.stanchina/debian/fglrx-installer_x.x.xx-x.dsc
$ wget http://xoomer.virgilio.it/flavio.stanchina/debian/fglrx-installer_x.x.xx-x.tar.gz
$ dpkg-source -x fglrx-installer_x.x.xx-x.dsc
$ cd fglrx-installer-x.x.xx
$ fakeroot debian/rules binary

Le script va télécharger le pilote sur le site ATI, puis il va construire les paquets suivant :

• fglrx-driver_x.x.xx-x_arch.deb (pilote ATI)
• fglrx-driver-dev_x.x.xx-x_arch.deb
• fglrx-kernel-src_x.x.xx-x_arch.deb (source du module noyau à compiler)
• fglrx-control-qt2_x.x.xx-x_arch.deb
• fglrx-control-qt3_x.x.xx-x_arch.deb (contient le panneau de contrôle sous X, uniquement pour XFree86 4.3)
• fglrx-sources_x.x.xx-x_arch.deb

Maintenant il ne reste plus qu'à installer les paquets :

apt-get remove "fglrx-4.*"

# dpkg -i fglrx-driver_x.x.xx-x_arch.deb
# dpkg -i fglrx-kernel-src_x.x.xx-x_arch.deb
# dpkg -i fglrx-control-qt3_x.x.xx-x_arch.deb

Le paquet -driver-dev contient les en-têtes et la bibliothèque statique libfglrx_gamma.a, ce qui est utile uniquement si vous comptez développer des applications pour les cartes ATI ; le paquet sources contient les sources du panneau de contrôle.

L'installation du paquet -kernel-src a placé un fichier dans le répertoire /usr/src/. On va y aller et le décompresser :

$ cd /usr/src
$ tar -xvzf fglrx-kernel-src.tar.gz

Cela crée un répertoire /usr/src/modules/fglrx-kernel-src contenant les modules du noyau à compiler. Vous pouvez le faire de différentes façons : avec le script fourni, avec le makefile du noyau (pour les versions 2.6.x), ou avec make-kpkg. C'est, bien sûr, cette dernière méthode que je vous conseille.

Ces méthodes compilent un module pour la même version que le noyau qui tourne sur votre machine. Normalement les nouveaux pilotes ATI peuvent se compiler avec les fichiers d'en-têtes de votre noyau, mais je n'ai pas testé cette façon de procéder.

Si la méthode avec les en-têtes du noyau ne marche pas, il vous faut récupérer les sources de votre noyau et le configurer correctement :

$ apt-get install kernel-source-2.x.y
$ cd /usr/src
$ tar xjvf kernel-source-2.x.y.tar.bz2
$ cd kernel-source-2.x.y
$ cp /boot/config-2.x.y-saveur .config
$ make-kpkg --append-to-version "-flavour" --revision 2.x.y-z --config old configure

-saveur dépend de votre architecture, par exemple -1-k7 pour un Athlon.

Cette méthode compile un module pour la même version que le noyau qui tourne sur votre machine, sources dont vous avez besoin.

$ cd /usr/src/modules/fglrx-kernel-src
$ ./make.sh

Cette méthode compile un module pour la même version que le noyau qui tourne sur votre machine. Si vous n'arrivez pas à compiler un module avec la méthode make-kpkg, essayez cette méthode et installez le module à la main. Si le module marche alors vous devez juste vous trompez dans les paramètres de make-kpkg.

$ cd /usr/src/linux
$ make SUBDIRS=/usr/src/modules/fglrx-kernel-src modules

$ cd /usr/src/linux
$ fakeroot make-kpkg --append-to-version "-flavour" --added-modules fglrx-kernel-src modules_image

-flavour doit correspondre à la valeur de votre noyau, quelque chose comme -1-k7 pour un noyau précompilé par Debian pour un processeur Athlon. Il ne vous reste plus maintenant qu'à installer le paquet :

$ cd ..
# dpkg -i /usr/src/fglrx-kernel-x.y.z_x.x.xx-x+kernelversion_i386.deb

Je viens juste de tester cette méthode avec un noyau 2.6.10 (sources non-Debian), et ça marche très bien !

# module-assistant -k /usr/src/linux update
# module-assistant -k /usr/src/linux build fglrx-kernel
# module-assistant -k /usr/src/linux install fglrx-kernel

Si vous préférez construire les paquets avec module-assistant depuis votre compte utilisateur :

$ mkdir ~/src/modass
$ module-assistant -u ~/src/modass -k ~/src/linux update
$ module-assistant -u ~/src/modass -k ~/src/linux build fglrx-kernel
$ module-assistant -u ~/src/modass -k ~/src/linux install fglrx-kernel

Si vous avez compilé votre module à l'aide de la commande make-kpkg, vous avez un paquet Debian à installer. Sinon vous devez copier le module du répertoire /usr/src/modules/fglrx-kernel-src vers le répertoire des modules de votre noyau, /lib/modules/2.6.8* par exemple, puis lancer un depmod -ae :

# cp /usr/src/modules/fglrx-kernel-src/fglrx.ko /lib/modules/2.6.8./misc
# depmod -ae

Maintenant il ne reste plus qu'à charger le module :

# modprobe -k fglrx
[fglrx] Maximum main memory to use for locked dma buffers: 431 MBytes.
ACPI: PCI interrupt 0000:01:00.0[A] -> GSI 16 (level, low) -> IRQ 16
[fglrx] module loaded - fglrx 8.8.25 [Jan 14 2005] on minor 0

Si le module n'arrive pas à se charger, vérifiez que vous avez bien installé le module du noyau, que vous avez lu l'avertissement concernant le bogue #248624, et consultez votre dmesg pour d'éventuels messages d'erreurs.

# cp /etc/X11/XF86Config-4 /etc/X11/XF86Config-4.custom
# md5sum /etc/X11/XF86Config-4 > /var/lib/xfree86/XF86Config-4.md5sum
# dpkg-reconfigure xserver-xfree86

Editez votre fichier /etc/X11/XF86Config-4 pour avoir les options suivantes :

Section "Module"
...
Load "GLcore"
Load "glx"
Load "dri"
...
# Charge "extmod" mais sans DGA extension
SubSection "extmod"
Option "omit xfree86-dga"
EndSubSection
...
EndSection
Section "Device"
Identifier "ATI"
Driver "fglrx" # La partie importante
# Si X refuse de se charger à la résolution spécifiée,
# essayez de dé-commenter l'option suivante.
#Option "NoDDC"
# === Video Overlay for the Xv extension ===
Option "VideoOverlay" "on"
# === OpenGL Overlay ===
# Note: quand OpenGL Overlay est activé, Video Overlay
# est automatiquement désactivé.
Option "OpenGLOverlay" "off"
# === Use internal AGP GART support? ===
# Si l'accélération OpenGL ne marche pas, essayez de mettre "yes" ici
# et désactivez le module agpgart du noyau.
Option "UseInternalAGPGART" "no"
EndSection
Section "Screen"
Identifier "your screen"
Device "ATI"
Monitor "your monitor"
DefaultDepth 24
SubSection "Display"
Depth 24
Modes "1280x960" # juste un exemple,
# mettez votre résolution préférée ici
EndSubSection
EndSection
Section "DRI"
Mode 0666
EndSection

Stoppez et redémarrez votre serveur X. Si vous utilisez gdm, voici comment faire :

# /etc/init.d/gdm restart

Remplacez gdm par kdm ou xdm selon votre configuration.

Les pilotes ATI sont fournis sans aucun support, et sans aucune garantie. Si vous endommagez votre système, je ne peux en aucun cas être tenu pour responsable, vous avez utilisé cette documentation à vos risques et périls.

Une fois X chargé, vous pouvez vérifier que l'accélération fonctionne bien :

$ fglrxinfo
display: :0.0 screen: 0
OpenGL vendor string: ATI Technologies Inc.
OpenGL renderer string: RADEON 9500 Pro Generic
OpenGL version string: 1.3.4769 (X4.3.0-8.8.25)
$ glxinfo
name of display: :0.0
display: :0 screen: 0
direct rendering: Yes
[...]
$ glxgears
14188 frames in 5.0 seconds = 2837.600 FPS
14190 frames in 5.0 seconds = 2838.000 FPS
14187 frames in 5.0 seconds = 2837.400 FPS
$ fgl_glxgears
2928 frames in 5.0 seconds = 585.600 FPS
2860 frames in 5.0 seconds = 572.000 FPS
2702 frames in 5.0 seconds = 540.400 FPS
2808 frames in 5.0 seconds = 561.600 FPS

Ces résultats sont obtenus avec une carte ATI Radeon 9700 PRO en AGP 8x.

• Je tiens avant tout à remercier Flavio Stanchina pour son excellente documentation.
• ATI Radeon Linux How-To de Rage3D.com
• ATI Linux How-To v2.1 de linuX-gamers.net
• ATI Radeon de desktop-linux.net
• ATI Radeon FAQ de Gentoo
• Installation d'une carte Rage128/Radeon/Radeon 7500 de ati.fr.st