[BACK]Return to pcisupport.c CVS log [TXT] [DIR] Up to [DragonFly] / src / sys / bus / pci

Diff for /src/sys/bus/pci/pcisupport.c between versions 1.12 and 1.13

version 1.12, 2004/02/21 17:05:52 version 1.13, 2004/02/24 15:21:25
Line 71 Line 71
 **---------------------------------------------------------  **---------------------------------------------------------
 */  */
   
 static  void    chipset_attach(device_t dev, int unit);  
   
 struct condmsg {  
     unsigned char       port;  
     unsigned char       mask;  
     unsigned char       value;  
     char                flags;  
     const char          *text;  
 };  
   
   
 static void  static void
 fixbushigh_i1225(device_t dev)  fixbushigh_i1225(device_t dev)
 {  {
Line 114  fixwsc_natoma(device_t dev) Line 103  fixwsc_natoma(device_t dev)
         }          }
 #endif  #endif
 }  }
                   
 #ifndef PCI_QUIET  
   
 #define M_XX 0  /* end of list */  
 #define M_EQ 1  /* mask and return true if equal */  
 #define M_NE 2  /* mask and return true if not equal */  
 #define M_TR 3  /* don't read config, always true */  
 #define M_EN 4  /* mask and print "enabled" if true, "disabled" if false */  
 #define M_NN 5  /* opposite sense of M_EN */  
   
 static const struct condmsg conf82425ex[] =  
 {  
     { 0x00, 0x00, 0x00, M_TR, "\tClock " },  
     { 0x50, 0x06, 0x00, M_EQ, "25" },  
     { 0x50, 0x06, 0x02, M_EQ, "33" },  
     { 0x50, 0x04, 0x04, M_EQ, "??", },  
     { 0x00, 0x00, 0x00, M_TR, "MHz, L1 Cache " },  
     { 0x50, 0x01, 0x00, M_EQ, "Disabled\n" },  
     { 0x50, 0x09, 0x01, M_EQ, "Write-through\n" },  
     { 0x50, 0x09, 0x09, M_EQ, "Write-back\n" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\tL2 Cache " },  
     { 0x52, 0x07, 0x00, M_EQ, "Disabled" },  
     { 0x52, 0x0f, 0x01, M_EQ, "64KB Write-through" },  
     { 0x52, 0x0f, 0x02, M_EQ, "128KB Write-through" },  
     { 0x52, 0x0f, 0x03, M_EQ, "256KB Write-through" },  
     { 0x52, 0x0f, 0x04, M_EQ, "512KB Write-through" },  
     { 0x52, 0x0f, 0x01, M_EQ, "64KB Write-back" },  
     { 0x52, 0x0f, 0x02, M_EQ, "128KB Write-back" },  
     { 0x52, 0x0f, 0x03, M_EQ, "256KB Write-back" },  
     { 0x52, 0x0f, 0x04, M_EQ, "512KB Write-back" },  
     { 0x53, 0x01, 0x00, M_EQ, ", 3-" },  
     { 0x53, 0x01, 0x01, M_EQ, ", 2-" },  
     { 0x53, 0x06, 0x00, M_EQ, "3-3-3" },  
     { 0x53, 0x06, 0x02, M_EQ, "2-2-2" },  
     { 0x53, 0x06, 0x04, M_EQ, "1-1-1" },  
     { 0x53, 0x06, 0x06, M_EQ, "?-?-?" },  
     { 0x53, 0x18, 0x00, M_EQ, "/4-2-2-2\n" },  
     { 0x53, 0x18, 0x08, M_EQ, "/3-2-2-2\n" },  
     { 0x53, 0x18, 0x10, M_EQ, "/?-?-?-?\n" },  
     { 0x53, 0x18, 0x18, M_EQ, "/2-1-1-1\n" },  
   
     { 0x56, 0x00, 0x00, M_TR, "\tDRAM: " },  
     { 0x56, 0x02, 0x02, M_EQ, "Fast Code Read, " },  
     { 0x56, 0x04, 0x04, M_EQ, "Fast Data Read, " },  
     { 0x56, 0x08, 0x08, M_EQ, "Fast Write, " },  
     { 0x57, 0x20, 0x20, M_EQ, "Pipelined CAS" },  
     { 0x57, 0x2e, 0x00, M_NE, "\n\t" },  
     { 0x57, 0x00, 0x00, M_TR, "Timing: RAS: " },  
     { 0x57, 0x07, 0x00, M_EQ, "4" },  
     { 0x57, 0x07, 0x01, M_EQ, "3" },  
     { 0x57, 0x07, 0x02, M_EQ, "2" },  
     { 0x57, 0x07, 0x04, M_EQ, "1.5" },  
     { 0x57, 0x07, 0x05, M_EQ, "1" },  
     { 0x57, 0x00, 0x00, M_TR, " Clocks, CAS Read: " },  
     { 0x57, 0x18, 0x00, M_EQ, "3/1", },  
     { 0x57, 0x18, 0x00, M_EQ, "2/1", },  
     { 0x57, 0x18, 0x00, M_EQ, "1.5/0.5", },  
     { 0x57, 0x18, 0x00, M_EQ, "1/1", },  
     { 0x57, 0x00, 0x00, M_TR, ", CAS Write: " },  
     { 0x57, 0x20, 0x00, M_EQ, "2/1", },  
     { 0x57, 0x20, 0x20, M_EQ, "1/1", },  
     { 0x57, 0x00, 0x00, M_TR, "\n" },  
   
     { 0x40, 0x01, 0x01, M_EQ, "\tCPU-to-PCI Byte Merging\n" },  
     { 0x40, 0x02, 0x02, M_EQ, "\tCPU-to-PCI Bursting\n" },  
     { 0x40, 0x04, 0x04, M_EQ, "\tPCI Posted Writes\n" },  
     { 0x40, 0x20, 0x00, M_EQ, "\tDRAM Parity Disabled\n" },  
   
     { 0x48, 0x03, 0x01, M_EQ, "\tPCI IDE controller: Primary (1F0h-1F7h,3F6h,3F7h)" },  
     { 0x48, 0x03, 0x02, M_EQ, "\tPCI IDE controller: Secondary (170h-177h,376h,377h)" },  
     { 0x4d, 0x01, 0x01, M_EQ, "\tRTC (70-77h)\n" },  
     { 0x4d, 0x02, 0x02, M_EQ, "\tKeyboard (60,62,64,66h)\n" },  
     { 0x4d, 0x08, 0x08, M_EQ, "\tIRQ12/M Mouse Function\n" },  
   
 /* end marker */  
     { 0 }  
 };  
   
 static const struct condmsg conf82424zx[] =  
 {  
     { 0x00, 0x00, 0x00, M_TR, "\tCPU: " },  
     { 0x50, 0xe0, 0x00, M_EQ, "486DX" },  
     { 0x50, 0xe0, 0x20, M_EQ, "486SX" },  
     { 0x50, 0xe0, 0x40, M_EQ, "486DX2 or 486DX4" },  
     { 0x50, 0xe0, 0x80, M_EQ, "Overdrive (writeback)" },  
   
     { 0x00, 0x00, 0x00, M_TR, ", bus=" },  
     { 0x50, 0x03, 0x00, M_EQ, "25MHz" },  
     { 0x50, 0x03, 0x01, M_EQ, "33MHz" },  
     { 0x53, 0x01, 0x01, M_TR, ", CPU->Memory posting "},  
     { 0x53, 0x01, 0x00, M_EQ, "OFF" },  
     { 0x53, 0x01, 0x01, M_EQ, "ON" },  
   
     { 0x56, 0x30, 0x00, M_NE, "\n\tWarning:" },  
     { 0x56, 0x20, 0x00, M_NE, " NO cache parity!" },  
     { 0x56, 0x10, 0x00, M_NE, " NO DRAM parity!" },  
     { 0x55, 0x04, 0x04, M_EQ, "\n\tWarning: refresh OFF! " },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n\tCache: " },  
     { 0x52, 0x01, 0x00, M_EQ, "None" },  
     { 0x52, 0xc1, 0x01, M_EQ, "64KB" },  
     { 0x52, 0xc1, 0x41, M_EQ, "128KB" },  
     { 0x52, 0xc1, 0x81, M_EQ, "256KB" },  
     { 0x52, 0xc1, 0xc1, M_EQ, "512KB" },  
     { 0x52, 0x03, 0x01, M_EQ, " writethrough" },  
     { 0x52, 0x03, 0x03, M_EQ, " writeback" },  
   
     { 0x52, 0x01, 0x01, M_EQ, ", cache clocks=" },  
     { 0x52, 0x05, 0x01, M_EQ, "3-1-1-1" },  
     { 0x52, 0x05, 0x05, M_EQ, "2-1-1-1" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n\tDRAM:" },  
     { 0x55, 0x43, 0x00, M_NE, " page mode" },  
     { 0x55, 0x02, 0x02, M_EQ, " code fetch" },  
     { 0x55, 0x43, 0x43, M_EQ, "," },  
     { 0x55, 0x43, 0x42, M_EQ, " and" },  
     { 0x55, 0x40, 0x40, M_EQ, " read" },  
     { 0x55, 0x03, 0x03, M_EQ, " and" },  
     { 0x55, 0x43, 0x41, M_EQ, " and" },  
     { 0x55, 0x01, 0x01, M_EQ, " write" },  
     { 0x55, 0x43, 0x00, M_NE, "," },  
   
     { 0x00, 0x00, 0x00, M_TR, " memory clocks=" },  
     { 0x55, 0x20, 0x00, M_EQ, "X-2-2-2" },  
     { 0x55, 0x20, 0x20, M_EQ, "X-1-2-1" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU->PCI: posting " },  
     { 0x53, 0x02, 0x00, M_NE, "ON" },  
     { 0x53, 0x02, 0x00, M_EQ, "OFF" },  
     { 0x00, 0x00, 0x00, M_TR, ", burst mode " },  
     { 0x54, 0x02, 0x00, M_NE, "ON" },  
     { 0x54, 0x02, 0x00, M_EQ, "OFF" },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI->Memory: posting " },  
     { 0x54, 0x01, 0x00, M_NE, "ON" },  
     { 0x54, 0x01, 0x00, M_EQ, "OFF" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
 /* end marker */  
     { 0 }  
 };  
   
 static const struct condmsg conf82434lx[] =  
 {  
     { 0x00, 0x00, 0x00, M_TR, "\tCPU: " },  
     { 0x50, 0xe3, 0x82, M_EQ, "Pentium, 60MHz" },  
     { 0x50, 0xe3, 0x83, M_EQ, "Pentium, 66MHz" },  
     { 0x50, 0xe3, 0xa2, M_EQ, "Pentium, 90MHz" },  
     { 0x50, 0xe3, 0xa3, M_EQ, "Pentium, 100MHz" },  
     { 0x50, 0xc2, 0x82, M_NE, "(unknown)" },  
     { 0x50, 0x04, 0x00, M_EQ, " (primary cache OFF)" },  
   
     { 0x53, 0x01, 0x01, M_TR, ", CPU->Memory posting "},  
     { 0x53, 0x01, 0x01, M_NE, "OFF" },  
     { 0x53, 0x01, 0x01, M_EQ, "ON" },  
   
     { 0x53, 0x08, 0x00, M_NE, ", read around write"},  
   
     { 0x70, 0x04, 0x00, M_EQ, "\n\tWarning: Cache parity disabled!" },  
     { 0x57, 0x20, 0x00, M_NE, "\n\tWarning: DRAM parity mask!" },  
     { 0x57, 0x01, 0x00, M_EQ, "\n\tWarning: refresh OFF! " },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n\tCache: " },  
     { 0x52, 0x01, 0x00, M_EQ, "None" },  
     { 0x52, 0x81, 0x01, M_EQ, "" },  
     { 0x52, 0xc1, 0x81, M_EQ, "256KB" },  
     { 0x52, 0xc1, 0xc1, M_EQ, "512KB" },  
     { 0x52, 0x03, 0x01, M_EQ, " writethrough" },  
     { 0x52, 0x03, 0x03, M_EQ, " writeback" },  
   
     { 0x52, 0x01, 0x01, M_EQ, ", cache clocks=" },  
     { 0x52, 0x21, 0x01, M_EQ, "3-2-2-2/4-2-2-2" },  
     { 0x52, 0x21, 0x21, M_EQ, "3-1-1-1" },  
   
     { 0x52, 0x01, 0x01, M_EQ, "\n\tCache flags: " },  
     { 0x52, 0x11, 0x11, M_EQ, " cache-all" },  
     { 0x52, 0x09, 0x09, M_EQ, " byte-control" },  
     { 0x52, 0x05, 0x05, M_EQ, " powersaver" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n\tDRAM:" },  
     { 0x57, 0x10, 0x00, M_EQ, " page mode" },  
   
     { 0x00, 0x00, 0x00, M_TR, " memory clocks=" },  
     { 0x57, 0xc0, 0x00, M_EQ, "X-4-4-4 (70ns)" },  
     { 0x57, 0xc0, 0x40, M_EQ, "X-4-4-4/X-3-3-3 (60ns)" },  
     { 0x57, 0xc0, 0x80, M_EQ, "???" },  
     { 0x57, 0xc0, 0xc0, M_EQ, "X-3-3-3 (50ns)" },  
     { 0x58, 0x02, 0x02, M_EQ, ", RAS-wait" },  
     { 0x58, 0x01, 0x01, M_EQ, ", CAS-wait" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU->PCI: posting " },  
     { 0x53, 0x02, 0x02, M_EQ, "ON" },  
     { 0x53, 0x02, 0x00, M_EQ, "OFF" },  
     { 0x00, 0x00, 0x00, M_TR, ", burst mode " },  
     { 0x54, 0x02, 0x00, M_NE, "ON" },  
     { 0x54, 0x02, 0x00, M_EQ, "OFF" },  
     { 0x54, 0x04, 0x00, M_TR, ", PCI clocks=" },  
     { 0x54, 0x04, 0x00, M_EQ, "2-2-2-2" },  
     { 0x54, 0x04, 0x00, M_NE, "2-1-1-1" },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI->Memory: posting " },  
     { 0x54, 0x01, 0x00, M_NE, "ON" },  
     { 0x54, 0x01, 0x00, M_EQ, "OFF" },  
   
     { 0x57, 0x01, 0x01, M_EQ, "\n\tRefresh:" },  
     { 0x57, 0x03, 0x03, M_EQ, " CAS#/RAS#(Hidden)" },  
     { 0x57, 0x03, 0x01, M_EQ, " RAS#Only" },  
     { 0x57, 0x05, 0x05, M_EQ, " BurstOf4" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
 /* end marker */  
     { 0 }  
 };  
   
 static const struct condmsg conf82378[] =  
 {  
     { 0x00, 0x00, 0x00, M_TR, "\tBus Modes:" },  
     { 0x41, 0x04, 0x04, M_EQ, " Bus Park," },  
     { 0x41, 0x02, 0x02, M_EQ, " Bus Lock," },  
     { 0x41, 0x02, 0x00, M_EQ, " Resource Lock," },  
     { 0x41, 0x01, 0x01, M_EQ, " GAT" },  
     { 0x4d, 0x20, 0x20, M_EQ, "\n\tCoprocessor errors enabled" },  
     { 0x4d, 0x10, 0x10, M_EQ, "\n\tMouse function enabled" },  
   
     { 0x4e, 0x30, 0x10, M_EQ, "\n\tIDE controller: Primary (1F0h-1F7h,3F6h,3F7h)" },  
     { 0x4e, 0x30, 0x30, M_EQ, "\n\tIDE controller: Secondary (170h-177h,376h,377h)" },  
     { 0x4e, 0x28, 0x08, M_EQ, "\n\tFloppy controller: 3F0h,3F1h " },  
     { 0x4e, 0x24, 0x04, M_EQ, "\n\tFloppy controller: 3F2h-3F7h " },  
     { 0x4e, 0x28, 0x28, M_EQ, "\n\tFloppy controller: 370h,371h " },  
     { 0x4e, 0x24, 0x24, M_EQ, "\n\tFloppy controller: 372h-377h " },  
     { 0x4e, 0x02, 0x02, M_EQ, "\n\tKeyboard controller: 60h,62h,64h,66h" },  
     { 0x4e, 0x01, 0x01, M_EQ, "\n\tRTC: 70h-77h" },  
   
     { 0x4f, 0x80, 0x80, M_EQ, "\n\tConfiguration RAM: 0C00h,0800h-08FFh" },  
     { 0x4f, 0x40, 0x40, M_EQ, "\n\tPort 92: enabled" },  
     { 0x4f, 0x03, 0x00, M_EQ, "\n\tSerial Port A: COM1 (3F8h-3FFh)" },  
     { 0x4f, 0x03, 0x01, M_EQ, "\n\tSerial Port A: COM2 (2F8h-2FFh)" },  
     { 0x4f, 0x0c, 0x00, M_EQ, "\n\tSerial Port B: COM1 (3F8h-3FFh)" },  
     { 0x4f, 0x0c, 0x04, M_EQ, "\n\tSerial Port B: COM2 (2F8h-2FFh)" },  
     { 0x4f, 0x30, 0x00, M_EQ, "\n\tParallel Port: LPT1 (3BCh-3BFh)" },  
     { 0x4f, 0x30, 0x04, M_EQ, "\n\tParallel Port: LPT2 (378h-37Fh)" },  
     { 0x4f, 0x30, 0x20, M_EQ, "\n\tParallel Port: LPT3 (278h-27Fh)" },  
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
 /* end marker */  
     { 0 }  
 };  
   
 static const struct condmsg conf82437fx[] =   
 {  
     /* PCON -- PCI Control Register */  
     { 0x00, 0x00, 0x00, M_TR, "\tCPU Inactivity timer: " },  
     { 0x50, 0xe0, 0xe0, M_EQ, "8" },  
     { 0x50, 0xe0, 0xd0, M_EQ, "7" },  
     { 0x50, 0xe0, 0xc0, M_EQ, "6" },  
     { 0x50, 0xe0, 0xb0, M_EQ, "5" },  
     { 0x50, 0xe0, 0xa0, M_EQ, "4" },  
     { 0x50, 0xe0, 0x90, M_EQ, "3" },  
     { 0x50, 0xe0, 0x80, M_EQ, "2" },  
     { 0x50, 0xe0, 0x00, M_EQ, "1" },  
     { 0x00, 0x00, 0x00, M_TR, " clocks\n\tPeer Concurrency: " },  
     { 0x50, 0x08, 0x08, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU-to-PCI Write Bursting: " },  
     { 0x50, 0x04, 0x00, M_NN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI Streaming: " },  
     { 0x50, 0x02, 0x00, M_NN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tBus Concurrency: " },  
     { 0x50, 0x01, 0x00, M_NN, 0 },  
   
     /* CC -- Cache Control Regsiter */  
     { 0x00, 0x00, 0x00, M_TR, "\n\tCache:" },  
     { 0x52, 0xc0, 0x80, M_EQ, " 512K" },  
     { 0x52, 0xc0, 0x40, M_EQ, " 256K" },  
     { 0x52, 0xc0, 0x00, M_EQ, " NO" },  
     { 0x52, 0x30, 0x00, M_EQ, " pipelined-burst" },  
     { 0x52, 0x30, 0x10, M_EQ, " burst" },  
     { 0x52, 0x30, 0x20, M_EQ, " asynchronous" },  
     { 0x52, 0x30, 0x30, M_EQ, " dual-bank pipelined-burst" },  
     { 0x00, 0x00, 0x00, M_TR, " secondary; L1 " },  
     { 0x52, 0x01, 0x00, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
     /* DRAMC -- DRAM Control Register */  
     { 0x57, 0x07, 0x00, M_EQ, "Warning: refresh OFF!\n" },  
     { 0x00, 0x00, 0x00, M_TR, "\tDRAM:" },  
     { 0x57, 0xc0, 0x00, M_EQ, " no memory hole" },  
     { 0x57, 0xc0, 0x40, M_EQ, " 512K-640K memory hole" },  
     { 0x57, 0xc0, 0x80, M_EQ, " 15M-16M memory hole" },  
     { 0x57, 0x07, 0x01, M_EQ, ", 50 MHz refresh" },  
     { 0x57, 0x07, 0x02, M_EQ, ", 60 MHz refresh" },  
     { 0x57, 0x07, 0x03, M_EQ, ", 66 MHz refresh" },  
   
     /* DRAMT = DRAM Timing Register */  
     { 0x00, 0x00, 0x00, M_TR, "\n\tRead burst timing: " },  
     { 0x58, 0x60, 0x00, M_EQ, "x-4-4-4/x-4-4-4" },  
     { 0x58, 0x60, 0x20, M_EQ, "x-3-3-3/x-4-4-4" },  
     { 0x58, 0x60, 0x40, M_EQ, "x-2-2-2/x-3-3-3" },  
     { 0x58, 0x60, 0x60, M_EQ, "???" },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tWrite burst timing: " },  
     { 0x58, 0x18, 0x00, M_EQ, "x-4-4-4" },  
     { 0x58, 0x18, 0x08, M_EQ, "x-3-3-3" },  
     { 0x58, 0x18, 0x10, M_EQ, "x-2-2-2" },  
     { 0x58, 0x18, 0x18, M_EQ, "???" },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tRAS-CAS delay: " },  
     { 0x58, 0x04, 0x00, M_EQ, "3" },  
     { 0x58, 0x04, 0x04, M_EQ, "2" },  
     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },  
   
     /* end marker */  
     { 0 }  
 };  
   
 static const struct condmsg conf82437vx[] =   
 {  
     /* PCON -- PCI Control Register */  
     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI Concurrency: " },  
     { 0x50, 0x08, 0x08, M_EN, 0 },  
   
     /* CC -- Cache Control Regsiter */  
     { 0x00, 0x00, 0x00, M_TR, "\n\tCache:" },  
     { 0x52, 0xc0, 0x80, M_EQ, " 512K" },  
     { 0x52, 0xc0, 0x40, M_EQ, " 256K" },  
     { 0x52, 0xc0, 0x00, M_EQ, " NO" },  
     { 0x52, 0x30, 0x00, M_EQ, " pipelined-burst" },  
     { 0x52, 0x30, 0x10, M_EQ, " burst" },  
     { 0x52, 0x30, 0x20, M_EQ, " asynchronous" },  
     { 0x52, 0x30, 0x30, M_EQ, " dual-bank pipelined-burst" },  
     { 0x00, 0x00, 0x00, M_TR, " secondary; L1 " },  
     { 0x52, 0x01, 0x00, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
     /* DRAMC -- DRAM Control Register */  
     { 0x57, 0x07, 0x00, M_EQ, "Warning: refresh OFF!\n" },  
     { 0x00, 0x00, 0x00, M_TR, "\tDRAM:" },  
     { 0x57, 0xc0, 0x00, M_EQ, " no memory hole" },  
     { 0x57, 0xc0, 0x40, M_EQ, " 512K-640K memory hole" },  
     { 0x57, 0xc0, 0x80, M_EQ, " 15M-16M memory hole" },  
     { 0x57, 0x07, 0x01, M_EQ, ", 50 MHz refresh" },  
     { 0x57, 0x07, 0x02, M_EQ, ", 60 MHz refresh" },  
     { 0x57, 0x07, 0x03, M_EQ, ", 66 MHz refresh" },  
   
     /* DRAMT = DRAM Timing Register */  
     { 0x00, 0x00, 0x00, M_TR, "\n\tRead burst timing: " },  
     { 0x58, 0x60, 0x00, M_EQ, "x-4-4-4/x-4-4-4" },  
     { 0x58, 0x60, 0x20, M_EQ, "x-3-3-3/x-4-4-4" },  
     { 0x58, 0x60, 0x40, M_EQ, "x-2-2-2/x-3-3-3" },  
     { 0x58, 0x60, 0x60, M_EQ, "???" },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tWrite burst timing: " },  
     { 0x58, 0x18, 0x00, M_EQ, "x-4-4-4" },  
     { 0x58, 0x18, 0x08, M_EQ, "x-3-3-3" },  
     { 0x58, 0x18, 0x10, M_EQ, "x-2-2-2" },  
     { 0x58, 0x18, 0x18, M_EQ, "???" },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tRAS-CAS delay: " },  
     { 0x58, 0x04, 0x00, M_EQ, "3" },  
     { 0x58, 0x04, 0x04, M_EQ, "2" },  
     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },  
   
     /* end marker */  
     { 0 }  
 };  
   
 static const struct condmsg conf82371fb[] =  
 {  
     /* IORT -- ISA I/O Recovery Timer Register */  
     { 0x00, 0x00, 0x00, M_TR, "\tI/O Recovery Timing: 8-bit " },  
     { 0x4c, 0x40, 0x00, M_EQ, "3.5" },  
     { 0x4c, 0x78, 0x48, M_EQ, "1" },  
     { 0x4c, 0x78, 0x50, M_EQ, "2" },  
     { 0x4c, 0x78, 0x58, M_EQ, "3" },  
     { 0x4c, 0x78, 0x60, M_EQ, "4" },  
     { 0x4c, 0x78, 0x68, M_EQ, "5" },  
     { 0x4c, 0x78, 0x70, M_EQ, "6" },  
     { 0x4c, 0x78, 0x78, M_EQ, "7" },  
     { 0x4c, 0x78, 0x40, M_EQ, "8" },  
     { 0x00, 0x00, 0x00, M_TR, " clocks, 16-bit " },  
     { 0x4c, 0x04, 0x00, M_EQ, "3.5" },  
     { 0x4c, 0x07, 0x05, M_EQ, "1" },  
     { 0x4c, 0x07, 0x06, M_EQ, "2" },  
     { 0x4c, 0x07, 0x07, M_EQ, "3" },  
     { 0x4c, 0x07, 0x04, M_EQ, "4" },  
     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },  
   
     /* XBCS -- X-Bus Chip Select Register */  
     { 0x00, 0x00, 0x00, M_TR, "\tExtended BIOS: " },  
     { 0x4e, 0x80, 0x80, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tLower BIOS: " },  
     { 0x4e, 0x40, 0x40, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tCoprocessor IRQ13: " },  
     { 0x4e, 0x20, 0x20, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tMouse IRQ12: " },  
     { 0x4e, 0x10, 0x10, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
     { 0x00, 0x00, 0x00, M_TR, "\tInterrupt Routing: " },  const char *
 #define PIRQ(x, n) \  
     { 0x00, 0x00, 0x00, M_TR, n ": " }, \  
     { x, 0x80, 0x80, M_EQ, "disabled" }, \  
     { x, 0xc0, 0x40, M_EQ, "[shared] " }, \  
     { x, 0x8f, 0x03, M_EQ, "IRQ3" }, \  
     { x, 0x8f, 0x04, M_EQ, "IRQ4" }, \  
     { x, 0x8f, 0x05, M_EQ, "IRQ5" }, \  
     { x, 0x8f, 0x06, M_EQ, "IRQ6" }, \  
     { x, 0x8f, 0x07, M_EQ, "IRQ7" }, \  
     { x, 0x8f, 0x09, M_EQ, "IRQ9" }, \  
     { x, 0x8f, 0x0a, M_EQ, "IRQ10" }, \  
     { x, 0x8f, 0x0b, M_EQ, "IRQ11" }, \  
     { x, 0x8f, 0x0c, M_EQ, "IRQ12" }, \  
     { x, 0x8f, 0x0e, M_EQ, "IRQ14" }, \  
     { x, 0x8f, 0x0f, M_EQ, "IRQ15" }  
   
     /* Interrupt routing */  
     PIRQ(0x60, "A"),  
     PIRQ(0x61, ", B"),  
     PIRQ(0x62, ", C"),  
     PIRQ(0x63, ", D"),  
     PIRQ(0x70, "\n\t\tMB0"),  
     PIRQ(0x71, ", MB1"),  
   
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
 #undef PIRQ  
   
     /* XXX - do DMA routing, too? */  
     { 0 }  
 };  
   
 static const struct condmsg conf82371fb2[] =  
 {  
     /* IDETM -- IDE Timing Register */  
     { 0x00, 0x00, 0x00, M_TR, "\tPrimary IDE: " },  
     { 0x41, 0x80, 0x80, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n\tSecondary IDE: " },  
     { 0x43, 0x80, 0x80, M_EN, 0 },  
     { 0x00, 0x00, 0x00, M_TR, "\n" },  
   
     /* end of list */  
     { 0 }  
 };  
   
 static void  
 writeconfig (device_t dev, const struct condmsg *tbl)  
 {  
     while (tbl->flags != M_XX) {  
         const char *text = 0;  
   
         if (tbl->flags == M_TR) {  
             text = tbl->text;  
         } else {  
             unsigned char v = pci_read_config(dev, tbl->port, 1);  
             switch (tbl->flags) {  
     case M_EQ:  
                 if ((v & tbl->mask) == tbl->value) text = tbl->text;  
                 break;  
     case M_NE:  
                 if ((v & tbl->mask) != tbl->value) text = tbl->text;  
                 break;  
     case M_EN:  
                 text = (v & tbl->mask) ? "enabled" : "disabled";  
                 break;  
     case M_NN:  
                 text = (v & tbl->mask) ? "disabled" : "enabled";  
             }  
         }  
         if (text) printf ("%s", text);  
         tbl++;  
     }  
 }  
   
 #ifdef DUMPCONFIGSPACE  
 static void  
 dumpconfigspace (device_t dev)  
 {  
     int reg;  
     printf ("configuration space registers:");  
     for (reg = 0; reg < 0x100; reg+=4) {  
         if ((reg & 0x0f) == 0)   
             printf ("\n%02x:\t", reg);  
         printf ("%08x ", pci_read_config(dev, reg, 4));  
     }  
     printf ("\n");  
 }  
 #endif /* DUMPCONFIGSPACE */  
   
 #endif /* PCI_QUIET */  
   
   
 static void  
 chipset_attach (device_t dev, int unit)  
 {  
 #ifndef PCI_QUIET  
         if (!bootverbose)  
                 return;  
   
         switch (pci_get_devid(dev)) {  
         case 0x04868086:  
                 writeconfig (dev, conf82425ex);  
                 break;  
         case 0x04838086:  
                 writeconfig (dev, conf82424zx);  
                 break;  
         case 0x04a38086:  
                 writeconfig (dev, conf82434lx);  
                 break;  
         case 0x04848086:  
                 writeconfig (dev, conf82378);  
                 break;  
         case 0x122d8086:  
                 writeconfig (dev, conf82437fx);  
                 break;  
         case 0x70308086:  
                 writeconfig (dev, conf82437vx);  
                 break;  
         case 0x70008086:  
         case 0x122e8086:  
                 writeconfig (dev, conf82371fb);  
                 break;  
         case 0x70108086:  
         case 0x12308086:  
                 writeconfig (dev, conf82371fb2);  
                 break;  
 #if 0  
         case 0x00011011: /* DEC 21050 */  
         case 0x00221014: /* IBM xxx */  
                 writeconfig (dev, conf_pci2pci);  
                 break;  
 #endif  
         };  
 #endif /* PCI_QUIET */  
 }  
   
 static const char *  
 pci_bridge_type(device_t dev)  pci_bridge_type(device_t dev)
 {  {
     char *descr, tmpbuf[120];      char *descr, tmpbuf[120];
Line 676  pci_bridge_type(device_t dev) Line 135  pci_bridge_type(device_t dev)
     return descr;      return descr;
 }  }
   
 static const char*  
 pcib_match(device_t dev)  
 {  
         switch (pci_get_devid(dev)) {  
         /* Intel -- vendor 0x8086 */  
         case 0x71818086:  
                 return ("Intel 82443LX (440 LX) PCI-PCI (AGP) bridge");  
         case 0x71918086:  
                 return ("Intel 82443BX (440 BX) PCI-PCI (AGP) bridge");  
         case 0x71A18086:  
                 return ("Intel 82443GX (440 GX) PCI-PCI (AGP) bridge");  
         case 0x84cb8086:  
                 return ("Intel 82454NX PCI Expander Bridge");  
         case 0x11318086:  
                 return ("Intel 82801BA/BAM (ICH2) PCI-PCI (AGP) bridge");  
         case 0x124b8086:  
                 return ("Intel 82380FB mobile PCI to PCI bridge");  
         case 0x24188086:  
                 return ("Intel 82801AA (ICH) Hub to PCI bridge");  
         case 0x24288086:  
                 return ("Intel 82801AB (ICH0) Hub to PCI bridge");  
         case 0x244e8086:  
                 return ("Intel 82801BA/BAM (ICH2) Hub to PCI bridge");  
         case 0x1a318086:  
                 return ("Intel 82845 PCI-PCI (AGP) bridge");  
           
         /* VLSI -- vendor 0x1004 */  
         case 0x01021004:  
                 return ("VLSI 82C534 Eagle II PCI Bus bridge");  
         case 0x01031004:  
                 return ("VLSI 82C538 Eagle II PCI Docking bridge");  
   
         /* VIA Technologies -- vendor 0x1106 */  
         case 0x83051106:  
                 return ("VIA 8363 (Apollo KT133) PCI-PCI (AGP) bridge");  
         case 0x85981106:  
                 return ("VIA 82C598MVP (Apollo MVP3) PCI-PCI (AGP) bridge");  
         /* Exclude the ACPI function of VT82Cxxx series */  
         case 0x30401106:  
         case 0x30501106:  
         case 0x30571106:  
                 return NULL;  
   
         /* AcerLabs -- vendor 0x10b9 */  
         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */  
         /* id is '10b9" but the register always shows "10b9". -Foxfair  */  
         case 0x524710b9:  
                 return ("AcerLabs M5247 PCI-PCI(AGP Supported) bridge");  
         case 0x524310b9:/* 5243 seems like 5247, need more info to divide*/  
                 return ("AcerLabs M5243 PCI-PCI bridge");  
   
         /* AMD -- vendor 0x1022 */  
         case 0x70071022:  
                 return ("AMD-751 PCI-PCI (1x/2x AGP) bridge");  
         case 0x700f1022:  
                 return ("AMD-761 PCI-PCI (4x AGP) bridge");  
   
         /* DEC -- vendor 0x1011 */  
         case 0x00011011:  
                 return ("DEC 21050 PCI-PCI bridge");  
         case 0x00211011:  
                 return ("DEC 21052 PCI-PCI bridge");  
         case 0x00221011:  
                 return ("DEC 21150 PCI-PCI bridge");  
         case 0x00241011:  
                 return ("DEC 21152 PCI-PCI bridge");  
         case 0x00251011:  
                 return ("DEC 21153 PCI-PCI bridge");  
         case 0x00261011:  
                 return ("DEC 21154 PCI-PCI bridge");  
   
         /* NVIDIA -- vendor 0x10de */  
         case 0x006c10de:  
         case 0x01e810de:  
                 return ("NVIDIA nForce2 PCI-PCI bridge");  
   
         /* Others */  
         case 0x00221014:  
                 return ("IBM 82351 PCI-PCI bridge");  
         /* UMC United Microelectronics 0x1060 */  
         case 0x88811060:  
                 return ("UMC UM8881 HB4 486 PCI Chipset");  
         };  
   
         if (pci_get_class(dev) == PCIC_BRIDGE  
             && pci_get_subclass(dev) == PCIS_BRIDGE_PCI)  
                 return pci_bridge_type(dev);  
   
         return NULL;  
 }  
   
 static int pcib_probe(device_t dev)  
 {  
         const char *desc;  
   
         desc = pcib_match(dev);  
         if (desc) {  
                 device_set_desc_copy(dev, desc);  
                 return -1000;  
         }  
   
         return ENXIO;  
 }  
   
 /*  
  * Attach a pci bus device to a motherboard or pci-to-pci bridge bus.  
  * Due to probe recursion it is possible for pci-to-pci bridges (such as  
  * on the DELL2550) to attach before all the motherboard bridges have  
  * attached.  We must call device_add_child() with the secondary id  
  * rather then -1 in order to ensure that we do not accidently use  
  * a motherboard PCI id, otherwise the device probe will believe that  
  * the later motherboard bridge bus has already been probed and refuse  
  * to probe it.  The result: disappearing busses!  
  *  
  * Bridges will cause recursions or duplicate attach attempts.  If  
  * we have already attached this bus we don't do it again!  
  */  
   
 void  
 pcib_attach_common(device_t dev)  
 {  
     struct pcib_softc   *sc;  
     uint8_t             iolow;  
   
     sc = device_get_softc(dev);  
     sc->dev = dev;  
   
     /*  
      * Get current bridge configuration.  
      */  
     sc->command   = pci_read_config(dev, PCIR_COMMAND, 1);  
     sc->secbus    = pci_read_config(dev, PCIR_SECBUS_1, 1);  
     sc->subbus    = pci_read_config(dev, PCIR_SUBBUS_1, 1);  
     sc->secstat   = pci_read_config(dev, PCIR_SECSTAT_1, 2);  
     sc->bridgectl = pci_read_config(dev, PCIR_BRIDGECTL_1, 2);  
     sc->seclat    = pci_read_config(dev, PCIR_SECLAT_1, 1);  
   
     /*  
      * Determine current I/O decode.  
      */  
     if (sc->command & PCIM_CMD_PORTEN) {  
         iolow = pci_read_config(dev, PCIR_IOBASEL_1, 1);  
         if ((iolow & PCIM_BRIO_MASK) == PCIM_BRIO_32) {  
             sc->iobase = PCI_PPBIOBASE(pci_read_config(dev, PCIR_IOBASEH_1, 2),  
                                        pci_read_config(dev, PCIR_IOBASEL_1, 1));  
         } else {  
             sc->iobase = PCI_PPBIOBASE(0, pci_read_config(dev, PCIR_IOBASEL_1, 1));  
         }  
   
         iolow = pci_read_config(dev, PCIR_IOLIMITL_1, 1);  
         if ((iolow & PCIM_BRIO_MASK) == PCIM_BRIO_32) {  
             sc->iolimit = PCI_PPBIOLIMIT(pci_read_config(dev, PCIR_IOLIMITH_1, 2),  
                                          pci_read_config(dev, PCIR_IOLIMITL_1, 1));  
         } else {  
             sc->iolimit = PCI_PPBIOLIMIT(0, pci_read_config(dev, PCIR_IOLIMITL_1, 1));  
         }  
     }  
   
     /*  
      * Determine current memory decode.  
      */  
     if (sc->command & PCIM_CMD_MEMEN) {  
         sc->membase   = PCI_PPBMEMBASE(0, pci_read_config(dev, PCIR_MEMBASE_1, 2));  
         sc->memlimit  = PCI_PPBMEMLIMIT(0, pci_read_config(dev, PCIR_MEMLIMIT_1, 2));  
         sc->pmembase  = PCI_PPBMEMBASE((pci_addr_t)pci_read_config(dev, PCIR_PMBASEH_1, 4),  
                                        pci_read_config(dev, PCIR_PMBASEL_1, 2));  
         sc->pmemlimit = PCI_PPBMEMLIMIT((pci_addr_t)pci_read_config(dev, PCIR_PMLIMITH_1, 4),  
                                         pci_read_config(dev, PCIR_PMLIMITL_1, 2));  
     }  
   
     /*  
      * Quirk handling.  
      */  
     switch (pci_get_devid(dev)) {  
     case 0x12258086:            /* Intel 82454KX/GX (Orion) */  
         {  
             uint8_t     supbus;  
   
             supbus = pci_read_config(dev, 0x41, 1);  
             if (supbus != 0xff) {  
                 sc->secbus = supbus + 1;  
                 sc->subbus = supbus + 1;  
             }  
             break;  
         }  
   
     /*  
      * The i82380FB mobile docking controller is a PCI-PCI bridge,  
      * and it is a subtractive bridge.  However, the ProgIf is wrong  
      * so the normal setting of PCIB_SUBTRACTIVE bit doesn't  
      * happen.  There's also a Toshiba bridge that behaves this  
      * way.  
      */  
     case 0x124b8086:            /* Intel 82380FB Mobile */  
     case 0x060513d7:            /* Toshiba ???? */  
         sc->flags |= PCIB_SUBTRACTIVE;  
         break;  
     }  
   
     /*  
      * Intel 815, 845 and other chipsets say they are PCI-PCI bridges,  
      * but have a ProgIF of 0x80.  The 82801 family (AA, AB, BAM/CAM,  
      * BA/CA/DB and E) PCI bridges are HUB-PCI bridges, in Intelese.  
      * This means they act as if they were subtractively decoding  
      * bridges and pass all transactions.  Mark them and real ProgIf 1  
      * parts as subtractive.  
      */  
     if ((pci_get_devid(dev) & 0xff00ffff) == 0x24008086 ||  
       pci_read_config(dev, PCIR_PROGIF, 1) == 1)  
         sc->flags |= PCIB_SUBTRACTIVE;  
           
     if (bootverbose) {  
         device_printf(dev, "  secondary bus     %d\n", sc->secbus);  
         device_printf(dev, "  subordinate bus   %d\n", sc->subbus);  
         device_printf(dev, "  I/O decode        0x%x-0x%x\n", sc->iobase, sc->iolimit);  
         device_printf(dev, "  memory decode     0x%x-0x%x\n", sc->membase, sc->memlimit);  
         device_printf(dev, "  prefetched decode 0x%x-0x%x\n", sc->pmembase, sc->pmemlimit);  
         if (sc->flags & PCIB_SUBTRACTIVE)  
             device_printf(dev, "  Subtractively decoded bridge.\n");  
     }  
   
     /*  
      * XXX If the secondary bus number is zero, we should assign a bus number  
      *     since the BIOS hasn't, then initialise the bridge.  
      */  
   
     /*  
      * XXX If the subordinate bus number is less than the secondary bus number,  
      *     we should pick a better value.  One sensible alternative would be to  
      *     pick 255; the only tradeoff here is that configuration transactions  
      *     would be more widely routed than absolutely necessary.  
      */  
 }  
 int  
 pcib_attach(device_t dev)  
 {  
         struct pcib_softc *sc;  
         device_t child;  
   
         pcib_attach_common(dev);  
         sc = device_get_softc(dev);  
         /*chipset_attach(dev, device_get_unit(dev));*/  
   
         if (sc->secbus != 0) {  
                 child = device_add_child(dev, "pci", sc->secbus);  
                 if (child != NULL)  
                     return bus_generic_attach(dev);  
         }   
         return 0;  
 }  
   
 int  
 pcib_read_ivar(device_t dev, device_t child, int which, uintptr_t *result)  
 {  
         struct pcib_softc *sc = device_get_softc(dev);  
   
         switch (which) {  
         case PCIB_IVAR_BUS:  
                 *result = sc->secbus;  
                 return (0);  
         }  
         return (ENOENT);  
 }  
   
 int  
 pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value)  
 {  
         struct pcib_softc *sc = device_get_softc(dev);  
   
         switch (which) {  
         case PCIB_IVAR_BUS:  
                 sc->secbus = value;  
                 return (0);  
         }  
         return (ENOENT);  
 }  
   
 /*  
  * Is the prefetch window open (eg, can we allocate memory in it?)  
  */  
 static int  
 pcib_is_prefetch_open(struct pcib_softc *sc)  
 {  
         return (sc->pmembase > 0 && sc->pmembase < sc->pmemlimit);  
 }  
   
 /*  
  * Is the nonprefetch window open (eg, can we allocate memory in it?)  
  */  
 static int  
 pcib_is_nonprefetch_open(struct pcib_softc *sc)  
 {  
         return (sc->membase > 0 && sc->membase < sc->memlimit);  
 }  
   
 /*  
  * Is the io window open (eg, can we allocate ports in it?)  
  */  
 static int  
 pcib_is_io_open(struct pcib_softc *sc)  
 {  
         return (sc->iobase > 0 && sc->iobase < sc->iolimit);  
 }  
   
 /*  
  * We have to trap resource allocation requests and ensure that the bridge  
  * is set up to, or capable of handling them.  
  */  
 struct resource *  
 pcib_alloc_resource(device_t dev, device_t child, int type, int *rid,   
                     u_long start, u_long end, u_long count, u_int flags)  
 {  
         struct pcib_softc *sc = device_get_softc(dev);  
         int ok;  
   
         /*  
          * Fail the allocation for this range if it's not supported.  
          */  
         switch (type) {  
         case SYS_RES_IOPORT:  
                 ok = 0;  
                 if (!pcib_is_io_open(sc))  
                         break;  
                 ok = (start >= sc->iobase && end <= sc->iolimit);  
                 if ((sc->flags & PCIB_SUBTRACTIVE) == 0) {  
                         if (!ok) {  
                                 if (start < sc->iobase)  
                                         start = sc->iobase;  
                                 if (end > sc->iolimit)  
                                         end = sc->iolimit;  
                         }  
                 } else {  
                         ok = 1;  
 #if 0  
                         if (start < sc->iobase && end > sc->iolimit) {  
                                 start = sc->iobase;  
                                 end = sc->iolimit;  
                         }  
 #endif                    
                 }  
                 if (end < start) {  
                         device_printf(dev, "ioport: end (%lx) < start (%lx)\n", end, start);  
                         start = 0;  
                         end = 0;  
                         ok = 0;  
                 }  
                 if (!ok) {  
                         device_printf(dev, "device %s requested unsupported I/O "  
                             "range 0x%lx-0x%lx (decoding 0x%x-0x%x)\n",  
                             device_get_nameunit(child), start, end,  
                             sc->iobase, sc->iolimit);  
                         return (NULL);  
                 }  
                 if (bootverbose)  
                         device_printf(dev, "device %s requested decoded I/O range 0x%lx-0x%lx\n",  
                             device_get_nameunit(child), start, end);  
                 break;  
   
         case SYS_RES_MEMORY:  
                 ok = 0;  
                 if (pcib_is_nonprefetch_open(sc))  
                         ok = ok || (start >= sc->membase && end <= sc->memlimit);  
                 if (pcib_is_prefetch_open(sc))  
                         ok = ok || (start >= sc->pmembase && end <= sc->pmemlimit);  
                 if ((sc->flags & PCIB_SUBTRACTIVE) == 0) {  
                         if (!ok) {  
                                 ok = 1;  
                                 if (flags & RF_PREFETCHABLE) {  
                                         if (pcib_is_prefetch_open(sc)) {  
                                                 if (start < sc->pmembase)  
                                                         start = sc->pmembase;  
                                                 if (end > sc->pmemlimit)  
                                                         end = sc->pmemlimit;  
                                         } else {  
                                                 ok = 0;  
                                         }  
                                 } else {        /* non-prefetchable */  
                                         if (pcib_is_nonprefetch_open(sc)) {  
                                                 if (start < sc->membase)  
                                                         start = sc->membase;  
                                                 if (end > sc->memlimit)  
                                                         end = sc->memlimit;  
                                         } else {  
                                                 ok = 0;  
                                         }  
                                 }  
                         }  
                 } else if (!ok) {  
                         ok = 1; /* subtractive bridge: always ok */  
 #if 0  
                         if (pcib_is_nonprefetch_open(sc)) {  
                                 if (start < sc->membase && end > sc->memlimit) {  
                                         start = sc->membase;  
                                         end = sc->memlimit;  
                                 }  
                         }  
                         if (pcib_is_prefetch_open(sc)) {  
                                 if (start < sc->pmembase && end > sc->pmemlimit) {  
                                         start = sc->pmembase;  
                                         end = sc->pmemlimit;  
                                 }  
                         }  
 #endif  
                 }  
                 if (end < start) {  
                         device_printf(dev, "memory: end (%lx) < start (%lx)\n", end, start);  
                         start = 0;  
                         end = 0;  
                         ok = 0;  
                 }  
                 if (!ok && bootverbose)  
                         device_printf(dev,  
                             "device %s requested unsupported memory range "  
                             "0x%lx-0x%lx (decoding 0x%x-0x%x, 0x%x-0x%x)\n",  
                             device_get_nameunit(child), start, end,  
                             sc->membase, sc->memlimit, sc->pmembase,  
                             sc->pmemlimit);  
                 if (!ok)  
                         return (NULL);  
                 if (bootverbose)  
                         device_printf(dev,"device %s requested decoded memory range 0x%lx-0x%lx\n",  
                             device_get_nameunit(child), start, end);  
                 break;  
   
         default:  
                 break;  
         }  
         /*  
          * Bridge is OK decoding this resource, so pass it up.  
          */  
         return (bus_generic_alloc_resource(dev, child, type, rid, start, end, count, flags));  
 }  
   
   
 int  
 pcib_maxslots(device_t dev)  
 {  
         return 31;  
 }  
   
 u_int32_t  
 pcib_read_config(device_t dev, int b, int s, int f,  
                  int reg, int width)  
 {  
         /*  
          * Pass through to the next ppb up the chain (i.e. our  
          * grandparent).  
          */  
         return PCIB_READ_CONFIG(device_get_parent(device_get_parent(dev)),  
                                 b, s, f, reg, width);  
 }  
   
 void  
 pcib_write_config(device_t dev, int b, int s, int f,  
                   int reg, uint32_t val, int width)  
 {  
         /*  
          * Pass through to the next ppb up the chain (i.e. our  
          * grandparent).  
          */  
         PCIB_WRITE_CONFIG(device_get_parent(device_get_parent(dev)),  
                                 b, s, f, reg, val, width);        
 }  
   
 /*  
  * Route an interrupt across a PCI bridge.  
  */  
 int  
 pcib_route_interrupt(device_t pcib, device_t dev, int pin)  
 {  
         device_t        bus;  
         int             parent_intpin;  
         int             intnum;  
   
         device_printf(pcib, "Hi!\n");  
   
         /*        
          *  
          * The PCI standard defines a swizzle of the child-side device/intpin  
          * to the parent-side intpin as follows.  
          *  
          * device = device on child bus  
          * child_intpin = intpin on child bus slot (0-3)  
          * parent_intpin = intpin on parent bus slot (0-3)  
          *  
          * parent_intpin = (device + child_intpin) % 4  
          */  
         parent_intpin = (pci_get_slot(pcib) + (pin - 1)) % 4;  
   
         /*  
          * Our parent is a PCI bus.  Its parent must export the pci interface  
          * which includes the ability to route interrupts.  
          */  
         bus = device_get_parent(pcib);  
         intnum = PCI_ROUTE_INTERRUPT(device_get_parent(bus), pcib,  
             parent_intpin + 1);  
         device_printf(pcib, "routed slot %d INT%c to irq %d\n",  
             pci_get_slot(dev), 'A' + pin - 1, intnum);  
         return(intnum);  
 }  
   
 /*  
  * Try to read the bus number of a host-PCI bridge using appropriate config  
  * registers.  
  */  
 int  
 host_pcib_get_busno(pci_read_config_fn read_config, int bus, int slot, int func,  
     uint8_t *busnum)  
 {  
         uint32_t id;  
   
         id = read_config(bus, slot, func, PCIR_DEVVENDOR, 4);  
         if (id == 0xffffffff)  
                 return (0);  
   
         switch (id) {  
         case 0x12258086:  
                 /* Intel 824?? */  
                 /* XXX This is a guess */  
                 /* *busnum = read_config(bus, slot, func, 0x41, 1); */  
                 *busnum = bus;  
                 break;  
         case 0x84c48086:  
                 /* Intel 82454KX/GX (Orion) */  
                 *busnum = read_config(bus, slot, func, 0x4a, 1);  
                 break;  
         case 0x84ca8086:  
                 /*  
                  * For the 450nx chipset, there is a whole bundle of  
                  * things pretending to be host bridges. The MIOC will   
                  * be seen first and isn't really a pci bridge (the  
                  * actual busses are attached to the PXB's). We need to   
                  * read the registers of the MIOC to figure out the  
                  * bus numbers for the PXB channels.  
                  *  
                  * Since the MIOC doesn't have a pci bus attached, we  
                  * pretend it wasn't there.  
                  */  
                 return (0);  
         case 0x84cb8086:  
                 switch (slot) {  
                 case 0x12:  
                         /* Intel 82454NX PXB#0, Bus#A */  
                         *busnum = read_config(bus, 0x10, func, 0xd0, 1);  
                         break;  
                 case 0x13:  
                         /* Intel 82454NX PXB#0, Bus#B */  
                         *busnum = read_config(bus, 0x10, func, 0xd1, 1) + 1;  
                         break;  
                 case 0x14:  
                         /* Intel 82454NX PXB#1, Bus#A */  
                         *busnum = read_config(bus, 0x10, func, 0xd3, 1);  
                         break;  
                 case 0x15:  
                         /* Intel 82454NX PXB#1, Bus#B */  
                         *busnum = read_config(bus, 0x10, func, 0xd4, 1) + 1;  
                         break;  
                 }  
                 break;  
   
                 /* ServerWorks -- vendor 0x1166 */  
         case 0x00051166:  
         case 0x00061166:  
         case 0x00081166:  
         case 0x00091166:  
         case 0x00101166:  
         case 0x00111166:  
         case 0x00171166:  
         case 0x01011166:  
         case 0x010f1014:  
         case 0x02011166:  
         case 0x03021014:  
                 *busnum = read_config(bus, slot, func, 0x44, 1);  
                 break;  
         default:  
                 /* Don't know how to read bus number. */  
                 return 0;  
         }  
   
         return 1;  
 }  
   
 static device_method_t pcib_methods[] = {  
         /* Device interface */  
         DEVMETHOD(device_probe,         pcib_probe),  
         DEVMETHOD(device_attach,        pcib_attach),  
         DEVMETHOD(device_shutdown,      bus_generic_shutdown),  
         DEVMETHOD(device_suspend,       bus_generic_suspend),  
         DEVMETHOD(device_resume,        bus_generic_resume),  
   
         /* Bus interface */  
         DEVMETHOD(bus_print_child,      bus_generic_print_child),  
         DEVMETHOD(bus_read_ivar,        pcib_read_ivar),  
         DEVMETHOD(bus_write_ivar,       pcib_write_ivar),  
         DEVMETHOD(bus_alloc_resource,   pcib_alloc_resource),  
         DEVMETHOD(bus_release_resource, bus_generic_release_resource),  
         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),  
         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),  
         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),  
         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),  
   
         /* pcib interface */  
         DEVMETHOD(pcib_maxslots,        pcib_maxslots),  
         DEVMETHOD(pcib_read_config,     pcib_read_config),  
         DEVMETHOD(pcib_write_config,    pcib_write_config),  
         DEVMETHOD(pcib_route_interrupt, pcib_route_interrupt),  
   
         { 0, 0 }  
 };  
   
 static driver_t pcib_driver = {  
         "pcib",  
         pcib_methods,  
         sizeof(struct pcib_softc)  
 };  
   
 devclass_t pcib_devclass;  
   
 DRIVER_MODULE(pcib, pci, pcib_driver, pcib_devclass, 0, 0);  
   
 static const char *  
 eisab_match(device_t dev)  
 {  
         switch (pci_get_devid(dev)) {  
         case 0x04828086:  
                 /* Recognize this specifically, it has PCI-HOST class (!) */  
                 return ("Intel 82375EB PCI-EISA bridge");  
         }  
         if (pci_get_class(dev) == PCIC_BRIDGE  
             && pci_get_subclass(dev) == PCIS_BRIDGE_EISA)  
                 return pci_bridge_type(dev);  
   
         return NULL;  
 }  
   
 static const char *  
 isab_match(device_t dev)  
 {  
         unsigned        rev;  
   
         switch (pci_get_devid(dev)) {  
         case 0x04848086:  
                 rev = pci_get_revid(dev);  
                 if (rev == 3)  
                     return ("Intel 82378ZB PCI to ISA bridge");  
                 return ("Intel 82378IB PCI to ISA bridge");  
         case 0x122e8086:  
                 return ("Intel 82371FB PCI to ISA bridge");  
         case 0x70008086:  
                 return ("Intel 82371SB PCI to ISA bridge");  
         case 0x71108086:  
                 return ("Intel 82371AB PCI to ISA bridge");  
         case 0x71988086:  
                 return ("Intel 82443MX PCI to ISA bridge");  
         case 0x24108086:  
                 return ("Intel 82801AA (ICH) PCI to LPC bridge");  
         case 0x24208086:  
                 return ("Intel 82801AB (ICH0) PCI to LPC bridge");  
         case 0x24408086:  
                 return ("Intel 82801BA/BAM (ICH2) PCI to LPC bridge");  
   
         /* NVIDIA -- vendor 0x10de */  
         case 0x006010de:  
                 return ("NVIDIA nForce2 PCI to ISA bridge");  
           
         /* VLSI -- vendor 0x1004 */  
         case 0x00061004:  
                 return ("VLSI 82C593 PCI to ISA bridge");  
   
         /* VIA Technologies -- vendor 0x1106 */  
         case 0x05861106: /* south bridge section */  
                 return ("VIA 82C586 PCI-ISA bridge");  
         case 0x05961106:  
                 return ("VIA 82C596B PCI-ISA bridge");  
         case 0x06861106:  
                 return ("VIA 82C686 PCI-ISA bridge");  
   
         /* AcerLabs -- vendor 0x10b9 */  
         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */  
         /* id is '10b9" but the register always shows "10b9". -Foxfair  */  
         case 0x153310b9:  
                 return ("AcerLabs M1533 portable PCI-ISA bridge");  
         case 0x154310b9:  
                 return ("AcerLabs M1543 desktop PCI-ISA bridge");  
   
         /* SiS -- vendor 0x1039 */  
         case 0x00081039:  
                 return ("SiS 85c503 PCI-ISA bridge");  
   
         /* Cyrix -- vendor 0x1078 */  
         case 0x00001078:  
                 return ("Cyrix Cx5510 PCI-ISA bridge");  
         case 0x01001078:  
                 return ("Cyrix Cx5530 PCI-ISA bridge");  
   
         /* NEC -- vendor 0x1033 */  
         /* The "C-bus" is 16-bits bus on PC98. */  
         case 0x00011033:  
                 return ("NEC 0001 PCI to PC-98 C-bus bridge");  
         case 0x002c1033:  
                 return ("NEC 002C PCI to PC-98 C-bus bridge");  
         case 0x003b1033:  
                 return ("NEC 003B PCI to PC-98 C-bus bridge");  
         /* UMC United Microelectronics 0x1060 */  
         case 0x886a1060:  
                 return ("UMC UM8886 ISA Bridge with EIDE");  
   
         /* Cypress -- vendor 0x1080 */  
         case 0xc6931080:  
                 if (pci_get_class(dev) == PCIC_BRIDGE  
                     && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)  
                         return ("Cypress 82C693 PCI-ISA bridge");  
                 break;  
   
         /* ServerWorks -- vendor 0x1166 */  
         case 0x02001166:  
                 return ("ServerWorks IB6566 PCI to ISA bridge");  
         }  
   
         if (pci_get_class(dev) == PCIC_BRIDGE  
             && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)  
                 return pci_bridge_type(dev);  
   
         return NULL;  
 }  
   
 static int  
 isab_probe(device_t dev)  
 {  
         const char *desc;  
         int     is_eisa;  
   
         is_eisa = 0;  
         desc = eisab_match(dev);  
         if (desc)  
                 is_eisa = 1;  
         else  
                 desc = isab_match(dev);  
         if (desc) {  
                 /*  
                  * For a PCI-EISA bridge, add both eisa and isa.  
                  * Only add one instance of eisa or isa for now.  
                  */  
                 device_set_desc_copy(dev, desc);  
                 if (is_eisa && !devclass_get_device(devclass_find("eisa"), 0))  
                         device_add_child(dev, "eisa", -1);  
   
                 if (!devclass_get_device(devclass_find("isa"), 0))  
                         device_add_child(dev, "isa", -1);  
                 return -1000;  
         }  
         return ENXIO;  
 }  
   
 static int  
 isab_attach(device_t dev)  
 {  
         chipset_attach(dev, device_get_unit(dev));  
         return bus_generic_attach(dev);  
 }  
   
 static device_method_t isab_methods[] = {  
         /* Device interface */  
         DEVMETHOD(device_probe,         isab_probe),  
         DEVMETHOD(device_attach,        isab_attach),  
         DEVMETHOD(device_shutdown,      bus_generic_shutdown),  
         DEVMETHOD(device_suspend,       bus_generic_suspend),  
         DEVMETHOD(device_resume,        bus_generic_resume),  
   
         /* Bus interface */  
         DEVMETHOD(bus_print_child,      bus_generic_print_child),  
         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),  
         DEVMETHOD(bus_release_resource, bus_generic_release_resource),  
         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),  
         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),  
         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),  
         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),  
   
         { 0, 0 }  
 };  
   
 static driver_t isab_driver = {  
         "isab",  
         isab_methods,  
         1,  
 };  
   
 devclass_t isab_devclass;  
   
 DRIVER_MODULE(isab, pci, isab_driver, isab_devclass, 0, 0);  
   
 const char *  const char *
 pci_usb_match(device_t dev)  pci_usb_match(device_t dev)
 {  {
Removed from v.1.12  
changed lines
  Added in v.1.13