La tanière d'Ustilago

valid-css !

Valid XHTML 1.0!

Introduction

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.

Pré-requis au niveau du noyau

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.

Le support du jeu de composants VIA KT400 n'est pas idéal dans les noyaux 2.4.xx, je vous conseille d'utiliser un noyau 2.6.xx. Ma carte mère MSI KT4Ultra marche très bien avec un noyau 2.6.8 ainsi qu'un 2.6.10.

Options à compiler

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, ...).

Il ne faut surtout pas compiler en dur le support Direct Rendering Manager, cela peut empêcher le pilote de fonctionner correctement.

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 :

Options du noyau Remarques
CONFIG_MODULES=y
CONFIG_MODULE_UNLOAD=y
CONFIG_KMOD=y
Vérifiez bien que CONFIG_MODVERSIONS n'est pas sélectionné
CONFIG_MTRR=y Le pilote fglrx a besoin du support MTRR (Memory Type Range Register)
CONFIG_AGP=m
CONFIG_AGP_chipset=m
Activez les pilotes pour les jeux de composants AGP de votre carte mère, par exemple CONFIG_AGP_VIA, CONFIG_AGP_NVIDIA, ... Ne sélectionnez pas CONFIG_AGP=y si vous voulez utiliser le support AGP interne au pilote fglrx.
CONFIG_DRM=y
CONFIG_DRM_RADEON=m
Les logiciels détectant automatiquement le matériel peuvent vouloir charger le module DRM radeon lors du démarrage de votre machine. Si c'est votre cas, personalisez la configuration des logiciels de détection pour les en empêcher, ou ne compilez pas ce module.
# CONFIG_FB is not set CONFIG_FB_VESA=y est censé marcher, mais apparement cela peut occasionner des erreurs de "mtrr overlapping";
CONFIG_FB_RADEON=y est source de problèmes, à désactiver absolument.
CONFIG_TMPFS=y ATI proclame POSIX shared memory is required!

Chargement des modules

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

Compilation et installation des pilotes

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

Personnellement je trouve la deuxième méthode plus propre, mais chacun est maitre 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

Première méthode : compiler les pilotes ATI directement

Fichiers nécessaires

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 27 décembre 2005, la dernière version disponible est la 8.19.10, et les notes de version sont disponibles ici.

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 :

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

Extraction de l'archive 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.xx.i386.rpm | cpio -i --make-directories

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

Compilation des modules

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/.

Installation des modules

$ 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.

Installation des pilotes pour XFree

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/X22R6/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).

Deuxième méthode : compiler des paquets Debian

Fichiers nécessaires

Au 27 décembre 2005, les scripts fournis par Flavio Stanchina vont empaqueter les pilotes ATI version 8.19.10. 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.

Flavio a intégré le support pour module-assistant. Il a dû supprimer du nom des paquet la version d'X pour laquelle ils sont créés, il faudra donc veiller à supprimer manuellement l'ancienne version lors de la mise à jour.

Voici les deux fichiers à télécharger :

Création et installation des paquets Debian

On va placer ces fichiers dans un répertoire radeon, puis on va les dépaqueter (x.x.xx-x = 8.19.10-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 :

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

attention N'oubliez pas de supprimer l'ancienne version des pilotes avant la mise à jour en exécutant : apt-get remove "fglrx-4.*"
# dpkg -i fglrx-driver_x.x.xx-x_i386.deb (pilote ATI)
# dpkg -i fglrx-kernel-src_x.x.xx-x_i386.deb (source du module noyau à compiler)
# dpkg -i fglrx-control-qt3_x.x.xx-x_i386.deb (contient le panneau de contrôle sous X)

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.

Compilation des modules du noyau

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çon : 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.

attention 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.

Compilation avec le script ATI

Cette méthode compile un module pour la même version que le noyau qui tourne sur votre machine.

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

Compilation avec le makefile du noyau (uniquement pour 2.6.x)

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

Compilation à l'aide de la commande make-kpkg

$ 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

attention Si vous compilez vos propres paquets il est souhaitable que vous mettiez à jour le paquet debhelper vers la version 4.2.11 (voir le bogue Debian #248624), sinon vous aurez besoin de lancer manuellement un update-modules après l'installation du paquet.

Compilation avec module-assistant

J'ai testé cette méthode, 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

Installation du module du noyau

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.

attention si vous avez une erreur du genre unresolved symbol dev_base_R863b01ad, cela signifie que le module a été compilé avec l'option CONFIG_MODVERSIONS=yes alors que le noyau en cours d'exécution ne l'a pas été. Autrement dit, la configuration des sources du noyau est différente de celle du noyau en cours d'exécution : vérifiez que vous avez bien configuré les sources de votre noyau, et surtout que CONFIG_MODVERSIONSn'est pas activé.

Configuration de XFree

attention Le paquet du pilote fournit un outil de configuration automatique appelé fglrxconfig. Surtout ne l'utilisez pas ! Cet utilitaire est utile si vous voulez utiliser les fonctionnalités d'affichage sur deux écrans. Mais avant d'en arriver là, vérifiez au préalable que l'affichage sur un seul écran marche correctement. Quoi qu'il en soit, soyez prévenu que fglrxconfig remplacera votre fichier de configuration d'XFree86, alors faites en une sauvegarde avant toute chose !

attention si vous éditez manuellement votre fichier /etc/X11/XF86Config-4, il ne sera alors plus géré par debconf. Si vous voulez que debconf en reprenne la gestion, il faut faire :
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

Éditez 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.

Liens

Page maintenue par Sébastien KALT - Copyright (c) 1999-2011 Sébastien KALT.