---
title: "Ce Motorola 68000 pilote du PCI. Tout le travail est dans le traducteur"
locale: "fr"
url: "https://irz.fr/fr/articles/m68k-pci-traducteur-fr"
markdown_url: "https://irz.fr/fr/articles/m68k-pci-traducteur-fr.md"
category: "tech"
tags: ["Motorola 68000", "PCI", "FPGA", "rétro-informatique", "hardware"]
published_at: "2026-08-22T09:27:00.000Z"
author: "Léa Perrin"
translation: "https://irz.fr/en/articles/m68k-pci-translator-en.md"
---

# Ce Motorola 68000 pilote du PCI. Tout le travail est dans le traducteur

Brancher des cartes PCI sur un Motorola 68000 n'est pas un gag rétro. Le projet de maniek86 montre ce qu'il faut réellement traduire entre deux générations de bus : cycles, octets, adressage, interruptions et démarrage.

Un Motorola 68000 à 10 MHz, deux slots PCI récupérés sur de vieilles cartes mères et une carte VGA des années 1990. Mis côte à côte, les composants donnent l'impression d'une blague de banc d'électronique. Pourtant le projet de maniek86 est intéressant pour la raison inverse : **rien n'est naturellement compatible**.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

Le 68000 expose un bus processeur 16 bits, big-endian, conçu à la fin des années 1970. PCI est un bus local 32 bits, little-endian, avec son espace de configuration, ses transactions synchrones et son protocole de négociation. Entre les deux, un Xilinx Spartan II XC2S100 joue donc le rôle essentiel : il ne convertit pas seulement des niveaux électriques, il traduit des règles.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)[3](https://github.com/maniekx86/m68k_pci/blob/main/fpga_pci_bridge/m68k_pci_main.vhd)

## Deux mondes

Le montage final utilise un 68000 à 10 MHz, 1 Mo de SRAM, 128 Ko de ROM, un MC68681 pour les liaisons série, un CPLD XC95144XL pour la logique générale et deux slots PCI 32 bits en 5 V. Le FPGA Spartan II est le host bridge.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

Le choix le plus révélateur est la fréquence. Un PCI classique tourne normalement jusqu'à 33 MHz, mais le projet le maintient à **10 MHz**, comme le CPU. Le standard permet de descendre sous sa fréquence nominale; ici, perdre du débit simplifie la logique parce que les deux côtés avancent sur la même horloge.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

C'est une bonne façon de lire toute la machine. Elle ne cherche pas à fabriquer le 68000 le plus rapide ni un PC bizarrement ancien. Elle réduit le problème jusqu'à ce qu'on puisse voir chaque couche.

> Illustration: Schéma des étapes de traduction d'un cycle Motorola 68000 en transaction PCI. Un cycle CPU devient une phase d'adresse PCI, puis un handshake. Le FPGA ne rend DTACK au 68000 qu'une fois la transaction PCI terminée. Credit: [Illustration IRZ d'après le VHDL du projet](https://github.com/maniekx86/m68k_pci/blob/main/fpga_pci_bridge/m68k_pci_main.vhd).

## Le pont

Sur un bus simple, un processeur présente une adresse, indique lecture ou écriture et attend que le périphérique réponde. PCI ajoute une grammaire. L'initiateur place d'abord adresse et commande sur les mêmes lignes multiplexées, abaisse `FRAME#`, puis les deux appareils négocient le transfert avec `IRDY#`, `TRDY#` et `DEVSEL#`.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

Le VHDL du Spartan II contient précisément cette machine à états : lecture et écriture de configuration, lecture et écriture mémoire, accès I/O, turnaround obligatoire pendant une lecture, détection de périphérique et gestion de l'acquittement côté 68000.[3](https://github.com/maniekx86/m68k_pci/blob/main/fpga_pci_bridge/m68k_pci_main.vhd) Le `DTACK` que voit le CPU n'est donc plus directement celui d'un composant accroché au bus. C'est la réponse synthétique du bridge : « la transaction de l'autre côté est finie ».

Cette traduction permet aussi au logiciel du 68000 de découvrir les cartes comme le ferait un firmware PC. Le code lit Vendor ID, Device ID et classe, sonde les BAR en écrivant tous les bits à 1 pour connaître la taille demandée, puis attribue espaces I/O, mémoire et interruptions.[4](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci/pci_core.c)

## Octets inversés

La différence d'endianness est moins spectaculaire sur une photo, mais c'est probablement le meilleur exemple de la difficulté réelle. Le 68000 range l'octet de poids fort à l'adresse la plus basse. PCI suit la convention inverse. Une valeur `0xAABBCCDD` n'occupe donc pas les quatre offsets dans le même ordre.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

> Illustration: Comparaison du rangement de quatre octets en big-endian sur Motorola 68000 et little-endian sur PCI. Pour les registres, on veut souvent préserver la valeur numérique. Pour un tableau de pixels ou une chaîne d'octets, il faut plutôt préserver la position. Credit: [Illustration IRZ d'après les notes et le code de maniek86](https://github.com/maniekx86/m68k_pci).

Maniek86 alterne donc les deux méthodes suivant ce qu'il manipule : un registre 32 bits gagne à conserver sa valeur, alors qu'un buffer VGA ou une chaîne doit surtout garder ses octets aux bonnes adresses. Le code PCI va jusqu'à inverser explicitement l'offset lors des accès 8 bits à l'espace de configuration.[4](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci/pci_core.c)

L'effet apparaît très concrètement avec la VGA. Une macro classique de mode texte, où caractère et attribut partagent un mot de 16 bits, remplit alors l'écran de couleurs incohérentes. Le correctif n'a rien de graphique : il faut inverser l'ordre de packing pour que le périphérique little-endian voie les deux octets à la bonne place.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

## Pas un PC

Le bridge ne tente pas de recréer tout le chipset d'un ordinateur x86. Il expose ce qui est nécessaire. Une fenêtre du bus mémoire du 68000 est traduite vers l'espace I/O PCI; une autre option remappe une partie de la mémoire pour atteindre la zone VGA historique située sous 1 Mo.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)[3](https://github.com/maniekx86/m68k_pci/blob/main/fpga_pci_bridge/m68k_pci_main.vhd)

Ce détour évite un obstacle plus sérieux : les cartes PCI embarquent généralement un BIOS vidéo écrit pour x86. Le 68000 ne peut pas les exécuter. Pour la Cirrus Logic GD5440, maniek86 initialise donc la carte directement en programmant ses registres, puis configure les registres VGA standards. Résultat : texte 80×25, puis mode graphique 320×200 en 256 couleurs, sans émulateur x86.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

Le projet estime le remplissage des 64 Ko du framebuffer du mode 13h à environ 300 ms, soit quelque 200 Ko/s. L'auteur précise lui-même qu'il s'agit d'une estimation tirée d'un enregistrement vidéo, pas d'un benchmark instrumenté.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php) Lent, oui. Mais ici la mesure sert surtout à suivre le trajet d'un octet, pas à concurrencer un Pentium.

