Peripheral Component Interconnect

Peripheral Component Interconnect (kurz PCI) ist ein Bus zur leichten Verbindung von Peripheriegeräten mit der CPU.

Die Informationen in diesem Artikel beziehen sich auch auf die vom klassischen PCI-Bus abgeleiteten Bus-Standards: PCI-Express, Hypertransport, PCI-X und AGP. Diese Busse basieren vom logischen Protokoll her auf PCI aber benutzen andere physikalische Daten-Übertragungsmechanismen bzw. andere Topologien.

Konfigurations-Adressraum

Jedes PCI-Gerät besitzt einen eigenen Konfigurations-Adressraum, welcher 256 Byte groß ist und verschiedene Konfigurations-Register enthält. Bei PCI-Express, Hypertransport und PCI-X ist der Konfigurations-Adress-Raum 4096 Byte groß. Auf den Konfigurations-Adressraum kann immer Zugegriffen werden, unabhängig vom Zustand des PCI-Geräts (von den Zuständen "defekt", "ausgebaut" oder "abgeschaltet" mal abgesehen). Für den Zugriff auf den Konfigurations-Adressraum werden die PCI-Geräte über ihre Bus-Nummer, Device-Nummer und Function-Nummer angesprochen, dazu müssen eventuelle PCI-to-PCI-Bridges korrekt konfiguriert sein.

Aufbau des Konfigurations-Adressraum

Im Konfigurations-Adressraum sind die ersten 64 Byte fest für den Basis-Header reserviert. Die restlichen Bytes stehen zur freien Nutzung durch das Gerät zur Verfügung, in diesem Bereich sind auch die Capabilities untergebracht.

Im Basis-Header sind die Bytes 0x000 – 0x00F, 0x034, 0x03C und 0x03D für alle PCI-Geräte identisch definiert. Diese Bytes dienen dazu, das PCI-Gerät zu klassifizieren und identifizieren.

Register	31-24	23-16	15-8	7-0
0x000	Device ID		Vendor ID
0x004	Status		Command
0x008	Classcode			Revision ID
0x00C	BIST	Header Type	Latency Timer	Cache Line Size
0x010	Header Type Specific
0x014	Header Type Specific
0x018	Header Type Specific
0x01C	Header Type Specific
0x020	Header Type Specific
0x024	Header Type Specific
0x028	Header Type Specific
0x02C	Header Type Specific
0x030	Header Type Specific
0x034	Header Type Specific			Capabilities Pointer
0x038	Header Type Specific
0x03C	Header Type Specific		Interrupt Pin	Interrupt Line

• Die Vendor IDs werden von PCI-SIG verwaltet und den Herstellern zugewiesen. Der Wert 0xffff ist für den Fall reserviert, dass an dieser Stelle kein Gerät vorhanden ist. Der Wert 0x0001 kommt wenn das Gerät zwar vorhanden aber noch nicht bereit ist zu reagieren. Der Wert 0x0000 ist ungültig (ähnlich 0xffff). Alle anderen Werte können als gültige Vendor-IDs zugewiesen werden.
• Die Device IDs verwalten die Hardwarehersteller selbst. Sie dient zusammen mit der Vendor ID der eindeutigen Identifikation des Gerätes. Alle 65536 möglichen Werte sind erlaubt (nur der jeweilige Hersteller bestimmt welche Werte gültig sind und welche nicht).
• Im Status-Register werden verschiedene Basis-Status und Gerät-Fähigkeiten angezeigt.
• Im Command-Register werden verschiedene Basis-Konfigurationen vorgenommen.
• Classcode ist noch einmal geteilt. Die oberen 8 Bit (Byte 0x00B) repräsentieren die Base Class, die mittleren 8 Bit (Byte 0x00A) stehen für die Subclass und die unteren 8 Bit (Byte 0x009) für das Programming Interface.
• Die Revision ID wird vom Hardwarehersteller selbst verwaltet und kann als "Nachkommastelle" der Device-ID betrachtet werden.
• Mit dem BIST-Register kann ein gerätespezifischer Selbsttest ausgelöst und ausgewertet werden. Diese Funktion ist optional und wird nur von wenigen PCI-Geräten unterstützt.
• Header Type spezifiziert den Inhalt der Register 0x010 – 0x03F. Dabei gibt Bit 7 an, ob es sich um ein Multifunction-Device handelt oder nicht, in dem Fall muss das Bit 7 in allen vorhandenen Funktionen gesetzt sein.

Header Type	Kurze Beschreibung
0x00	Standard
0x01	PCI/PCI-Bridge
0x02	CardBus-Bridge

• Der Capabilities Pointer zeigt, falls er gültig ist, auf die erste Capability-Struktur, welche der Start einer verketteten Liste ist. Für gültige Capabilities Pointer sind nur Werte von 0x40 bis 0xF0 erlaubt.
• Im Interrupt Pin-Register wird angegeben, welches Interrupt-Pin das Gerät verwendet. 0x00 steht für kein Interrupt-Signal, trotzdem kann noch MSI(-X) benutzt werden. Die Werte 0x01 bis 0x04 stehen für #INTA bis #INTD, alle anderen Werte sind nicht erlaubt. Bei Singlefunction-Devices ist nur Pin #INTA erlaubt. Bei Multifunction-Devices dürfen auch #INTB bis #INTD benutzt werden, es dürfen auch mehrere Funktionen in einem PCI-Gerät sich eine Interrupt-Leitung teilen.
• Im Interrupt Line-Register legt das BIOS die zugewiesene x86-Interrupt-Nummer ab, welche das #INT?-Signal des betreffendem PCI-Geräts auslöst. Diese Info ist nur relevant wenn man die IRQs über den klassischen PIC vermitteln lässt, wenn die APICs benutzt werden ist diese Info unter Umständen nur noch von begrenztem Nutzen. Diese Info ist eine reine Freundlichkeit des BIOS der x86-Plattform, auf allen anderen Plattformen bleibt dieses Register leer. Dem PCI-Gerät ist der Wert in diesem Register egal und wird es auch nicht verändern. Falls das PCI-Gerät keine Interrupts benutzt, oder nur per MSI(-X) signalisiert, kann dieses Register auch fest auf 0x00 geklemmt sein.

