Sur certains PCs actuels il peut être nécessaire, ou désirable, de
charger des firmwares pour faire travailler les PC au maximum de
leurs possibilités. Le noyau contient un répertoire, /lib/firmware
, ou le noyau ou les pilotes du noyau
cherche des images de firmware.
Actuellement, on peut trouver la plupart des firmwares sur un dépôt
git
:
http://git.kernel.org/cgit/linux/kernel/git/firmware/linux-firmware.git/tree/.
Par commodité, le projet LFS a créé un miroir, mis à jour
quotidiennement, où on peut accéder à ces fichiers de firmwares via
wget
ou un navigateur
web sur https://anduin.linuxfromscratch.org/BLFS/linux-firmware/.
Pour récupérer le microprogramme, vous devez soit aller sur un des dépôts ci-dessus avec un navigateur pour télécharger les fichiers dont vous avez besoin, soit installer git-2.33.0 et cloner ce dépôt.
Pour certains autres firmwares, particulièrement pour les micro-codes d'Intel, et certains périphériques wi-fi, le firmware recherché n'est pas disponible dans le dépôt précédent. Certains d'entre eux seront ajouté ensuite, mais il est parfois nécessaire de faire une recherche sur internet pour les firmwares souhaités.
Les fichiers firmwares sont par convention référencés comme des blobs car vous ne pouvez pas déterminer ce qu'ils font. Notez que ces firmwares sont distribués sous des licences différentes et variées qui ne permettent pas le désassemblage ou la retro ingénierie.
Les firmwares pour PC tombent dans 4 catégories :
Les firmwares mettant à jour le processeur pour travailler correctement, couramment appelé micro-code.
Microprogramme pour les contrôleurs vidéo. Sur les machines x86 ils sont requis pour les périphériques ATI (puces Radeon et AMDGPU) et peuvent être utiles pour les GPU Intel (Skylake et ultérieur) et Nvidia (Kepler et ultérieurs).
Les périphériques ATI Radeom et AMDGPU demandent des microprogrammes pour pouvoir utiliser le KMS (kernel modesetting — l'option préférée) ainsi que Xorg. Pour les puces radeon plus anciennes (avant R600), le microprogramme est resté dans le noyau.
Les GPU intégrés d'Intel de Skylake et supérieur peuvent utiliser le microprogramme pour GuC (the microcontrôleur graphique), et le le HuC (le microcontrôleur HEVC/H265 qui décharge vers le GPU) et DMC (microcontrôleur pour l'affichage) pour fournir des états à basse consommation supplémentaires. Le GuC et HuC ont un historique mouvementé dans le noyau et les microprogrammes à jour peuvent être désactivés par défaut, en fonction de la version de votre noyau. Des détails supplémentaires se trouvent sur 01.org et Arch linux.
Les GPU Nvidia à partir de Kepler ont besoin d'un microprogramme signé, sinon le pilote nouveau est incapable de fournir l'accélération matérielle. Nvidia a maintenant fourni des microprogrammes jusqu'à Turing (la plupart des GPU, sinon tous, GTX16xx et RTX20xx) dans linux-firmware, et les noyaux à partir de linux-5.6 les prennent en charge, bien que la prise en charge de Mesa puisse nécessiter une version de développement jusqu'à la publication de Mesa-20.2. Remarquez que les horloges plus rapides que par défaut ne sont pas activées dans le microprogramme publié.
Mises à jour des firmware pour les interfaces réseaux filaires. La plupart du temps elles fonctionnent sans mise à jour, mais elles fonctionneront sans doute mieux avec un firmware à jour. Pour certains ordinateurs portables récentes, les firmware pour le port ethernet (p. ex. rtl_nic) mais aussi pour les périphériques bluetooth (p. ex. qca) sont requis avant de pouvoir utiliser les réseau filaire.
Les Firmwares pour les autres périphériques, comme le wi-fi. Ces périphériques ne sont pas requis pour que le PC démarre, mais demande un firmware avant que ces périphériques puissent être utilisés.
Bien qu’ils soient inutiles pour charger un firmware fermé (blob), les outils suivants peuvent être utiles pour déterminer, obtenir, ou préparer le firmware à utiliser afin de le charger dans le système : cpio-2.13, git-2.33.0, pciutils-3.7.0 et Wget-1.21.1
Notes utilisateur : https://wiki.linuxfromscratch.org/blfs/wiki/aboutfirmware
En général, le micro-code peut être chargé par le BIOS ou l'UEFI, et il peut être mis à jour en passant à une nouvelle version de celui-ci. Sur Linux, vous pouvez également charger le micro-code depuis le noyau si vous utilisez au moins un AMD de la famille 10h ou un plus récent (introduit après fin 2007), ou un processeur Intel de 1998 et plus (Pentium4, Core, etc), si un micro-code mis à jour a été publié. Ces mises à jour sont actives seulement jusqu'à ce que la machine soit éteinte, il est donc nécessaire de les appliquer à chaque démarrage.
Intel fournit des mises à jour de leur microcode pour les versions Skylake et ultérieures de leurs processeurs quand de nouvelles vulnérabilités sont découvertes, et l'ont fait pour les processeurs SandyBridge et ultérieurs par le passé, bien qu'ils ne soient plus pris en charge pour les nouvelles corrections. Les nouvelles versions de microprogramme d'AMD sont rares et ne s'appliquent qu'à quelques modèles, bien que les fabricants de carte mères obtiennent des mises à jour supplémentaires et peuvent mettre à jour des microcodes avec des changements pour supporter de nouveau CPU ou une mémoire plus rapide.
Il y a deux façons de charger le microcode, décrit comme « au plus tôt » et « le plus tard ». Le chargement « au plus tôt » arrive avant que l'espace utilisateur ne démarre, le chargement « le plus tard » arrive quand l'espace utilisateur est démarré. Sans surprise, le chargement « au plus tôt » est préféré (voir par exemple un commentaire d'explication dans un commit du noyau noté x86/microcode: Early load microcode sur LWN). En effet, il est nécessaire de contourner une erreur particulière dans les premiers processeurs Intel Haswell qui ont le TSX d'activé. (Voir Intel Disables TSX Instructions: Erratum Found in Haswell, Haswell-E/EP, Broadwell-Y). Sans cette mise à jour glibc peut produire des erreurs dans des situations particulières.
Il reste possible de manuellement forcer le chargement « au
plus tard » du microcode, soit pour tester soit pour éviter de
devoir redémarrer. Vous devrez reconfigurer votre noyau pour l'une
ou l'autre méthode. Les instructions ici créeront un fichier
.config
du noyau pour satisfaire un
chargement « au plus tôt », avant de forcer le chargement
« au plus tard » pour voir s'il reste des microcodes. Si
tel est le cas, les instructions vous montrent comment créer un
initrd pour un chargement « au plus tôt ».
Pour confirmer quel(s) processeur(s) vous avez (si plus d'un, ils seront identiques) regardez dans /proc/cpuinfo.
Si vous créez un initrd pour mettre à jour le microcode de différentes machines, comme le ferait une distro, regardez « Chargement du microcode au plus tôt » et regardez tous les blobs Intel de GenuineIntel.bin ou tous ceux de AUthenticAMD.bin. cela créer un gros initrd — pour toutes les machines Intel dans la mise à jour 20200609 la taille est de 3,0 Mo par rapport à 24 Ko pour une seule machine.
La première étape est d'obtenir la version la plus récente du
microcode d'Intel. Vous devez pour cela aller sur
https://github.com/intel/Intel-Linux-Processor-Microcode-Data-Files/releases/
et télécharger le fichier le plus récent. Au moment de l'écriture
de ces lignes la version la plus récente du micro-code est
microcode-20210608. Extrayez ce fichier normalement, le microcode
se trouve dans le répertoire intel-ucode
qui contient les divers blobs avec
des noms de la forme XX-YY-ZZ. Il y a aussi d'autres fichiers
divers et un fichier releasenote.
Par le passé, intel ne fournissait aucun détail sur les blobs qui changeaient de version, mais maintenant les notes de versions contiennent ces détails.
Le firmware récent pour les processeurs les plus anciens est fournit pour traiter des vulnérabilités qui ont été rendue publiques, et pour certains d'entre eux comme le Microarchitectural Data Sampling (MDS) vous pourriez vouloir augmenter la protection en désactivant l'hyperthreading ou en désactivant les contournements par défaut du noyau à cause de son impact sur les temps de compilation. Lisez bien la documentation en ligne sur https://www.kernel.org/doc/html/latest/admin-guide/hw-vuln/index.html.
Maintenant vous devez déterminer l'identité de votre processeur, pour voir s'il y a un micro-code pour lui. Déterminez les valeurs décimales de la famille du processeur, le modèle, et le pas en lançant la commande suivante (elle rapportera aussi la vesrion actuelle du micro-code) :
head -n7 /proc/cpuinfo
Convertissez la famille du CPU, le modèle et le pas en paire de chiffres hexadécimaux. Pour un Skylake i3 6100 (décrit comme un Intel(R) Core(TM) i3-6100 CPU) les bonnes valeurs sont famille de processeur 6, modèle 94, pas 3 donc dans ce cas l'identification requise est 06-5e-03. Un coup d’œil sur les blobs montrera qu'il y en a un pour ce processeur (mais les versions plus anciennes peuvent déjà être appliquées par le BIOS). S'il y a un blob pour votre système alors testez s'il peut être appliqué en le copiant (remplacez <XX-YY-ZZ> par l'identifiant de votre machine) là où le noyau pourra le trouver :
mkdir -pv /lib/firmware/intel-ucode cp -v intel-ucode/<XX-YY-ZZ> /lib/firmware/intel-ucode
Maintenant que le micro-code Intel a été préparé, utilisez les options suivantes quand vous configurez le noyau pour charger le microcode Intel :
General Setup --->
[*] Initial RAM filesystem and RAM disk (initramfs/initrd) support [CONFIG_BLK_DEV_INITRD]
Processor type and features --->
[*] CPU microcode loading support [CONFIG_MICROCODE]
[*] Intel microcode loading support [CONFIG_MICROCODE_INTEL]
Après avoir démarré avec succès votre nouveau système, forcez le chargement "au plus tard" en utilisant la commande :
echo 1 > /sys/devices/system/cpu/microcode/reload
Ensuite utilisez la commande suivante pour vérifier que tout est bien chargé (N.B. les dates de création du microcode peuvent être des mois plus tôt par rapport à leur diffusion).
dmesg | grep -e 'microcode' -e 'Linux version' -e 'Command line'
Cet exemple reformaté pour une machine avec un ancien microcode dans son BIOS a été créé en démarrant temporairement sans les microcodes, pour montrer le message actuel de Bogue Firmware, puis le chargement au plus tard montre la révision mise à jour vers la 0xea.
[ 0.000000] Linux version 5.12.8 (lfs@leshp) (gcc (GCC) 11.1.0,
GNU ld (GNU Binutils) 2.36.1)
#2 SMP PREEMPT Fri Jun 4 01:25:02 BST 2021
[ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-5.12.8-sda11 root=/dev/sda11 ro
resume=/dev/sda10
[ 0.028741] [Firmware Bug]: TSC_DEADLINE disabled due to Errata;
please update microcode to version: 0xb2 (or later)
[ 0.115716] SRBDS: Vulnerable: No microcode
[ 0.115826] MDS: Vulnerable: Clear CPU buffers attempted, no microcode
[ 0.389005] microcode: sig=0x506e3, pf=0x2, revision=0x74
[ 0.389030] microcode: Microcode Update Driver: v2.2.
[ 70.089502] microcode: updated to revision 0xea, date = 2021-01-25
[ 70.089528] x86/CPU: CPU features have changed after loading microcode,
but might not take effect.
[ 70.089530] microcode: Reload completed, microcode revision: 0xea
Si le micro-code n'a pas été mis à jour, il n'y a pas de nouveau micro-code pour ce processeur. S'il a été mis à jour, vous pouvez maintenant faire la section intitulée la section intitulée « Chargement "tôt" du micro-code ».
Commencez par télécharger un paquet de firmware pour votre
famille de CPU sur
https://anduin.linuxfromscratch.org/BLFS/linux-firmware/amd-ucode/.
La famille est toujours spécifiée en hexadécimal. Les familles
10h à 14h (16 à 20) sont dans microcode_amd.bin. Les familles
15h, 16h et 17h ont leur propre paquet. Créez le répertoire
requis et placez le firmware télécharger dedans en tant
qu'utilisateur root
:
mkdir -pv /lib/firmware/amd-ucode cp -v microcode_amd* /lib/firmware/amd-ucode
Quand vous configurez le noyau, utilisez les options suivantes pour charger le micro-code AMD :
General Setup --->
[*] Initial RAM filesystem and RAM disk (initramfs/initrd) support [CONFIG_BLK_DEV_INITRD]
Processor type and features --->
[*] CPU microcode loading support [CONFIG_MICROCODE]
[*] AMD microcode loading support [CONFIG_MICROCODE_AMD]
Après avoir démarré avec succès votre nouveau système, forcez le chargement "au plus tard" en utilisant la commande :
echo 1 > /sys/devices/system/cpu/microcode/reload
Ensuite utilisez la commande suivante pour voir si quelque chose a été chargé :
dmesg | grep -e 'microcode' -e 'Linux version' -e 'Command line'
Cet exemple historique d'un ancien Athlon(tm) II X2 montre qu'il a été mis à jour. Actuellement, tous les CPU sont encore signalés dans les détails du microcode sur les machines AMD (la position actuelle d'AMD pour les machines où un nouveau microcode est disponible est inconnue) :
[ 0.000000] Linux version 4.15.3 (ken@testserver) (gcc version 7.3.0 (GCC))
#1 SMP Sun Feb 18 02:08:12 GMT 2018
[ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-4.15.3-sda5 root=/dev/sda5 ro
[ 0.307619] microcode: CPU0: patch_level=0x010000b6
[ 0.307671] microcode: CPU1: patch_level=0x010000b6
[ 0.307743] microcode: Microcode Update Driver: v2.2.
[ 187.928891] microcode: CPU0: new patch_level=0x010000c8
[ 187.928899] microcode: CPU1: new patch_level=0x010000c8
Si le micro-code n'a pas été mis à jour, il n'y a pas de nouveau micro-code pour ce processeur. S'il a été mis à jour, vous pouvez maintenant faire la section intitulée la section intitulée « Chargement "tôt" du micro-code ».
Si vous avez établi qu'un micro-code mis à jour est disponible pour votre système, il est temps de le préparer pour un chargement "tôt". Cela demande un paquet supplémentaire, cpio-2.13 et la création d'un initrd qui devra être ajouté à grub.cfg.
L'endroit ou vous préparez l'initrd n'est pas important, et une fois fonctionnel vous pouvez appliquer le même initrd aux versions futures de LFS ou aux nouveaux noyaux sur cette même machine, au moins jusqu'à ce qu'une nouvelle version du micro-code soit publiée. Utiliser la suite :
mkdir -p initrd/kernel/x86/microcode cd initrd
Pour une machine AMD, utilisez la commande suivante (remplacez <MYCONTAINER> par le nom du paquet de votre famille de CPU) :
cp -v /lib/firmware/amd-ucode/<MYCONTAINER> kernel/x86/microcode/AuthenticAMD.bin
Ou pour une machine Intel copiez le blob approprié en utilisant cette commande :
cp -v /lib/firmware/intel-ucode/<XX-YY-ZZ> kernel/x86/microcode/GenuineIntel.bin
Maintenant préparez l'initrd :
find . | cpio -o -H newc > /boot/microcode.img
Vous devrez également ajouter une nouvelle entrée à /boot/grub/grub.cfg et vous devrez ajouter une ligne après la ligne linux entre les apostrophes. Si /boot est dans une partition séparée :
initrd /microcode.img
ou sinon :
initrd /boot/microcode.img
Si vous avez déjà démarré avec un initrd (voir la section
intitulée « À propos de initramfs ») vous deviez de
nouveau lancer mkinitramfs après avoir placé
le blob ou le conteneur approprié dans /lib/firmware
comme expliqué ci-dessus.
Autrement, vous pouvez avoir les deux initrd sur la même ligne,
comme dans initrd /microcode.img
/other-initrd.img
(adaptez comme ci-dessus si
/boot n'est pas dans une partition séparée) :
Vous pouvez maintenant redémarrer avec l'initrd ajouté, et ensuite utiliser la même commande pour vérifier que le chargement « au plus tôt » a fonctionné.
dmesg | grep -e 'microcode' -e 'Linux version' -e 'Command line'
Si vous avez mis à jour pour corriger des vulnérabilités, vous
pouvez regarder dans /sys/devices/system/cpu/vulnerabilities/
pour
voir ce qu'il rapporte maintenant.
Les endroits et les moments où le chargement au plus tôt se passent sont très différents entre les machines AMD et Intel. En premier, un exemple d'Intel (Skylake) avec le chargement au plus tôt :
[ 0.000000] microcode: microcode updated early to revision 0xea, date = 2021-01-25
[ 0.000000] Linux version 5.12.8 (lfs@leshp) (gcc (GCC) 11.1.0,
GNU ld (GNU Binutils) 2.36.1) #2 SMP PREEMPT Fri Jun 4 01:25:02 BST 2021
[ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-5.12.8-sda11 root=/dev/sda11 ro
resume=/dev/sda10
[ 0.381420] microcode: sig=0x506e3, pf=0x2, revision=0xea
[ 0.381479] microcode: Microcode Update Driver: v2.2.
Un exemple historique pour AMD :
[ 0.000000] Linux version 4.15.3 (ken@testserver) (gcc version 7.3.0 (GCC))
#2 SMP Sun Feb 18 02:32:03 GMT 2018
[ 0.000000] Command line: BOOT_IMAGE=/vmlinuz-4.15.3-sda5 root=/dev/sda5 ro
[ 0.307619] microcode: microcode updated early to new patch_level=0x010000c8
[ 0.307678] microcode: CPU0: patch_level=0x010000c8
[ 0.307723] microcode: CPU1: patch_level=0x010000c8
[ 0.307795] microcode: Microcode Update Driver: v2.2.
Ces instructions NE s'appliquent PAS aux anciennes radeons avant
la famille R600. Pour elles, le firmware est dans le répertoire
du noyau /lib/firmware/
.
Appliquez-les seulement si vous prévoyez d'éviter une
configuration graphique tels que Xorg et que vous voulez vous
contenter d'utiliser l'affichage 80x25 par défaut plutôt qu'un
framebuffer.
Les périphériques radeon plus anciens demandaient seulement un simple blob de 2 Ko. Les périphériques récents ont besoin de plusieurs blobs différents, et certains d'entre eux sont bien plus gros. La taille totale du répertoire des firmwares radeon est de plus de 500 Ko — sur un gros système moderne vous pouvez probablement utiliser cet espace, mais cela reste redondant d'installer tous les fichiers inutiles chaque fois que vous construisez un système.
Une meilleure approche est d'installerpciutils-3.7.0 et ensuite utiliser
lspci
pour
identifier quel controleur VGA est installé.
Avec cette information, vérifiez la page RadeonFeature du wiki Xorg Decoder ring for engineering vs marketing names pour identifier la famille (vous aurez besoin de savoir cela pour identifier le pilote Xorg dans BLFS — Southern Islands et Sea Islands utilise le pilote radeonsi) et le modèle spécifique.
Maintenant que vous savez quel contrôleur vous allez utiliser, consultez la page Radeon du wiki de Gentoo qui a un tableau listant les blobs de firmware requis pour les différentes puces. Notez que les puces Southern Islands et Sea Islands utilisent des firmwares différents pour les noyaux 3.17 et supérieur par rapport aux noyaux antérieurs. Identifiez et téléchargez les blobs requis et ensuite installez les :
mkdir -pv /lib/firmware/radeon cp -v <YOUR_BLOBS> /lib/firmware/radeon
Il y a en fait deux façons d'installer ces firmwares. BLFS, dans le sous-chapitre 'Configuration du noyau pour les firmwares supplémentaires' du chapitre Xorg ATI Driver-19.1.0 donne un exemple de compilation des firmwares dans le noyau - c'est légèrement plus rapide à charger, mais utilises plus de mémoire pour le noyau. Ici nous utiliserons la méthode alternative en faisant un module du pilote radeon. Dans votre configuration du noyau initialisez la suite :
Device Drivers --->
Graphics support --->
Direct Rendering Manager --->
[*] Direct Rendering Manager (XFree86 ... support) [CONFIG_DRM]
[M] ATI Radeon [CONFIG_DRM_RADEON]
Le chargement de plusieurs blobs volumineux dans /lib/firmware prend un temps notable, pendant lequel l'écran est blanc. Si vous n'avez pas activé le logo framebuffer du pingouin, ou changé la taille de la console en utilisant une police plus grosse, cela n'a probablement pas d'importance. Si vous le souhaitez, vous pouvez légèrement réduire le temps si vous suivez la méthode alternative en spécifiant 'y' pour CONFIG_DRM_RADEON couvert dans BLFS au lien précédent — vous devez spécifier chaque blob radeon utile si vous faite cela.
Certaines puces graphiques Nvidia requièrent une mise à jour de leur firmware pour tirer parti de toutes les capacités de la carte. Ce sont généralement les puces des séries GeForce 8, 9, 9300 et 200-900. Pour de plus amples informations, visitez https://nouveau.freedesktop.org/wiki/VideoAcceleration/#firmware.
Tout d'abord, le pilote Nvidia doit être activé dans le noyau :
Device Drivers --->
Graphics support --->
Direct Rendering Manager --->
<*> Direct Rendering Manager (XFree86 ... support) [CONFIG_DRM]
<*/M> Nouveau (NVIDIA) cards [CONFIG_DRM_NOUVEAU]
Les étapes pour installer le firmware Nvidia sont :
wget https://raw.github.com/imirkin/re-vp2/master/extract_firmware.py wget http://us.download.nvidia.com/XFree86/Linux-x86/325.15/NVIDIA-Linux-x86-325.15.run sh NVIDIA-Linux-x86-325.15.run --extract-only python extract_firmware.py mkdir -p /lib/firmware/nouveau cp -d nv* vuc-* /lib/firmware/nouveau/
Le noyau aime charger des firmware pour quelques pilotes réseaux,
particulièrement ceux du répertoire Realtek
(/lib/linux-firmware/rtl_nic/), mais il apparaît généralement que
cela fonctionne sans. Cependant, vous pouvez démarrer le noyau,
vérifier si dmesg contient des messages à propos de firmwares
manquants, et si nécessaire télécharger les firmwares et les mettre
dans un répertoire spécifique dans /lib/firmware
afin qu'ils puissent être trouvés
lors des prochains démarrages. Notez qu'avec les noyaux actuels
cela fonctionne que le pilote soit compilé dedans ou construit
comme un module, il n'est pas utile de construire ce firmware dans
le noyau. Ici un exemple ou le pilote R8169 a été compilé dedans
mais le firmware n'est pas disponible. Une fois que le firmware a
été fourni, il n'y est plus fait mention dans les démarrages
suivants.
dmesg | grep firmware | grep r8169
[ 7.018028] r8169 0000:01:00.0: Direct firmware load for rtl_nic/rtl8168g-2.fw failed with error -2
[ 7.018036] r8169 0000:01:00.0 eth0: unable to load firmware patch rtl_nic/rtl8168g-2.fw (-2)
Pour identifier le bon firmware vous devrez normallement install
pciutils-3.7.0 puis utiliser lspci
pour identifier le
matériel. Vous devriez ensuite chercher en ligne pour vérifier le
module qu’il utilise, quel firmware et où obtenir le firmware — ils
ne sont pas tous dans linux-firmware.
Si possible, vous pouvez commencer par utiliser une connexion filaire quand vous démarrez la première fois votre système LFS. Pour utiliser une connexion sans fils vous aurez besoin d'utiliser des outils réseau tel que Wireless Tools-29 et wpa_supplicant-2.9.
Plusieurs pays ont des réglementations différentes sur
l'utilisation du spectre radio des appareils sans-fil. Vous pouvez
installer un microprogramme pour qu'un appareil sans-fil obéisse
aux réglementations sur les émissions, pour ne pas être inquiété
par les autorités ou découvrir que votre wifi brouille les
fréquences d'autres appareils (par exemple des télécommandes). Le
microprogramme qui contient la base de régulations se trouve sur
https://kernel.org/pub/software/network/wireless-regdb/.
Pour l'installer, extrayez simplement regulatory.db
et regulatory.db.p7s
de l'archive vers /lib/firmware
. Le point d'accès envoie un code de
pays à votre antenne, et wpa_supplicant-2.9 le dit au noyau qui
charge les réglementations de ce pays à partir de regulatory.db
et les met en place.
Les firmwares peuvent aussi être utiles pour d'autres périphériques comme les contrôleurs SCSI, les adaptateurs Bluetooth, ou les enregistreurs TV. Les mêmes principes s'appliquent.
Last updated on