{{Hinweis|Text=Ich kenne mich mit der PCnet-Karte nicht besonders aus. Ich habe diesen Artikel auf Basis des týndur-Treibers und der drei unten genannten Spezifikationen erstellt, da diese Seite schon sehr lange auf der TODO-Liste steht, sich jedoch niemand darum gekümmert hat. Wenn '''du''' dich mit dieser Netzwerkkarte einigermaßen auskennst, dann bist du '''jetzt''' aufgerufen, diesen Artikel zu erweitern und/oder zu korrigieren (oder natürlich diesen Hinweis zu entfernen, wenn du den Artikel für korrekt befindest)!}} Dieser Artikel beschäftigt sich mit der Programmierung der AMD-PCnet-FAST-III-Netzwerkkarte (Am79C973). == Einführung == === Vorwort === Wenn ich hier von "Bytes" spreche, meine ich acht Bit große Einheiten. Zwei Bytes (16 Bit) sind ein Word und vier Bytes (32 Bit) ein DWord. Acht Bytes (64 Bit) sind ein QWord. Wenn ich keine Endianess explizit angebe, dann ist Little Endian gemeint. === Grundlagen === Wie beim [[RTL8139]]-Tutorial gilt auch hier: Euer Betriebssystem sollte bereits einen gewissen Stand aufweisen, um die Karte erkennen und bedienen zu können. Dies sind also [[Interrupt Service Routine|ISRs]] für [[IRQ|IRQs]], eine [[Speicherverwaltung]] und eine Möglichkeit, die [[I/O-Ports]] eines bestimmten (anhand von Vendor- und Device-ID) [[Peripheral Component Interconnect|PCI]]-Gerätes herauszufinden. Mögliche Emulatoren für PCnet sind sowohl [[QEMU]] als auch [[VirtualBox]]. Um die Karte unter QEMU zu benutzen, können zum Beispiel die folgenden Kommandozeilenoptionen angegeben werden: 
qemu -net user -net nic,model=pcnet
Dadurch erstellt QEMU eine virtuelle PCnet-Karte. An der IP-Adresse 10.0.2.2 gibt es einen virtuellen Gateway ins Internet. Um mit VirtualBox die gleiche Konfiguration zu erreichen, muss die PCnet-FAST III (Am79C973) an NAT angeschlossen werden. Die Netzwerkkarte hat die PCI-Vendor-ID 0x1022 und die Geräte-ID 0x2000. === Verwendete Resourcen === * I/O-Ports: Es gibt einen I/O-Raum, der dazu dient, einige Register der Netzwerkkarte anzusprechen und die weiteren zu erreichen. * IRQ: Per IRQ wird der Treiber über eine Statusänderung der Netzwerkkarte informiert (zum Beispiel ist ein Paket eingetroffen oder wurde versendet) == Zugriff == === Grundlagen === Die "direkt" erreichbaren Register (ein Portzugriff) sind nur ein kleiner Teil der gesamten Register der Karte. Neben ihnen gibt es noch die CSR (Control and Status Register) und die BCR (Bus Control Register). Um auf sie zuzugreifen, muss zuerst die Adresse des Registers in den 16-Bit-I/O-Port RAP (Register Address Port) geschrieben werden. Betrifft diese Adresse eines der CSR, so kann der Wert anschließend am 16-Bit-I/O-Port RDP (Register Data Port) ausgelesen oder verändert werden. Betrifft die Adresse eines der BCR, so handelt es sich nicht um den RDP, sondern um den BDP (BCR Data Port). === Initialisierung === 1. IRQ und I/O-Ports vom PCI-Treiber holen und gegebenenfalls registrieren 2. MAC-Adresse herausfinden; diese steht in drei 16-Bit-Registern ab 0x00 (APROM0, APROM2 und APROM4) in Little-Endian-Reihenfolge (also in APROM0 (0x00) die niederwertigsten 16 Bit und in APROM4 (0x04) die höchstwertigen 16 Bit). 3. Die Karte zurücksetzen; es muss ein Word vom Resetregister (0x14) eingelesen werden, um einen Software-Reset durchzuführen. Anschließend empfiehlt es sich, zehn Millisekunden zu warten, bis der Reset beendet ist. Danach sollte das BCR20-Register auf 0x0102 gesetzt werden, dies verändert den Softwarestyle zu PCnet-PCI, dadurch werden 32-Bit- und nicht 16-Bit-Strukturen verwendet. Außerdem wird dadurch das SSIZE32-Bit gesetzt, auch dadurch werden 32-Bit-Strukturen aktiviert. 4. Nun muss ein STOP-Reset ausgeführt werden. Dies wird erreicht, indem 0x04 nach CSR0 geschrieben wird. 5. Puffer zum Senden und Empfangen initialisieren; beide müssen 2 kB groß und physisch kontinuierlich sein. 6. Nun muss die Karte initialisiert werden. Dies geschieht mittels eines Initialization Block, der folgendermaßen aussieht: struct initialization_block { uint16_t mode; unsigned reserved1 : 4; unsigned receive_length : 4; unsigned reserved2 : 4; unsigned transfer_length : 4; uint64_t physical_address : 48; uint16_t reserved3; uint64_t logical_address; uint32_t receive_descriptor; uint32_t transmit_descriptor; } __attribute__((packed)); "reservedX"-Felder sind reserviert. "mode" ist 0x8000, wenn die Karte in den Promiscuous-Mode geschaltet werden soll (Alle Pakete empfangen, nicht nur Broadcasts und die für die eigene MAC-Adresse), sonst 0x0000. "receive_length" gibt die Anzahl der Empfangsdeskriptoren an, dazu später. "transfer_length" enthält im Gegensatz dazu die Anzahl der Sendedeskriptoren. Beide Werte können auf 3 gesetzt werden, dies entspricht jeweils acht Deskriptoren. "physical_address" enthält die MAC-Adresse der Karte. "logical_address" kann auf 0 gesetzt werden. "receive_descriptor" enthält die physische Adresse zu einem 2-kB-Puffer, "transmit_descriptor" zu einem anderen. Beide Puffer müssen physisch kontinuierlich sein und an 16-Bytes-Grenzen ausgerichtet. 7. Jetzt müssen die Empfangs- und Sendedeskriptoren initialisiert werden. So ein Deskriptor sieht so aus: struct descriptor { uint32_t address; uint32_t flags; uint32_t flags2; uint32_t avail; } __attribute__((packed)); "address" gibt die physische Adresse eines 2-kB-Puffers (physisch kontinuierlich) an, "flags" und "flags2" enthalten Flags (siehe unten), "avail" kann vom Benutzer (also von dir) frei verwendet werden. Bei den Empfangsdeskriptoren muss das OWN-Bit (0x80000000) im "flags"-Feld gesetzt werden, zudem müssen die Bits 0 bis 11 des "flags"-Feldes auf 0x7FF gesetzt werden (negative Länge des Puffers, also -2048). Außerdem müssen in beiden Deskriptortypen die Bits 12 bis 15 (0x0000F000) im "flags"-Feld gesetzt werden. Die acht Empfangsdeskriptoren müssen hintereinander in den Puffer geschrieben werden, der in das "receive_descriptor"-Feld des Initialization Blocks eingetragen wurde. Die acht Sendedeskriptoren müssen analog dazu in den Puffer geschrieben werden, der in das "transmit_descriptor"-Feld eingetragen wurde. 8. Wenn auch die Deskriptoren initialisiert sind, sollte der Initialization Block bei der Karte registriert werden. Hierzu werden die niederwertigen 16 Bits der physischen Adresse in das CSR1-Register und die höherwertigen in das CSR2-Register geschrieben. 9. Danach muss 0x0041 nach CSR0 geschrieben werden. Das initialisiert die Karte und aktiviert Interrupts. Gleich darauf wird ein IRQ eintreffen. Die ISR sollte einfach den Wert von CSR0 nach CSR0 (sic!) schreiben, um den Interrupt anzunehmen. 10. Wenn der Interrupt empfangen wurde, sollte der Inhalt von CSR4 mit 0xC00 ge-OR-t und wieder nach CSR4 geschrieben werden. Dadurch werden Pakete, die kleiner als 64 Bytes sind, automatisch auf diese größe vergrößert und einige relativ überflüssige Informationen von empfangenen Paketen entfernt. 11. Jetzt ist die Initialisierung endlich abgeschlossen und die Karte darf in Betrieb genommen werden, indem 0x42 nach CSR0 geschrieben wird. === Konstanten === //Die Werte, auf die RAP gesetzt werden muss, um dieses Register zu benutzen #define CSR0 0 #define CSR1 1 #define CSR2 2 #define CSR4 4 #define BCR20 20 //Aliasnamen, damit man auch weiß, was es bedeutet #define CSR_STATUS CSR0 #define CSR_INITIALIZATION_BLOCK_LOW CSR1 #define CSR_INITIALIZATION_BLOCK_HIGH CSR2 #define CSR_TEST_AND_FEATURES CSR4 #define BCR_SOFTWARE_STYLE BCR20 //16-Bit-I/O-Ports (bzw. Offsets zum Beginn des I/O-Raums) #define APROM0 0x00 #define APROM2 0x02 #define APROM4 0x04 #define RDP 0x10 #define RAP 0x12 #define RESET 0x14 #define BDP 0x16 === Die ISR === Wenn ein Interrupt eintrifft, dann zeigt das CSR0-Register den Grund dafür an. Ist das ERR-Bit (0x00008000) gesetzt, so trat ein Fehler auf. Wenn das TINT-Flag (0x00000200) gesetzt ist, dann wurde ein Sendedeskriptor abgearbeitet. Ob erfolgreich oder nicht, dass steht im entsprechenden Deskriptor. Ist im "flags"-Feld das ERROR-Bit gesetzt (0x40000000), dann trat ein Fehler auf, ansonsten wurde das Paket gesendet. Die "flags"-Felder (also "flags" und "flags2") des Deskriptors sollten dann auf 0 gesetzt werden. Sollte das RINT-Flag (0x00000400) gesetzt sein, dann wurde ein Paket abgearbeitet. Siehe dazu "Empfangen von Paketen". Am Ende der ISR sollte der Inhalt des CSR0-Registers dorthin zurückgeschrieben werden, um der Karte anzuzeigen, dass der Interrupt abgearbeitet wurde. === Senden eines Pakets === Um ein Paket zu senden, muss die physische Adresse des entsprechenden Datenpuffers in das "address"-Felds des nächsten Sendedeskriptors geschrieben werden (zuerst Deskriptor 0, dann 1 und so weiter bis Deskriptor 7 (also der achte), danach wieder von vorn beginnen). "flags2" zeigt ein, ob ein Fehler beim Senden geschehen ist, sollte daher vom Treiber auf 0 gesetzt werden. Im "flags"-Feld muss nun das OWN-Bit gesetzt werden (0x80000000), um der Karte den Deskriptor zu "übergeben". Desweiteren sollten STP (Start of Packet, 0x02000000) und ENP (End of Packet, 0x01000000) gesetzt werden - dies zeigt an, dass die Daten nicht aufgeteilt werden, sondern dass es sich um ein einzelnes Ethernetpaket handelt. Weiterhin müssen die Bits 12-15 gesetzt werden (0x0000F000, sind wohl reserviert) und die Bits 0-11 geben die '''negative''' Größe des Pakets an. Nun könnte man einfach warten, bis die Karte sich das Paket abholt. Alternativ dazu kann man auch das TDMD-Bit (0x08) in CSR0 setzen (Also 0x48 nach CSR0 schreiben, um die Interrupts aktiviert zu lassen), um diese Wartezeit abzukürzen. Dazu ein Codebeispiel: void write_csr(struct pcnet_card *ncard, uint16_t csr, uint16_t val) { outw(ncard->port_base + RAP, csr); outw(ncard->port_base + RDP, val); } uint16_t read_csr(struct pcnet_card *ncard, uint16_t csr) { outw(ncard->port_base + RAP, csr); return inw(ncard->port_base + RDP); } void send_packet(struct pcnet_card *ncard, void *buffer, size_t length) { int current_descriptor; //Achtung, Beginn eines kritischen Abschnitts! if (ncard->current_transmit_descriptor > 7) ncard->current_transmit_descriptor = 0; current_descriptor = ncard->current_transmit_descriptor++; if (current_descriptor == 7) //ncard->current_transmit_descriptor ist also 8 ncard->current_transmit_descriptor = 0; //Ende des Abschnitts if (length > 1518) //Maximale Länge eines Ethernetframes length = 1518; //ncard->linear_transmit_buffer enthält die lineare Adresse des Puffers memcpy(ncard->linear_transmit_buffer[current_descriptor], buffer, length); //Die physische Adresse (also ncard->physical_transmit_buffer[current_descriptor]) sollte schon bei der //Initialisierung in das "address"-Feld geschrieben worden sein ncard->linear_transmit_descriptor[current_descriptor].flags2 = 0; ncard->linear_transmit_descriptor[current_descriptor].flags = 0x8030F000 | ((-length) & 0x7FF); write_csr(ncard, CSR0, 0x48); } === Empfangen von Paketen === Sobald ein Paket empfangen wurde (das heißt, die ISR wurde aufgerufen und das RINT-Flag im CR0-Register ist gesetzt), müssen alle Empfangsdeskriptoren ab dem aktuellen abgearbeitet werden, bis das OWN-Bit (0x80000000 im "flags"-Feld) bei einem gesetzt ist. Denn alle Deskriptoren mit gelöschtem OWN-Bit wurden gerade von der Karte bearbeitet. Zum Abholen der Daten sollte dann das OWN-Bit gesetzt werden und die Daten können aus dem im Deskriptor angegebenen Puffer kopiert werden. Die Anzahl der Bytes steht in den Bits 0 bis 11 des "flags2"-Feldes. Zu diesen Daten gehört auch eine 4 Bytes lange CRC32-Checksumme am Ende des Pakets. Die Daten sollten nur dann gelesen werden, wenn das ERROR-Bit (0x40000000) im "flags"-Feld nicht gesetzt ist. Außerdem sollten die Bits STP und ENP (0x02000000 bzw. 0x01000000) - ebenfalls im "flags"-Feld - beide gesetzt sein. Beispielcode: size_t size_of_packet; while ((ncard->linear_receive_descriptor[ncard->receive_descriptor].flags & 0x80000000) == 0) { if (!(ncard->linear_receive_descriptor[netcard->receive_descriptor].flags & 0x40000000) && (ncard->linear_receive_descriptor[netcard->receive_descriptor].flags & 0x03000000) == 0x03000000) { size_of_packet = netcard->linear_receive_descriptor[netcard->receive_descriptor].flags2 & 0xFFF; if (size_of_packet > 64) size_of_packet -= 4; //CRC32 nicht mitkopieren //Mach mit den Daten, was du willst! //Sie stehen in der virtuellen Version von netcard->linear_receive_descriptor[netcard_receive_descriptor].address //und sind [size_of_packet] Bytes lang } ncard->linear_receive_descriptor[netcard->receive_descriptor].flags = 0x8000F7FF; //OWN-Bit und Standardwerte setzen ncard->linear_receive_descriptor[netcard->receive_descriptor++].flags2 = 0; if (netcard->last_receive_descriptor == 8) netcard->last_receive_descriptor = 0; } == Siehe auch == * [[Ethernet]] * [[Address Resolution Protocol]] * [[Internet Protocol]] == Weblinks == * [http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/21510.pdf Umfangreiche Spezifikation für die Am79C973 (PCnet-FAST III) und Am79C975] * [http://www.amd.com/us-en/assets/content_type/DownloadableAssets/22351.pdf AMD-Hardware-Spezifikation] * [http://www.amd.com/us-en/assets/content_type/white_papers_and_tech_docs/21485_pt1.pdf Umfangreiche Spezifikation für die Am79C972 (PCnet-FAST+)] - sollte zur Am79C973 (PCnet-FAST III) kompatibel sein [[Kategorie:Tutorials]] [[Kategorie:Netzwerkkarte]]