Guest User

Untitled

a guest
Apr 1st, 2017
70
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 23.81 KB | None | 0 0
  1. /*** Diesen Code darf jeder, unter Berücksichtigung der Lizenz für diesen Wiki-Artikel, zu jedem Zweck kopieren, nutzen und verändern!
  2.      (C) <http://www.lowlevel.eu/> ***/
  3.  
  4. #define PCI_CONFIG_DATA    0x0CFC
  5. #define PCI_CONFIG_ADDRESS 0x0CF8
  6.  
  7. typedef struct {
  8.     int bus;
  9.     int dev;
  10.     int func;
  11. } pci_bdf_t;
  12.  
  13. typedef struct {
  14.     pci_bdf_t address;
  15.     uint16_t device_id;
  16.     uint16_t vendor_id;
  17.     uint16_t status;
  18.     uint16_t command;
  19.     uint8_t class_high;
  20.     uint8_t class_middle;
  21.     uint8_t prog_if;
  22.     uint8_t revision;
  23.     uint8_t BIST;
  24.     uint8_t header_type;
  25.     uint8_t latency_timer;
  26.     uint8_t cache_line_size;
  27.     uint8_t capabilities;
  28.     uint8_t interrupt_pin;
  29.     uint8_t interrupt_line;
  30. } pci_device;
  31.  
  32. pci_device get_pci_device(pci_bdf_t addr);
  33. void print_pci_info(pci_bdf_t dev);
  34. void class_to_text(pci_device dev);
  35.  
  36. /* ließt einen 32Bit-Wert aus dem Config-Space vom PCI-Gerät (addr) an Offset (offset) und gibt ihn zurück */
  37. uint32_t pci_config_readd(pci_bdf_t addr,uint offset);
  38.  
  39. uint32_t pci_config_readd(pci_bdf_t addr,uint offset) {
  40.   int bus=addr.bus;
  41.   int dev=addr.dev;
  42.   int func=addr.func;
  43.   uint32_t val;
  44.   int address = 0x80000000|(bus<<16)|(dev<<11)|(func<<8)|(offset&0xFC);
  45.   outl(PCI_CONFIG_ADDRESS,address);
  46.   val = inl(PCI_CONFIG_DATA);
  47.   return val;
  48. }
  49.  
  50. /* schreibt einen 32Bit-Wert (value) in den Config-Space vom PCI-Gerät (addr) an Offset (offset) */
  51. void pci_config_writed(pci_bdf_t addr,uint offset,uint32_t value);
  52.  
  53. void pci_config_writed(pci_bdf_t addr,uint offset,uint32_t value) {
  54.   int bus=addr.bus;
  55.   int dev=addr.dev;
  56.   int func=addr.func;
  57.   int address = 0x80000000|(bus<<16)|(dev<<11)|(func<<8)|(offset&0xFC);
  58.   outl(PCI_CONFIG_ADDRESS,address);
  59.   outl(PCI_CONFIG_DATA,value);
  60. }
  61.  
  62. /* sucht das unterste gesetzte Bit in einem 32Bit-Wert , value darf nicht 0 sein */
  63. static uint get_number_of_lowest_set_bit(uint32_t value);
  64. static uint get_number_of_lowest_set_bit(uint32_t value)
  65. {
  66.   uint pos = 0;
  67.   uint32_t mask = 0x00000001;
  68.   while (!(value & mask))
  69.    { ++pos; mask=mask<<1; }
  70.   return pos;
  71. }
  72.  
  73. /* sucht das oberste gesetzte Bit in einem 32Bit-Wert , value darf nicht 0 sein */
  74. static uint get_number_of_highest_set_bit(uint32_t value);
  75. static uint get_number_of_highest_set_bit(uint32_t value)
  76. {
  77.   uint pos = 31;
  78.   uint32_t mask = 0x80000000;
  79.   while (!(value & mask))
  80.    { --pos; mask=mask>>1; }
  81.   return pos;
  82. }
  83.  
  84.  
  85. /* analysiert die BARs eines bestimmten PCI-Gerätes, das PCI-Gerät sollte hierfür unbenutzt sein */
  86. void pci_config_bar_analyze(const pci_bdf_t addr)
  87. {
  88.   // Header-Type auslesen um zu ermitteln wie viele BARs vorhanden sind :
  89.   const uint32_t headerType = ( pci_config_readd(addr,0x00C) >> 16 ) & 0x7F;
  90.   // es werden nur Type 0x00 (normale Devices) und 0x01 (PCI-to-PCI-Bridges) unterstützt :
  91.   if (headerType >= 0x02) {
  92.       //kprintf("FEHLER : nicht unterstützter Header-Type gefunden!\n");
  93.       return;
  94.   }
  95.  
  96.   // 6 BARs für Type 0x00 und 2 BARs für Type 0x01 :
  97.   const uint max_bars = 6 - (headerType * 4);
  98.   uint bar;
  99.   for (bar = 0 ; bar < max_bars ; ++bar)
  100.    {
  101.      // Offset des aktuellen BAR ermitteln :
  102.      const uint barOffset = 0x010+(bar*4);
  103.  
  104.      // prüfen ob Speicher oder IO :
  105.      if ( (pci_config_readd(addr,barOffset) & 0x1) == 0 )
  106.       { // Speicher-Ressource :
  107.  
  108.         // Prefetchable-Bit auslesen und passenden Text auswählen :
  109.         static const char* ptext_pref = "prefetchable"; // Text für prefetchable
  110.         static const char* ptext_nopr = "non-prefetchable"; // Text für non-prefetchable
  111.         const char* const ptext = (((pci_config_readd(addr,barOffset) >> 3) & 0x1) == 1) ? ptext_pref : ptext_nopr;
  112.  
  113.         // check Memory-BAR-Type :
  114.         switch((pci_config_readd(addr,barOffset) >> 1) & 0x3)
  115.          {
  116.            case 0x0: // 32Bit Memory-BAR :
  117.              {
  118.              pci_config_writed(addr,barOffset,0xFFFFFFF0); // mit lauter 1en überschreiben
  119.              const uint32_t barValue = pci_config_readd(addr,barOffset) & 0xFFFFFFF0; // und wieder zurücklesen
  120.              if (barValue == 0) // es muss mindestens ein Adressbit 1 (also beschreibbar) sein
  121.               {
  122.                 if (ptext != ptext_nopr) // unbenutzte BARs müssen komplett 0 sein (auch das Prefetchable-Bit darf nicht gesetzt sein)
  123.                  { kprintf("FEHLER : 32Bit-Memory-BAR %u enthaelt keine beschreibbaren Adressbits!\n",bar); return; }
  124.  
  125.                 // BAR-Infos ausgeben :
  126.                 //kprintf("BAR %u ist unbenutzt.\n",bar);
  127.               }
  128.              else
  129.               {
  130.                 const uint lowestBit = get_number_of_lowest_set_bit(barValue);
  131.                 // es muss eine gültige 32Bit-Adresse sein :
  132.                 if ( (get_number_of_highest_set_bit(barValue) != 31) || (lowestBit > 31) || (lowestBit < 4) )
  133.                  { kprintf("FEHLER : 32Bit-Memory-BAR %u enthaelt ungueltige beschreibbare Adressbits!\n",bar); return; }
  134.  
  135.                 // BAR-Infos ausgeben :
  136.                 kprintf("BAR %u enhaelt eine %s 32Bit-Memory-Ressource mit einer Groesse von 2^%u Bytes.\n",bar,ptext,lowestBit);
  137.               }
  138.              }
  139.              break;
  140.  
  141.            case 0x1: // 20Bit Memory-BAR :
  142.              {
  143.              if (headerType == 0x01)
  144.               { kprintf("FEHLER : 20Bit-Memory-BAR %u ist fuer eine Bridge nicht erlaubt!\n",bar); return; }
  145.  
  146.              pci_config_writed(addr,barOffset,0xFFFFFFF0); // mit lauter 1en überschreiben
  147.              const uint32_t barValue = pci_config_readd(addr,barOffset) & 0xFFFFFFF0; // und wieder zurücklesen
  148.              if (barValue == 0) // es muss mindestens ein Adressbit 1 (also beschreibbar) sein
  149.               { kprintf("FEHLER : 20Bit-Memory-BAR %u enthaelt keine beschreibbaren Adressbits!\n",bar); return; }
  150.  
  151.              const uint lowestBit = get_number_of_lowest_set_bit(barValue);
  152.              // es muss eine gültige 20Bit-Adresse sein :
  153.              if ( (get_number_of_highest_set_bit(barValue) != 19) || (lowestBit > 19) || (lowestBit < 4) )
  154.               { kprintf("FEHLER : 20Bit-Memory-BAR %u enthaelt ungueltige beschreibbare Adressbits!\n",bar); return; }
  155.  
  156.              // BAR-Infos ausgeben :
  157.              kprintf("BAR %u enhaelt eine %s 20Bit-Memory-Ressource mit einer Groesse von 2^%u Bytes.\n",bar,ptext,lowestBit);
  158.              }
  159.              break;
  160.  
  161.            case 0x2: // 64Bit Memory-BAR :
  162.              {
  163.              // prüfen ob ein 64Bit-BAR an der aktuellen Position überhaupt möglich ist :
  164.              if (bar >= (max_bars-1))
  165.               { kprintf("FEHLER : 64Bit-Memory-BAR %u darf nicht an letzter Position beginnen!\n",bar); return; }
  166.              // non-prefetchable 64-BARs können nicht hinter Bridges benutzt werden (? aber in der Spec sind sie nicht verboten ?) :
  167.              if (ptext != &ptext_pref[0])
  168.               { kprintf("FEHLER : 64Bit-Memory-BAR %u enthaelt eine non-prefetchable Memory-Ressource!\n",bar); return; }
  169.  
  170.              pci_config_writed(addr,barOffset,0xFFFFFFF0); // mit lauter 1en überschreiben
  171.              pci_config_writed(addr,barOffset+4,0xFFFFFFFF); // mit lauter 1en überschreiben
  172.              const uint32_t barLowValue  = pci_config_readd(addr,barOffset) & 0xFFFFFFF0; // und wieder zurücklesen
  173.              const uint32_t barHighValue = pci_config_readd(addr,barOffset+4); // und wieder zurücklesen
  174.  
  175.              uint lowestBit = 0;
  176.              if (barLowValue != 0)
  177.               { // kleiner als 4 GByte :
  178.                 lowestBit = get_number_of_lowest_set_bit(barLowValue);
  179.                 // es muss eine gültige kleine 64Bit-Adresse sein :
  180.                 if ( (barHighValue != 0xFFFFFFFF) || (get_number_of_highest_set_bit(barLowValue) != 31) || (lowestBit > 31) || (lowestBit < 4) )
  181.                  { kprintf("FEHLER : 64Bit-Memory-BAR %u enthaelt ungueltige beschreibbare Adressbits im unteren Adressteil!\n",bar); return; }
  182.               }
  183.              else
  184.               { // größer/gleich als 4 GByte :
  185.                 lowestBit = get_number_of_lowest_set_bit(barHighValue) + 32;
  186.                 // es muss eine gültige große 64Bit-Adresse sein :
  187.                 if ( (get_number_of_highest_set_bit(barHighValue) != 31) || (lowestBit > 63) || (lowestBit < 32) )
  188.                  { kprintf("FEHLER : 64Bit-Memory-BAR %u enthaelt ungueltige beschreibbare Adressbits im oberen Adressteil!\n",bar); return; }
  189.               }
  190.  
  191.              // BAR-Infos ausgeben :
  192.              kprintf("BAR %u enhaelt eine %s 64Bit-Memory-Ressource mit einer Groesse von 2^%u Bytes.\n",bar,ptext,lowestBit);
  193.  
  194.              // den nachfolgenden BAR für die Analyse überspringen :
  195.              ++bar;
  196.  
  197.              // BAR-Infos ausgeben :
  198.              kprintf("BAR %u ist nicht nutzbar da er die oberen 32 Bits des vorrangegangenen 64Bit-BARs enthaelt\n",bar);
  199.              }
  200.              break;
  201.  
  202.            default: // ungültiger Memory-BAR :
  203.              kprintf("FEHLER : Memory-BAR %u ist ungueltig!\n",bar); return;
  204.          }
  205.       }
  206.      else
  207.       { // IO-Ressource :
  208.         pci_config_writed(addr,barOffset,0xFFFFFFFC); // mit lauter 1en überschreiben
  209.         const uint32_t barValue = pci_config_readd(addr,barOffset) & 0xFFFFFFFC; // und wieder zurücklesen
  210.         if (barValue == 0) // es muss mindestens ein Adressbit 1 (also beschreibbar) sein
  211.          { kprintf("FEHLER : IO-BAR %u enthaelt keine beschreibbaren Adressbits!\n",bar); return; }
  212.  
  213.         const uint lowestBit  = get_number_of_lowest_set_bit(barValue);
  214.         const uint highestBit = get_number_of_highest_set_bit(barValue);
  215.         // es muss entwerder eine gültige 32Bit-Adresse oder eine gültige 16Bit-Adresse sein :
  216.         if ( ( (highestBit != 31) && (highestBit != 15) ) || (highestBit < lowestBit) || (lowestBit < 2) )
  217.          { kprintf("FEHLER : IO-BAR %u enthaelt ungueltige beschreibbare Adressbits!\n",bar); return; }
  218.  
  219.         // BAR-Infos ausgeben :
  220.         kprintf("BAR %u enhaelt eine %uBit-IO-Ressource mit einer Groesse von 2^%u Bytes.\n",bar,highestBit+1,lowestBit);
  221.       }
  222.    }
  223.   if (bar != max_bars)
  224.    { kprintf("interner Fehler in Schleife!\n"); return; }
  225. }
  226.  
  227. void get_pci_devices(void);
  228.  
  229. void get_pci_devices(void) {
  230.     kprintf("Reading PCI\n");
  231.     pci_bdf_t pci;
  232.     for(int i=0;i<256;i++) {
  233.         for(int j=0;j<32;j++) {
  234.             for(int k=0;k<8;k++) {
  235.                 pci.bus=i;
  236.                 pci.dev=j;
  237.                 pci.func=k;
  238.                 uint32_t res=pci_config_readd(pci,0);
  239.                 uint16_t dev=(uint16_t)(res >> 16);
  240.                 uint16_t ven=(uint16_t)(res & 0x0000FFFF);
  241.                 if(ven!=0xffff) {
  242.                     kprintf("Geraet gefunden: Bus: %d Dev: %d Func: %d Vendor: %x Device: %x\n",i,j,k,ven,dev);
  243.                 }
  244.             }
  245.         }
  246.     }  
  247. }
  248.  
  249. pci_device get_pci_device(pci_bdf_t addr) {
  250.     pci_device pci;
  251.    
  252.     uint32_t res=pci_config_readd(addr,0x000);
  253.     pci.address=addr;
  254.     pci.device_id=(uint16_t)(res >> 16); //High
  255.     pci.vendor_id=(uint16_t)(res & 0x0000FFFF); //Low
  256.    
  257.     res=pci_config_readd(addr,0x004);  
  258.     pci.status=(uint16_t)(res >> 16);
  259.     pci.command=(uint16_t)(res & 0x0000FFFF);
  260.    
  261.     res=pci_config_readd(addr,0x008);
  262.     pci.class_high=(uint8_t)(res >> 24);
  263.     pci.class_middle=(uint8_t)(res >> 16);
  264.     pci.prog_if=(uint8_t)(res >> 8);
  265.     pci.revision=(uint8_t)(res & 0x000000FF);
  266.    
  267.     res=pci_config_readd(addr,0x00C);
  268.     pci.BIST=(uint8_t)(res >> 24);
  269.     pci.header_type=(uint8_t)(res >> 16);
  270.     pci.latency_timer=(uint8_t)(res >> 8);
  271.     pci.cache_line_size=(uint8_t)(res & 0x000000FF);
  272.    
  273.     res=pci_config_readd(addr,0x034);
  274.     pci.capabilities=(uint8_t)(res & 0x000000FF);
  275.    
  276.     res=pci_config_readd(addr,0x03C);
  277.     pci.interrupt_pin=(uint8_t)(res >> 8);
  278.     pci.interrupt_line=(uint8_t)(res & 0x000000FF);
  279.    
  280.     return pci;
  281. }
  282.  
  283. void print_pci_info(pci_bdf_t addr) {
  284.     pci_device dev=get_pci_device(addr);
  285.     kprintf("     Device-ID: %x\n",dev.device_id);
  286.     kprintf("     Vendor-ID: %x\n",dev.vendor_id);
  287.     kprintf("     Status: %b\n",dev.status);
  288.     kprintf("     Command: %b\n",dev.command);
  289.     kprintf("     Base-Class: %x\n",dev.class_high);
  290.     kprintf("     Sub-Class: %x\n",dev.class_middle);
  291.     kprintf("     Prog-Interface: %x\n",dev.prog_if);
  292.     kprintf("     Revision: %x\n",dev.revision);
  293.     kprintf("     BIST: %x\n",dev.BIST);
  294.     kprintf("     Header-Type: %x\n",dev.header_type);
  295.     kprintf("     Latency-Timer: %x\n",dev.latency_timer);
  296.     kprintf("     Cache-Line-Size: %x\n",dev.cache_line_size);
  297.     kprintf("     Capabilities: %x\n",dev.capabilities);
  298.     kprintf("     IRQ-Pin: %x\n",dev.interrupt_pin);
  299.     kprintf("     IRQ-Line: %x\n",dev.interrupt_line);
  300.     pci_config_bar_analyze(addr);  
  301. }
  302.  
  303. void class_to_text(pci_device dev) {
  304.     switch(dev.class_high) {
  305.         case 0x0:
  306.             kprintf("Klasse nicht vorhanden: ");
  307.             if(dev.class_middle==0x00) kprintf("Kein VGA-Geraet");
  308.             if(dev.class_middle==0x01) kprintf("VGA-Geraet");
  309.             kprintf("\n");
  310.             break;
  311.         case 0x01:
  312.             kprintf("Massenspeicher: ");
  313.             switch(dev.class_middle) {
  314.                 case 0x0:
  315.                     kprintf("SCSI");
  316.                     break;
  317.                 case 0x01:
  318.                     kprintf("IDE");
  319.                     break;
  320.                 case 0x02:
  321.                     kprintf("Floppy");
  322.                     break;
  323.                 case 0x03:
  324.                     kprintf("IPI");
  325.                     break;
  326.                 case 0x04:
  327.                     kprintf("RAID");
  328.                     break;
  329.                 case 0x05:
  330.                     kprintf("ATA-Controller");
  331.                     if(dev.prog_if==0x20) kprintf(" (Single DMA)");
  332.                     if(dev.prog_if==0x20) kprintf(" (Chained DMA)");
  333.                     break;
  334.                 case 0x06:
  335.                     kprintf("SATA-Controller");
  336.                     if(dev.prog_if==0x0) kprintf(" (Herstellerspezifische Schnittstelle)");
  337.                     if(dev.prog_if==0x01) kprintf(" (AHCI 1.0)");
  338.                     break;
  339.                 case 0x07:
  340.                     kprintf("SAS-Controller");
  341.                     break;
  342.                 case 0x08:
  343.                     kprintf("Non-Volatile-Memory");
  344.                     if(dev.prog_if==0x0) kprintf(" (Allgemein)");
  345.                     if(dev.prog_if==0x01) kprintf(" NVMHCI (NVM(-Express) Host-Controller)");
  346.                     if(dev.prog_if==0x02) kprintf(" Enterprise-NVMHCI (NVM(-Express) Host-Controller)");
  347.                     break;
  348.                 case 0x80:
  349.                     kprintf("Anderes (unbekannt)");
  350.                     break;
  351.             }
  352.             kprintf("\n");
  353.             break;
  354.         case 0x02:
  355.             kprintf("Netzwerk: ");
  356.             switch(dev.class_middle) {
  357.                 case 0x0:
  358.                     kprintf("Ethernet");
  359.                     break;
  360.                 case 0x01:
  361.                     kprintf("Token Ring");
  362.                     break;
  363.                 case 0x02:
  364.                     kprintf("FDDI");
  365.                     break;
  366.                 case 0x03:
  367.                     kprintf("ATM");
  368.                     break;
  369.                 case 0x04:
  370.                     kprintf("ISDN");
  371.                     break;
  372.                 case 0x05:
  373.                     kprintf("World FIP (Feldbus)");
  374.                     break;
  375.                 case 0x06:
  376.                     kprintf("PICMG 2.14, Multi-Computing");
  377.                     break;
  378.                 case 0x80:
  379.                     kprintf("Anderer");
  380.                     break;
  381.             }
  382.             kprintf("\n");
  383.             break;
  384.         case 0x03:
  385.             kprintf("Bildschirmcontroller: ");
  386.             switch(dev.class_middle) {
  387.                 case 0x0:
  388.                     kprintf("0x0: ");
  389.                     if(dev.prog_if==0x0) kprintf("VGA");
  390.                     if(dev.prog_if==0x01) kprintf("8514");
  391.                     break;
  392.                 case 0x01:
  393.                     kprintf("XGA");
  394.                     break;
  395.                 case 0x02:
  396.                     kprintf("3D");
  397.                     break;
  398.                 case 0x80:
  399.                     kprintf("Anderer");
  400.                     break;
  401.             }
  402.             kprintf("\n");
  403.             break;
  404.         case 0x04:
  405.             kprintf("Multimedia: ");
  406.             switch(dev.class_middle) {
  407.                 case 0x0:
  408.                     kprintf("Video");
  409.                     break;
  410.                 case 0x01:
  411.                     kprintf("Audio");
  412.                     break;
  413.                 case 0x02:
  414.                     kprintf("Telefonie");
  415.                     break;
  416.                 case 0x03:
  417.                     kprintf("HD-Audio");
  418.                     break;
  419.                 case 0x80:
  420.                     kprintf("Anderer");
  421.                     break;
  422.             }
  423.             kprintf("\n");
  424.             break;
  425.         case 0x05:
  426.             kprintf("Speicher-Controller: ");
  427.             switch(dev.class_middle) {
  428.                 case 0x0:
  429.                     kprintf("RAM");
  430.                     break;
  431.                 case 0x01:
  432.                     kprintf("Flash-Speicher");
  433.                     break;
  434.                 case 0x80:
  435.                     kprintf("Anderer");
  436.                     break;
  437.             }
  438.             kprintf("\n");
  439.             break;
  440.         case 0x06:
  441.             kprintf("Bridge: ");
  442.             switch(dev.class_middle) {
  443.                 case 0x0:
  444.                     kprintf("Host/PCI");
  445.                     break;
  446.                 case 0x01:
  447.                     kprintf("PCI/ISA");
  448.                     break;
  449.                 case 0x02:
  450.                     kprintf("PCI/EISA");
  451.                     break;
  452.                 case 0x03:
  453.                     kprintf("PCI/MicroChannel");
  454.                     break;
  455.                 case 0x04:
  456.                     kprintf("PCI/PCI");
  457.                     if(dev.prog_if==0x01) kprintf(" (Subtractive Decode)");
  458.                     break;
  459.                 case 0x05:
  460.                     kprintf("PCI/PCMCIA");
  461.                     break;
  462.                 case 0x06:
  463.                     kprintf("PCI/NuBus");
  464.                     break;
  465.                 case 0x07:
  466.                     kprintf("PCI/CardBus");
  467.                     break;
  468.                 case 0x08:
  469.                     kprintf("Raceway, Switched Fabric");
  470.                     if(dev.prog_if==0x0) kprintf(" (Allgemein)");
  471.                     if(dev.prog_if==0x01) kprintf(" NVMHCI (NVM(-Express) Host-Controller)");
  472.                     if(dev.prog_if==0x02) kprintf(" Enterprise-NVMHCI (NVM(-Express) Host-Controller)");
  473.                     break;
  474.                 case 0x09:
  475.                     kprintf("Semitransparent PCI/PCI");
  476.                     if(dev.prog_if==0x40) kprintf(" (primaer zu Host)");
  477.                     if(dev.prog_if==0x80) kprintf(" (sekundaer zu Host)");
  478.                     break;
  479.                 case 0x0A:
  480.                     kprintf("InfiniBand/PCI");
  481.                     break;
  482.                 case 0x80:
  483.                     kprintf("Anderes (unbekannt)");
  484.                     break;
  485.             }
  486.             kprintf("\n");
  487.             break;
  488.         case 0x07:
  489.             kprintf("einfache Kommunikation: ");
  490.             switch(dev.class_middle) {
  491.                 case 0x0:
  492.                     kprintf("Serielle Schnittstelle");
  493.                     if(dev.prog_if==0x0) kprintf(" (XT-kompatibel)");
  494.                     if(dev.prog_if==0x01) kprintf(" (16450)");
  495.                     if(dev.prog_if==0x02) kprintf(" (16550)");
  496.                     if(dev.prog_if==0x03) kprintf(" (16650)");
  497.                     if(dev.prog_if==0x04) kprintf(" (16750)");
  498.                     if(dev.prog_if==0x05) kprintf(" (16850)");
  499.                     if(dev.prog_if==0x06) kprintf(" (16950)");
  500.                     break;
  501.                 case 0x01:
  502.                     kprintf("Parallelport");
  503.                     if(dev.prog_if==0x0) kprintf(" (Standard)");
  504.                     if(dev.prog_if==0x01) kprintf(" (Bidirektional)");
  505.                     if(dev.prog_if==0x02) kprintf(" (ECP 1.0)");
  506.                     if(dev.prog_if==0x03) kprintf(" (IEEE 1284)");
  507.                     if(dev.prog_if==0xFE) kprintf(" (IEEE-1284-Geraet, Target)");
  508.                     break;
  509.                 case 0x02:
  510.                     kprintf("Multiport Serial Controller");
  511.                     break;
  512.                 case 0x03:
  513.                     kprintf("0x03: ");
  514.                     if(dev.prog_if==0x0) kprintf("Standard-Modem");
  515.                     if(dev.prog_if==0x01) kprintf("Hayes-kompatibles Modem (16450)");
  516.                     break;
  517.                 case 0x04:
  518.                     kprintf("0x04");
  519.                     if(dev.prog_if==0x0) kprintf("GPIB (IEEE488.1/2) Controller");
  520.                     if(dev.prog_if==0x02) kprintf("Hayes-kompatibles Modem (16550)");
  521.                     if(dev.prog_if==0x03) kprintf("Hayes-kompatibles Modem (16650)");
  522.                     if(dev.prog_if==0x04) kprintf("Hayes-kompatibles Modem (16750)");
  523.                     break;
  524.                 case 0x05:
  525.                     kprintf("SmartCard");
  526.                     break;
  527.                 case 0x80:
  528.                     kprintf("Anderes (unbekannt)");
  529.                     break;
  530.             }
  531.             kprintf("\n");
  532.             break;
  533.         case 0x08:
  534.             kprintf("System-Peripherie: ");
  535.             switch(dev.class_middle) {
  536.                 case 0x0:
  537.                     kprintf("0x0: ");
  538.                     if(dev.prog_if==0x0) kprintf("8259- PIC");
  539.                     if(dev.prog_if==0x01) kprintf("ISA-PIC");
  540.                     if(dev.prog_if==0x02) kprintf("EISA-PIC");
  541.                     if(dev.prog_if==0x10) kprintf("IO- APIC");
  542.                     if(dev.prog_if==0x20) kprintf("IOx-APIC");
  543.                     break;
  544.                 case 0x01:
  545.                     kprintf("0x01: ");
  546.                     if(dev.prog_if==0x0) kprintf("8237-DMA-Controller");
  547.                     if(dev.prog_if==0x01) kprintf("ISA-DMA-Controller");
  548.                     if(dev.prog_if==0x02) kprintf("EISA-DMA-Controller");
  549.                     break;
  550.                 case 0x02:
  551.                     kprintf("0x02: ");
  552.                     if(dev.prog_if==0x0) kprintf("Standard-8254-Timer");
  553.                     if(dev.prog_if==0x01) kprintf("ISA-System-Timer");
  554.                     if(dev.prog_if==0x02) kprintf("EISA-System-Timer");
  555.                     if(dev.prog_if==0x03) kprintf("High Performance Event Timer");
  556.                     break;
  557.                 case 0x03:
  558.                     kprintf("0x03: ");
  559.                     if(dev.prog_if==0x0) kprintf("Standard Real Time Clock");
  560.                     if(dev.prog_if==0x01) kprintf("ISA Real Time Clock");
  561.                     break;
  562.                 case 0x04:
  563.                     kprintf("generic PCI Hot Plug Controller");
  564.                     break;
  565.                 case 0x05:
  566.                     kprintf("SD Host Controller");
  567.                     break;
  568.                 case 0x06:
  569.                     kprintf("IOMMU");
  570.                     break;
  571.                 case 0x07:
  572.                     kprintf("Root Complex Event Collector");
  573.                     break;
  574.                 case 0x80:
  575.                     kprintf("Anderes");
  576.                     break;
  577.             }
  578.             kprintf("\n");
  579.             break;
  580.         case 0x09:
  581.             kprintf("Input-Geraet: ");
  582.             switch(dev.class_middle) {
  583.                 case 0x0:
  584.                     kprintf("Tastatur");
  585.                     break;
  586.                 case 0x01:
  587.                     kprintf("Digitizer (Stift)");
  588.                     break;
  589.                 case 0x02:
  590.                     kprintf("Maus");
  591.                     break;
  592.                 case 0x03:
  593.                     kprintf("Scanner");
  594.                     break;
  595.                 case 0x04:
  596.                     kprintf("0x04: ");
  597.                     if(dev.prog_if==0x0) kprintf("Standard-Gameport");
  598.                     if(dev.prog_if==0x01) kprintf("Gameport");
  599.                     break;
  600.                 case 0x80:
  601.                     kprintf("Anderes");
  602.                     break;
  603.             }
  604.             kprintf("\n");
  605.             break;
  606.         case 0x0A:
  607.             kprintf("Docking-Stationen: ");
  608.             switch(dev.class_middle) {
  609.                 case 0x0:
  610.                     kprintf("Normale Docking-Station");
  611.                     break;
  612.                 case 0x80:
  613.                     kprintf("Andere");
  614.                     break;
  615.             }
  616.             kprintf("\n");
  617.             break;
  618.         case 0x0B:
  619.             kprintf("Prozessor: ");
  620.             switch(dev.class_middle) {
  621.                 case 0x0:
  622.                     kprintf("386");
  623.                     break;
  624.                 case 0x01:
  625.                     kprintf("486");
  626.                     break;
  627.                 case 0x02:
  628.                     kprintf("Pentium");
  629.                     break;
  630.                 case 0x10:
  631.                     kprintf("Alpha");
  632.                     break;
  633.                 case 0x20:
  634.                     kprintf("PowerPC");
  635.                     break;
  636.                 case 0x30:
  637.                     kprintf("Mips");
  638.                     break;
  639.                 case 0x40:
  640.                     kprintf("Coprozessor");
  641.                     break;
  642.             }
  643.             kprintf("\n");
  644.             break;
  645.         case 0x0C:
  646.             kprintf("Serielle Buscontroller: ");
  647.             switch(dev.class_middle) {
  648.                 case 0x0:
  649.                     kprintf("Firewire");
  650.                     if(dev.prog_if==0x0) kprintf(" (IEEE 1394)");
  651.                     if(dev.prog_if==0x10) kprintf(" (OHCI)");
  652.                     break;
  653.                 case 0x01:
  654.                     kprintf("ACCESS-Bus");
  655.                     break;
  656.                 case 0x02:
  657.                     kprintf("SSA (Serial Storage Architecture)");
  658.                     break;
  659.                 case 0x03:
  660.                     kprintf("USB-Host ");
  661.                     if(dev.prog_if==0x0) kprintf("(UHCI)");
  662.                     if(dev.prog_if==0x10) kprintf("(OHCI)");
  663.                     if(dev.prog_if==0x20) kprintf("(EHCI)");
  664.                     if(dev.prog_if==0x30) kprintf("(xHCI)");
  665.                     if(dev.prog_if==0x80) kprintf("(kein HCI)");
  666.                     if(dev.prog_if==0xFE) kprintf("(USB-Device)");
  667.                     break;
  668.                 case 0x04:
  669.                     kprintf("Fibre Channel");
  670.                     break;
  671.                 case 0x05:
  672.                     kprintf("SMB (System Management Bus)");
  673.                     break;
  674.                 case 0x06:
  675.                     kprintf("InfiniBand");
  676.                     break;
  677.                 case 0x07:
  678.                     kprintf("IPMI ");
  679.                     if(dev.prog_if==0x0) kprintf("SMIC Interface");
  680.                     if(dev.prog_if==0x01) kprintf("Keyboard Style Interface");
  681.                     if(dev.prog_if==0x02) kprintf("Block Transfer Device");
  682.                     break;
  683.                 case 0x08:
  684.                     kprintf("SERCOS Interface");
  685.                     break;
  686.                 case 0x09:
  687.                     kprintf("CAN-Bus");
  688.                     break;
  689.             }
  690.             kprintf("\n");
  691.             break;
  692.         case 0x0D:
  693.             kprintf("Wireless-Controller: ");
  694.             switch(dev.class_middle) {
  695.                 case 0x0:
  696.                     kprintf("iRDA");
  697.                     break;
  698.                 case 0x01:
  699.                     kprintf("Consumer Infrared");
  700.                     break;
  701.                 case 0x10:
  702.                     kprintf("Radio Frequency");
  703.                     break;
  704.                 case 0x11:
  705.                     kprintf("Bluetooth");
  706.                     break;
  707.                 case 0x12:
  708.                     kprintf("Broadband");
  709.                     break;
  710.                 case 0x80:
  711.                     kprintf("Anderer");
  712.                     break;
  713.             }
  714.             kprintf("\n");
  715.             break;
  716.         case 0x0E:
  717.             kprintf("Intelligente Controller: ");
  718.             switch(dev.class_middle) {
  719.                 case 0x0:
  720.                     kprintf("0x0");
  721.                     break;
  722.             }
  723.             kprintf("\n");
  724.             break;
  725.         case 0x0F:
  726.             kprintf("Satelliten-Kommunikation: ");
  727.             switch(dev.class_middle) {
  728.                 case 0x01:
  729.                     kprintf("TV");
  730.                     break;
  731.                 case 0x02:
  732.                     kprintf("Audio");
  733.                     break;
  734.                 case 0x03:
  735.                     kprintf("Sprache");
  736.                     break;
  737.                 case 0x04:
  738.                     kprintf("Daten");
  739.                     break;
  740.             }
  741.             kprintf("\n");
  742.             break;
  743.         case 0x10:
  744.             kprintf("Encryption/Decryption: ");
  745.             switch(dev.class_middle) {
  746.                 case 0x01:
  747.                     kprintf("Netzwerk");
  748.                     break;
  749.                 case 0x10:
  750.                     kprintf("Entertainment");
  751.                     break;
  752.                 case 0x80:
  753.                     kprintf("Anderer");
  754.                     break;
  755.             }
  756.             kprintf("\n");
  757.             break;
  758.         case 0x11:
  759.             kprintf("Datenerfassung/Signalprozessor: ");
  760.             switch(dev.class_middle) {
  761.                 case 0x0:
  762.                     kprintf("Digital Input/Output");
  763.                     break;
  764.                 case 0x01:
  765.                     kprintf("Zaehler");
  766.                     break;
  767.                 case 0x10:
  768.                     kprintf("Synchronisation und Frequenzmessung");
  769.                     break;
  770.                 case 0x20:
  771.                     kprintf("Management Card");
  772.                     break;
  773.                 case 0x80:
  774.                     kprintf("Anderer");
  775.                     break;
  776.             }
  777.             kprintf("\n");
  778.             break;
  779.         default:
  780.             kprintf("Unbekannt\n");
  781.             break;
  782.     }
  783. }
Advertisement
Add Comment
Please, Sign In to add comment