Header Type 0x00

Register	31-24	23-16	15-8	7-0
0x010	Base Address #0 (BAR0)
0x014	Base Address #1 (BAR1)
0x018	Base Address #2 (BAR2)
0x01C	Base Address #3 (BAR3)
0x020	Base Address #4 (BAR4)
0x024	Base Address #5 (BAR5)
0x028	Cardbus CIS Pointer
0x02C	Subsystem ID		Subsystem Vendor ID
0x030	Expansion ROM base address
0x034	Reserviert			Capabilities Pointer
0x038	Reserviert
0x03C	Max Latency	Min Grant	Interrupt Pin	Interrupt Line

Header Type 0x01

Register	31-24	23-16	15-8	7-0
0x010	Base Address #0 (BAR0)
0x014	Base Address #1 (BAR1)
0x018	Secondary latency timer	Subordinate bus №	Secondary bus №	Primary bus №
0x01C	Secondary Status		I/O Limit	I/O base
0x020	Memory limit		Memory base
0x024	Prefetchable memory limit		Prefetchable memory base
0x028	Prefetchable base upper 32 bits
0x02C	Prefetchable limit upper 32 bits
0x030	I/O limit upper 16 bits		I/O base upper 16 bits
0x034	Reserviert			Capabilities pointer
0x038	Extension ROM base address
0x03C	Bridge control		Interrupt pin	Interrupt line

Bedeutung einiger Register

Status-Register

Bit	Name	Typ	Bedeutung
0	Immediate Readiness	RO / fix	Wenn dieses Bit auf 1 gesetzt ist, bedeutet das, dass das betreffende PCI-Gerät sofort nach dem Reset Zugriffe auf den Konfigurationsadressraum korrekt verarbeitet.
3	Interrupt Status	RO / dynamic	Wenn dieses Bit auf 1 gesetzt ist möchte das betreffende PCI-Gerät einen Interrupt über sein #INT?-Signal melden. Nur wenn das Bit 10 im Command-Register gelöscht ist wird auch tatsächlich ein Interrupt (an den PIC o.ä.) signalisiert. Falls das PCI-Gerät keine Interrupts benutzt oder diese ausschließlich per MSI(-X) signalisiert kann dieses Bit fest auf 0 geklemmt sein. Auf Bridges meldet dieses Bit nur eigene Interrupts, durch geleitete Interrupts, von sekundären Bussen zum übergeordnetem Bus, beeinflussen dieses Bit nicht.
4	Capabilities List	RO / fix	Wenn dieses Bit auf 1 gesetzt ist ist der Capabilities-Pointer (Offset 0x034) gültig. Bei PCI-Express, Hypertransport und PCI-X (und wahrscheinlich auch AGP) muss dieses Bit immer gesetzt sein da dort bus-spezifische Capabilities Pflicht sind.
5	66 MHz Capable	RO / fix	Dieses Bit gibt an ob eine PCI-Karte nicht nur mit maximal 33 MHz-Bus-Takt arbeiten kann sondern bis zu 66 MHz verträgt. Nur wenn alle PCI-Geräte auf dem betreffenden physischen PCI-Bus-Segment mit mehr als 33 MHz umgehen können darf dieses Bus-Segment auch mit mehr als 33 MHz, bis maximal 66 MHz, betrieben werden. Dieses Bit ist nur beim klassischen PCI gültig und bei allen PCI-Nachfolgern immer fest auf 0 geklemmt, außer bei AGP dort ist es immer fest auf 1 geklemmt. Für die Software hat dieses Bit keine Bedeutung, auf dem PCI-Bus wird die Geschwindigkeit in Hardware ausgehandelt, wenn die Software auf den Konfigurations-Adressraum der angeschlossenen Geräte zugreifen kann ist der Bus bereits funktionsfähig.
7	Fast Back-to-Back Transactions Capable	RO / fix	Wenn dieses Bit auf 1 gesetzt ist, bedeutet das, dass das betreffende PCI-Gerät die minimal schnelleren Back-to-Back Transfers unterstützt. Als Target werden diese Transfers immer unterstützt, aber als Master dürfen diese Transfers nur benutzt werden falls das Bit 9 im Command-Register gesetzt ist.
8	Master Data Parity Error	RW1C / dynamic	TODO
10-9	DEVSEL Timing	RO / fix	Diese 2 Bits, als unsigned Integer betrachtet, geben an nach wie vielen PCI-Bus-Takten das PCI-Gerät erkannt hat ob es das Target eines Zugriffs ist. Gültige Werte sind 0, 1 und 2. Der Wert 3 darf nicht verwendet werden, jedes PCI-Gerät muss nach spätestens 2 Takten dekodiert haben ob es das gewünschte Target ist oder nicht. Im 3ten Takt wird dann eine eventuell vorhandene Subtractive-Bridge aktiv und nimmt den Transfer entgegen ansonsten der Zugriff geht ins Leere und der Initiator meldet das als Fehler. Diese Bits sind nur für den klassischen PCI-Bus relevant und auf allen anderen PCI-Implementierungen als reserved zu betrachten.
11	Signalled Target-Abort	RW1C / dynamic	TODO
12	Received Target-Abort	RW1C / dynamic	TODO
13	Received Master-Abort	RW1C / dynamic	TODO
14	Signalled System Error	RW1C / dynamic	TODO
15	Detected Parity Error	RW1C / dynamic	TODO

Nicht beschriebene Bits sind reserviert und müssen beim Lesen ignoriert werden. Die Bits im Status-Register sind entweder Read-Only (RO) oder lassen sich durch beschreiben mit einer 1 rücksetzen (RW1C), das beschreiben mit einer 0 hat keinen Effekt. Einige Bits ändern ihren Zustand nie (fix) und andere können ihren Zustand durch bestimmte Ereignisse ändern (dynamic).

