sys/bus/pci/pcisupport.c

   1 /**************************************************************************
   2 **
   3 ** $FreeBSD: src/sys/pci/pcisupport.c,v 1.154.2.15 2003/04/29 15:55:06 simokawa Exp $
   4 ** $DragonFly: src/sys/bus/pci/pcisupport.c,v 1.8 2004/01/15 20:35:06 joerg Exp $
   5 **
   6 **  Device driver for DEC/INTEL PCI chipsets.
   7 **
   8 **  FreeBSD
   9 **
  10 **-------------------------------------------------------------------------
  11 **
  12 **  Written for FreeBSD by
  13 **      wolf@cologne.de         Wolfgang Stanglmeier
  14 **      se@mi.Uni-Koeln.de      Stefan Esser
  15 **
  16 **-------------------------------------------------------------------------
  17 **
  18 ** Copyright (c) 1994,1995 Stefan Esser.  All rights reserved.
  19 **
  20 ** Redistribution and use in source and binary forms, with or without
  21 ** modification, are permitted provided that the following conditions
  22 ** are met:
  23 ** 1. Redistributions of source code must retain the above copyright
  24 **    notice, this list of conditions and the following disclaimer.
  25 ** 2. Redistributions in binary form must reproduce the above copyright
  26 **    notice, this list of conditions and the following disclaimer in the
  27 **    documentation and/or other materials provided with the distribution.
  28 ** 3. The name of the author may not be used to endorse or promote products
  29 **    derived from this software without specific prior written permission.
  30 **
  31 ** THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  32 ** IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  33 ** OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  34 ** IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  35 ** INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  36 ** NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  37 ** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  38 ** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  39 ** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  40 ** THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  41 **
  42 ***************************************************************************
  43 */
  44
  45 #include "opt_bus.h"
  46 #include "opt_pci.h"
  47
  48 #include <sys/param.h>
  49 #include <sys/systm.h>
  50 #include <sys/malloc.h>
  51 #include <sys/kernel.h>
  52 #include <sys/bus.h>
  53
  54 #include "pcivar.h"
  55 #include "pcireg.h"
  56
  57 #include <vm/vm.h>
  58 #include <vm/vm_object.h>
  59 #include <vm/pmap.h>
  60
  61 #include "pcib_if.h"
  62
  63 /*---------------------------------------------------------
  64 **
  65 **      Intel chipsets for 486 / Pentium processor
  66 **
  67 **---------------------------------------------------------
  68 */
  69
  70 static  void    chipset_attach(device_t dev, int unit);
  71
  72 struct condmsg {
  73     unsigned char       port;
  74     unsigned char       mask;
  75     unsigned char       value;
  76     char                flags;
  77     const char          *text;
  78 };
  79
  80
  81 static void
  82 fixbushigh_i1225(device_t dev)
  83 {
  84         int sublementarybus;
  85
  86         sublementarybus = pci_read_config(dev, 0x41, 1);
  87         if (sublementarybus != 0xff) {
  88                 pci_set_secondarybus(dev, sublementarybus + 1);
  89                 pci_set_subordinatebus(dev, sublementarybus + 1);
  90         }
  91 }
  92
  93 static void
  94 fixwsc_natoma(device_t dev)
  95 {
  96         int pmccfg;
  97
  98         pmccfg = pci_read_config(dev, 0x50, 2);
  99 #if defined(SMP)
 100         if (pmccfg & 0x8000) {
 101                 printf("Correcting Natoma config for SMP\n");
 102                 pmccfg &= ~0x8000;
 103                 pci_write_config(dev, 0x50, pmccfg, 2);
 104         }
 105 #else
 106         if ((pmccfg & 0x8000) == 0) {
 107                 printf("Correcting Natoma config for non-SMP\n");
 108                 pmccfg |= 0x8000;
 109                 pci_write_config(dev, 0x50, pmccfg, 2);
 110         }
 111 #endif
 112 }
 113
 114 #ifndef PCI_QUIET
 115
 116 #define M_XX 0  /* end of list */
 117 #define M_EQ 1  /* mask and return true if equal */
 118 #define M_NE 2  /* mask and return true if not equal */
 119 #define M_TR 3  /* don't read config, always true */
 120 #define M_EN 4  /* mask and print "enabled" if true, "disabled" if false */
 121 #define M_NN 5  /* opposite sense of M_EN */
 122
 123 static const struct condmsg conf82425ex[] =
 124 {
 125     { 0x00, 0x00, 0x00, M_TR, "\tClock " },
 126     { 0x50, 0x06, 0x00, M_EQ, "25" },
 127     { 0x50, 0x06, 0x02, M_EQ, "33" },
 128     { 0x50, 0x04, 0x04, M_EQ, "??", },
 129     { 0x00, 0x00, 0x00, M_TR, "MHz, L1 Cache " },
 130     { 0x50, 0x01, 0x00, M_EQ, "Disabled\n" },
 131     { 0x50, 0x09, 0x01, M_EQ, "Write-through\n" },
 132     { 0x50, 0x09, 0x09, M_EQ, "Write-back\n" },
 133
 134     { 0x00, 0x00, 0x00, M_TR, "\tL2 Cache " },
 135     { 0x52, 0x07, 0x00, M_EQ, "Disabled" },
 136     { 0x52, 0x0f, 0x01, M_EQ, "64KB Write-through" },
 137     { 0x52, 0x0f, 0x02, M_EQ, "128KB Write-through" },
 138     { 0x52, 0x0f, 0x03, M_EQ, "256KB Write-through" },
 139     { 0x52, 0x0f, 0x04, M_EQ, "512KB Write-through" },
 140     { 0x52, 0x0f, 0x01, M_EQ, "64KB Write-back" },
 141     { 0x52, 0x0f, 0x02, M_EQ, "128KB Write-back" },
 142     { 0x52, 0x0f, 0x03, M_EQ, "256KB Write-back" },
 143     { 0x52, 0x0f, 0x04, M_EQ, "512KB Write-back" },
 144     { 0x53, 0x01, 0x00, M_EQ, ", 3-" },
 145     { 0x53, 0x01, 0x01, M_EQ, ", 2-" },
 146     { 0x53, 0x06, 0x00, M_EQ, "3-3-3" },
 147     { 0x53, 0x06, 0x02, M_EQ, "2-2-2" },
 148     { 0x53, 0x06, 0x04, M_EQ, "1-1-1" },
 149     { 0x53, 0x06, 0x06, M_EQ, "?-?-?" },
 150     { 0x53, 0x18, 0x00, M_EQ, "/4-2-2-2\n" },
 151     { 0x53, 0x18, 0x08, M_EQ, "/3-2-2-2\n" },
 152     { 0x53, 0x18, 0x10, M_EQ, "/?-?-?-?\n" },
 153     { 0x53, 0x18, 0x18, M_EQ, "/2-1-1-1\n" },
 154
 155     { 0x56, 0x00, 0x00, M_TR, "\tDRAM: " },
 156     { 0x56, 0x02, 0x02, M_EQ, "Fast Code Read, " },
 157     { 0x56, 0x04, 0x04, M_EQ, "Fast Data Read, " },
 158     { 0x56, 0x08, 0x08, M_EQ, "Fast Write, " },
 159     { 0x57, 0x20, 0x20, M_EQ, "Pipelined CAS" },
 160     { 0x57, 0x2e, 0x00, M_NE, "\n\t" },
 161     { 0x57, 0x00, 0x00, M_TR, "Timing: RAS: " },
 162     { 0x57, 0x07, 0x00, M_EQ, "4" },
 163     { 0x57, 0x07, 0x01, M_EQ, "3" },
 164     { 0x57, 0x07, 0x02, M_EQ, "2" },
 165     { 0x57, 0x07, 0x04, M_EQ, "1.5" },
 166     { 0x57, 0x07, 0x05, M_EQ, "1" },
 167     { 0x57, 0x00, 0x00, M_TR, " Clocks, CAS Read: " },
 168     { 0x57, 0x18, 0x00, M_EQ, "3/1", },
 169     { 0x57, 0x18, 0x00, M_EQ, "2/1", },
 170     { 0x57, 0x18, 0x00, M_EQ, "1.5/0.5", },
 171     { 0x57, 0x18, 0x00, M_EQ, "1/1", },
 172     { 0x57, 0x00, 0x00, M_TR, ", CAS Write: " },
 173     { 0x57, 0x20, 0x00, M_EQ, "2/1", },
 174     { 0x57, 0x20, 0x20, M_EQ, "1/1", },
 175     { 0x57, 0x00, 0x00, M_TR, "\n" },
 176
 177     { 0x40, 0x01, 0x01, M_EQ, "\tCPU-to-PCI Byte Merging\n" },
 178     { 0x40, 0x02, 0x02, M_EQ, "\tCPU-to-PCI Bursting\n" },
 179     { 0x40, 0x04, 0x04, M_EQ, "\tPCI Posted Writes\n" },
 180     { 0x40, 0x20, 0x00, M_EQ, "\tDRAM Parity Disabled\n" },
 181
 182     { 0x48, 0x03, 0x01, M_EQ, "\tPCI IDE controller: Primary (1F0h-1F7h,3F6h,3F7h)" },
 183     { 0x48, 0x03, 0x02, M_EQ, "\tPCI IDE controller: Secondary (170h-177h,376h,377h)" },
 184     { 0x4d, 0x01, 0x01, M_EQ, "\tRTC (70-77h)\n" },
 185     { 0x4d, 0x02, 0x02, M_EQ, "\tKeyboard (60,62,64,66h)\n" },
 186     { 0x4d, 0x08, 0x08, M_EQ, "\tIRQ12/M Mouse Function\n" },
 187
 188 /* end marker */
 189     { 0 }
 190 };
 191
 192 static const struct condmsg conf82424zx[] =
 193 {
 194     { 0x00, 0x00, 0x00, M_TR, "\tCPU: " },
 195     { 0x50, 0xe0, 0x00, M_EQ, "486DX" },
 196     { 0x50, 0xe0, 0x20, M_EQ, "486SX" },
 197     { 0x50, 0xe0, 0x40, M_EQ, "486DX2 or 486DX4" },
 198     { 0x50, 0xe0, 0x80, M_EQ, "Overdrive (writeback)" },
 199
 200     { 0x00, 0x00, 0x00, M_TR, ", bus=" },
 201     { 0x50, 0x03, 0x00, M_EQ, "25MHz" },
 202     { 0x50, 0x03, 0x01, M_EQ, "33MHz" },
 203     { 0x53, 0x01, 0x01, M_TR, ", CPU->Memory posting "},
 204     { 0x53, 0x01, 0x00, M_EQ, "OFF" },
 205     { 0x53, 0x01, 0x01, M_EQ, "ON" },
 206
 207     { 0x56, 0x30, 0x00, M_NE, "\n\tWarning:" },
 208     { 0x56, 0x20, 0x00, M_NE, " NO cache parity!" },
 209     { 0x56, 0x10, 0x00, M_NE, " NO DRAM parity!" },
 210     { 0x55, 0x04, 0x04, M_EQ, "\n\tWarning: refresh OFF! " },
 211
 212     { 0x00, 0x00, 0x00, M_TR, "\n\tCache: " },
 213     { 0x52, 0x01, 0x00, M_EQ, "None" },
 214     { 0x52, 0xc1, 0x01, M_EQ, "64KB" },
 215     { 0x52, 0xc1, 0x41, M_EQ, "128KB" },
 216     { 0x52, 0xc1, 0x81, M_EQ, "256KB" },
 217     { 0x52, 0xc1, 0xc1, M_EQ, "512KB" },
 218     { 0x52, 0x03, 0x01, M_EQ, " writethrough" },
 219     { 0x52, 0x03, 0x03, M_EQ, " writeback" },
 220
 221     { 0x52, 0x01, 0x01, M_EQ, ", cache clocks=" },
 222     { 0x52, 0x05, 0x01, M_EQ, "3-1-1-1" },
 223     { 0x52, 0x05, 0x05, M_EQ, "2-1-1-1" },
 224
 225     { 0x00, 0x00, 0x00, M_TR, "\n\tDRAM:" },
 226     { 0x55, 0x43, 0x00, M_NE, " page mode" },
 227     { 0x55, 0x02, 0x02, M_EQ, " code fetch" },
 228     { 0x55, 0x43, 0x43, M_EQ, "," },
 229     { 0x55, 0x43, 0x42, M_EQ, " and" },
 230     { 0x55, 0x40, 0x40, M_EQ, " read" },
 231     { 0x55, 0x03, 0x03, M_EQ, " and" },
 232     { 0x55, 0x43, 0x41, M_EQ, " and" },
 233     { 0x55, 0x01, 0x01, M_EQ, " write" },
 234     { 0x55, 0x43, 0x00, M_NE, "," },
 235
 236     { 0x00, 0x00, 0x00, M_TR, " memory clocks=" },
 237     { 0x55, 0x20, 0x00, M_EQ, "X-2-2-2" },
 238     { 0x55, 0x20, 0x20, M_EQ, "X-1-2-1" },
 239
 240     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU->PCI: posting " },
 241     { 0x53, 0x02, 0x00, M_NE, "ON" },
 242     { 0x53, 0x02, 0x00, M_EQ, "OFF" },
 243     { 0x00, 0x00, 0x00, M_TR, ", burst mode " },
 244     { 0x54, 0x02, 0x00, M_NE, "ON" },
 245     { 0x54, 0x02, 0x00, M_EQ, "OFF" },
 246     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI->Memory: posting " },
 247     { 0x54, 0x01, 0x00, M_NE, "ON" },
 248     { 0x54, 0x01, 0x00, M_EQ, "OFF" },
 249
 250     { 0x00, 0x00, 0x00, M_TR, "\n" },
 251
 252 /* end marker */
 253     { 0 }
 254 };
 255
 256 static const struct condmsg conf82434lx[] =
 257 {
 258     { 0x00, 0x00, 0x00, M_TR, "\tCPU: " },
 259     { 0x50, 0xe3, 0x82, M_EQ, "Pentium, 60MHz" },
 260     { 0x50, 0xe3, 0x83, M_EQ, "Pentium, 66MHz" },
 261     { 0x50, 0xe3, 0xa2, M_EQ, "Pentium, 90MHz" },
 262     { 0x50, 0xe3, 0xa3, M_EQ, "Pentium, 100MHz" },
 263     { 0x50, 0xc2, 0x82, M_NE, "(unknown)" },
 264     { 0x50, 0x04, 0x00, M_EQ, " (primary cache OFF)" },
 265
 266     { 0x53, 0x01, 0x01, M_TR, ", CPU->Memory posting "},
 267     { 0x53, 0x01, 0x01, M_NE, "OFF" },
 268     { 0x53, 0x01, 0x01, M_EQ, "ON" },
 269
 270     { 0x53, 0x08, 0x00, M_NE, ", read around write"},
 271
 272     { 0x70, 0x04, 0x00, M_EQ, "\n\tWarning: Cache parity disabled!" },
 273     { 0x57, 0x20, 0x00, M_NE, "\n\tWarning: DRAM parity mask!" },
 274     { 0x57, 0x01, 0x00, M_EQ, "\n\tWarning: refresh OFF! " },
 275
 276     { 0x00, 0x00, 0x00, M_TR, "\n\tCache: " },
 277     { 0x52, 0x01, 0x00, M_EQ, "None" },
 278     { 0x52, 0x81, 0x01, M_EQ, "" },
 279     { 0x52, 0xc1, 0x81, M_EQ, "256KB" },
 280     { 0x52, 0xc1, 0xc1, M_EQ, "512KB" },
 281     { 0x52, 0x03, 0x01, M_EQ, " writethrough" },
 282     { 0x52, 0x03, 0x03, M_EQ, " writeback" },
 283
 284     { 0x52, 0x01, 0x01, M_EQ, ", cache clocks=" },
 285     { 0x52, 0x21, 0x01, M_EQ, "3-2-2-2/4-2-2-2" },
 286     { 0x52, 0x21, 0x21, M_EQ, "3-1-1-1" },
 287
 288     { 0x52, 0x01, 0x01, M_EQ, "\n\tCache flags: " },
 289     { 0x52, 0x11, 0x11, M_EQ, " cache-all" },
 290     { 0x52, 0x09, 0x09, M_EQ, " byte-control" },
 291     { 0x52, 0x05, 0x05, M_EQ, " powersaver" },
 292
 293     { 0x00, 0x00, 0x00, M_TR, "\n\tDRAM:" },
 294     { 0x57, 0x10, 0x00, M_EQ, " page mode" },
 295
 296     { 0x00, 0x00, 0x00, M_TR, " memory clocks=" },
 297     { 0x57, 0xc0, 0x00, M_EQ, "X-4-4-4 (70ns)" },
 298     { 0x57, 0xc0, 0x40, M_EQ, "X-4-4-4/X-3-3-3 (60ns)" },
 299     { 0x57, 0xc0, 0x80, M_EQ, "???" },
 300     { 0x57, 0xc0, 0xc0, M_EQ, "X-3-3-3 (50ns)" },
 301     { 0x58, 0x02, 0x02, M_EQ, ", RAS-wait" },
 302     { 0x58, 0x01, 0x01, M_EQ, ", CAS-wait" },
 303
 304     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU->PCI: posting " },
 305     { 0x53, 0x02, 0x02, M_EQ, "ON" },
 306     { 0x53, 0x02, 0x00, M_EQ, "OFF" },
 307     { 0x00, 0x00, 0x00, M_TR, ", burst mode " },
 308     { 0x54, 0x02, 0x00, M_NE, "ON" },
 309     { 0x54, 0x02, 0x00, M_EQ, "OFF" },
 310     { 0x54, 0x04, 0x00, M_TR, ", PCI clocks=" },
 311     { 0x54, 0x04, 0x00, M_EQ, "2-2-2-2" },
 312     { 0x54, 0x04, 0x00, M_NE, "2-1-1-1" },
 313     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI->Memory: posting " },
 314     { 0x54, 0x01, 0x00, M_NE, "ON" },
 315     { 0x54, 0x01, 0x00, M_EQ, "OFF" },
 316
 317     { 0x57, 0x01, 0x01, M_EQ, "\n\tRefresh:" },
 318     { 0x57, 0x03, 0x03, M_EQ, " CAS#/RAS#(Hidden)" },
 319     { 0x57, 0x03, 0x01, M_EQ, " RAS#Only" },
 320     { 0x57, 0x05, 0x05, M_EQ, " BurstOf4" },
 321
 322     { 0x00, 0x00, 0x00, M_TR, "\n" },
 323
 324 /* end marker */
 325     { 0 }
 326 };
 327
 328 static const struct condmsg conf82378[] =
 329 {
 330     { 0x00, 0x00, 0x00, M_TR, "\tBus Modes:" },
 331     { 0x41, 0x04, 0x04, M_EQ, " Bus Park," },
 332     { 0x41, 0x02, 0x02, M_EQ, " Bus Lock," },
 333     { 0x41, 0x02, 0x00, M_EQ, " Resource Lock," },
 334     { 0x41, 0x01, 0x01, M_EQ, " GAT" },
 335     { 0x4d, 0x20, 0x20, M_EQ, "\n\tCoprocessor errors enabled" },
 336     { 0x4d, 0x10, 0x10, M_EQ, "\n\tMouse function enabled" },
 337
 338     { 0x4e, 0x30, 0x10, M_EQ, "\n\tIDE controller: Primary (1F0h-1F7h,3F6h,3F7h)" },
 339     { 0x4e, 0x30, 0x30, M_EQ, "\n\tIDE controller: Secondary (170h-177h,376h,377h)" },
 340     { 0x4e, 0x28, 0x08, M_EQ, "\n\tFloppy controller: 3F0h,3F1h " },
 341     { 0x4e, 0x24, 0x04, M_EQ, "\n\tFloppy controller: 3F2h-3F7h " },
 342     { 0x4e, 0x28, 0x28, M_EQ, "\n\tFloppy controller: 370h,371h " },
 343     { 0x4e, 0x24, 0x24, M_EQ, "\n\tFloppy controller: 372h-377h " },
 344     { 0x4e, 0x02, 0x02, M_EQ, "\n\tKeyboard controller: 60h,62h,64h,66h" },
 345     { 0x4e, 0x01, 0x01, M_EQ, "\n\tRTC: 70h-77h" },
 346
 347     { 0x4f, 0x80, 0x80, M_EQ, "\n\tConfiguration RAM: 0C00h,0800h-08FFh" },
 348     { 0x4f, 0x40, 0x40, M_EQ, "\n\tPort 92: enabled" },
 349     { 0x4f, 0x03, 0x00, M_EQ, "\n\tSerial Port A: COM1 (3F8h-3FFh)" },
 350     { 0x4f, 0x03, 0x01, M_EQ, "\n\tSerial Port A: COM2 (2F8h-2FFh)" },
 351     { 0x4f, 0x0c, 0x00, M_EQ, "\n\tSerial Port B: COM1 (3F8h-3FFh)" },
 352     { 0x4f, 0x0c, 0x04, M_EQ, "\n\tSerial Port B: COM2 (2F8h-2FFh)" },
 353     { 0x4f, 0x30, 0x00, M_EQ, "\n\tParallel Port: LPT1 (3BCh-3BFh)" },
 354     { 0x4f, 0x30, 0x04, M_EQ, "\n\tParallel Port: LPT2 (378h-37Fh)" },
 355     { 0x4f, 0x30, 0x20, M_EQ, "\n\tParallel Port: LPT3 (278h-27Fh)" },
 356     { 0x00, 0x00, 0x00, M_TR, "\n" },
 357
 358 /* end marker */
 359     { 0 }
 360 };
 361
 362 static const struct condmsg conf82437fx[] =
 363 {
 364     /* PCON -- PCI Control Register */
 365     { 0x00, 0x00, 0x00, M_TR, "\tCPU Inactivity timer: " },
 366     { 0x50, 0xe0, 0xe0, M_EQ, "8" },
 367     { 0x50, 0xe0, 0xd0, M_EQ, "7" },
 368     { 0x50, 0xe0, 0xc0, M_EQ, "6" },
 369     { 0x50, 0xe0, 0xb0, M_EQ, "5" },
 370     { 0x50, 0xe0, 0xa0, M_EQ, "4" },
 371     { 0x50, 0xe0, 0x90, M_EQ, "3" },
 372     { 0x50, 0xe0, 0x80, M_EQ, "2" },
 373     { 0x50, 0xe0, 0x00, M_EQ, "1" },
 374     { 0x00, 0x00, 0x00, M_TR, " clocks\n\tPeer Concurrency: " },
 375     { 0x50, 0x08, 0x08, M_EN, 0 },
 376     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU-to-PCI Write Bursting: " },
 377     { 0x50, 0x04, 0x00, M_NN, 0 },
 378     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI Streaming: " },
 379     { 0x50, 0x02, 0x00, M_NN, 0 },
 380     { 0x00, 0x00, 0x00, M_TR, "\n\tBus Concurrency: " },
 381     { 0x50, 0x01, 0x00, M_NN, 0 },
 382
 383     /* CC -- Cache Control Regsiter */
 384     { 0x00, 0x00, 0x00, M_TR, "\n\tCache:" },
 385     { 0x52, 0xc0, 0x80, M_EQ, " 512K" },
 386     { 0x52, 0xc0, 0x40, M_EQ, " 256K" },
 387     { 0x52, 0xc0, 0x00, M_EQ, " NO" },
 388     { 0x52, 0x30, 0x00, M_EQ, " pipelined-burst" },
 389     { 0x52, 0x30, 0x10, M_EQ, " burst" },
 390     { 0x52, 0x30, 0x20, M_EQ, " asynchronous" },
 391     { 0x52, 0x30, 0x30, M_EQ, " dual-bank pipelined-burst" },
 392     { 0x00, 0x00, 0x00, M_TR, " secondary; L1 " },
 393     { 0x52, 0x01, 0x00, M_EN, 0 },
 394     { 0x00, 0x00, 0x00, M_TR, "\n" },
 395
 396     /* DRAMC -- DRAM Control Register */
 397     { 0x57, 0x07, 0x00, M_EQ, "Warning: refresh OFF!\n" },
 398     { 0x00, 0x00, 0x00, M_TR, "\tDRAM:" },
 399     { 0x57, 0xc0, 0x00, M_EQ, " no memory hole" },
 400     { 0x57, 0xc0, 0x40, M_EQ, " 512K-640K memory hole" },
 401     { 0x57, 0xc0, 0x80, M_EQ, " 15M-16M memory hole" },
 402     { 0x57, 0x07, 0x01, M_EQ, ", 50 MHz refresh" },
 403     { 0x57, 0x07, 0x02, M_EQ, ", 60 MHz refresh" },
 404     { 0x57, 0x07, 0x03, M_EQ, ", 66 MHz refresh" },
 405
 406     /* DRAMT = DRAM Timing Register */
 407     { 0x00, 0x00, 0x00, M_TR, "\n\tRead burst timing: " },
 408     { 0x58, 0x60, 0x00, M_EQ, "x-4-4-4/x-4-4-4" },
 409     { 0x58, 0x60, 0x20, M_EQ, "x-3-3-3/x-4-4-4" },
 410     { 0x58, 0x60, 0x40, M_EQ, "x-2-2-2/x-3-3-3" },
 411     { 0x58, 0x60, 0x60, M_EQ, "???" },
 412     { 0x00, 0x00, 0x00, M_TR, "\n\tWrite burst timing: " },
 413     { 0x58, 0x18, 0x00, M_EQ, "x-4-4-4" },
 414     { 0x58, 0x18, 0x08, M_EQ, "x-3-3-3" },
 415     { 0x58, 0x18, 0x10, M_EQ, "x-2-2-2" },
 416     { 0x58, 0x18, 0x18, M_EQ, "???" },
 417     { 0x00, 0x00, 0x00, M_TR, "\n\tRAS-CAS delay: " },
 418     { 0x58, 0x04, 0x00, M_EQ, "3" },
 419     { 0x58, 0x04, 0x04, M_EQ, "2" },
 420     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },
 421
 422     /* end marker */
 423     { 0 }
 424 };
 425
 426 static const struct condmsg conf82437vx[] =
 427 {
 428     /* PCON -- PCI Control Register */
 429     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI Concurrency: " },
 430     { 0x50, 0x08, 0x08, M_EN, 0 },
 431
 432     /* CC -- Cache Control Regsiter */
 433     { 0x00, 0x00, 0x00, M_TR, "\n\tCache:" },
 434     { 0x52, 0xc0, 0x80, M_EQ, " 512K" },
 435     { 0x52, 0xc0, 0x40, M_EQ, " 256K" },
 436     { 0x52, 0xc0, 0x00, M_EQ, " NO" },
 437     { 0x52, 0x30, 0x00, M_EQ, " pipelined-burst" },
 438     { 0x52, 0x30, 0x10, M_EQ, " burst" },
 439     { 0x52, 0x30, 0x20, M_EQ, " asynchronous" },
 440     { 0x52, 0x30, 0x30, M_EQ, " dual-bank pipelined-burst" },
 441     { 0x00, 0x00, 0x00, M_TR, " secondary; L1 " },
 442     { 0x52, 0x01, 0x00, M_EN, 0 },
 443     { 0x00, 0x00, 0x00, M_TR, "\n" },
 444
 445     /* DRAMC -- DRAM Control Register */
 446     { 0x57, 0x07, 0x00, M_EQ, "Warning: refresh OFF!\n" },
 447     { 0x00, 0x00, 0x00, M_TR, "\tDRAM:" },
 448     { 0x57, 0xc0, 0x00, M_EQ, " no memory hole" },
 449     { 0x57, 0xc0, 0x40, M_EQ, " 512K-640K memory hole" },
 450     { 0x57, 0xc0, 0x80, M_EQ, " 15M-16M memory hole" },
 451     { 0x57, 0x07, 0x01, M_EQ, ", 50 MHz refresh" },
 452     { 0x57, 0x07, 0x02, M_EQ, ", 60 MHz refresh" },
 453     { 0x57, 0x07, 0x03, M_EQ, ", 66 MHz refresh" },
 454
 455     /* DRAMT = DRAM Timing Register */
 456     { 0x00, 0x00, 0x00, M_TR, "\n\tRead burst timing: " },
 457     { 0x58, 0x60, 0x00, M_EQ, "x-4-4-4/x-4-4-4" },
 458     { 0x58, 0x60, 0x20, M_EQ, "x-3-3-3/x-4-4-4" },
 459     { 0x58, 0x60, 0x40, M_EQ, "x-2-2-2/x-3-3-3" },
 460     { 0x58, 0x60, 0x60, M_EQ, "???" },
 461     { 0x00, 0x00, 0x00, M_TR, "\n\tWrite burst timing: " },
 462     { 0x58, 0x18, 0x00, M_EQ, "x-4-4-4" },
 463     { 0x58, 0x18, 0x08, M_EQ, "x-3-3-3" },
 464     { 0x58, 0x18, 0x10, M_EQ, "x-2-2-2" },
 465     { 0x58, 0x18, 0x18, M_EQ, "???" },
 466     { 0x00, 0x00, 0x00, M_TR, "\n\tRAS-CAS delay: " },
 467     { 0x58, 0x04, 0x00, M_EQ, "3" },
 468     { 0x58, 0x04, 0x04, M_EQ, "2" },
 469     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },
 470
 471     /* end marker */
 472     { 0 }
 473 };
 474
 475 static const struct condmsg conf82371fb[] =
 476 {
 477     /* IORT -- ISA I/O Recovery Timer Register */
 478     { 0x00, 0x00, 0x00, M_TR, "\tI/O Recovery Timing: 8-bit " },
 479     { 0x4c, 0x40, 0x00, M_EQ, "3.5" },
 480     { 0x4c, 0x78, 0x48, M_EQ, "1" },
 481     { 0x4c, 0x78, 0x50, M_EQ, "2" },
 482     { 0x4c, 0x78, 0x58, M_EQ, "3" },
 483     { 0x4c, 0x78, 0x60, M_EQ, "4" },
 484     { 0x4c, 0x78, 0x68, M_EQ, "5" },
 485     { 0x4c, 0x78, 0x70, M_EQ, "6" },
 486     { 0x4c, 0x78, 0x78, M_EQ, "7" },
 487     { 0x4c, 0x78, 0x40, M_EQ, "8" },
 488     { 0x00, 0x00, 0x00, M_TR, " clocks, 16-bit " },
 489     { 0x4c, 0x04, 0x00, M_EQ, "3.5" },
 490     { 0x4c, 0x07, 0x05, M_EQ, "1" },
 491     { 0x4c, 0x07, 0x06, M_EQ, "2" },
 492     { 0x4c, 0x07, 0x07, M_EQ, "3" },
 493     { 0x4c, 0x07, 0x04, M_EQ, "4" },
 494     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },
 495
 496     /* XBCS -- X-Bus Chip Select Register */
 497     { 0x00, 0x00, 0x00, M_TR, "\tExtended BIOS: " },
 498     { 0x4e, 0x80, 0x80, M_EN, 0 },
 499     { 0x00, 0x00, 0x00, M_TR, "\n\tLower BIOS: " },
 500     { 0x4e, 0x40, 0x40, M_EN, 0 },
 501     { 0x00, 0x00, 0x00, M_TR, "\n\tCoprocessor IRQ13: " },
 502     { 0x4e, 0x20, 0x20, M_EN, 0 },
 503     { 0x00, 0x00, 0x00, M_TR, "\n\tMouse IRQ12: " },
 504     { 0x4e, 0x10, 0x10, M_EN, 0 },
 505     { 0x00, 0x00, 0x00, M_TR, "\n" },
 506
 507     { 0x00, 0x00, 0x00, M_TR, "\tInterrupt Routing: " },
 508 #define PIRQ(x, n) \
 509     { 0x00, 0x00, 0x00, M_TR, n ": " }, \
 510     { x, 0x80, 0x80, M_EQ, "disabled" }, \
 511     { x, 0xc0, 0x40, M_EQ, "[shared] " }, \
 512     { x, 0x8f, 0x03, M_EQ, "IRQ3" }, \
 513     { x, 0x8f, 0x04, M_EQ, "IRQ4" }, \
 514     { x, 0x8f, 0x05, M_EQ, "IRQ5" }, \
 515     { x, 0x8f, 0x06, M_EQ, "IRQ6" }, \
 516     { x, 0x8f, 0x07, M_EQ, "IRQ7" }, \
 517     { x, 0x8f, 0x09, M_EQ, "IRQ9" }, \
 518     { x, 0x8f, 0x0a, M_EQ, "IRQ10" }, \
 519     { x, 0x8f, 0x0b, M_EQ, "IRQ11" }, \
 520     { x, 0x8f, 0x0c, M_EQ, "IRQ12" }, \
 521     { x, 0x8f, 0x0e, M_EQ, "IRQ14" }, \
 522     { x, 0x8f, 0x0f, M_EQ, "IRQ15" }
 523
 524     /* Interrupt routing */
 525     PIRQ(0x60, "A"),
 526     PIRQ(0x61, ", B"),
 527     PIRQ(0x62, ", C"),
 528     PIRQ(0x63, ", D"),
 529     PIRQ(0x70, "\n\t\tMB0"),
 530     PIRQ(0x71, ", MB1"),
 531
 532     { 0x00, 0x00, 0x00, M_TR, "\n" },
 533
 534 #undef PIRQ
 535
 536     /* XXX - do DMA routing, too? */
 537     { 0 }
 538 };
 539
 540 static const struct condmsg conf82371fb2[] =
 541 {
 542     /* IDETM -- IDE Timing Register */
 543     { 0x00, 0x00, 0x00, M_TR, "\tPrimary IDE: " },
 544     { 0x41, 0x80, 0x80, M_EN, 0 },
 545     { 0x00, 0x00, 0x00, M_TR, "\n\tSecondary IDE: " },
 546     { 0x43, 0x80, 0x80, M_EN, 0 },
 547     { 0x00, 0x00, 0x00, M_TR, "\n" },
 548
 549     /* end of list */
 550     { 0 }
 551 };
 552
 553 static void
 554 writeconfig (device_t dev, const struct condmsg *tbl)
 555 {
 556     while (tbl->flags != M_XX) {
 557         const char *text = 0;
 558
 559         if (tbl->flags == M_TR) {
 560             text = tbl->text;
 561         } else {
 562             unsigned char v = pci_read_config(dev, tbl->port, 1);
 563             switch (tbl->flags) {
 564     case M_EQ:
 565                 if ((v & tbl->mask) == tbl->value) text = tbl->text;
 566                 break;
 567     case M_NE:
 568                 if ((v & tbl->mask) != tbl->value) text = tbl->text;
 569                 break;
 570     case M_EN:
 571                 text = (v & tbl->mask) ? "enabled" : "disabled";
 572                 break;
 573     case M_NN:
 574                 text = (v & tbl->mask) ? "disabled" : "enabled";
 575             }
 576         }
 577         if (text) printf ("%s", text);
 578         tbl++;
 579     }
 580 }
 581
 582 #ifdef DUMPCONFIGSPACE
 583 static void
 584 dumpconfigspace (device_t dev)
 585 {
 586     int reg;
 587     printf ("configuration space registers:");
 588     for (reg = 0; reg < 0x100; reg+=4) {
 589         if ((reg & 0x0f) == 0)
 590             printf ("\n%02x:\t", reg);
 591         printf ("%08x ", pci_read_config(dev, reg, 4));
 592     }
 593     printf ("\n");
 594 }
 595 #endif /* DUMPCONFIGSPACE */
 596
 597 #endif /* PCI_QUIET */
 598
 599
 600 static void
 601 chipset_attach (device_t dev, int unit)
 602 {
 603 #ifndef PCI_QUIET
 604         if (!bootverbose)
 605                 return;
 606
 607         switch (pci_get_devid(dev)) {
 608         case 0x04868086:
 609                 writeconfig (dev, conf82425ex);
 610                 break;
 611         case 0x04838086:
 612                 writeconfig (dev, conf82424zx);
 613                 break;
 614         case 0x04a38086:
 615                 writeconfig (dev, conf82434lx);
 616                 break;
 617         case 0x04848086:
 618                 writeconfig (dev, conf82378);
 619                 break;
 620         case 0x122d8086:
 621                 writeconfig (dev, conf82437fx);
 622                 break;
 623         case 0x70308086:
 624                 writeconfig (dev, conf82437vx);
 625                 break;
 626         case 0x70008086:
 627         case 0x122e8086:
 628                 writeconfig (dev, conf82371fb);
 629                 break;
 630         case 0x70108086:
 631         case 0x12308086:
 632                 writeconfig (dev, conf82371fb2);
 633                 break;
 634 #if 0
 635         case 0x00011011: /* DEC 21050 */
 636         case 0x00221014: /* IBM xxx */
 637                 writeconfig (dev, conf_pci2pci);
 638                 break;
 639 #endif
 640         };
 641 #endif /* PCI_QUIET */
 642 }
 643
 644 static const char *
 645 pci_bridge_type(device_t dev)
 646 {
 647     char *descr, tmpbuf[120];
 648
 649     if (pci_get_class(dev) != PCIC_BRIDGE)
 650             return NULL;
 651
 652     switch (pci_get_subclass(dev)) {
 653     case PCIS_BRIDGE_HOST:      strcpy(tmpbuf, "Host to PCI"); break;
 654     case PCIS_BRIDGE_ISA:       strcpy(tmpbuf, "PCI to ISA"); break;
 655     case PCIS_BRIDGE_EISA:      strcpy(tmpbuf, "PCI to EISA"); break;
 656     case PCIS_BRIDGE_MCA:       strcpy(tmpbuf, "PCI to MCA"); break;
 657     case PCIS_BRIDGE_PCI:       strcpy(tmpbuf, "PCI to PCI"); break;
 658     case PCIS_BRIDGE_PCMCIA:    strcpy(tmpbuf, "PCI to PCMCIA"); break;
 659     case PCIS_BRIDGE_NUBUS:     strcpy(tmpbuf, "PCI to NUBUS"); break;
 660     case PCIS_BRIDGE_CARDBUS:   strcpy(tmpbuf, "PCI to CardBus"); break;
 661     case PCIS_BRIDGE_OTHER:     strcpy(tmpbuf, "PCI to Other"); break;
 662     default:
 663             snprintf(tmpbuf, sizeof(tmpbuf),
 664                      "PCI to 0x%x", pci_get_subclass(dev));
 665             break;
 666     }
 667     snprintf(tmpbuf+strlen(tmpbuf), sizeof(tmpbuf)-strlen(tmpbuf),
 668              " bridge (vendor=%04x device=%04x)",
 669              pci_get_vendor(dev), pci_get_device(dev));
 670     descr = malloc (strlen(tmpbuf) +1, M_DEVBUF, M_WAITOK);
 671     strcpy(descr, tmpbuf);
 672     return descr;
 673 }
 674
 675 static const char*
 676 pcib_match(device_t dev)
 677 {
 678         switch (pci_get_devid(dev)) {
 679         /* Intel -- vendor 0x8086 */
 680         case 0x71818086:
 681                 return ("Intel 82443LX (440 LX) PCI-PCI (AGP) bridge");
 682         case 0x71918086:
 683                 return ("Intel 82443BX (440 BX) PCI-PCI (AGP) bridge");
 684         case 0x71A18086:
 685                 return ("Intel 82443GX (440 GX) PCI-PCI (AGP) bridge");
 686         case 0x84cb8086:
 687                 return ("Intel 82454NX PCI Expander Bridge");
 688         case 0x11318086:
 689                 return ("Intel 82801BA/BAM (ICH2) PCI-PCI (AGP) bridge");
 690         case 0x124b8086:
 691                 return ("Intel 82380FB mobile PCI to PCI bridge");
 692         case 0x24188086:
 693                 return ("Intel 82801AA (ICH) Hub to PCI bridge");
 694         case 0x24288086:
 695                 return ("Intel 82801AB (ICH0) Hub to PCI bridge");
 696         case 0x244e8086:
 697                 return ("Intel 82801BA/BAM (ICH2) Hub to PCI bridge");
 698         case 0x1a318086:
 699                 return ("Intel 82845 PCI-PCI (AGP) bridge");
 700
 701         /* VLSI -- vendor 0x1004 */
 702         case 0x01021004:
 703                 return ("VLSI 82C534 Eagle II PCI Bus bridge");
 704         case 0x01031004:
 705                 return ("VLSI 82C538 Eagle II PCI Docking bridge");
 706
 707         /* VIA Technologies -- vendor 0x1106 */
 708         case 0x83051106:
 709                 return ("VIA 8363 (Apollo KT133) PCI-PCI (AGP) bridge");
 710         case 0x85981106:
 711                 return ("VIA 82C598MVP (Apollo MVP3) PCI-PCI (AGP) bridge");
 712         /* Exclude the ACPI function of VT82Cxxx series */
 713         case 0x30401106:
 714         case 0x30501106:
 715         case 0x30571106:
 716                 return NULL;
 717
 718         /* AcerLabs -- vendor 0x10b9 */
 719         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
 720         /* id is '10b9" but the register always shows "10b9". -Foxfair  */
 721         case 0x524710b9:
 722                 return ("AcerLabs M5247 PCI-PCI(AGP Supported) bridge");
 723         case 0x524310b9:/* 5243 seems like 5247, need more info to divide*/
 724                 return ("AcerLabs M5243 PCI-PCI bridge");
 725
 726         /* AMD -- vendor 0x1022 */
 727         case 0x70071022:
 728                 return ("AMD-751 PCI-PCI (1x/2x AGP) bridge");
 729         case 0x700f1022:
 730                 return ("AMD-761 PCI-PCI (4x AGP) bridge");
 731
 732         /* DEC -- vendor 0x1011 */
 733         case 0x00011011:
 734                 return ("DEC 21050 PCI-PCI bridge");
 735         case 0x00211011:
 736                 return ("DEC 21052 PCI-PCI bridge");
 737         case 0x00221011:
 738                 return ("DEC 21150 PCI-PCI bridge");
 739         case 0x00241011:
 740                 return ("DEC 21152 PCI-PCI bridge");
 741         case 0x00251011:
 742                 return ("DEC 21153 PCI-PCI bridge");
 743         case 0x00261011:
 744                 return ("DEC 21154 PCI-PCI bridge");
 745
 746         /* NVIDIA -- vendor 0x10de */
 747         case 0x006c10de:
 748         case 0x01e810de:
 749                 return ("NVIDIA nForce2 PCI-PCI bridge");
 750
 751         /* Others */
 752         case 0x00221014:
 753                 return ("IBM 82351 PCI-PCI bridge");
 754         /* UMC United Microelectronics 0x1060 */
 755         case 0x88811060:
 756                 return ("UMC UM8881 HB4 486 PCI Chipset");
 757         };
 758
 759         if (pci_get_class(dev) == PCIC_BRIDGE
 760             && pci_get_subclass(dev) == PCIS_BRIDGE_PCI)
 761                 return pci_bridge_type(dev);
 762
 763         return NULL;
 764 }
 765
 766 static int pcib_probe(device_t dev)
 767 {
 768         const char *desc;
 769
 770         desc = pcib_match(dev);
 771         if (desc) {
 772                 device_set_desc_copy(dev, desc);
 773                 return -1000;
 774         }
 775
 776         return ENXIO;
 777 }
 778
 779 static int pcib_attach(device_t dev)
 780 {
 781         u_int8_t secondary;
 782         device_t child;
 783
 784         chipset_attach(dev, device_get_unit(dev));
 785
 786         secondary = pci_get_secondarybus(dev);
 787         if (secondary) {
 788                 child = device_add_child(dev, "pci", -1);
 789                 *(int*) device_get_softc(dev) = secondary;
 790                 return bus_generic_attach(dev);
 791         } else
 792                 return 0;
 793 }
 794
 795 static int
 796 pcib_read_ivar(device_t dev, device_t child, int which, u_long *result)
 797 {
 798         switch (which) {
 799         case PCIB_IVAR_BUS:
 800                 *result = *(int*) device_get_softc(dev);
 801                 return (0);
 802         }
 803         return (ENOENT);
 804 }
 805
 806 static int
 807 pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
 808 {
 809         switch (which) {
 810         case PCIB_IVAR_BUS:
 811                 *(int*) device_get_softc(dev) = value;
 812                 return (0);
 813         }
 814         return (ENOENT);
 815 }
 816
 817 static int
 818 pcib_maxslots(device_t dev)
 819 {
 820         return 31;
 821 }
 822
 823 static u_int32_t
 824 pcib_read_config(device_t dev, int b, int s, int f,
 825                  int reg, int width)
 826 {
 827         /*
 828          * Pass through to the next ppb up the chain (i.e. our
 829          * grandparent).
 830          */
 831         return PCIB_READ_CONFIG(device_get_parent(device_get_parent(dev)),
 832                                 b, s, f, reg, width);
 833 }
 834
 835 static void
 836 pcib_write_config(device_t dev, int b, int s, int f,
 837                   int reg, int val, int width)
 838 {
 839         /*
 840          * Pass through to the next ppb up the chain (i.e. our
 841          * grandparent).
 842          */
 843         PCIB_WRITE_CONFIG(device_get_parent(device_get_parent(dev)),
 844                                 b, s, f, reg, val, width);
 845 }
 846
 847 /*
 848  * Route an interrupt across a PCI bridge.
 849  */
 850 static int
 851 pcib_route_interrupt(device_t pcib, device_t dev, int pin)
 852 {
 853         device_t        bus;
 854         int             parent_intpin;
 855         int             intnum;
 856
 857         device_printf(pcib, "Hi!\n");
 858
 859         /*
 860          *
 861          * The PCI standard defines a swizzle of the child-side device/intpin
 862          * to the parent-side intpin as follows.
 863          *
 864          * device = device on child bus
 865          * child_intpin = intpin on child bus slot (0-3)
 866          * parent_intpin = intpin on parent bus slot (0-3)
 867          *
 868          * parent_intpin = (device + child_intpin) % 4
 869          */
 870         parent_intpin = (pci_get_slot(pcib) + (pin - 1)) % 4;
 871
 872         /*
 873          * Our parent is a PCI bus.  Its parent must export the pci interface
 874          * which includes the ability to route interrupts.
 875          */
 876         bus = device_get_parent(pcib);
 877         intnum = PCI_ROUTE_INTERRUPT(device_get_parent(bus), pcib,
 878             parent_intpin + 1);
 879         device_printf(pcib, "routed slot %d INT%c to irq %d\n",
 880             pci_get_slot(dev), 'A' + pin - 1, intnum);
 881         return(intnum);
 882 }
 883
 884 static device_method_t pcib_methods[] = {
 885         /* Device interface */
 886         DEVMETHOD(device_probe,         pcib_probe),
 887         DEVMETHOD(device_attach,        pcib_attach),
 888         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 889         DEVMETHOD(device_suspend,       bus_generic_suspend),
 890         DEVMETHOD(device_resume,        bus_generic_resume),
 891
 892         /* Bus interface */
 893         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 894         DEVMETHOD(bus_read_ivar,        pcib_read_ivar),
 895         DEVMETHOD(bus_write_ivar,       pcib_write_ivar),
 896         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
 897         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
 898         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 899         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 900         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
 901         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 902
 903         /* pci interface */
 904         DEVMETHOD(pci_route_interrupt,  pcib_route_interrupt),
 905
 906         /* pcib interface */
 907         DEVMETHOD(pcib_maxslots,        pcib_maxslots),
 908         DEVMETHOD(pcib_read_config,     pcib_read_config),
 909         DEVMETHOD(pcib_write_config,    pcib_write_config),
 910
 911         { 0, 0 }
 912 };
 913
 914 static driver_t pcib_driver = {
 915         "pcib",
 916         pcib_methods,
 917         sizeof(int),
 918 };
 919
 920 static devclass_t pcib_devclass;
 921
 922 DRIVER_MODULE(pcib, pci, pcib_driver, pcib_devclass, 0, 0);
 923
 924 static const char *
 925 eisab_match(device_t dev)
 926 {
 927         switch (pci_get_devid(dev)) {
 928         case 0x04828086:
 929                 /* Recognize this specifically, it has PCI-HOST class (!) */
 930                 return ("Intel 82375EB PCI-EISA bridge");
 931         }
 932         if (pci_get_class(dev) == PCIC_BRIDGE
 933             && pci_get_subclass(dev) == PCIS_BRIDGE_EISA)
 934                 return pci_bridge_type(dev);
 935
 936         return NULL;
 937 }
 938
 939 static const char *
 940 isab_match(device_t dev)
 941 {
 942         unsigned        rev;
 943
 944         switch (pci_get_devid(dev)) {
 945         case 0x04848086:
 946                 rev = pci_get_revid(dev);
 947                 if (rev == 3)
 948                     return ("Intel 82378ZB PCI to ISA bridge");
 949                 return ("Intel 82378IB PCI to ISA bridge");
 950         case 0x122e8086:
 951                 return ("Intel 82371FB PCI to ISA bridge");
 952         case 0x70008086:
 953                 return ("Intel 82371SB PCI to ISA bridge");
 954         case 0x71108086:
 955                 return ("Intel 82371AB PCI to ISA bridge");
 956         case 0x71988086:
 957                 return ("Intel 82443MX PCI to ISA bridge");
 958         case 0x24108086:
 959                 return ("Intel 82801AA (ICH) PCI to LPC bridge");
 960         case 0x24208086:
 961                 return ("Intel 82801AB (ICH0) PCI to LPC bridge");
 962         case 0x24408086:
 963                 return ("Intel 82801BA/BAM (ICH2) PCI to LPC bridge");
 964
 965         /* NVIDIA -- vendor 0x10de */
 966         case 0x006010de:
 967                 return ("NVIDIA nForce2 PCI to ISA bridge");
 968
 969         /* VLSI -- vendor 0x1004 */
 970         case 0x00061004:
 971                 return ("VLSI 82C593 PCI to ISA bridge");
 972
 973         /* VIA Technologies -- vendor 0x1106 */
 974         case 0x05861106: /* south bridge section */
 975                 return ("VIA 82C586 PCI-ISA bridge");
 976         case 0x05961106:
 977                 return ("VIA 82C596B PCI-ISA bridge");
 978         case 0x06861106:
 979                 return ("VIA 82C686 PCI-ISA bridge");
 980
 981         /* AcerLabs -- vendor 0x10b9 */
 982         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
 983         /* id is '10b9" but the register always shows "10b9". -Foxfair  */
 984         case 0x153310b9:
 985                 return ("AcerLabs M1533 portable PCI-ISA bridge");
 986         case 0x154310b9:
 987                 return ("AcerLabs M1543 desktop PCI-ISA bridge");
 988
 989         /* SiS -- vendor 0x1039 */
 990         case 0x00081039:
 991                 return ("SiS 85c503 PCI-ISA bridge");
 992
 993         /* Cyrix -- vendor 0x1078 */
 994         case 0x00001078:
 995                 return ("Cyrix Cx5510 PCI-ISA bridge");
 996         case 0x01001078:
 997                 return ("Cyrix Cx5530 PCI-ISA bridge");
 998
 999         /* NEC -- vendor 0x1033 */
1000         /* The "C-bus" is 16-bits bus on PC98. */
1001         case 0x00011033:
1002                 return ("NEC 0001 PCI to PC-98 C-bus bridge");
1003         case 0x002c1033:
1004                 return ("NEC 002C PCI to PC-98 C-bus bridge");
1005         case 0x003b1033:
1006                 return ("NEC 003B PCI to PC-98 C-bus bridge");
1007         /* UMC United Microelectronics 0x1060 */
1008         case 0x886a1060:
1009                 return ("UMC UM8886 ISA Bridge with EIDE");
1010
1011         /* Cypress -- vendor 0x1080 */
1012         case 0xc6931080:
1013                 if (pci_get_class(dev) == PCIC_BRIDGE
1014                     && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)
1015                         return ("Cypress 82C693 PCI-ISA bridge");
1016                 break;
1017
1018         /* ServerWorks -- vendor 0x1166 */
1019         case 0x02001166:
1020                 return ("ServerWorks IB6566 PCI to ISA bridge");
1021         }
1022
1023         if (pci_get_class(dev) == PCIC_BRIDGE
1024             && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)
1025                 return pci_bridge_type(dev);
1026
1027         return NULL;
1028 }
1029
1030 static int
1031 isab_probe(device_t dev)
1032 {
1033         const char *desc;
1034         int     is_eisa;
1035
1036         is_eisa = 0;
1037         desc = eisab_match(dev);
1038         if (desc)
1039                 is_eisa = 1;
1040         else
1041                 desc = isab_match(dev);
1042         if (desc) {
1043                 /*
1044                  * For a PCI-EISA bridge, add both eisa and isa.
1045                  * Only add one instance of eisa or isa for now.
1046                  */
1047                 device_set_desc_copy(dev, desc);
1048                 if (is_eisa && !devclass_get_device(devclass_find("eisa"), 0))
1049                         device_add_child(dev, "eisa", -1);
1050
1051                 if (!devclass_get_device(devclass_find("isa"), 0))
1052                         device_add_child(dev, "isa", -1);
1053                 return -1000;
1054         }
1055         return ENXIO;
1056 }
1057
1058 static int
1059 isab_attach(device_t dev)
1060 {
1061         chipset_attach(dev, device_get_unit(dev));
1062         return bus_generic_attach(dev);
1063 }
1064
1065 static device_method_t isab_methods[] = {
1066         /* Device interface */
1067         DEVMETHOD(device_probe,         isab_probe),
1068         DEVMETHOD(device_attach,        isab_attach),
1069         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
1070         DEVMETHOD(device_suspend,       bus_generic_suspend),
1071         DEVMETHOD(device_resume,        bus_generic_resume),
1072
1073         /* Bus interface */
1074         DEVMETHOD(bus_print_child,      bus_generic_print_child),
1075         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
1076         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
1077         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1078         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1079         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
1080         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
1081
1082         { 0, 0 }
1083 };
1084
1085 static driver_t isab_driver = {
1086         "isab",
1087         isab_methods,
1088         1,
1089 };
1090
1091 static devclass_t isab_devclass;
1092
1093 DRIVER_MODULE(isab, pci, isab_driver, isab_devclass, 0, 0);
1094
1095 const char *
1096 pci_usb_match(device_t dev)
1097 {
1098         switch (pci_get_devid(dev)) {
1099
1100         /* Intel -- vendor 0x8086 */
1101         case 0x70208086:
1102                 return ("Intel 82371SB (PIIX3) USB controller");
1103         case 0x71128086:
1104                 return ("Intel 82371AB/EB (PIIX4) USB controller");
1105         case 0x24128086:
1106                 return ("Intel 82801AA (ICH) USB controller");
1107         case 0x24228086:
1108                 return ("Intel 82801AB (ICH0) USB controller");
1109         case 0x24428086:
1110                 return ("Intel 82801BA/BAM (ICH2) USB controller USB-A");
1111         case 0x24448086:
1112                 return ("Intel 82801BA/BAM (ICH2) USB controller USB-B");
1113
1114         /* VIA Technologies -- vendor 0x1106 (0x1107 on the Apollo Master) */
1115         case 0x30381106:
1116                 return ("VIA 83C572 USB controller");
1117
1118         /* AcerLabs -- vendor 0x10b9 */
1119         case 0x523710b9:
1120                 return ("AcerLabs M5237 (Aladdin-V) USB controller");
1121
1122         /* OPTi -- vendor 0x1045 */
1123         case 0xc8611045:
1124                 return ("OPTi 82C861 (FireLink) USB controller");
1125
1126         /* NEC -- vendor 0x1033 */
1127         case 0x00351033:
1128                 return ("NEC uPD 9210 USB controller");
1129
1130         /* CMD Tech -- vendor 0x1095 */
1131         case 0x06701095:
1132                 return ("CMD Tech 670 (USB0670) USB controller");
1133         case 0x06731095:
1134                 return ("CMD Tech 673 (USB0673) USB controller");
1135         }
1136
1137         if (pci_get_class(dev) == PCIC_SERIALBUS
1138             && pci_get_subclass(dev) == PCIS_SERIALBUS_USB) {
1139                 if (pci_get_progif(dev) == 0x00 /* UHCI */ ) {
1140                         return ("UHCI USB controller");
1141                 } else if (pci_get_progif(dev) == 0x10 /* OHCI */ ) {
1142                         return ("OHCI USB controller");
1143                 } else {
1144                         return ("USB controller");
1145                 }
1146         }
1147         return NULL;
1148 }
1149
1150 const char *
1151 pci_ata_match(device_t dev)
1152 {
1153
1154         switch (pci_get_devid(dev)) {
1155
1156         /* Intel -- vendor 0x8086 */
1157         case 0x12308086:
1158                 return ("Intel PIIX ATA controller");
1159         case 0x70108086:
1160                 return ("Intel PIIX3 ATA controller");
1161         case 0x71118086:
1162                 return ("Intel PIIX4 ATA controller");
1163         case 0x12348086:
1164                 return ("Intel 82371MX mobile PCI ATA accelerator (MPIIX)");
1165
1166         /* Promise -- vendor 0x105a */
1167         case 0x4d33105a:
1168                 return ("Promise Ultra/33 ATA controller");
1169         case 0x4d38105a:
1170                 return ("Promise Ultra/66 ATA controller");
1171
1172         /* AcerLabs -- vendor 0x10b9 */
1173         case 0x522910b9:
1174                 return ("AcerLabs Aladdin ATA controller");
1175
1176         /* VIA Technologies -- vendor 0x1106 (0x1107 on the Apollo Master) */
1177         case 0x05711106:
1178                 switch (pci_read_config(dev, 0x08, 1)) {
1179                 case 1:
1180                         return ("VIA 85C586 ATA controller");
1181                 case 6:
1182                         return ("VIA 85C586 ATA controller");
1183                 }
1184                 /* FALL THROUGH */
1185         case 0x15711106:
1186                 return ("VIA Apollo ATA controller");
1187
1188         /* CMD Tech -- vendor 0x1095 */
1189         case 0x06401095:
1190                 return ("CMD 640 ATA controller");
1191         case 0x06461095:
1192                 return ("CMD 646 ATA controller");
1193
1194         /* Cypress -- vendor 0x1080 */
1195         case 0xc6931080:
1196                 return ("Cypress 82C693 ATA controller");
1197
1198         /* Cyrix -- vendor 0x1078 */
1199         case 0x01021078:
1200                 return ("Cyrix 5530 ATA controller");
1201
1202         /* SiS -- vendor 0x1039 */
1203         case 0x55131039:
1204                 return ("SiS 5591 ATA controller");
1205
1206         /* Highpoint tech -- vendor 0x1103 */
1207         case 0x00041103:
1208                 return ("HighPoint HPT366 ATA controller");
1209         }
1210
1211         if (pci_get_class(dev) == PCIC_STORAGE &&
1212             pci_get_subclass(dev) == PCIS_STORAGE_IDE)
1213                 return ("Unknown PCI ATA controller");
1214
1215         return NULL;
1216 }
1217
1218
1219 const char*
1220 pci_chip_match(device_t dev)
1221 {
1222         unsigned        rev;
1223
1224         switch (pci_get_devid(dev)) {
1225         /* Intel -- vendor 0x8086 */
1226         case 0x00088086:
1227                 /* Silently ignore this one! What is it, anyway ??? */
1228                 return ("");
1229         case 0x71108086:
1230                 /*
1231                  * On my laptop (Tecra 8000DVD), this device has a
1232                  * bogus subclass 0x80 so make sure that it doesn't
1233                  * match the generic 'chip' driver by accident.
1234                  */
1235                 return NULL;
1236         case 0x12258086:
1237                 fixbushigh_i1225(dev);
1238                 return ("Intel 824?? host to PCI bridge");
1239         case 0x71808086:
1240                 return ("Intel 82443LX (440 LX) host to PCI bridge");
1241         case 0x71908086:
1242                 return ("Intel 82443BX (440 BX) host to PCI bridge");
1243         case 0x71928086:
1244                 return ("Intel 82443BX host to PCI bridge (AGP disabled)");
1245         case 0x71a08086:
1246                 return ("Intel 82443GX host to PCI bridge");
1247         case 0x71a18086:
1248                 return ("Intel 82443GX host to AGP bridge");
1249         case 0x71a28086:
1250                 return ("Intel 82443GX host to PCI bridge (AGP disabled)");
1251         case 0x84c48086:
1252                 return ("Intel 82454KX/GX (Orion) host to PCI bridge");
1253         case 0x84ca8086:
1254                 return ("Intel 82451NX Memory and I/O controller");
1255         case 0x04868086:
1256                 return ("Intel 82425EX PCI system controller");
1257         case 0x04838086:
1258                 return ("Intel 82424ZX (Saturn) cache DRAM controller");
1259         case 0x04a38086:
1260                 rev = pci_get_revid(dev);
1261                 if (rev == 16 || rev == 17)
1262                     return ("Intel 82434NX (Neptune) PCI cache memory controller");
1263                 return ("Intel 82434LX (Mercury) PCI cache memory controller");
1264         case 0x122d8086:
1265                 return ("Intel 82437FX PCI cache memory controller");
1266         case 0x12358086:
1267                 return ("Intel 82437MX mobile PCI cache memory controller");
1268         case 0x12508086:
1269                 return ("Intel 82439HX PCI cache memory controller");
1270         case 0x70308086:
1271                 return ("Intel 82437VX PCI cache memory controller");
1272         case 0x71008086:
1273                 return ("Intel 82439TX System controller (MTXC)");
1274         case 0x71138086:
1275                 return ("Intel 82371AB Power management controller");
1276         case 0x719b8086:
1277                 return ("Intel 82443MX Power management controller");
1278         case 0x12378086:
1279                 fixwsc_natoma(dev);
1280                 return ("Intel 82440FX (Natoma) PCI and memory controller");
1281         case 0x84c58086:
1282                 return ("Intel 82453KX/GX (Orion) PCI memory controller");
1283         case 0x71208086:
1284                 return ("Intel 82810 (i810 GMCH) Host To Hub bridge");
1285         case 0x71228086:
1286         return ("Intel 82810-DC100 (i810-DC100 GMCH) Host To Hub bridge");
1287         case 0x71248086:
1288         return ("Intel 82810E (i810E GMCH) Host To Hub bridge");
1289         case 0x24158086:
1290                 return ("Intel 82801AA (ICH) AC'97 Audio Controller");
1291         case 0x24258086:
1292                 return ("Intel 82801AB (ICH0) AC'97 Audio Controller");
1293
1294         /* Sony -- vendor 0x104d */
1295         case 0x8009104d:
1296                 return ("Sony CXD1947A FireWire Host Controller");
1297
1298         /* SiS -- vendor 0x1039 */
1299         case 0x04961039:
1300                 return ("SiS 85c496 PCI/VL Bridge");
1301         case 0x04061039:
1302                 return ("SiS 85c501");
1303         case 0x06011039:
1304                 return ("SiS 85c601");
1305         case 0x55911039:
1306                 return ("SiS 5591 host to PCI bridge");
1307         case 0x00011039:
1308                 return ("SiS 5591 host to AGP bridge");
1309
1310         /* VLSI -- vendor 0x1004 */
1311         case 0x00051004:
1312                 return ("VLSI 82C592 Host to PCI bridge");
1313         case 0x01011004:
1314                 return ("VLSI 82C532 Eagle II Peripheral controller");
1315         case 0x01041004:
1316                 return ("VLSI 82C535 Eagle II System controller");
1317         case 0x01051004:
1318                 return ("VLSI 82C147 IrDA controller");
1319
1320         /* VIA Technologies -- vendor 0x1106 (0x1107 on the Apollo Master) */
1321         case 0x15761107:
1322                 return ("VIA 82C570 (Apollo Master) system controller");
1323         case 0x05851106:
1324                 return ("VIA 82C585 (Apollo VP1/VPX) system controller");
1325         case 0x05951106:
1326         case 0x15951106:
1327                 return ("VIA 82C595 (Apollo VP2) system controller");
1328         case 0x05971106:
1329                 return ("VIA 82C597 (Apollo VP3) system controller");
1330         /* XXX Here is MVP3, I got the datasheet but NO M/B to test it  */
1331         /* totally. Please let me know if anything wrong.            -F */
1332         /* XXX need info on the MVP3 -- any takers? */
1333         case 0x05981106:
1334                 return ("VIA 82C598MVP (Apollo MVP3) host bridge");
1335         case 0x30401106:
1336         case 0x30501106:
1337         case 0x30571106:
1338                 return NULL;
1339         case 0x30581106:
1340                 return ("VIA 82C686 AC97 Audio");
1341         case 0x30681106:
1342                 return ("VIA 82C686 AC97 Modem");
1343
1344         /* AMD -- vendor 0x1022 */
1345         case 0x70061022:
1346                 return ("AMD-751 host to PCI bridge");
1347         case 0x700e1022:
1348                 return ("AMD-761 host to PCI bridge");
1349
1350         /* NEC -- vendor 0x1033 */
1351         case 0x00021033:
1352                 return ("NEC 0002 PCI to PC-98 local bus bridge");
1353         case 0x00161033:
1354                 return ("NEC 0016 PCI to PC-98 local bus bridge");
1355
1356         /* AcerLabs -- vendor 0x10b9 */
1357         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
1358         /* id is '10b9" but the register always shows "10b9". -Foxfair  */
1359         case 0x154110b9:
1360                 return ("AcerLabs M1541 (Aladdin-V) PCI host bridge");
1361         case 0x710110b9:
1362                 return ("AcerLabs M15x3 Power Management Unit");
1363
1364         /* OPTi -- vendor 0x1045 */
1365         case 0xc5571045:
1366                 return ("Opti 82C557 (Viper-M) host to PCI bridge");
1367         case 0xc5581045:
1368                 return ("Opti 82C558 (Viper-M) ISA+IDE");
1369         case 0xc8221045:
1370                 return ("OPTi 82C822 host to PCI Bridge");
1371
1372         /* Texas Instruments -- vendor 0x104c */
1373         case 0xac1c104c:
1374                 return ("Texas Instruments PCI1225 CardBus controller");
1375         case 0xac50104c:
1376                 return ("Texas Instruments PCI1410 CardBus controller");
1377         case 0xac51104c:
1378                 return ("Texas Instruments PCI1420 CardBus controller");
1379         case 0xac1b104c:
1380                 return ("Texas Instruments PCI1450 CardBus controller");
1381         case 0xac52104c:
1382                 return ("Texas Instruments PCI1451 CardBus controller");
1383
1384         /* NeoMagic -- vendor 0x10c8 */
1385         case 0x800510c8:
1386                 return ("NeoMagic MagicMedia 256AX Audio controller");
1387         case 0x800610c8:
1388                 return ("NeoMagic MagicMedia 256ZX Audio controller");
1389
1390         /* ESS Technology Inc -- vendor 0x125d */
1391         case 0x1978125d:
1392                 return ("ESS Technology Maestro 2E Audio controller");
1393
1394         /* Toshiba -- vendor 0x1179 */
1395         case 0x07011179:
1396                 return ("Toshiba Fast Infra Red controller");
1397
1398         /* NEC -- vendor 0x1033 */
1399
1400         /* PCI to C-bus bridge */
1401         /* The following chipsets are PCI to PC98 C-bus bridge.
1402          * The C-bus is the 16-bits bus on PC98 and it should be probed as
1403          * PCI to ISA bridge.  Because class of the C-bus is not defined,
1404          * C-bus bridges are recognized as "other bridge."  To make C-bus
1405          * bridge be recognized as ISA bridge, this function returns NULL.
1406          */
1407         case 0x00011033:
1408         case 0x002c1033:
1409         case 0x003b1033:
1410                 return NULL;
1411         };
1412
1413         if (pci_get_class(dev) == PCIC_BRIDGE
1414             && pci_get_subclass(dev) != PCIS_BRIDGE_PCI
1415             && pci_get_subclass(dev) != PCIS_BRIDGE_ISA
1416             && pci_get_subclass(dev) != PCIS_BRIDGE_EISA)
1417                 return pci_bridge_type(dev);
1418
1419         return NULL;
1420 }
1421
1422 /*---------------------------------------------------------
1423 **
1424 **      Catchall driver for VGA devices
1425 **
1426 **      By Garrett Wollman
1427 **      <wollman@halloran-eldar.lcs.mit.edu>
1428 **
1429 **---------------------------------------------------------
1430 */
1431
1432 const char* pci_vga_match(device_t dev)
1433 {
1434         u_int id = pci_get_devid(dev);
1435         const char *vendor, *chip, *type;
1436
1437         vendor = chip = type = 0;
1438         switch (id & 0xffff) {
1439         case 0x003d:
1440                 vendor = "Real 3D";
1441                 switch (id >> 16) {
1442                 case 0x00d1:
1443                         chip = "i740"; break;
1444                 }
1445                 break;
1446         case 0x10c8:
1447                 vendor = "NeoMagic";
1448                 switch (id >> 16) {
1449                 case 0x0003:
1450                         chip = "MagicGraph 128ZV"; break;
1451                 case 0x0004:
1452                         chip = "MagicGraph 128XD"; break;
1453                 case 0x0005:
1454                         chip = "MagicMedia 256AV"; break;
1455                 case 0x0006:
1456                         chip = "MagicMedia 256ZX"; break;
1457                 }
1458                 break;
1459         case 0x121a:
1460                 vendor = "3Dfx";
1461                 type = "graphics accelerator";
1462                 switch (id >> 16) {
1463                 case 0x0001:
1464                         chip = "Voodoo"; break;
1465                 case 0x0002:
1466                         chip = "Voodoo 2"; break;
1467                 case 0x0003:
1468                         chip = "Voodoo Banshee"; break;
1469                 case 0x0005:
1470                         chip = "Voodoo 3"; break;
1471                 }
1472                 break;
1473         case 0x102b:
1474                 vendor = "Matrox";
1475                 type = "graphics accelerator";
1476                 switch (id >> 16) {
1477                 case 0x0518:
1478                         chip = "MGA 2085PX"; break;
1479                 case 0x0519:
1480                         chip = "MGA Millennium 2064W"; break;
1481                 case 0x051a:
1482                         chip = "MGA 1024SG/1064SG/1164SG"; break;
1483                 case 0x051b:
1484                         chip = "MGA Millennium II 2164W"; break;
1485                 case 0x051f:
1486                         chip = "MGA Millennium II 2164WA-B AG"; break;
1487                 case 0x0520:
1488                         chip = "MGA G200"; break;
1489                 case 0x0521:
1490                         chip = "MGA G200 AGP"; break;
1491                 case 0x0525:
1492                         chip = "MGA G400 AGP"; break;
1493                 case 0x0d10:
1494                         chip = "MGA Impression"; break;
1495                 case 0x1000:
1496                         chip = "MGA G100"; break;
1497                 case 0x1001:
1498                         chip = "MGA G100 AGP"; break;
1499                 case 0x2527:
1500                         chip = "MGA G550 AGP"; break;
1501
1502                 }
1503                 break;
1504         case 0x1002:
1505                 vendor = "ATI";
1506                 type = "graphics accelerator";
1507                 switch (id >> 16) {
1508                 case 0x4158:
1509                         chip = "Mach32"; break;
1510                 case 0x4354:
1511                         chip = "Mach64-CT"; break;
1512                 case 0x4358:
1513                         chip = "Mach64-CX"; break;
1514                 case 0x4554:
1515                         chip = "Mach64-ET"; break;
1516                 case 0x4654:
1517                 case 0x5654:
1518                         chip = "Mach64-VT"; break;
1519                 case 0x4742:
1520                         chip = "Mach64-GB"; break;
1521                 case 0x4744:
1522                         chip = "Mach64-GD"; break;
1523                 case 0x4749:
1524                         chip = "Mach64-GI"; break;
1525                 case 0x474d:
1526                         chip = "Mach64-GM"; break;
1527                 case 0x474e:
1528                         chip = "Mach64-GN"; break;
1529                 case 0x474f:
1530                         chip = "Mach64-GO"; break;
1531                 case 0x4750:
1532                         chip = "Mach64-GP"; break;
1533                 case 0x4751:
1534                         chip = "Mach64-GQ"; break;
1535                 case 0x4752:
1536                         chip = "Mach64-GR"; break;
1537                 case 0x4753:
1538                         chip = "Mach64-GS"; break;
1539                 case 0x4754:
1540                         chip = "Mach64-GT"; break;
1541                 case 0x4755:
1542                         chip = "Mach64-GU"; break;
1543                 case 0x4756:
1544                         chip = "Mach64-GV"; break;
1545                 case 0x4757:
1546                         chip = "Mach64-GW"; break;
1547                 case 0x4758:
1548                         chip = "Mach64-GX"; break;
1549                 case 0x4c4d:
1550                         chip = "Mobility-1"; break;
1551                 case 0x4c52:
1552                         chip = "RageMobility-P/M"; break;
1553                 case 0x475a:
1554                         chip = "Mach64-GZ"; break;
1555                 case 0x5245:
1556                         chip = "Rage128-RE"; break;
1557                 case 0x5246:
1558                         chip = "Rage128-RF"; break;
1559                 case 0x524b:
1560                         chip = "Rage128-RK"; break;
1561                 case 0x524c:
1562                         chip = "Rage128-RL"; break;
1563                 }
1564                 break;
1565         case 0x1005:
1566                 vendor = "Avance Logic";
1567                 switch (id >> 16) {
1568                 case 0x2301:
1569                         chip = "ALG2301"; break;
1570                 case 0x2302:
1571                         chip = "ALG2302"; break;
1572                 }
1573                 break;
1574         case 0x100c:
1575                 vendor = "Tseng Labs";
1576                 type = "graphics accelerator";
1577                 switch (id >> 16) {
1578                 case 0x3202:
1579                 case 0x3205:
1580                 case 0x3206:
1581                 case 0x3207:
1582                         chip = "ET4000 W32P"; break;
1583                 case 0x3208:
1584                         chip = "ET6000/ET6100"; break;
1585                 case 0x4702:
1586                         chip = "ET6300"; break;
1587                 }
1588                 break;
1589         case 0x100e:
1590                 vendor = "Weitek";
1591                 type = "graphics accelerator";
1592                 switch (id >> 16) {
1593                 case 0x9001:
1594                         chip = "P9000"; break;
1595                 case 0x9100:
1596                         chip = "P9100"; break;
1597                 }
1598                 break;
1599         case 0x1013:
1600                 vendor = "Cirrus Logic";
1601                 switch (id >> 16) {
1602                 case 0x0038:
1603                         chip = "GD7548"; break;
1604                 case 0x0040:
1605                         chip = "GD7555"; break;
1606                 case 0x004c:
1607                         chip = "GD7556"; break;
1608                 case 0x00a0:
1609                         chip = "GD5430"; break;
1610                 case 0x00a4:
1611                 case 0x00a8:
1612                         chip = "GD5434"; break;
1613                 case 0x00ac:
1614                         chip = "GD5436"; break;
1615                 case 0x00b8:
1616                         chip = "GD5446"; break;
1617                 case 0x00bc:
1618                         chip = "GD5480"; break;
1619                 case 0x00d0:
1620                         chip = "GD5462"; break;
1621                 case 0x00d4:
1622                 case 0x00d5:
1623                         chip = "GD5464"; break;
1624                 case 0x00d6:
1625                         chip = "GD5465"; break;
1626                 case 0x1200:
1627                         chip = "GD7542"; break;
1628                 case 0x1202:
1629                         chip = "GD7543"; break;
1630                 case 0x1204:
1631                         chip = "GD7541"; break;
1632                 }
1633                 break;
1634         case 0x1023:
1635                 vendor = "Trident";
1636                 break;          /* let default deal with it */
1637         case 0x102c:
1638                 vendor = "Chips & Technologies";
1639                 switch (id >> 16) {
1640                 case 0x00b8:
1641                         chip = "64310"; break;
1642                 case 0x00d8:
1643                         chip = "65545"; break;
1644                 case 0x00dc:
1645                         chip = "65548"; break;
1646                 case 0x00c0:
1647                         chip = "69000"; break;
1648                 case 0x00e0:
1649                         chip = "65550"; break;
1650                 case 0x00e4:
1651                         chip = "65554"; break;
1652                 case 0x00e5:
1653                         chip = "65555"; break;
1654                 case 0x00f4:
1655                         chip = "68554"; break;
1656                 }
1657                 break;
1658         case 0x1033:
1659                 vendor = "NEC";
1660                 switch (id >> 16) {
1661                 case 0x0009:
1662                         type = "PCI to PC-98 Core Graph bridge";
1663                         break;
1664                 }
1665                 break;
1666         case 0x1039:
1667                 vendor = "SiS";
1668                 switch (id >> 16) {
1669                 case 0x0001:
1670                         chip = "86c201"; break;
1671                 case 0x0002:
1672                         chip = "86c202"; break;
1673                 case 0x0205:
1674                         chip = "86c205"; break;
1675                 case 0x0215:
1676                         chip = "86c215"; break;
1677                 case 0x0225:
1678                         chip = "86c225"; break;
1679                 case 0x0200:
1680                         chip = "5597/98"; break;
1681                 case 0x6326:
1682                         chip = "6326"; break;
1683                 case 0x6306:
1684                         chip = "530/620"; break;
1685                 }
1686                 break;
1687         case 0x105d:
1688                 vendor = "Number Nine";
1689                 type = "graphics accelerator";
1690                 switch (id >> 16) {
1691                 case 0x2309:
1692                         chip = "Imagine 128"; break;
1693                 case 0x2339:
1694                         chip = "Imagine 128 II"; break;
1695                 }
1696                 break;
1697         case 0x1142:
1698                 vendor = "Alliance";
1699                 switch (id >> 16) {
1700                 case 0x3210:
1701                         chip = "PM6410"; break;
1702                 case 0x6422:
1703                         chip = "PM6422"; break;
1704                 case 0x6424:
1705                         chip = "PMAT24"; break;
1706                 }
1707                 break;
1708         case 0x1163:
1709                 vendor = "Rendition Verite";
1710                 switch (id >> 16) {
1711                 case 0x0001:
1712                         chip = "V1000"; break;
1713                 case 0x2000:
1714                         chip = "V2000"; break;
1715                 }
1716                 break;
1717         case 0x1236:
1718                 vendor = "Sigma Designs";
1719                 if ((id >> 16) == 0x6401)
1720                         chip = "REALmagic64/GX";
1721                 break;
1722         case 0x5333:
1723                 vendor = "S3";
1724                 type = "graphics accelerator";
1725                 switch (id >> 16) {
1726                 case 0x8811:
1727                         chip = "Trio"; break;
1728                 case 0x8812:
1729                         chip = "Aurora 64"; break;
1730                 case 0x8814:
1731                         chip = "Trio 64UV+"; break;
1732                 case 0x8901:
1733                         chip = "Trio 64V2/DX/GX"; break;
1734                 case 0x8902:
1735                         chip = "Plato"; break;
1736                 case 0x8904:
1737                         chip = "Trio3D"; break;
1738                 case 0x8880:
1739                         chip = "868"; break;
1740                 case 0x88b0:
1741                         chip = "928"; break;
1742                 case 0x88c0:
1743                 case 0x88c1:
1744                         chip = "864"; break;
1745                 case 0x88d0:
1746                 case 0x88d1:
1747                         chip = "964"; break;
1748                 case 0x88f0:
1749                         chip = "968"; break;
1750                 case 0x5631:
1751                         chip = "ViRGE"; break;
1752                 case 0x883d:
1753                         chip = "ViRGE VX"; break;
1754                 case 0x8a01:
1755                         chip = "ViRGE DX/GX"; break;
1756                 case 0x8a10:
1757                         chip = "ViRGE GX2"; break;
1758                 case 0x8a13:
1759                         chip = "Trio3D/2X"; break;
1760                 case 0x8a20:
1761                 case 0x8a21:
1762                         chip = "Savage3D"; break;
1763                 case 0x8a22:
1764                         chip = "Savage 4"; break;
1765                 case 0x8c01:
1766                         chip = "ViRGE MX"; break;
1767                 case 0x8c03:
1768                         chip = "ViRGE MX+"; break;
1769                 }
1770                 break;
1771         case 0xedd8:
1772                 vendor = "ARK Logic";
1773                 switch (id >> 16) {
1774                 case 0xa091:
1775                         chip = "1000PV"; break;
1776                 case 0xa099:
1777                         chip = "2000PV"; break;
1778                 case 0xa0a1:
1779                         chip = "2000MT"; break;
1780                 case 0xa0a9:
1781                         chip = "2000MI"; break;
1782                 }
1783                 break;
1784         case 0x3d3d:
1785                 vendor = "3D Labs";
1786                 type = "graphics accelerator";
1787                 switch (id >> 16) {
1788                 case 0x0001:
1789                         chip = "300SX"; break;
1790                 case 0x0002:
1791                         chip = "500TX"; break;
1792                 case 0x0003:
1793                         chip = "Delta"; break;
1794                 case 0x0004:
1795                         chip = "PerMedia"; break;
1796                 }
1797                 break;
1798         case 0x10de:
1799                 vendor = "NVidia";
1800                 type = "graphics accelerator";
1801                 switch (id >> 16) {
1802                 case 0x0008:
1803                         chip = "NV1"; break;
1804                 case 0x0020:
1805                         chip = "Riva TNT"; break;
1806                 case 0x0028:
1807                         chip = "Riva TNT2"; break;
1808                 case 0x0029:
1809                         chip = "Riva Ultra TNT2"; break;
1810                 case 0x002c:
1811                         chip = "Riva Vanta TNT2"; break;
1812                 case 0x002d:
1813                         chip = "Riva Ultra Vanta TNT2"; break;
1814                 case 0x00a0:
1815                         chip = "Riva Integrated TNT2"; break;
1816                 case 0x0100:
1817                         chip = "GeForce 256"; break;
1818                 case 0x0101:
1819                         chip = "GeForce DDR"; break;
1820                 case 0x0103:
1821                         chip = "Quadro"; break;
1822                 case 0x0150:
1823                 case 0x0151:
1824                 case 0x0152:
1825                         chip = "GeForce2 GTS"; break;
1826                 case 0x0153:
1827                         chip = "Quadro2"; break;
1828                 }
1829                 break;
1830         case 0x12d2:
1831                 vendor = "NVidia/SGS-Thomson";
1832                 type = "graphics accelerator";
1833                 switch (id >> 16) {
1834                 case 0x0018:
1835                         chip = "Riva128"; break;
1836                 }
1837                 break;
1838         case 0x104a:
1839                 vendor = "SGS-Thomson";
1840                 switch (id >> 16) {
1841                 case 0x0008:
1842                         chip = "STG2000"; break;
1843                 }
1844                 break;
1845         case 0x8086:
1846                 vendor = "Intel";
1847                 switch (id >> 16) {
1848                 case 0x7121:
1849                         chip = "82810 (i810 GMCH)"; break;
1850                 case 0x7123:
1851                         chip = "82810-DC100 (i810-DC100 GMCH)"; break;
1852                 case 0x7125:
1853                         chip = "82810E (i810E GMCH)"; break;
1854                 case 0x7800:
1855                         chip = "i740 AGP"; break;
1856                 }
1857                 break;
1858         case 0x10ea:
1859                 vendor = "Intergraphics";
1860                 switch (id >> 16) {
1861                 case 0x1680:
1862                         chip = "IGA-1680"; break;
1863                 case 0x1682:
1864                         chip = "IGA-1682"; break;
1865                 }
1866                 break;
1867         }
1868
1869         if (vendor && chip) {
1870                 char *buf;
1871                 int len;
1872
1873                 if (type == 0)
1874                         type = "SVGA controller";
1875
1876                 len = strlen(vendor) + strlen(chip) + strlen(type) + 4;
1877                 MALLOC(buf, char *, len, M_TEMP, M_NOWAIT);
1878                 if (buf)
1879                         sprintf(buf, "%s %s %s", vendor, chip, type);
1880                 return buf;
1881         }
1882
1883         switch (pci_get_class(dev)) {
1884
1885         case PCIC_OLD:
1886                 if (pci_get_subclass(dev) != PCIS_OLD_VGA)
1887                         return 0;
1888                 if (type == 0)
1889                         type = "VGA-compatible display device";
1890                 break;
1891
1892         case PCIC_DISPLAY:
1893                 if (type == 0) {
1894                         if (pci_get_subclass(dev) == PCIS_DISPLAY_VGA)
1895                                 type = "VGA-compatible display device";
1896                         else {
1897                                 /*
1898                                  * If it isn't a vga display device,
1899                                  * don't pretend we found one.
1900                                  */
1901                                 return 0;
1902                         }
1903                 }
1904                 break;
1905
1906         default:
1907                 return 0;
1908         };
1909         /*
1910          * If we got here, we know for sure it's some sort of display
1911          * device, but we weren't able to identify it specifically.
1912          * At a minimum we can return the type, but we'd like to
1913          * identify the vendor and chip ID if at all possible.
1914          * (Some of the checks above intentionally don't bother for
1915          * vendors where we know the chip ID is the same as the
1916          * model number.)
1917          */
1918         if (vendor) {
1919                 char *buf;
1920                 int len;
1921
1922                 len = strlen(vendor) + strlen(type) + 2 + 6 + 4 + 1;
1923                 MALLOC(buf, char *, len, M_TEMP, M_NOWAIT);
1924                 if (buf)
1925                         sprintf(buf, "%s model %04x %s", vendor, id >> 16, type);
1926                 return buf;
1927         }
1928         return type;
1929 }
1930
1931 /*---------------------------------------------------------
1932 **
1933 **      Devices to ignore
1934 **
1935 **---------------------------------------------------------
1936 */
1937
1938 static const char*
1939 ign_match(device_t dev)
1940 {
1941         switch (pci_get_devid(dev)) {
1942
1943         case 0x10001042ul:      /* wd */
1944                 return ("SMC FDC 37c665");
1945         };
1946
1947         return NULL;
1948 }
1949
1950 static int
1951 ign_probe(device_t dev)
1952 {
1953         const char *s;
1954
1955         s = ign_match(dev);
1956         if (s) {
1957                 device_set_desc(dev, s);
1958                 device_quiet(dev);
1959                 return -1000;
1960         }
1961         return ENXIO;
1962 }
1963
1964 static int
1965 ign_attach(device_t dev)
1966 {
1967         return 0;
1968 }
1969
1970 static device_method_t ign_methods[] = {
1971         /* Device interface */
1972         DEVMETHOD(device_probe,         ign_probe),
1973         DEVMETHOD(device_attach,        ign_attach),
1974
1975         { 0, 0 }
1976 };
1977
1978 static driver_t ign_driver = {
1979         "ign",
1980         ign_methods,
1981         1,
1982 };
1983
1984 static devclass_t ign_devclass;
1985
1986 DRIVER_MODULE(ign, pci, ign_driver, ign_devclass, 0, 0);