## Cartes réelles

Le système va bien plus loin que l'énumération d'un périphérique. Une carte série PCI Moschip/NetMos a été utilisée avec interruptions matérielles. La GD5440 affiche réellement. Deux autres cartes VGA, dont une S3 Trio64V2/DX, ont aussi été initialisées.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

> Illustration: Schéma du logiciel PCI qui scanne, mesure les BAR, mappe les ressources, route les interruptions et charge les drivers. Le logiciel du 68000 fait le travail qu'on associe d'habitude au firmware et au noyau d'un PC : découvrir, dimensionner, mapper puis piloter. Credit: [Illustration IRZ d'après pci_core.c](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci/pci_core.c).

La démonstration la plus amusante reste le réseau. Un RTL8029, compatible NE2000, reçoit un driver, une petite pile réseau, un serveur Telnet et un serveur HTTP. Le 68000 peut donc répondre sur Ethernet via une carte PCI, ce qui donne au projet sa photo mentale la plus absurde : un processeur lancé en 1979 sert une requête réseau à travers un standard apparu plus d'une décennie après lui.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)[5](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci_network/pci_rtl8029.c)

Mais ce succès repose justement sur le choix du RTL8029. Beaucoup d'autres cartes réseau PCI sont inutilisables ici.

## DMA manquant