Command-Register

Bit	Name	Bedeutung
0	IO Space	Nur wenn dieses Bit gesetzt ist, kann der I/O-Raum des Geräts verwendet werden, sonst ist er deaktiviert. Falls das Gerät keine IO-Ports anbietet, ist dieses Bit fest auf 0 geklemmt. Wenn dieses Bit bei Bridges auf 0 steht, wird damit das Durchleiten von I/O-Zugriffen vom primären zum sekundären Bus unterbunden.
1	Memory Space	Nur wenn dieses Bit gesetzt ist, können MMIO-Register verwendet werden, sonst sind diese deaktiviert. Falls das Gerät kein MMIO (oder andere Speicherbereiche) anbietet, ist dieses Bit fest auf 0 geklemmt. Wenn dieses Bit bei Bridges auf 0 steht, wird damit das Durchleiten von Speicherzugriffen vom primären zum sekundären Bus unterbunden.
2	Bus Master	Ist dieses Bit gesetzt, so darf das Gerät als Busmaster auf dem PCI-Bus arbeiten. Das ist z. B. für PCI-DMA notwendig (wird u. a. von Netzwerkkarten und (S)ATA-Host-Controllern verwendet). Falls das Gerät nicht busmasterfähig ist, ist dieses Bit fest auf 0 geklemmt. Wenn dieses Bit auf 0 steht, wird damit auch MSI(-X) und bei Bridges das Durchleiten von jeglichen Zugriffen vom sekundären zum primären Bus unterbunden.
3	Special Cycles	Wenn dieses Bit gelöscht ist, dann muss das Gerät alle Special Cycles auf dem PCI-Bus ignorieren. Special Cycles werden zum Broadcasten von speziellen Nachrichten an alle PCI-Geräte auf einem klassischen PCI-Bus benutzt. (mir ist keine reale Anwendung dieses Features bekannt) Es gibt nur wenige PCI-Geräte, bei denen dieses Bit überhaupt beschreibbar ist, bei den meisten ist es fest auf 0 geklemmt. Bei PCI-Express ist es immer fest auf 0 geklemmt da PCI-Express keine Special Cycles unterstützt.
4	Memory Write and Invalidate Enable	Falls gesetzt, kann das Gerät diesen Befehl (Memory Write and Invalidate) ausführen, sonst muss es sich mit einem einfachen Memory Write begnügen. Bei PCI-Express ist dieses Bit immer fest auf 0 geklemmt.
5	VGA Palette Snoop	Dieses Bit ist nur für VGA-kompatible Geräte interessant (ist es gesetzt, so werden Zugriffe auf die VGA-Palettenregister gesondert behandelt), auf allen anderen Geräten ist es immer fest auf 0 geklemmt. Bei PCI-Express und Hypertransport ist dieses Bit immer fest auf 0 geklemmt, dort wird sowas in den Bridges konfiguriert.
6	Parity Error Response	Ist dieses Bit gesetzt, so wird bei Parityfehlern auf dem PCI-Bus das Detected-Parity-Error-Statusbit im Statusregister gesetzt. Nicht jede PCI-Hardware unterstützt die Generierung und Prüfung des Paritybits auf dem PCI-Bus, sodass dieses Bit dann fest auf 0 geklemmt ist. Daher sollte dieses Bit nur dann auf 1 gesetzt werden, wenn alle PCI-Geräte auf dem betreffenden physischen PCI-Bus-Segment die Parity-Bit-Generierung unterstützen. Bei PCI-Express und Hypertransport gibt es leistungsfähigere Fehlersignalisierungsmechanismen (das klassische Paritybit gibt es dort eh nicht mehr), deren Benutzung zu bevorzugen ist.
7	IDSEL Stepping / Wait Cycle Control	Dieses Bit war nur in den ersten PCI-Spezifikationen gültig (vor 2.0) und muss immer auf 0 gesetzt werden. Auf allen PCI-Geräten seit der PCI-Spezifikation 2.0 (ab 1993) ist dieses Bit immer fest auf 0 geklemmt.
8	SERR# Enable	Wenn dieses Bit gesetzt ist darf/soll das Gerät erkannte schwerwiegende Fehler (z. B. Parityfehler während der Adressierungsphase oder ungültige Kommandos) über die extra #SERR-Leitung, oder bei PCI-Express über spezielle Messages, melden. Solche Fehler lösen für gewöhnlich einen NMI oder eine Machine-Check-Exception aus. Bei PCI-Express und Hypertransport gibt es leistungsfähigere Fehlersignalisierungsmechanismen, deren Benutzung zu bevorzugen ist.
9	Fast Back-to-Back Enable	Wenn dieses Bit auf 1 gesetzt ist soll das PCI-Gerät Back-to-Back-Zugriffe (als Target) unterstützen und darf auch solche Zugriffe (als Master) ausführen. Dieses Bit lässt sich nur auf 1 setzen, wenn das zugehörige Bit 7 im Status-Register diese Fähigkeit signalisiert, andernfalls ist es fest auf 0 geklemmt. Dieses Bit darf nur dann auf 1 gesetzt werden wenn alle PCI-Geräte auf dem betreffenden physischen PCI-Bus-Segment Back-to-Back-Zugriffe unterstützen. Wenn alle Geräte diesen Modus unterstützen, kann die Idle-Phase zwischen zwei PCI-Zyklen entfallen. Das erhöht etwas den Datendurchsatz auf dem PCI-Bus. Bei PCI-Express, Hypertransport und PCI-X ist dieses Bit immer fest auf 0 geklemmt.
10	Interrupt Disable	Ist dieses Flag gesetzt, dann kann das entsprechende Gerät keine IRQs auslösen. Nach dem Hardware-Reset muss dieses Bit dummerweise immer gelöscht sein, sodass IRQs anfangs nicht verboten sind. MSI(-X) ist davon unabhängig, dafür gibt es spezielle Interrupt-Enable-Bits in den entsprechenden Capabilities.

