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