Le Spartan II ne met pas en œuvre le **bus mastering PCI**. Une carte ne peut donc pas demander la maîtrise du bus et transférer directement des blocs vers la RAM système. L'auteur explique avoir manqué de broches sur le FPGA et avoir volontairement laissé cette partie de côté.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php)

Cela exclut une grande famille de périphériques : contrôleurs USB, nombreuses cartes son, cartes réseau plus récentes, SCSI ou accélérateurs qui supposent des transferts DMA vers la mémoire.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php) Le projet reste un host bridge partiel, pas une implémentation exhaustive de PCI.

Il faut toutefois être précis avec le mot DMA. Le driver RTL8029 parle bien de « Remote DMA » : dans l'architecture NE2000, ce mécanisme déplace des octets entre les registres du contrôleur et sa mémoire locale. Mais le CPU lit et écrit ces mots via les ports PCI : la carte ne devient jamais maître du bus système.[5](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci_network/pci_rtl8029.c)

Cette limite a même produit un bug matériel instructif. Un `GNT#` laissé flottant a poussé certaines cartes à croire qu'elles pouvaient prendre le bus, jusqu'à faire déclencher la protection en courant de l'alimentation de labo. Un pull-up a remis les cartes dans le rang.[1](https://maniek86.xyz/projects/homebrew_m68k_pci.php) Difficile d'imaginer meilleure leçon sur la différence entre « connecteur compatible » et « protocole correctement arbitré ».

## Conservation active

Le résultat dépasse le rétrocomputing décoratif. Un bus standardisé comme PCI sépare suffisamment le périphérique du processeur pour qu'un bridge artisanal puisse relier des générations qui n'ont jamais été conçues pour coexister. Cette indépendance a un coût très concret : quelqu'un doit reconstruire configuration, transactions, mapping, interruptions et règles d'encodage.

Le dépôt est publié sous licence MIT et contient le VHDL du bridge, la logique CPLD, le bootloader et les drivers.[2](https://github.com/maniekx86/m68k_pci) Le dépôt permet de suivre la traduction jusqu'aux lignes qui décident quel octet va où, au lieu de s'arrêter à l'écran « Hello World ».

C'est ce qui rend la machine utile au-delà du stunt. **Conserver un vieux processeur ne signifie pas forcément conserver tout son environnement d'origine.** Autre option : préserver son modèle de calcul et construire autour une couche capable de parler à des périphériques plus récents. Dans ce projet, cette couche est littéralement le morceau le plus moderne de l'ordinateur.

## References

1. [maniek86, « Homebrew 68000 computer with a PCI bus », août 2026](https://maniek86.xyz/projects/homebrew_m68k_pci.php)
2. [maniekx86/m68k_pci, sources du projet, GitHub, licence MIT](https://github.com/maniekx86/m68k_pci)
3. [m68k_pci_main.vhd, bridge FPGA Motorola 68000 ↔ PCI](https://github.com/maniekx86/m68k_pci/blob/main/fpga_pci_bridge/m68k_pci_main.vhd)
4. [pci_core.c, scan et configuration du bus PCI](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci/pci_core.c)
5. [pci_rtl8029.c, driver réseau NE2000/RTL8029](https://github.com/maniekx86/m68k_pci/blob/main/software/prog/drivers/pci_network/pci_rtl8029.c)