Bit 7 ist auf 0 zu setzen, Bits 11 bis 15 sind reserviert (und undefiniert) und müssen ebenfalls immer auf 0 gesetzt werden. Nach dem Reset des Geräts sind alle hier aufgeführten Bits auf 0 gesetzt (wobei das BIOS der x86-Platform wohl einige davon setzen wird). Die Software sollte immer prüfen, ob sich die gewünschten Bits auch wirklich auf 1 setzen lassen, einige Bits sind eben fest auf 0 geklemmt. Es sind zwar nicht alle Bits beschreibbar aber kein Bit im Command-Register wird seinen Zustand von alleine ändern. Bei Bridges haben die Bits 0 und 1 keinen Einfluss ob Zugriffe auf den Konfigurations-Adressraum durchgeleitet werden (von primär nach sekundär, andersherum werden Zugriffe auf den Konfigurations-Adressraum grundsätzlich nicht durchgeleitet so das Bit 2 auf diesen Aspekt keinen Einfluss hat), das funktioniert immer solange der sekundäre PCI-Bus nicht im Reset ist.

Base-Address-Register

Die Base-Address-Register dienen dem Zuweisen von Adressen an die Ressourcen des PCI-Gerätes. Ein PCI-Gerät kann bis zu 6, bei Bridges nur maximal 2, Ressourcen anbieten, denen das BIOS oder OS eine Adresse zuweist, über welche diese Ressourcen dann ansprechbar sind. Als Ressourcen können Speicherbereiche aber auch IO-Bereiche angeboten werden, der IO-Adress-Raum wird aber nicht auf jeder Plattform unterstützt, eigentlich nur beim PC. Die IO-Ressourcen haben verschiedene Nachteile, u.a. sind sie langsamer da es keine Burst-Zugriffe gibt und es gibt Einschränkungen bei der Adressenraumgröße. Speicher-Ressourcen können neben den einfachen 32-Bit-Adressen auch 64-Bit-Adressen nutzen, wofür dann aber 2 hintereinander liegende BARs für eine Ressource benutzt werden müssen, das folgende BAR enthält dann die oberen 32 Bit der Basis-Adresse.

In den unteren 2 Bit (IO-Ressourcen) oder 4 Bit (Speicher-Ressourcen) eines BAR ist codiert was für eine Ressource dieses BAR anbietet, diese Bits sind immer fest und können nicht verändert werden. Die restlichen Bits können für die Basis-Adresse benutzt werden wobei für die Basis-Adresse als ganzes die unteren 2 oder 4 Bits als 0 angenommen werden. Daraus ergibt sich das IO-Ressourcen immer mindestens 4 Bytes und Speicher-Ressourcen immer mindesten 16 Bytes groß sein müssen. Um größere Ressourcen anzubieten, können oberhalb der fest definierten unteren Bits noch weitere Bits fest auf 0 geklemmt sein. Um z. B. eine 256 Byte große Speicher-Ressource anzubieten müssen dann auch die Bits 4 bis 7 fest auf 0 geklemmt sein. Wenn dann das BIOS oder OS das BAR mit lauter 1en beschreibt und anschließend zurück ließt, was den Wert 0xFFFFFF00 ergibt, kann es ermitteln welche Bits zur Konfiguration der Basis-Adresse zur Verfügung stehen. Wenn z. B. der Wert 0xFFFF0000 von einem BAR für eine 32-Bit-Speicher-Ressource gelesen wird bedeutet dass das die Bits 16 bis 31 für die Basis-Adresse zu Verfügung stehen und diese Speicher-Ressource 64 kBytes groß ist. Daraus das die Bits 0 bis 15 der Basis-Adresse 0 sind ergibt sich das diese Speicher-Ressource auch an einer 64-kByte-Grenze ausgerichtet sein muss. Da immer mindestens 1 Bit für die Basis-Adresse beschreibbar sein muss, können mit einer 32-Bit-Adresse maximal 2 GByte große Ressourcen angeboten werden. Die angebotenen Ressourcen müssen immer eine Zweierpotenz als Größe haben und sind dann auch entsprechend ausgerichtet.

Nur alleine durch lesen der BAR-Register kann man nicht auf die Größe der betreffenden Ressourcen schließen. Zum kompletten analysieren der BARs müssen diese auch immer beschrieben werden. Darüber hinaus haben es die PCI-Erfinder auch versäumt wenigstens dafür zu sorgen das man nur durch lesen den genauen Type des BARs erkennen kann. Falls die unteren 4 Bit alle 0 sind ist es entweder ein unbenutzter BAR oder eine non-prefetchable 32-Bit-Speicher-Ressource, genau kann man das erst ermitteln indem man prüft ob die restlichen Bits beschreibbar sind.

Base-Address-Register für Speicher-Ressourcen mit 32-Bit-Adresse

31-4	3	2-1	0
Base Address	P	Typ	0

Das Bit 0 signalisiert mit seinem Wert 0 das es sich bei dem betreffenden BAR um eine Speicher-Ressource handelt und die Werte 00 und 01 in den Bits 2-1 signalisieren das es sich um einen 32-Bit-BAR handelt. Die Bits 31-4 geben die Basis-Adressbits 31-4 der Speicher-Ressource an.

Base-Address-Register für Speicher-Ressourcen mit 64-Bit-Adresse

63-4	3	2-1	0
Base Address	P	Typ	0

Das Bit 0 signalisiert mit seinem Wert 0 das es sich bei dem betreffenden BAR um eine Speicher-Ressource handelt und der Wert 10 in den Bits 2-1 signalisiert das es sich um einen 64-Bit-BAR handelt. Die Bits 63-4 geben die Basis-Adressbits 63-4 der Speicher-Ressource an. Das Prefetchable-Bit muss bei 64-Bit-Speicher-Ressourcen eigentlich immer fest auf 1 geklemmt sein, die PCI-Spezifikation verlangt das zwar nicht explizit aber bei Non-Prefetchable-Speicher macht eine 64-Bit-Adresse keinen Sinn da PCI-to-PCI-Bridges Zugriffe auf Non-Prefetchable-Speicher nur mit einer 32-Bit-Adresse weiterleiten können (siehe Bytes 0x020 bis 0x023 im Type 0x01 Konfigurations-Adressraum).

