Add PCIR_BAR and PCIR_BARS for FreeBSD 5 compatibility
[dragonfly.git] / 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.9 2004/02/10 07:26:06 dillon 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 /*
780  * Attach a pci bus device to a motherboard or pci-to-pci bridge bus.
781  * Due to probe recursion it is possible for pci-to-pci bridges (such as
782  * on the DELL2550) to attach before all the motherboard bridges have
783  * attached.  We must call device_add_child() with the secondary id
784  * rather then -1 in order to ensure that we do not accidently use
785  * a motherboard PCI id, otherwise the device probe will believe that
786  * the later motherboard bridge bus has already been probed and refuse
787  * to probe it.  The result: disappearing busses!
788  */
789 static int pcib_attach(device_t dev)
790 {
791         u_int8_t secondary;
792         device_t child;
793
794         chipset_attach(dev, device_get_unit(dev));
795
796         secondary = pci_get_secondarybus(dev);
797         if (secondary) {
798                 child = device_add_child(dev, "pci", secondary);
799                 *(int*) device_get_softc(dev) = secondary;
800                 return bus_generic_attach(dev);
801         } else
802                 return 0;
803 }
804
805 static int
806 pcib_read_ivar(device_t dev, device_t child, int which, u_long *result)
807 {
808         switch (which) {
809         case PCIB_IVAR_BUS:
810                 *result = *(int*) device_get_softc(dev);
811                 return (0);
812         }
813         return (ENOENT);
814 }
815
816 static int
817 pcib_write_ivar(device_t dev, device_t child, int which, uintptr_t value)
818 {
819         switch (which) {
820         case PCIB_IVAR_BUS:
821                 *(int*) device_get_softc(dev) = value;
822                 return (0);
823         }
824         return (ENOENT);
825 }
826
827 static int
828 pcib_maxslots(device_t dev)
829 {
830         return 31;
831 }
832
833 static u_int32_t
834 pcib_read_config(device_t dev, int b, int s, int f,
835                  int reg, int width)
836 {
837         /*
838          * Pass through to the next ppb up the chain (i.e. our
839          * grandparent).
840          */
841         return PCIB_READ_CONFIG(device_get_parent(device_get_parent(dev)),
842                                 b, s, f, reg, width);
843 }
844
845 static void
846 pcib_write_config(device_t dev, int b, int s, int f,
847                   int reg, int val, int width)
848 {
849         /*
850          * Pass through to the next ppb up the chain (i.e. our
851          * grandparent).
852          */
853         PCIB_WRITE_CONFIG(device_get_parent(device_get_parent(dev)),
854                                 b, s, f, reg, val, width);      
855 }
856
857 /*
858  * Route an interrupt across a PCI bridge.
859  */
860 static int
861 pcib_route_interrupt(device_t pcib, device_t dev, int pin)
862 {
863         device_t        bus;
864         int             parent_intpin;
865         int             intnum;
866
867         device_printf(pcib, "Hi!\n");
868
869         /*      
870          *
871          * The PCI standard defines a swizzle of the child-side device/intpin
872          * to the parent-side intpin as follows.
873          *
874          * device = device on child bus
875          * child_intpin = intpin on child bus slot (0-3)
876          * parent_intpin = intpin on parent bus slot (0-3)
877          *
878          * parent_intpin = (device + child_intpin) % 4
879          */
880         parent_intpin = (pci_get_slot(pcib) + (pin - 1)) % 4;
881
882         /*
883          * Our parent is a PCI bus.  Its parent must export the pci interface
884          * which includes the ability to route interrupts.
885          */
886         bus = device_get_parent(pcib);
887         intnum = PCI_ROUTE_INTERRUPT(device_get_parent(bus), pcib,
888             parent_intpin + 1);
889         device_printf(pcib, "routed slot %d INT%c to irq %d\n",
890             pci_get_slot(dev), 'A' + pin - 1, intnum);
891         return(intnum);
892 }
893
894 static device_method_t pcib_methods[] = {
895         /* Device interface */
896         DEVMETHOD(device_probe,         pcib_probe),
897         DEVMETHOD(device_attach,        pcib_attach),
898         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
899         DEVMETHOD(device_suspend,       bus_generic_suspend),
900         DEVMETHOD(device_resume,        bus_generic_resume),
901
902         /* Bus interface */
903         DEVMETHOD(bus_print_child,      bus_generic_print_child),
904         DEVMETHOD(bus_read_ivar,        pcib_read_ivar),
905         DEVMETHOD(bus_write_ivar,       pcib_write_ivar),
906         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
907         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
908         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
909         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
910         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
911         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
912
913         /* pci interface */
914         DEVMETHOD(pci_route_interrupt,  pcib_route_interrupt),
915
916         /* pcib interface */
917         DEVMETHOD(pcib_maxslots,        pcib_maxslots),
918         DEVMETHOD(pcib_read_config,     pcib_read_config),
919         DEVMETHOD(pcib_write_config,    pcib_write_config),
920
921         { 0, 0 }
922 };
923
924 static driver_t pcib_driver = {
925         "pcib",
926         pcib_methods,
927         sizeof(int),
928 };
929
930 static devclass_t pcib_devclass;
931
932 DRIVER_MODULE(pcib, pci, pcib_driver, pcib_devclass, 0, 0);
933
934 static const char *
935 eisab_match(device_t dev)
936 {
937         switch (pci_get_devid(dev)) {
938         case 0x04828086:
939                 /* Recognize this specifically, it has PCI-HOST class (!) */
940                 return ("Intel 82375EB PCI-EISA bridge");
941         }
942         if (pci_get_class(dev) == PCIC_BRIDGE
943             && pci_get_subclass(dev) == PCIS_BRIDGE_EISA)
944                 return pci_bridge_type(dev);
945
946         return NULL;
947 }
948
949 static const char *
950 isab_match(device_t dev)
951 {
952         unsigned        rev;
953
954         switch (pci_get_devid(dev)) {
955         case 0x04848086:
956                 rev = pci_get_revid(dev);
957                 if (rev == 3)
958                     return ("Intel 82378ZB PCI to ISA bridge");
959                 return ("Intel 82378IB PCI to ISA bridge");
960         case 0x122e8086:
961                 return ("Intel 82371FB PCI to ISA bridge");
962         case 0x70008086:
963                 return ("Intel 82371SB PCI to ISA bridge");
964         case 0x71108086:
965                 return ("Intel 82371AB PCI to ISA bridge");
966         case 0x71988086:
967                 return ("Intel 82443MX PCI to ISA bridge");
968         case 0x24108086:
969                 return ("Intel 82801AA (ICH) PCI to LPC bridge");
970         case 0x24208086:
971                 return ("Intel 82801AB (ICH0) PCI to LPC bridge");
972         case 0x24408086:
973                 return ("Intel 82801BA/BAM (ICH2) PCI to LPC bridge");
974
975         /* NVIDIA -- vendor 0x10de */
976         case 0x006010de:
977                 return ("NVIDIA nForce2 PCI to ISA bridge");
978         
979         /* VLSI -- vendor 0x1004 */
980         case 0x00061004:
981                 return ("VLSI 82C593 PCI to ISA bridge");
982
983         /* VIA Technologies -- vendor 0x1106 */
984         case 0x05861106: /* south bridge section */
985                 return ("VIA 82C586 PCI-ISA bridge");
986         case 0x05961106:
987                 return ("VIA 82C596B PCI-ISA bridge");
988         case 0x06861106:
989                 return ("VIA 82C686 PCI-ISA bridge");
990
991         /* AcerLabs -- vendor 0x10b9 */
992         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
993         /* id is '10b9" but the register always shows "10b9". -Foxfair  */
994         case 0x153310b9:
995                 return ("AcerLabs M1533 portable PCI-ISA bridge");
996         case 0x154310b9:
997                 return ("AcerLabs M1543 desktop PCI-ISA bridge");
998
999         /* SiS -- vendor 0x1039 */
1000         case 0x00081039:
1001                 return ("SiS 85c503 PCI-ISA bridge");
1002
1003         /* Cyrix -- vendor 0x1078 */
1004         case 0x00001078:
1005                 return ("Cyrix Cx5510 PCI-ISA bridge");
1006         case 0x01001078:
1007                 return ("Cyrix Cx5530 PCI-ISA bridge");
1008
1009         /* NEC -- vendor 0x1033 */
1010         /* The "C-bus" is 16-bits bus on PC98. */
1011         case 0x00011033:
1012                 return ("NEC 0001 PCI to PC-98 C-bus bridge");
1013         case 0x002c1033:
1014                 return ("NEC 002C PCI to PC-98 C-bus bridge");
1015         case 0x003b1033:
1016                 return ("NEC 003B PCI to PC-98 C-bus bridge");
1017         /* UMC United Microelectronics 0x1060 */
1018         case 0x886a1060:
1019                 return ("UMC UM8886 ISA Bridge with EIDE");
1020
1021         /* Cypress -- vendor 0x1080 */
1022         case 0xc6931080:
1023                 if (pci_get_class(dev) == PCIC_BRIDGE
1024                     && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)
1025                         return ("Cypress 82C693 PCI-ISA bridge");
1026                 break;
1027
1028         /* ServerWorks -- vendor 0x1166 */
1029         case 0x02001166:
1030                 return ("ServerWorks IB6566 PCI to ISA bridge");
1031         }
1032
1033         if (pci_get_class(dev) == PCIC_BRIDGE
1034             && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)
1035                 return pci_bridge_type(dev);
1036
1037         return NULL;
1038 }
1039
1040 static int
1041 isab_probe(device_t dev)
1042 {
1043         const char *desc;
1044         int     is_eisa;
1045
1046         is_eisa = 0;
1047         desc = eisab_match(dev);
1048         if (desc)
1049                 is_eisa = 1;
1050         else
1051                 desc = isab_match(dev);
1052         if (desc) {
1053                 /*
1054                  * For a PCI-EISA bridge, add both eisa and isa.
1055                  * Only add one instance of eisa or isa for now.
1056                  */
1057                 device_set_desc_copy(dev, desc);
1058                 if (is_eisa && !devclass_get_device(devclass_find("eisa"), 0))
1059                         device_add_child(dev, "eisa", -1);
1060
1061                 if (!devclass_get_device(devclass_find("isa"), 0))
1062                         device_add_child(dev, "isa", -1);
1063                 return -1000;
1064         }
1065         return ENXIO;
1066 }
1067
1068 static int
1069 isab_attach(device_t dev)
1070 {
1071         chipset_attach(dev, device_get_unit(dev));
1072         return bus_generic_attach(dev);
1073 }
1074
1075 static device_method_t isab_methods[] = {
1076         /* Device interface */
1077         DEVMETHOD(device_probe,         isab_probe),
1078         DEVMETHOD(device_attach,        isab_attach),
1079         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
1080         DEVMETHOD(device_suspend,       bus_generic_suspend),
1081         DEVMETHOD(device_resume,        bus_generic_resume),
1082
1083         /* Bus interface */
1084         DEVMETHOD(bus_print_child,      bus_generic_print_child),
1085         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
1086         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
1087         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
1088         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
1089         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
1090         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
1091
1092         { 0, 0 }
1093 };
1094
1095 static driver_t isab_driver = {
1096         "isab",
1097         isab_methods,
1098         1,
1099 };
1100
1101 static devclass_t isab_devclass;
1102
1103 DRIVER_MODULE(isab, pci, isab_driver, isab_devclass, 0, 0);
1104
1105 const char *
1106 pci_usb_match(device_t dev)
1107 {
1108         switch (pci_get_devid(dev)) {
1109
1110         /* Intel -- vendor 0x8086 */
1111         case 0x70208086:
1112                 return ("Intel 82371SB (PIIX3) USB controller");
1113         case 0x71128086:
1114                 return ("Intel 82371AB/EB (PIIX4) USB controller");
1115         case 0x24128086:
1116                 return ("Intel 82801AA (ICH) USB controller");
1117         case 0x24228086:
1118                 return ("Intel 82801AB (ICH0) USB controller");
1119         case 0x24428086:
1120                 return ("Intel 82801BA/BAM (ICH2) USB controller USB-A");
1121         case 0x24448086:
1122                 return ("Intel 82801BA/BAM (ICH2) USB controller USB-B");
1123
1124         /* VIA Technologies -- vendor 0x1106 (0x1107 on the Apollo Master) */
1125         case 0x30381106:
1126                 return ("VIA 83C572 USB controller");
1127
1128         /* AcerLabs -- vendor 0x10b9 */
1129         case 0x523710b9:
1130                 return ("AcerLabs M5237 (Aladdin-V) USB controller");
1131
1132         /* OPTi -- vendor 0x1045 */
1133         case 0xc8611045:
1134                 return ("OPTi 82C861 (FireLink) USB controller");
1135
1136         /* NEC -- vendor 0x1033 */
1137         case 0x00351033:
1138                 return ("NEC uPD 9210 USB controller");
1139
1140         /* CMD Tech -- vendor 0x1095 */
1141         case 0x06701095:
1142                 return ("CMD Tech 670 (USB0670) USB controller");
1143         case 0x06731095:
1144                 return ("CMD Tech 673 (USB0673) USB controller");
1145         }
1146
1147         if (pci_get_class(dev) == PCIC_SERIALBUS
1148             && pci_get_subclass(dev) == PCIS_SERIALBUS_USB) {
1149                 if (pci_get_progif(dev) == 0x00 /* UHCI */ ) {
1150                         return ("UHCI USB controller");
1151                 } else if (pci_get_progif(dev) == 0x10 /* OHCI */ ) {
1152                         return ("OHCI USB controller");
1153                 } else {
1154                         return ("USB controller");
1155                 }
1156         }
1157         return NULL;
1158 }
1159
1160 const char *
1161 pci_ata_match(device_t dev)
1162 {
1163
1164         switch (pci_get_devid(dev)) {
1165
1166         /* Intel -- vendor 0x8086 */
1167         case 0x12308086:
1168                 return ("Intel PIIX ATA controller");
1169         case 0x70108086:
1170                 return ("Intel PIIX3 ATA controller");
1171         case 0x71118086:
1172                 return ("Intel PIIX4 ATA controller");
1173         case 0x12348086:
1174                 return ("Intel 82371MX mobile PCI ATA accelerator (MPIIX)");
1175
1176         /* Promise -- vendor 0x105a */
1177         case 0x4d33105a:
1178                 return ("Promise Ultra/33 ATA controller");
1179         case 0x4d38105a:
1180                 return ("Promise Ultra/66 ATA controller");
1181
1182         /* AcerLabs -- vendor 0x10b9 */
1183         case 0x522910b9:
1184                 return ("AcerLabs Aladdin ATA controller");
1185
1186         /* VIA Technologies -- vendor 0x1106 (0x1107 on the Apollo Master) */
1187         case 0x05711106:
1188                 switch (pci_read_config(dev, 0x08, 1)) {
1189                 case 1:
1190                         return ("VIA 85C586 ATA controller");
1191                 case 6:
1192                         return ("VIA 85C586 ATA controller");
1193                 }
1194                 /* FALL THROUGH */
1195         case 0x15711106:
1196                 return ("VIA Apollo ATA controller");
1197
1198         /* CMD Tech -- vendor 0x1095 */
1199         case 0x06401095:
1200                 return ("CMD 640 ATA controller");
1201         case 0x06461095:
1202                 return ("CMD 646 ATA controller");
1203
1204         /* Cypress -- vendor 0x1080 */
1205         case 0xc6931080:
1206                 return ("Cypress 82C693 ATA controller");
1207
1208         /* Cyrix -- vendor 0x1078 */
1209         case 0x01021078:
1210                 return ("Cyrix 5530 ATA controller");
1211
1212         /* SiS -- vendor 0x1039 */
1213         case 0x55131039:
1214                 return ("SiS 5591 ATA controller");
1215
1216         /* Highpoint tech -- vendor 0x1103 */
1217         case 0x00041103:
1218                 return ("HighPoint HPT366 ATA controller");
1219         }
1220
1221         if (pci_get_class(dev) == PCIC_STORAGE &&
1222             pci_get_subclass(dev) == PCIS_STORAGE_IDE)
1223                 return ("Unknown PCI ATA controller");
1224
1225         return NULL;
1226 }
1227
1228
1229 const char*
1230 pci_chip_match(device_t dev)
1231 {
1232         unsigned        rev;
1233
1234         switch (pci_get_devid(dev)) {
1235         /* Intel -- vendor 0x8086 */
1236         case 0x00088086:
1237                 /* Silently ignore this one! What is it, anyway ??? */
1238                 return ("");
1239         case 0x71108086:
1240                 /*
1241                  * On my laptop (Tecra 8000DVD), this device has a
1242                  * bogus subclass 0x80 so make sure that it doesn't
1243                  * match the generic 'chip' driver by accident.
1244                  */
1245                 return NULL;
1246         case 0x12258086:
1247                 fixbushigh_i1225(dev);
1248                 return ("Intel 824?? host to PCI bridge");
1249         case 0x71808086:
1250                 return ("Intel 82443LX (440 LX) host to PCI bridge");
1251         case 0x71908086:
1252                 return ("Intel 82443BX (440 BX) host to PCI bridge");
1253         case 0x71928086:
1254                 return ("Intel 82443BX host to PCI bridge (AGP disabled)");
1255         case 0x71a08086:
1256                 return ("Intel 82443GX host to PCI bridge");
1257         case 0x71a18086:
1258                 return ("Intel 82443GX host to AGP bridge");
1259         case 0x71a28086:
1260                 return ("Intel 82443GX host to PCI bridge (AGP disabled)");
1261         case 0x84c48086:
1262                 return ("Intel 82454KX/GX (Orion) host to PCI bridge");
1263         case 0x84ca8086:
1264                 return ("Intel 82451NX Memory and I/O controller");
1265         case 0x04868086:
1266                 return ("Intel 82425EX PCI system controller");
1267         case 0x04838086:
1268                 return ("Intel 82424ZX (Saturn) cache DRAM controller");
1269         case 0x04a38086:
1270                 rev = pci_get_revid(dev);
1271                 if (rev == 16 || rev == 17)
1272                     return ("Intel 82434NX (Neptune) PCI cache memory controller");
1273                 return ("Intel 82434LX (Mercury) PCI cache memory controller");
1274         case 0x122d8086:
1275                 return ("Intel 82437FX PCI cache memory controller");
1276         case 0x12358086:
1277                 return ("Intel 82437MX mobile PCI cache memory controller");
1278         case 0x12508086:
1279                 return ("Intel 82439HX PCI cache memory controller");
1280         case 0x70308086:
1281                 return ("Intel 82437VX PCI cache memory controller");
1282         case 0x71008086:
1283                 return ("Intel 82439TX System controller (MTXC)");
1284         case 0x71138086:
1285                 return ("Intel 82371AB Power management controller");
1286         case 0x719b8086:
1287                 return ("Intel 82443MX Power management controller");
1288         case 0x12378086:
1289                 fixwsc_natoma(dev);
1290                 return ("Intel 82440FX (Natoma) PCI and memory controller");
1291         case 0x84c58086:
1292                 return ("Intel 82453KX/GX (Orion) PCI memory controller");
1293         case 0x71208086:
1294                 return ("Intel 82810 (i810 GMCH) Host To Hub bridge");
1295         case 0x71228086:
1296         return ("Intel 82810-DC100 (i810-DC100 GMCH) Host To Hub bridge");
1297         case 0x71248086:
1298         return ("Intel 82810E (i810E GMCH) Host To Hub bridge");
1299         case 0x24158086:
1300                 return ("Intel 82801AA (ICH) AC'97 Audio Controller");
1301         case 0x24258086:
1302                 return ("Intel 82801AB (ICH0) AC'97 Audio Controller");
1303
1304         /* Sony -- vendor 0x104d */
1305         case 0x8009104d:
1306                 return ("Sony CXD1947A FireWire Host Controller");
1307
1308         /* SiS -- vendor 0x1039 */
1309         case 0x04961039:
1310                 return ("SiS 85c496 PCI/VL Bridge");
1311         case 0x04061039:
1312                 return ("SiS 85c501");
1313         case 0x06011039:
1314                 return ("SiS 85c601");
1315         case 0x55911039:
1316                 return ("SiS 5591 host to PCI bridge");
1317         case 0x00011039:
1318                 return ("SiS 5591 host to AGP bridge");
1319         
1320         /* VLSI -- vendor 0x1004 */
1321         case 0x00051004:
1322                 return ("VLSI 82C592 Host to PCI bridge");
1323         case 0x01011004:
1324                 return ("VLSI 82C532 Eagle II Peripheral controller");
1325         case 0x01041004:
1326                 return ("VLSI 82C535 Eagle II System controller");
1327         case 0x01051004:
1328                 return ("VLSI 82C147 IrDA controller");
1329
1330         /* VIA Technologies -- vendor 0x1106 (0x1107 on the Apollo Master) */
1331         case 0x15761107:
1332                 return ("VIA 82C570 (Apollo Master) system controller");
1333         case 0x05851106:
1334                 return ("VIA 82C585 (Apollo VP1/VPX) system controller");
1335         case 0x05951106:
1336         case 0x15951106:
1337                 return ("VIA 82C595 (Apollo VP2) system controller");
1338         case 0x05971106:
1339                 return ("VIA 82C597 (Apollo VP3) system controller");
1340         /* XXX Here is MVP3, I got the datasheet but NO M/B to test it  */
1341         /* totally. Please let me know if anything wrong.            -F */
1342         /* XXX need info on the MVP3 -- any takers? */
1343         case 0x05981106:
1344                 return ("VIA 82C598MVP (Apollo MVP3) host bridge");
1345         case 0x30401106:
1346         case 0x30501106:
1347         case 0x30571106:
1348                 return NULL;
1349         case 0x30581106:
1350                 return ("VIA 82C686 AC97 Audio");
1351         case 0x30681106:
1352                 return ("VIA 82C686 AC97 Modem");
1353
1354         /* AMD -- vendor 0x1022 */
1355         case 0x70061022:
1356                 return ("AMD-751 host to PCI bridge");
1357         case 0x700e1022:
1358                 return ("AMD-761 host to PCI bridge");
1359
1360         /* NEC -- vendor 0x1033 */
1361         case 0x00021033:
1362                 return ("NEC 0002 PCI to PC-98 local bus bridge");
1363         case 0x00161033:
1364                 return ("NEC 0016 PCI to PC-98 local bus bridge");
1365
1366         /* AcerLabs -- vendor 0x10b9 */
1367         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
1368         /* id is '10b9" but the register always shows "10b9". -Foxfair  */
1369         case 0x154110b9:
1370                 return ("AcerLabs M1541 (Aladdin-V) PCI host bridge");
1371         case 0x710110b9:
1372                 return ("AcerLabs M15x3 Power Management Unit");
1373
1374         /* OPTi -- vendor 0x1045 */
1375         case 0xc5571045:
1376                 return ("Opti 82C557 (Viper-M) host to PCI bridge");
1377         case 0xc5581045:
1378                 return ("Opti 82C558 (Viper-M) ISA+IDE");
1379         case 0xc8221045:
1380                 return ("OPTi 82C822 host to PCI Bridge");
1381
1382         /* Texas Instruments -- vendor 0x104c */
1383         case 0xac1c104c:
1384                 return ("Texas Instruments PCI1225 CardBus controller");
1385         case 0xac50104c:
1386                 return ("Texas Instruments PCI1410 CardBus controller");
1387         case 0xac51104c:
1388                 return ("Texas Instruments PCI1420 CardBus controller");
1389         case 0xac1b104c:
1390                 return ("Texas Instruments PCI1450 CardBus controller");
1391         case 0xac52104c:
1392                 return ("Texas Instruments PCI1451 CardBus controller");
1393
1394         /* NeoMagic -- vendor 0x10c8 */
1395         case 0x800510c8:
1396                 return ("NeoMagic MagicMedia 256AX Audio controller");
1397         case 0x800610c8:
1398                 return ("NeoMagic MagicMedia 256ZX Audio controller");
1399
1400         /* ESS Technology Inc -- vendor 0x125d */
1401         case 0x1978125d:
1402                 return ("ESS Technology Maestro 2E Audio controller");
1403
1404         /* Toshiba -- vendor 0x1179 */
1405         case 0x07011179:
1406                 return ("Toshiba Fast Infra Red controller");
1407
1408         /* NEC -- vendor 0x1033 */
1409
1410         /* PCI to C-bus bridge */
1411         /* The following chipsets are PCI to PC98 C-bus bridge.
1412          * The C-bus is the 16-bits bus on PC98 and it should be probed as
1413          * PCI to ISA bridge.  Because class of the C-bus is not defined,
1414          * C-bus bridges are recognized as "other bridge."  To make C-bus
1415          * bridge be recognized as ISA bridge, this function returns NULL.
1416          */
1417         case 0x00011033:
1418         case 0x002c1033:
1419         case 0x003b1033:
1420                 return NULL;
1421         };
1422
1423         if (pci_get_class(dev) == PCIC_BRIDGE
1424             && pci_get_subclass(dev) != PCIS_BRIDGE_PCI
1425             && pci_get_subclass(dev) != PCIS_BRIDGE_ISA
1426             && pci_get_subclass(dev) != PCIS_BRIDGE_EISA)
1427                 return pci_bridge_type(dev);
1428
1429         return NULL;
1430 }
1431
1432 /*---------------------------------------------------------
1433 **
1434 **      Catchall driver for VGA devices
1435 **
1436 **      By Garrett Wollman
1437 **      <wollman@halloran-eldar.lcs.mit.edu>
1438 **
1439 **---------------------------------------------------------
1440 */
1441
1442 const char* pci_vga_match(device_t dev)
1443 {
1444         u_int id = pci_get_devid(dev);
1445         const char *vendor, *chip, *type;
1446
1447         vendor = chip = type = 0;
1448         switch (id & 0xffff) {
1449         case 0x003d:
1450                 vendor = "Real 3D";
1451                 switch (id >> 16) {
1452                 case 0x00d1:
1453                         chip = "i740"; break;
1454                 }
1455                 break;
1456         case 0x10c8:
1457                 vendor = "NeoMagic";
1458                 switch (id >> 16) {
1459                 case 0x0003:
1460                         chip = "MagicGraph 128ZV"; break;
1461                 case 0x0004:
1462                         chip = "MagicGraph 128XD"; break;
1463                 case 0x0005:
1464                         chip = "MagicMedia 256AV"; break;
1465                 case 0x0006:
1466                         chip = "MagicMedia 256ZX"; break;
1467                 }
1468                 break;
1469         case 0x121a:
1470                 vendor = "3Dfx";
1471                 type = "graphics accelerator";
1472                 switch (id >> 16) {
1473                 case 0x0001:
1474                         chip = "Voodoo"; break;
1475                 case 0x0002:
1476                         chip = "Voodoo 2"; break;
1477                 case 0x0003:
1478                         chip = "Voodoo Banshee"; break;
1479                 case 0x0005:
1480                         chip = "Voodoo 3"; break;
1481                 }
1482                 break;
1483         case 0x102b:
1484                 vendor = "Matrox";
1485                 type = "graphics accelerator";
1486                 switch (id >> 16) {
1487                 case 0x0518:
1488                         chip = "MGA 2085PX"; break;
1489                 case 0x0519:
1490                         chip = "MGA Millennium 2064W"; break;
1491                 case 0x051a:
1492                         chip = "MGA 1024SG/1064SG/1164SG"; break;
1493                 case 0x051b:
1494                         chip = "MGA Millennium II 2164W"; break;
1495                 case 0x051f:
1496                         chip = "MGA Millennium II 2164WA-B AG"; break;
1497                 case 0x0520:
1498                         chip = "MGA G200"; break;
1499                 case 0x0521:
1500                         chip = "MGA G200 AGP"; break;
1501                 case 0x0525:
1502                         chip = "MGA G400 AGP"; break;
1503                 case 0x0d10:
1504                         chip = "MGA Impression"; break;
1505                 case 0x1000:
1506                         chip = "MGA G100"; break;
1507                 case 0x1001:
1508                         chip = "MGA G100 AGP"; break;
1509                 case 0x2527:
1510                         chip = "MGA G550 AGP"; break;
1511
1512                 }
1513                 break;
1514         case 0x1002:
1515                 vendor = "ATI";
1516                 type = "graphics accelerator";
1517                 switch (id >> 16) {
1518                 case 0x4158:
1519                         chip = "Mach32"; break;
1520                 case 0x4354:
1521                         chip = "Mach64-CT"; break;
1522                 case 0x4358:
1523                         chip = "Mach64-CX"; break;
1524                 case 0x4554:
1525                         chip = "Mach64-ET"; break;
1526                 case 0x4654:
1527                 case 0x5654:
1528                         chip = "Mach64-VT"; break;
1529                 case 0x4742:
1530                         chip = "Mach64-GB"; break;
1531                 case 0x4744:
1532                         chip = "Mach64-GD"; break;
1533                 case 0x4749:
1534                         chip = "Mach64-GI"; break;
1535                 case 0x474d:
1536                         chip = "Mach64-GM"; break;
1537                 case 0x474e:
1538                         chip = "Mach64-GN"; break;
1539                 case 0x474f:
1540                         chip = "Mach64-GO"; break;
1541                 case 0x4750:
1542                         chip = "Mach64-GP"; break;
1543                 case 0x4751:
1544                         chip = "Mach64-GQ"; break;
1545                 case 0x4752:
1546                         chip = "Mach64-GR"; break;
1547                 case 0x4753:
1548                         chip = "Mach64-GS"; break;
1549                 case 0x4754:
1550                         chip = "Mach64-GT"; break;
1551                 case 0x4755:
1552                         chip = "Mach64-GU"; break;
1553                 case 0x4756:
1554                         chip = "Mach64-GV"; break;
1555                 case 0x4757:
1556                         chip = "Mach64-GW"; break;
1557                 case 0x4758:
1558                         chip = "Mach64-GX"; break;
1559                 case 0x4c4d:
1560                         chip = "Mobility-1"; break;
1561                 case 0x4c52:
1562                         chip = "RageMobility-P/M"; break;
1563                 case 0x475a:
1564                         chip = "Mach64-GZ"; break;
1565                 case 0x5245:
1566                         chip = "Rage128-RE"; break;
1567                 case 0x5246:
1568                         chip = "Rage128-RF"; break;
1569                 case 0x524b:
1570                         chip = "Rage128-RK"; break;
1571                 case 0x524c:
1572                         chip = "Rage128-RL"; break;
1573                 }
1574                 break;
1575         case 0x1005:
1576                 vendor = "Avance Logic";
1577                 switch (id >> 16) {
1578                 case 0x2301:
1579                         chip = "ALG2301"; break;
1580                 case 0x2302:
1581                         chip = "ALG2302"; break;
1582                 }
1583                 break;
1584         case 0x100c:
1585                 vendor = "Tseng Labs";
1586                 type = "graphics accelerator";
1587                 switch (id >> 16) {
1588                 case 0x3202:
1589                 case 0x3205:
1590                 case 0x3206:
1591                 case 0x3207:
1592                         chip = "ET4000 W32P"; break;
1593                 case 0x3208:
1594                         chip = "ET6000/ET6100"; break;
1595                 case 0x4702:
1596                         chip = "ET6300"; break;
1597                 }
1598                 break;
1599         case 0x100e:
1600                 vendor = "Weitek";
1601                 type = "graphics accelerator";
1602                 switch (id >> 16) {
1603                 case 0x9001:
1604                         chip = "P9000"; break;
1605                 case 0x9100:
1606                         chip = "P9100"; break;
1607                 }
1608                 break;
1609         case 0x1013:
1610                 vendor = "Cirrus Logic";
1611                 switch (id >> 16) {
1612                 case 0x0038:
1613                         chip = "GD7548"; break;
1614                 case 0x0040:
1615                         chip = "GD7555"; break;
1616                 case 0x004c:
1617                         chip = "GD7556"; break;
1618                 case 0x00a0:
1619                         chip = "GD5430"; break;
1620                 case 0x00a4:
1621                 case 0x00a8:
1622                         chip = "GD5434"; break;
1623                 case 0x00ac:
1624                         chip = "GD5436"; break;
1625                 case 0x00b8:
1626                         chip = "GD5446"; break;
1627                 case 0x00bc:
1628                         chip = "GD5480"; break;
1629                 case 0x00d0:
1630                         chip = "GD5462"; break;
1631                 case 0x00d4:
1632                 case 0x00d5:
1633                         chip = "GD5464"; break;
1634                 case 0x00d6:
1635                         chip = "GD5465"; break;
1636                 case 0x1200:
1637                         chip = "GD7542"; break;
1638                 case 0x1202:
1639                         chip = "GD7543"; break;
1640                 case 0x1204:
1641                         chip = "GD7541"; break;
1642                 }
1643                 break;
1644         case 0x1023:
1645                 vendor = "Trident";
1646                 break;          /* let default deal with it */
1647         case 0x102c:
1648                 vendor = "Chips & Technologies";
1649                 switch (id >> 16) {
1650                 case 0x00b8:
1651                         chip = "64310"; break;
1652                 case 0x00d8:
1653                         chip = "65545"; break;
1654                 case 0x00dc:
1655                         chip = "65548"; break;
1656                 case 0x00c0:
1657                         chip = "69000"; break;
1658                 case 0x00e0:
1659                         chip = "65550"; break;
1660                 case 0x00e4:
1661                         chip = "65554"; break;
1662                 case 0x00e5:
1663                         chip = "65555"; break;
1664                 case 0x00f4:
1665                         chip = "68554"; break;
1666                 }
1667                 break;
1668         case 0x1033:
1669                 vendor = "NEC";
1670                 switch (id >> 16) {
1671                 case 0x0009:
1672                         type = "PCI to PC-98 Core Graph bridge";
1673                         break;
1674                 }
1675                 break;
1676         case 0x1039:
1677                 vendor = "SiS";
1678                 switch (id >> 16) {
1679                 case 0x0001:
1680                         chip = "86c201"; break;
1681                 case 0x0002:
1682                         chip = "86c202"; break;
1683                 case 0x0205:
1684                         chip = "86c205"; break;
1685                 case 0x0215:
1686                         chip = "86c215"; break;
1687                 case 0x0225:
1688                         chip = "86c225"; break;
1689                 case 0x0200:
1690                         chip = "5597/98"; break;
1691                 case 0x6326:
1692                         chip = "6326"; break;
1693                 case 0x6306:
1694                         chip = "530/620"; break;
1695                 }
1696                 break;
1697         case 0x105d:
1698                 vendor = "Number Nine";
1699                 type = "graphics accelerator";
1700                 switch (id >> 16) {
1701                 case 0x2309:
1702                         chip = "Imagine 128"; break;
1703                 case 0x2339:
1704                         chip = "Imagine 128 II"; break;
1705                 }
1706                 break;
1707         case 0x1142:
1708                 vendor = "Alliance";
1709                 switch (id >> 16) {
1710                 case 0x3210:
1711                         chip = "PM6410"; break;
1712                 case 0x6422:
1713                         chip = "PM6422"; break;
1714                 case 0x6424:
1715                         chip = "PMAT24"; break;
1716                 }
1717                 break;
1718         case 0x1163:
1719                 vendor = "Rendition Verite";
1720                 switch (id >> 16) {
1721                 case 0x0001:
1722                         chip = "V1000"; break;
1723                 case 0x2000:
1724                         chip = "V2000"; break;
1725                 }
1726                 break;
1727         case 0x1236:
1728                 vendor = "Sigma Designs";
1729                 if ((id >> 16) == 0x6401)
1730                         chip = "REALmagic64/GX";
1731                 break;
1732         case 0x5333:
1733                 vendor = "S3";
1734                 type = "graphics accelerator";
1735                 switch (id >> 16) {
1736                 case 0x8811:
1737                         chip = "Trio"; break;
1738                 case 0x8812:
1739                         chip = "Aurora 64"; break;
1740                 case 0x8814:
1741                         chip = "Trio 64UV+"; break;
1742                 case 0x8901:
1743                         chip = "Trio 64V2/DX/GX"; break;
1744                 case 0x8902:
1745                         chip = "Plato"; break;
1746                 case 0x8904:
1747                         chip = "Trio3D"; break;
1748                 case 0x8880:
1749                         chip = "868"; break;
1750                 case 0x88b0:
1751                         chip = "928"; break;
1752                 case 0x88c0:
1753                 case 0x88c1:
1754                         chip = "864"; break;
1755                 case 0x88d0:
1756                 case 0x88d1:
1757                         chip = "964"; break;
1758                 case 0x88f0:
1759                         chip = "968"; break;
1760                 case 0x5631:
1761                         chip = "ViRGE"; break;
1762                 case 0x883d:
1763                         chip = "ViRGE VX"; break;
1764                 case 0x8a01:
1765                         chip = "ViRGE DX/GX"; break;
1766                 case 0x8a10:
1767                         chip = "ViRGE GX2"; break;
1768                 case 0x8a13:
1769                         chip = "Trio3D/2X"; break;
1770                 case 0x8a20:
1771                 case 0x8a21:
1772                         chip = "Savage3D"; break;
1773                 case 0x8a22:
1774                         chip = "Savage 4"; break;
1775                 case 0x8c01:
1776                         chip = "ViRGE MX"; break;
1777                 case 0x8c03:
1778                         chip = "ViRGE MX+"; break;
1779                 }
1780                 break;
1781         case 0xedd8:
1782                 vendor = "ARK Logic";
1783                 switch (id >> 16) {
1784                 case 0xa091:
1785                         chip = "1000PV"; break;
1786                 case 0xa099:
1787                         chip = "2000PV"; break;
1788                 case 0xa0a1:
1789                         chip = "2000MT"; break;
1790                 case 0xa0a9:
1791                         chip = "2000MI"; break;
1792                 }
1793                 break;
1794         case 0x3d3d:
1795                 vendor = "3D Labs";
1796                 type = "graphics accelerator";
1797                 switch (id >> 16) {
1798                 case 0x0001:
1799                         chip = "300SX"; break;
1800                 case 0x0002:
1801                         chip = "500TX"; break;
1802                 case 0x0003:
1803                         chip = "Delta"; break;
1804                 case 0x0004:
1805                         chip = "PerMedia"; break;
1806                 }
1807                 break;
1808         case 0x10de:
1809                 vendor = "NVidia";
1810                 type = "graphics accelerator";
1811                 switch (id >> 16) {
1812                 case 0x0008:
1813                         chip = "NV1"; break;
1814                 case 0x0020:
1815                         chip = "Riva TNT"; break;       
1816                 case 0x0028:
1817                         chip = "Riva TNT2"; break;
1818                 case 0x0029:
1819                         chip = "Riva Ultra TNT2"; break;
1820                 case 0x002c:
1821                         chip = "Riva Vanta TNT2"; break;
1822                 case 0x002d:
1823                         chip = "Riva Ultra Vanta TNT2"; break;
1824                 case 0x00a0:
1825                         chip = "Riva Integrated TNT2"; break;
1826                 case 0x0100:
1827                         chip = "GeForce 256"; break;
1828                 case 0x0101:
1829                         chip = "GeForce DDR"; break;
1830                 case 0x0103:
1831                         chip = "Quadro"; break;
1832                 case 0x0150:
1833                 case 0x0151:
1834                 case 0x0152:
1835                         chip = "GeForce2 GTS"; break;
1836                 case 0x0153:
1837                         chip = "Quadro2"; break;
1838                 }
1839                 break;
1840         case 0x12d2:
1841                 vendor = "NVidia/SGS-Thomson";
1842                 type = "graphics accelerator";
1843                 switch (id >> 16) {
1844                 case 0x0018:
1845                         chip = "Riva128"; break;        
1846                 }
1847                 break;
1848         case 0x104a:
1849                 vendor = "SGS-Thomson";
1850                 switch (id >> 16) {
1851                 case 0x0008:
1852                         chip = "STG2000"; break;
1853                 }
1854                 break;
1855         case 0x8086:
1856                 vendor = "Intel";
1857                 switch (id >> 16) {
1858                 case 0x7121:
1859                         chip = "82810 (i810 GMCH)"; break;
1860                 case 0x7123:
1861                         chip = "82810-DC100 (i810-DC100 GMCH)"; break;
1862                 case 0x7125:
1863                         chip = "82810E (i810E GMCH)"; break;
1864                 case 0x7800:
1865                         chip = "i740 AGP"; break;
1866                 }
1867                 break;
1868         case 0x10ea:
1869                 vendor = "Intergraphics";
1870                 switch (id >> 16) {
1871                 case 0x1680:
1872                         chip = "IGA-1680"; break;
1873                 case 0x1682:
1874                         chip = "IGA-1682"; break;
1875                 }
1876                 break;
1877         }
1878
1879         if (vendor && chip) {
1880                 char *buf;
1881                 int len;
1882
1883                 if (type == 0)
1884                         type = "SVGA controller";
1885
1886                 len = strlen(vendor) + strlen(chip) + strlen(type) + 4;
1887                 MALLOC(buf, char *, len, M_TEMP, M_NOWAIT);
1888                 if (buf)
1889                         sprintf(buf, "%s %s %s", vendor, chip, type);
1890                 return buf;
1891         }
1892
1893         switch (pci_get_class(dev)) {
1894
1895         case PCIC_OLD:
1896                 if (pci_get_subclass(dev) != PCIS_OLD_VGA)
1897                         return 0;
1898                 if (type == 0)
1899                         type = "VGA-compatible display device";
1900                 break;
1901
1902         case PCIC_DISPLAY:
1903                 if (type == 0) {
1904                         if (pci_get_subclass(dev) == PCIS_DISPLAY_VGA)
1905                                 type = "VGA-compatible display device";
1906                         else {
1907                                 /*
1908                                  * If it isn't a vga display device,
1909                                  * don't pretend we found one.
1910                                  */
1911                                 return 0;
1912                         }
1913                 }
1914                 break;
1915
1916         default:
1917                 return 0;
1918         };
1919         /*
1920          * If we got here, we know for sure it's some sort of display
1921          * device, but we weren't able to identify it specifically.
1922          * At a minimum we can return the type, but we'd like to
1923          * identify the vendor and chip ID if at all possible.
1924          * (Some of the checks above intentionally don't bother for
1925          * vendors where we know the chip ID is the same as the
1926          * model number.)
1927          */
1928         if (vendor) {
1929                 char *buf;
1930                 int len;
1931
1932                 len = strlen(vendor) + strlen(type) + 2 + 6 + 4 + 1;
1933                 MALLOC(buf, char *, len, M_TEMP, M_NOWAIT);
1934                 if (buf)
1935                         sprintf(buf, "%s model %04x %s", vendor, id >> 16, type);
1936                 return buf;
1937         }
1938         return type;
1939 }
1940
1941 /*---------------------------------------------------------
1942 **
1943 **      Devices to ignore
1944 **
1945 **---------------------------------------------------------
1946 */
1947
1948 static const char*
1949 ign_match(device_t dev)
1950 {
1951         switch (pci_get_devid(dev)) {
1952
1953         case 0x10001042ul:      /* wd */
1954                 return ("SMC FDC 37c665");
1955         };
1956
1957         return NULL;
1958 }
1959
1960 static int
1961 ign_probe(device_t dev)
1962 {
1963         const char *s;
1964
1965         s = ign_match(dev);
1966         if (s) {
1967                 device_set_desc(dev, s);
1968                 device_quiet(dev);
1969                 return -1000;
1970         }
1971         return ENXIO;
1972 }
1973
1974 static int
1975 ign_attach(device_t dev)
1976 {
1977         return 0;
1978 }
1979
1980 static device_method_t ign_methods[] = {
1981         /* Device interface */
1982         DEVMETHOD(device_probe,         ign_probe),
1983         DEVMETHOD(device_attach,        ign_attach),
1984
1985         { 0, 0 }
1986 };
1987
1988 static driver_t ign_driver = {
1989         "ign",
1990         ign_methods,
1991         1,
1992 };
1993
1994 static devclass_t ign_devclass;
1995
1996 DRIVER_MODULE(ign, pci, ign_driver, ign_devclass, 0, 0);