Base-Address-Register für IO-Ressourcen

31-2	1	0
Base Address	R	1

Das Bit 0 signalisiert mit seinem Wert 1 das es sich bei dem betreffenden BAR um eine IO-Ressource handelt. Das Bit 1 ist reserviert und muss beim lesen ignoriert und beim schreiben mit 0 gelöscht werden. Die Bits 31-2 geben die Basis-Adressbits 31-2 der IO-Ressource an. Die IO-Ressource muss also mindestens 4 Byte groß sein. Oft sind die Bits 31-16 fest auf 0 geklemmt so das nur 16-Bit-IO-Adressen benutzt werden können, auf der PC-Plattform unterstützen die CPUs sowieso nur 16-Bit-IO-Adressen so das normalerweise daraus kein Problem entsteht.

Beispiel-Code zur BAR-Analyse

Der folgende C-Code analysiert alle BARs im Konfigurations-Adressraum eines PCI-Gerätes und gibt alle verfügbaren Informationen aus. Dieser Code sollte möglichst nicht auf aktivierte PCI-Geräte angewendet werden, falls doch wäre es geschickt den Vorgang atomar zu gestalten und alle BARs vorher zu sichern und hinter zu restaurieren. Außerdem sollten die Bits 0 und 1 des Command-Registers gelöscht sein.

/*** Diesen Code darf jeder, unter Berücksichtigung der Lizenz für diesen Wiki-Artikel, zu jedem Zweck kopieren, nutzen und verändern!
     (C) <http://www.lowlevel.eu/> ***/


/* deklariert einen Typ der Bus, Device und Function enthält um ein bestimmtes PCI-Gerät zu adressieren,
   außerdem bin ich einfach zu faul 3 Einzelwerte durch meinen Quäl-Code zu schicken */
typedef  ....  pci_bdf_t;

/* ließt einen 32Bit-Wert aus dem Config-Space vom PCI-Gerät (addr) an Offset (offset) und gibt ihn zurück */
extern uint32_t pci_config_readd(pci_bdf_t addr,uint offset);

/* schreibt einen 32Bit-Wert (value) in den Config-Space vom PCI-Gerät (addr) an Offset (offset) */
extern void pci_config_writed(pci_bdf_t addr,uint offset,uint32_t value);


/* sucht das unterste gesetzte Bit in einem 32Bit-Wert , value darf nicht 0 sein */
static uint get_number_of_lowest_set_bit(uint32_t value);
static uint get_number_of_lowest_set_bit(uint32_t value)
{
  uint pos = 0;
  uint32_t mask = 0x00000001;
  while (!(value & mask))
   { ++pos; mask=mask<<1; }
  return pos;
}

/* sucht das oberste gesetzte Bit in einem 32Bit-Wert , value darf nicht 0 sein */
static uint get_number_of_highest_set_bit(uint32_t value);
static uint get_number_of_highest_set_bit(uint32_t value)
{
  uint pos = 31;
  uint32_t mask = 0x80000000;
  while (!(value & mask))
   { --pos; mask=mask>>1; }
  return pos;
}


/* analysiert die BARs eines bestimmten PCI-Gerätes, das PCI-Gerät sollte hierfür unbenutzt sein */
void pci_config_bar_analyze(const pci_bdf_t addr)
{
  // Header-Type auslesen um zu ermitteln wie viele BARs vorhanden sind :
  const uint32_t headerType = ( pci_config_readd(addr,0x00C) >> 16 ) & 0x7F;
  // es werden nur Type 0x00 (normale Devices) und 0x01 (PCI-to-PCI-Bridges) unterstützt :
  if (headerType >= 0x02)
   { printf("FEHLER : nicht unterstützter Header-Type gefunden!\n"); return; }

  // 6 BARs für Type 0x00 und 2 BARs für Type 0x01 :
  const uint max_bars = 6 - (headerType * 4);

  for (uint bar = 0 ; bar < max_bars ; ++bar)
   {
     // Offset des aktuellen BAR ermitteln :
     const uint barOffset = 0x010+(bar*4);

     // prüfen ob Speicher oder IO :
     if ( (pci_config_readd(addr,barOffset) & 0x1) == 0 )
      { // Speicher-Ressource :

        // Prefetchable-Bit auslesen und passenden Text auswählen :
        static const char* ptext_pref = "prefetchable"; // Text für prefetchable
        static const char* ptext_nopr = "non-prefetchable"; // Text für non-prefetchable
        const char* const ptext = (((pci_config_readd(addr,barOffset) >> 3) & 0x1) == 1) ? ptext_pref : ptext_nopr;

        // check Memory-BAR-Type :
        switch((pci_config_readd(addr,barOffset) >> 1) & 0x3)
         {
           case 0x0: // 32Bit Memory-BAR :
             {
             pci_config_writed(addr,barOffset,0xFFFFFFF0); // mit lauter 1en überschreiben
             const uint32_t barValue = pci_config_readd(addr,barOffset) & 0xFFFFFFF0; // und wieder zurücklesen
             if (barValue == 0) // es muss mindestens ein Adressbit 1 (also beschreibbar) sein
              {
                if (ptext != ptext_nopr) // unbenutzte BARs müssen komplett 0 sein (auch das Prefetchable-Bit darf nicht gesetzt sein)
                 { printf("FEHLER : 32Bit-Memory-BAR %u enthält keine beschreibbaren Adressbits!\n",bar); return; }

                // BAR-Infos ausgeben :
                printf("BAR %u ist unbenutzt.\n",bar);
              }
             else
              {
                const uint lowestBit = get_number_of_lowest_set_bit(barValue);
                // es muss eine gültige 32Bit-Adresse sein :
                if ( (get_number_of_highest_set_bit(barValue) != 31) || (lowestBit > 31) || (lowestBit < 4) )
                 { printf("FEHLER : 32Bit-Memory-BAR %u enthält ungültige beschreibbare Adressbits!\n",bar); return; }

                // BAR-Infos ausgeben :
                printf("BAR %u enhält eine %s 32Bit-Memory-Ressource mit einer Größe von 2^%u Bytes.\n",bar,ptext,lowestBit);
              }
             }
             break;

           case 0x1: // 20Bit Memory-BAR :
             {
             if (headerType == 0x01)
              { printf("FEHLER : 20Bit-Memory-BAR %u ist für eine Bridge nicht erlaubt!\n",bar); return; }

             pci_config_writed(addr,barOffset,0xFFFFFFF0); // mit lauter 1en überschreiben
             const uint32_t barValue = pci_config_readd(addr,barOffset) & 0xFFFFFFF0; // und wieder zurücklesen
             if (barValue == 0) // es muss mindestens ein Adressbit 1 (also beschreibbar) sein
              { printf("FEHLER : 20Bit-Memory-BAR %u enthält keine beschreibbaren Adressbits!\n",bar); return; }

             const uint lowestBit = get_number_of_lowest_set_bit(barValue);
             // es muss eine gültige 20Bit-Adresse sein :
             if ( (get_number_of_highest_set_bit(barValue) != 19) || (lowestBit > 19) || (lowestBit < 4) )
              { printf("FEHLER : 20Bit-Memory-BAR %u enthält ungültige beschreibbare Adressbits!\n",bar); return; }

             // BAR-Infos ausgeben :
             printf("BAR %u enhält eine %s 20Bit-Memory-Ressource mit einer Größe von 2^%u Bytes.\n",bar,ptext,lowestBit);
             }
             break;

           case 0x2: // 64Bit Memory-BAR :
             {
             // prüfen ob ein 64Bit-BAR an der aktuellen Position überhaupt möglich ist :
             if (bar >= (max_bars-1))
              { printf("FEHLER : 64Bit-Memory-BAR %u darf nicht an letzter Position beginnen!\n",bar); return; }
             // non-prefetchable 64-BARs können nicht hinter Bridges benutzt werden (? aber in der Spec sind sie nicht verboten ?) :
             if (ptext != &ptext_pref[0])
              { printf("FEHLER : 64Bit-Memory-BAR %u enthält eine non-prefetchable Memory-Ressource!\n",bar); return; }

             pci_config_writed(addr,barOffset,0xFFFFFFF0); // mit lauter 1en überschreiben
             pci_config_writed(addr,barOffset+4,0xFFFFFFFF); // mit lauter 1en überschreiben
             const uint32_t barLowValue  = pci_config_readd(addr,barOffset) & 0xFFFFFFF0; // und wieder zurücklesen
             const uint32_t barHighValue = pci_config_readd(addr,barOffset+4); // und wieder zurücklesen

             uint lowestBit = 0;
             if (barLowValue != 0)
              { // kleiner als 4 GByte :
                lowestBit = get_number_of_lowest_set_bit(barLowValue);
                // es muss eine gültige kleine 64Bit-Adresse sein :
                if ( (barHighValue != 0xFFFFFFFF) || (get_number_of_highest_set_bit(barLowValue) != 31) || (lowestBit > 31) || (lowestBit < 4) )
                 { printf("FEHLER : 64Bit-Memory-BAR %u enthält ungültige beschreibbare Adressbits im unteren Adressteil!\n",bar); return; }
              }
             else
              { // größer/gleich als 4 GByte :
                lowestBit = get_number_of_lowest_set_bit(barHighValue) + 32;
                // es muss eine gültige große 64Bit-Adresse sein :
                if ( (get_number_of_highest_set_bit(barHighValue) != 31) || (lowestBit > 63) || (lowestBit < 32) )
                 { printf("FEHLER : 64Bit-Memory-BAR %u enthält ungültige beschreibbare Adressbits im oberen Adressteil!\n",bar); return; }
              }

             // BAR-Infos ausgeben :
             printf("BAR %u enhält eine %s 64Bit-Memory-Ressource mit einer Größe von 2^%u Bytes.\n",bar,ptext,lowestBit);

             // den nachfolgenden BAR für die Analyse überspringen :
             ++bar;

             // BAR-Infos ausgeben :
             printf("BAR %u ist nicht nutzbar da er die oberen 32 Bits des vorrangegangenen 64Bit-BARs enthält\n",bar);
             }
             break;

           default: // ungültiger Memory-BAR :
             printf("FEHLER : Memory-BAR %u ist ungültig!\n",bar); return;
         }
      }
     else
      { // IO-Ressource :
        pci_config_writed(addr,barOffset,0xFFFFFFFC); // mit lauter 1en überschreiben
        const uint32_t barValue = pci_config_readd(addr,barOffset) & 0xFFFFFFFC; // und wieder zurücklesen
        if (barValue == 0) // es muss mindestens ein Adressbit 1 (also beschreibbar) sein
         { printf("FEHLER : IO-BAR %u enthält keine beschreibbaren Adressbits!\n",bar); return; }

        const uint lowestBit  = get_number_of_lowest_set_bit(barValue);
        const uint highestBit = get_number_of_highest_set_bit(barValue);
        // es muss entwerder eine gültige 32Bit-Adresse oder eine gültige 16Bit-Adresse sein :
        if ( ( (highestBit != 31) && (highestBit != 15) ) || (highestBit < lowestBit) || (lowestBit < 2) )
         { printf("FEHLER : IO-BAR %u enthält ungültige beschreibbare Adressbits!\n",bar); return; }

        // BAR-Infos ausgeben :
        printf("BAR %u enhält eine %uBit-IO-Ressource mit einer Größe von 2^%u Bytes.\n",bar,highestBit+1,lowestBit);
      }
   }
  if (bar != max_bars)
   { printf("interner Fehler in Schleife!\n"); return; }
}

Zugriff auf den Konfigurations-Adressraum

Gelesen und beschrieben wird der Konfigurations-Adressraum, bei PCs, 32bit-weise mithilfe eines Adress-I/O-Ports (0x0CF8) und eines Daten-I/O-Ports (0x0CFC).

Aufbau des Adress-I/O-Ports

31	30-24	23-16	15-11	10-8	7-0
Enable Bit	Reserviert	Busnummer	Gerätenummer	Funktionsnummer	Registernummer Bit 0 u. Bit 1 sind 0

Codebeispiel

#define PCI_CONFIG_DATA    0x0CFC
#define PCI_CONFIG_ADDRESS 0x0CF8

/**
 * Liest ein Dword aus einem PCI-Konfigurations-Register
 *  @param bus Bus
 *  @param dev Gerät
 *  @param func Funktion
 *  @param offset Registernummer
 *  @return Register content
 */
int pci_config_readd(int bus,int dev,int func,int offset) {
  int val;
  int address = 0x80000000|(bus<<16)|(dev<<11)|(func<<8)|(offset&0xFC);
  outl(PCI_CONFIG_ADDRESS,address);
  val = inl(PCI_CONFIG_DATA);
  return val;
}

/**
 * Schreibt ein Dword in ein PCI-Konfigurations-Register
 *  @param bus Bus
 *  @param dev Gerät
 *  @param func Funktion
 *  @param offset Registernummer
 *  @param val Wert zum Schreiben
 */
void pci_config_writed(int bus,int dev,int func,int offset,int val) {
  int address = 0x80000000|(bus<<16)|(dev<<11)|(func<<8)|(offset&0xFC);
  outl(PCI_CONFIG_ADDRESS,address);
  outl(PCI_CONFIG_DATA,val);
}

Classcodes

Baseclass	Beschreibung
0x00	Alle Geräte die gebaut wurden bevor Classcodes eingeführt wurden
0x01	Massenspeicher
0x02	Netzwerk-Controller
0x03	Bildschirm-Controller
0x04	Multimedia-Geräte
0x05	Speicher-Controller
0x06	Bridge-Geräte
0x07	Controller zur einfachen Kommunikation
0x08	System-Peripherie
0x09	Input-Geräte
0x0A	Docking-Stationen
0x0B	Prozessoren
0x0C	Serielle Buscontroller
0x0D	Wireless-Controller
0x0E	Intelligente Controller
0x0F	Satelliten-Kommunikations-Controller
0x10	Encryption/Decryption-Controller
0x11	Datenerfassungs- und Signalprozessor-Controller
0x12-0xFE	Reserviert
0xFF	Sonstige

In den folgenden Tabellen nicht aufgeführte Kombinationen aus Subclass und Programming Interface sind derzeit für zukünftige Definition reserviert. Bei PCI-Express gibt es in der PCI-Express-Capability eine klassifizierung des PCI-Gerätes und nicht jede Kombination aus Subclass und Programming Interface ist für jedes PCI-Gerät gültig, der Software wird offiziel empfohlen das zu prüfen.

Class 0x00 - Pre 2.0

Subclass	Programming Interface	Beschreibung
0x00	0x00	Alle nicht-VGA-Geräte
0x01	0x00	VGA-Geräte

Class 0x01 - Massenspeicher

Subclass	Programming Interface	Beschreibung
0x00	0x00	SCSI
0x01	0x??	IDE
0x02	0x00	Floppy
0x03	0x00	IPI
0x04	0x00	RAID
0x05	0x20	ATA-Controller (Single DMA)
0x05	0x30	ATA-Controller (Chained DMA)
0x06	0x00	SATA-Controller (Herstellerspezifische Schnittstelle)
0x06	0x01	SATA-Controller (AHCI 1.0)
0x07	0x00	SAS-Controller (Serial Attached SCSI)
0x08	0x00	Non-Volatile-Memory (allgemeiner/unspezifizierter Solide-State-Storage-Controller)
0x08	0x01	Non-Volatile-Memory - NVMHCI (NVM(-Express) Host-Controller)
0x08	0x02	Non-Volatile-Memory - Enterprise-NVMHCI (NVM(-Express) Host-Controller)
0x80	0x00	Anderer Massenspeicher

Class 0x02 - Netzwerk-Controller

Subclass	Programming Interface	Beschreibung
0x00	0x00	Ethernet
0x01	0x00	Token Ring
0x02	0x00	FDDI
0x03	0x00	ATM
0x04	0x00	ISDN
0x05	0x00	World FIP (Feldbus)
0x06	0x??	PICMG 2.14, Multi-Computing
0x80	0x00	Anderer Netzwerk-Controller

Class 0x03 - Bildschirm-Controller

Subclass	Programming Interface	Beschreibung
0x00	0x00	VGA
0x00	0x01	8514
0x01	0x00	XGA
0x02	0x00	3D
0x80	0x00	Anderer Bildschirm-Controller

Class 0x04 - Multimedia-Geräte

Subclass	Programming Interface	Beschreibung
0x00	0x00	Video-Gerät
0x01	0x00	Audio-Gerät
0x02	0x00	Telefonie
0x03	??	HD-Audio-Gerät
0x80	0x00	Anderes Multimedia-Gerät

Class 0x05 - Speicher-Controller

Subclass	Programming Interface	Beschreibung
0x00	0x00	RAM
0x01	0x00	Flash-Speicher
0x80	0x00	Anderer Speicher

Class 0x06 - Bridge-Geräte

Subclass	Programming Interface	Beschreibung
0x00	0x00	Host/PCI-Bridge
0x01	0x00	PCI/ISA-Bridge
0x02	0x00	PCI/EISA-Bridge
0x03	0x00	PCI/MicroChannel-Bridge
0x04	0x00	PCI/PCI-Bridge (hat Header Type 0x01)
0x04	0x01	PCI/PCI-Bridge (Subtractive Decode, hat Header Type 0x01)
0x05	0x00	PCI/PCMCIA-Bridge
0x06	0x00	PCI/NuBus-Bridge
0x07	0x00	PCI/CardBus-Bridge
0x08	0x??	Raceway, Switched Fabric
0x09	0x40	Semitransparente PCI/PCI-Bridge (primär zum Host)
0x09	0x80	Semitransparente PCI/PCI-Bridge (sekundär zum Host)
0x0A	0x00	InfiniBand/PCI-Brige
0x80	0x??	Anderer Bridge-Typ

Class 0x07 - Controller zur einfachen Kommunikation

Subclass	Programming Interface	Beschreibung
0x00	0x00	Serielle Schnittstelle (XT-kompatibel)
0x00	0x01	Serielle Schnittstelle (16450)
0x00	0x02	Serielle Schnittstelle (16550)
0x00	0x03	Serielle Schnittstelle (16650)
0x00	0x04	Serielle Schnittstelle (16750)
0x00	0x05	Serielle Schnittstelle (16850)
0x00	0x06	Serielle Schnittstelle (16950)
0x01	0x00	Parallelport (Standard)
0x01	0x01	Parallelport (Bidirektional)
0x01	0x02	Parallelport (ECP 1.0)
0x01	0x03	Parallelport (IEEE 1284)
0x01	0xFE	IEEE-1284-Gerät, Target
0x02	0x00	Multiport Serial Controller
0x03	0x00	Standard-Modem
0x03	0x01	Hayes-kompatibles Modem (16450)
0x04	0x00	GPIB (IEEE488.1/2) Controller
0x04	0x02	Hayes-kompatibles Modem (16550)
0x04	0x03	Hayes-kompatibles Modem (16650)
0x04	0x04	Hayes-kompatibles Modem (16750)
0x05	0x00	SmartCard
0x80	0x00	Anderer Controller

Class 0x08 - System-Peripherie

Subclass	Programming Interface	Beschreibung
0x00	0x00	8259- PIC
0x00	0x01	ISA-PIC
0x00	0x02	EISA-PIC
0x00	0x10	IO- APIC
0x00	0x20	IOx-APIC
0x01	0x00	8237-DMA-Controller
0x01	0x01	ISA-DMA-Controller
0x01	0x02	EISA-DMA-Controller
0x02	0x00	Standard-8254-Timer
0x02	0x01	ISA-System-Timer
0x02	0x02	EISA-System-Timer
0x02	0x03	High Performance Event Timer
0x03	0x00	Standard Real Time Clock
0x03	0x01	ISA Real Time Clock
0x04	0x00	generic PCI Hot Plug Controller (obsolete für PCI-Express)
0x05	0x00	SD Host Controller
0x06	0x00	IOMMU
0x07	0x00	Root Complex Event Collector (für PCI-Express)
0x80	0x00	Andere System-Peripherie

Class 0x09 - Input-Geräte

Subclass	Programming Interface	Beschreibung
0x00	0x00	Tastatur
0x01	0x00	Digitizer (Stift)
0x02	0x00	Maus
0x03	0x00	Scanner
0x04	0x00	Standard-Gameport
0x04	0x10	Gameport
0x80	0x00	Anderes Input-Gerät

Class 0x0A - Docking-Stationen

Subclass	Programming Interface	Beschreibung
0x00	0x00	Normale Docking-Station
0x80	0x00	Andere Docking-Station

Class 0x0B - Prozessoren

Subclass	Programming-Interface	Beschreibung
0x00	0x00	386
0x01	0x00	486
0x02	0x00	Pentium
0x10	0x00	Alpha
0x20	0x00	PowerPC
0x30	0x00	MIPS
0x40	0x00	Coprozessor

Class 0x0C - Serielle Buscontroller

Subclass	Programming Interface	Beschreibung
0x00	0x00	Firewire (IEEE 1394)
0x00	0x10	Firewire (OHCI)
0x01	0x00	ACCESS-Bus
0x02	0x00	SSA (Serial Storage Architecture)
0x03	0x00	USB-Host (UHCI)
0x03	0x10	USB-Host (OHCI)
0x03	0x20	USB-Host (EHCI)
0x03	0x30	USB-Host (xHCI)
0x03	0x80	USB-Host (kein HCI)
0x03	0xFE	USB-Device
0x04	0x00	Fibre Channel
0x05	0x00	SMB (System Management Bus)
0x06	0x00	InfiniBand
0x07	0x00	IPMI SMIC Interface
0x07	0x01	IPMI Keyboard Style Interface
0x07	0x02	IPMI Block Transfer Device
0x08	0x00	SERCOS Interface
0x09	0x00	CAN-Bus

Class 0x0D - Wireless-Controller

Subclass	Programming Interface	Beschreibung
0x00	0x00	iRDA
0x01	0x00	Consumer Infrared
0x10	0x00	Radio Frequency
0x11	0x00	Bluetooth
0x12	0x00	Broadband
0x80	0x00	Anderer Wireless-Controller

Class 0x0E - Intelligente Controller

Subclass	Programming Interface	Beschreibung
0x00	0x??	I²O-Architektur
0x00	0x00	Message FIFO

Class 0x0F - Satelliten-Kommunikations-Controller

Subclass	Programming Interface	Beschreibung
0x01	0x00	TV
0x02	0x00	Audio
0x03	0x00	Sprache
0x04	0x00	Daten

Class 0x10 - Encryption/Decryption-Controller

Subclass	Programming Interface	Beschreibung
0x01	0x00	Netzwerk
0x10	0x00	Entertainment
0x80	0x00	Anderer Controller

Class 0x11 - Datenerfassungs- und Signalprozessor-Controller

Subclass	Programming Interface	Beschreibung
0x00	0x00	Digital Input/Output Module
0x01	0x00	Zähler
0x10	0x00	Synchronisation und Frequenzmessung
0x20	0x00	Management Card
0x80	0x00	Anderer Controller

Weblinks

• Linux PCI ID Repositorium – Enthält viele Vendor- und die dazugehörigen Device-IDs
• PCI Vendor and Device Lists – Enthält ebenfalls eine große Liste Vendor- und Device-IDs