sys/bus/pci/pci_isab.c

   1 /*
   2  * Copyright (c) 2004, Joerg Sonnenberger <joerg@bec.de>
   3  * All rights reserved.
   4  * Copyright (c) 1994,1995 Stefan Esser.  All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice unmodified, this list of conditions, and the following
  11  *    disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  *
  29  * $DragonFly: src/sys/bus/pci/pci_isab.c,v 1.3 2005/01/17 17:50:21 joerg Exp $
  30  */
  31
  32 #include "opt_pci.h"
  33
  34 #include <sys/param.h>
  35 #include <sys/bus.h>
  36 #include <sys/kernel.h>
  37 #include <sys/malloc.h>
  38 #include <sys/module.h>
  39 #include <sys/rman.h>
  40 #include <sys/systm.h>
  41
  42 #include <machine/resource.h>
  43
  44 #include <bus/pci/pcivar.h>
  45 #include <bus/pci/pcireg.h>
  46
  47 #include "pcib_private.h"
  48
  49 static  void    chipset_attach(device_t dev, int unit);
  50
  51 #ifndef PCI_QUIET
  52
  53 struct condmsg {
  54     unsigned char       port;
  55     unsigned char       mask;
  56     unsigned char       value;
  57     char                flags;
  58     const char          *text;
  59 };
  60
  61 #define M_XX 0  /* end of list */
  62 #define M_EQ 1  /* mask and return true if equal */
  63 #define M_NE 2  /* mask and return true if not equal */
  64 #define M_TR 3  /* don't read config, always true */
  65 #define M_EN 4  /* mask and print "enabled" if true, "disabled" if false */
  66 #define M_NN 5  /* opposite sense of M_EN */
  67
  68 static const struct condmsg conf82425ex[] =
  69 {
  70     { 0x00, 0x00, 0x00, M_TR, "\tClock " },
  71     { 0x50, 0x06, 0x00, M_EQ, "25" },
  72     { 0x50, 0x06, 0x02, M_EQ, "33" },
  73     { 0x50, 0x04, 0x04, M_EQ, "??", },
  74     { 0x00, 0x00, 0x00, M_TR, "MHz, L1 Cache " },
  75     { 0x50, 0x01, 0x00, M_EQ, "Disabled\n" },
  76     { 0x50, 0x09, 0x01, M_EQ, "Write-through\n" },
  77     { 0x50, 0x09, 0x09, M_EQ, "Write-back\n" },
  78
  79     { 0x00, 0x00, 0x00, M_TR, "\tL2 Cache " },
  80     { 0x52, 0x07, 0x00, M_EQ, "Disabled" },
  81     { 0x52, 0x0f, 0x01, M_EQ, "64KB Write-through" },
  82     { 0x52, 0x0f, 0x02, M_EQ, "128KB Write-through" },
  83     { 0x52, 0x0f, 0x03, M_EQ, "256KB Write-through" },
  84     { 0x52, 0x0f, 0x04, M_EQ, "512KB Write-through" },
  85     { 0x52, 0x0f, 0x01, M_EQ, "64KB Write-back" },
  86     { 0x52, 0x0f, 0x02, M_EQ, "128KB Write-back" },
  87     { 0x52, 0x0f, 0x03, M_EQ, "256KB Write-back" },
  88     { 0x52, 0x0f, 0x04, M_EQ, "512KB Write-back" },
  89     { 0x53, 0x01, 0x00, M_EQ, ", 3-" },
  90     { 0x53, 0x01, 0x01, M_EQ, ", 2-" },
  91     { 0x53, 0x06, 0x00, M_EQ, "3-3-3" },
  92     { 0x53, 0x06, 0x02, M_EQ, "2-2-2" },
  93     { 0x53, 0x06, 0x04, M_EQ, "1-1-1" },
  94     { 0x53, 0x06, 0x06, M_EQ, "?-?-?" },
  95     { 0x53, 0x18, 0x00, M_EQ, "/4-2-2-2\n" },
  96     { 0x53, 0x18, 0x08, M_EQ, "/3-2-2-2\n" },
  97     { 0x53, 0x18, 0x10, M_EQ, "/?-?-?-?\n" },
  98     { 0x53, 0x18, 0x18, M_EQ, "/2-1-1-1\n" },
  99
 100     { 0x56, 0x00, 0x00, M_TR, "\tDRAM: " },
 101     { 0x56, 0x02, 0x02, M_EQ, "Fast Code Read, " },
 102     { 0x56, 0x04, 0x04, M_EQ, "Fast Data Read, " },
 103     { 0x56, 0x08, 0x08, M_EQ, "Fast Write, " },
 104     { 0x57, 0x20, 0x20, M_EQ, "Pipelined CAS" },
 105     { 0x57, 0x2e, 0x00, M_NE, "\n\t" },
 106     { 0x57, 0x00, 0x00, M_TR, "Timing: RAS: " },
 107     { 0x57, 0x07, 0x00, M_EQ, "4" },
 108     { 0x57, 0x07, 0x01, M_EQ, "3" },
 109     { 0x57, 0x07, 0x02, M_EQ, "2" },
 110     { 0x57, 0x07, 0x04, M_EQ, "1.5" },
 111     { 0x57, 0x07, 0x05, M_EQ, "1" },
 112     { 0x57, 0x00, 0x00, M_TR, " Clocks, CAS Read: " },
 113     { 0x57, 0x18, 0x00, M_EQ, "3/1", },
 114     { 0x57, 0x18, 0x00, M_EQ, "2/1", },
 115     { 0x57, 0x18, 0x00, M_EQ, "1.5/0.5", },
 116     { 0x57, 0x18, 0x00, M_EQ, "1/1", },
 117     { 0x57, 0x00, 0x00, M_TR, ", CAS Write: " },
 118     { 0x57, 0x20, 0x00, M_EQ, "2/1", },
 119     { 0x57, 0x20, 0x20, M_EQ, "1/1", },
 120     { 0x57, 0x00, 0x00, M_TR, "\n" },
 121
 122     { 0x40, 0x01, 0x01, M_EQ, "\tCPU-to-PCI Byte Merging\n" },
 123     { 0x40, 0x02, 0x02, M_EQ, "\tCPU-to-PCI Bursting\n" },
 124     { 0x40, 0x04, 0x04, M_EQ, "\tPCI Posted Writes\n" },
 125     { 0x40, 0x20, 0x00, M_EQ, "\tDRAM Parity Disabled\n" },
 126
 127     { 0x48, 0x03, 0x01, M_EQ, "\tPCI IDE controller: Primary (1F0h-1F7h,3F6h,3F7h)" },
 128     { 0x48, 0x03, 0x02, M_EQ, "\tPCI IDE controller: Secondary (170h-177h,376h,377h)" },
 129     { 0x4d, 0x01, 0x01, M_EQ, "\tRTC (70-77h)\n" },
 130     { 0x4d, 0x02, 0x02, M_EQ, "\tKeyboard (60,62,64,66h)\n" },
 131     { 0x4d, 0x08, 0x08, M_EQ, "\tIRQ12/M Mouse Function\n" },
 132
 133 /* end marker */
 134     { 0 }
 135 };
 136
 137 static const struct condmsg conf82424zx[] =
 138 {
 139     { 0x00, 0x00, 0x00, M_TR, "\tCPU: " },
 140     { 0x50, 0xe0, 0x00, M_EQ, "486DX" },
 141     { 0x50, 0xe0, 0x20, M_EQ, "486SX" },
 142     { 0x50, 0xe0, 0x40, M_EQ, "486DX2 or 486DX4" },
 143     { 0x50, 0xe0, 0x80, M_EQ, "Overdrive (writeback)" },
 144
 145     { 0x00, 0x00, 0x00, M_TR, ", bus=" },
 146     { 0x50, 0x03, 0x00, M_EQ, "25MHz" },
 147     { 0x50, 0x03, 0x01, M_EQ, "33MHz" },
 148     { 0x53, 0x01, 0x01, M_TR, ", CPU->Memory posting "},
 149     { 0x53, 0x01, 0x00, M_EQ, "OFF" },
 150     { 0x53, 0x01, 0x01, M_EQ, "ON" },
 151
 152     { 0x56, 0x30, 0x00, M_NE, "\n\tWarning:" },
 153     { 0x56, 0x20, 0x00, M_NE, " NO cache parity!" },
 154     { 0x56, 0x10, 0x00, M_NE, " NO DRAM parity!" },
 155     { 0x55, 0x04, 0x04, M_EQ, "\n\tWarning: refresh OFF! " },
 156
 157     { 0x00, 0x00, 0x00, M_TR, "\n\tCache: " },
 158     { 0x52, 0x01, 0x00, M_EQ, "None" },
 159     { 0x52, 0xc1, 0x01, M_EQ, "64KB" },
 160     { 0x52, 0xc1, 0x41, M_EQ, "128KB" },
 161     { 0x52, 0xc1, 0x81, M_EQ, "256KB" },
 162     { 0x52, 0xc1, 0xc1, M_EQ, "512KB" },
 163     { 0x52, 0x03, 0x01, M_EQ, " writethrough" },
 164     { 0x52, 0x03, 0x03, M_EQ, " writeback" },
 165
 166     { 0x52, 0x01, 0x01, M_EQ, ", cache clocks=" },
 167     { 0x52, 0x05, 0x01, M_EQ, "3-1-1-1" },
 168     { 0x52, 0x05, 0x05, M_EQ, "2-1-1-1" },
 169
 170     { 0x00, 0x00, 0x00, M_TR, "\n\tDRAM:" },
 171     { 0x55, 0x43, 0x00, M_NE, " page mode" },
 172     { 0x55, 0x02, 0x02, M_EQ, " code fetch" },
 173     { 0x55, 0x43, 0x43, M_EQ, "," },
 174     { 0x55, 0x43, 0x42, M_EQ, " and" },
 175     { 0x55, 0x40, 0x40, M_EQ, " read" },
 176     { 0x55, 0x03, 0x03, M_EQ, " and" },
 177     { 0x55, 0x43, 0x41, M_EQ, " and" },
 178     { 0x55, 0x01, 0x01, M_EQ, " write" },
 179     { 0x55, 0x43, 0x00, M_NE, "," },
 180
 181     { 0x00, 0x00, 0x00, M_TR, " memory clocks=" },
 182     { 0x55, 0x20, 0x00, M_EQ, "X-2-2-2" },
 183     { 0x55, 0x20, 0x20, M_EQ, "X-1-2-1" },
 184
 185     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU->PCI: posting " },
 186     { 0x53, 0x02, 0x00, M_NE, "ON" },
 187     { 0x53, 0x02, 0x00, M_EQ, "OFF" },
 188     { 0x00, 0x00, 0x00, M_TR, ", burst mode " },
 189     { 0x54, 0x02, 0x00, M_NE, "ON" },
 190     { 0x54, 0x02, 0x00, M_EQ, "OFF" },
 191     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI->Memory: posting " },
 192     { 0x54, 0x01, 0x00, M_NE, "ON" },
 193     { 0x54, 0x01, 0x00, M_EQ, "OFF" },
 194
 195     { 0x00, 0x00, 0x00, M_TR, "\n" },
 196
 197 /* end marker */
 198     { 0 }
 199 };
 200
 201 static const struct condmsg conf82434lx[] =
 202 {
 203     { 0x00, 0x00, 0x00, M_TR, "\tCPU: " },
 204     { 0x50, 0xe3, 0x82, M_EQ, "Pentium, 60MHz" },
 205     { 0x50, 0xe3, 0x83, M_EQ, "Pentium, 66MHz" },
 206     { 0x50, 0xe3, 0xa2, M_EQ, "Pentium, 90MHz" },
 207     { 0x50, 0xe3, 0xa3, M_EQ, "Pentium, 100MHz" },
 208     { 0x50, 0xc2, 0x82, M_NE, "(unknown)" },
 209     { 0x50, 0x04, 0x00, M_EQ, " (primary cache OFF)" },
 210
 211     { 0x53, 0x01, 0x01, M_TR, ", CPU->Memory posting "},
 212     { 0x53, 0x01, 0x01, M_NE, "OFF" },
 213     { 0x53, 0x01, 0x01, M_EQ, "ON" },
 214
 215     { 0x53, 0x08, 0x00, M_NE, ", read around write"},
 216
 217     { 0x70, 0x04, 0x00, M_EQ, "\n\tWarning: Cache parity disabled!" },
 218     { 0x57, 0x20, 0x00, M_NE, "\n\tWarning: DRAM parity mask!" },
 219     { 0x57, 0x01, 0x00, M_EQ, "\n\tWarning: refresh OFF! " },
 220
 221     { 0x00, 0x00, 0x00, M_TR, "\n\tCache: " },
 222     { 0x52, 0x01, 0x00, M_EQ, "None" },
 223     { 0x52, 0x81, 0x01, M_EQ, "" },
 224     { 0x52, 0xc1, 0x81, M_EQ, "256KB" },
 225     { 0x52, 0xc1, 0xc1, M_EQ, "512KB" },
 226     { 0x52, 0x03, 0x01, M_EQ, " writethrough" },
 227     { 0x52, 0x03, 0x03, M_EQ, " writeback" },
 228
 229     { 0x52, 0x01, 0x01, M_EQ, ", cache clocks=" },
 230     { 0x52, 0x21, 0x01, M_EQ, "3-2-2-2/4-2-2-2" },
 231     { 0x52, 0x21, 0x21, M_EQ, "3-1-1-1" },
 232
 233     { 0x52, 0x01, 0x01, M_EQ, "\n\tCache flags: " },
 234     { 0x52, 0x11, 0x11, M_EQ, " cache-all" },
 235     { 0x52, 0x09, 0x09, M_EQ, " byte-control" },
 236     { 0x52, 0x05, 0x05, M_EQ, " powersaver" },
 237
 238     { 0x00, 0x00, 0x00, M_TR, "\n\tDRAM:" },
 239     { 0x57, 0x10, 0x00, M_EQ, " page mode" },
 240
 241     { 0x00, 0x00, 0x00, M_TR, " memory clocks=" },
 242     { 0x57, 0xc0, 0x00, M_EQ, "X-4-4-4 (70ns)" },
 243     { 0x57, 0xc0, 0x40, M_EQ, "X-4-4-4/X-3-3-3 (60ns)" },
 244     { 0x57, 0xc0, 0x80, M_EQ, "???" },
 245     { 0x57, 0xc0, 0xc0, M_EQ, "X-3-3-3 (50ns)" },
 246     { 0x58, 0x02, 0x02, M_EQ, ", RAS-wait" },
 247     { 0x58, 0x01, 0x01, M_EQ, ", CAS-wait" },
 248
 249     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU->PCI: posting " },
 250     { 0x53, 0x02, 0x02, M_EQ, "ON" },
 251     { 0x53, 0x02, 0x00, M_EQ, "OFF" },
 252     { 0x00, 0x00, 0x00, M_TR, ", burst mode " },
 253     { 0x54, 0x02, 0x00, M_NE, "ON" },
 254     { 0x54, 0x02, 0x00, M_EQ, "OFF" },
 255     { 0x54, 0x04, 0x00, M_TR, ", PCI clocks=" },
 256     { 0x54, 0x04, 0x00, M_EQ, "2-2-2-2" },
 257     { 0x54, 0x04, 0x00, M_NE, "2-1-1-1" },
 258     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI->Memory: posting " },
 259     { 0x54, 0x01, 0x00, M_NE, "ON" },
 260     { 0x54, 0x01, 0x00, M_EQ, "OFF" },
 261
 262     { 0x57, 0x01, 0x01, M_EQ, "\n\tRefresh:" },
 263     { 0x57, 0x03, 0x03, M_EQ, " CAS#/RAS#(Hidden)" },
 264     { 0x57, 0x03, 0x01, M_EQ, " RAS#Only" },
 265     { 0x57, 0x05, 0x05, M_EQ, " BurstOf4" },
 266
 267     { 0x00, 0x00, 0x00, M_TR, "\n" },
 268
 269 /* end marker */
 270     { 0 }
 271 };
 272
 273 static const struct condmsg conf82378[] =
 274 {
 275     { 0x00, 0x00, 0x00, M_TR, "\tBus Modes:" },
 276     { 0x41, 0x04, 0x04, M_EQ, " Bus Park," },
 277     { 0x41, 0x02, 0x02, M_EQ, " Bus Lock," },
 278     { 0x41, 0x02, 0x00, M_EQ, " Resource Lock," },
 279     { 0x41, 0x01, 0x01, M_EQ, " GAT" },
 280     { 0x4d, 0x20, 0x20, M_EQ, "\n\tCoprocessor errors enabled" },
 281     { 0x4d, 0x10, 0x10, M_EQ, "\n\tMouse function enabled" },
 282
 283     { 0x4e, 0x30, 0x10, M_EQ, "\n\tIDE controller: Primary (1F0h-1F7h,3F6h,3F7h)" },
 284     { 0x4e, 0x30, 0x30, M_EQ, "\n\tIDE controller: Secondary (170h-177h,376h,377h)" },
 285     { 0x4e, 0x28, 0x08, M_EQ, "\n\tFloppy controller: 3F0h,3F1h " },
 286     { 0x4e, 0x24, 0x04, M_EQ, "\n\tFloppy controller: 3F2h-3F7h " },
 287     { 0x4e, 0x28, 0x28, M_EQ, "\n\tFloppy controller: 370h,371h " },
 288     { 0x4e, 0x24, 0x24, M_EQ, "\n\tFloppy controller: 372h-377h " },
 289     { 0x4e, 0x02, 0x02, M_EQ, "\n\tKeyboard controller: 60h,62h,64h,66h" },
 290     { 0x4e, 0x01, 0x01, M_EQ, "\n\tRTC: 70h-77h" },
 291
 292     { 0x4f, 0x80, 0x80, M_EQ, "\n\tConfiguration RAM: 0C00h,0800h-08FFh" },
 293     { 0x4f, 0x40, 0x40, M_EQ, "\n\tPort 92: enabled" },
 294     { 0x4f, 0x03, 0x00, M_EQ, "\n\tSerial Port A: COM1 (3F8h-3FFh)" },
 295     { 0x4f, 0x03, 0x01, M_EQ, "\n\tSerial Port A: COM2 (2F8h-2FFh)" },
 296     { 0x4f, 0x0c, 0x00, M_EQ, "\n\tSerial Port B: COM1 (3F8h-3FFh)" },
 297     { 0x4f, 0x0c, 0x04, M_EQ, "\n\tSerial Port B: COM2 (2F8h-2FFh)" },
 298     { 0x4f, 0x30, 0x00, M_EQ, "\n\tParallel Port: LPT1 (3BCh-3BFh)" },
 299     { 0x4f, 0x30, 0x04, M_EQ, "\n\tParallel Port: LPT2 (378h-37Fh)" },
 300     { 0x4f, 0x30, 0x20, M_EQ, "\n\tParallel Port: LPT3 (278h-27Fh)" },
 301     { 0x00, 0x00, 0x00, M_TR, "\n" },
 302
 303 /* end marker */
 304     { 0 }
 305 };
 306
 307 static const struct condmsg conf82437fx[] =
 308 {
 309     /* PCON -- PCI Control Register */
 310     { 0x00, 0x00, 0x00, M_TR, "\tCPU Inactivity timer: " },
 311     { 0x50, 0xe0, 0xe0, M_EQ, "8" },
 312     { 0x50, 0xe0, 0xd0, M_EQ, "7" },
 313     { 0x50, 0xe0, 0xc0, M_EQ, "6" },
 314     { 0x50, 0xe0, 0xb0, M_EQ, "5" },
 315     { 0x50, 0xe0, 0xa0, M_EQ, "4" },
 316     { 0x50, 0xe0, 0x90, M_EQ, "3" },
 317     { 0x50, 0xe0, 0x80, M_EQ, "2" },
 318     { 0x50, 0xe0, 0x00, M_EQ, "1" },
 319     { 0x00, 0x00, 0x00, M_TR, " clocks\n\tPeer Concurrency: " },
 320     { 0x50, 0x08, 0x08, M_EN, 0 },
 321     { 0x00, 0x00, 0x00, M_TR, "\n\tCPU-to-PCI Write Bursting: " },
 322     { 0x50, 0x04, 0x00, M_NN, 0 },
 323     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI Streaming: " },
 324     { 0x50, 0x02, 0x00, M_NN, 0 },
 325     { 0x00, 0x00, 0x00, M_TR, "\n\tBus Concurrency: " },
 326     { 0x50, 0x01, 0x00, M_NN, 0 },
 327
 328     /* CC -- Cache Control Regsiter */
 329     { 0x00, 0x00, 0x00, M_TR, "\n\tCache:" },
 330     { 0x52, 0xc0, 0x80, M_EQ, " 512K" },
 331     { 0x52, 0xc0, 0x40, M_EQ, " 256K" },
 332     { 0x52, 0xc0, 0x00, M_EQ, " NO" },
 333     { 0x52, 0x30, 0x00, M_EQ, " pipelined-burst" },
 334     { 0x52, 0x30, 0x10, M_EQ, " burst" },
 335     { 0x52, 0x30, 0x20, M_EQ, " asynchronous" },
 336     { 0x52, 0x30, 0x30, M_EQ, " dual-bank pipelined-burst" },
 337     { 0x00, 0x00, 0x00, M_TR, " secondary; L1 " },
 338     { 0x52, 0x01, 0x00, M_EN, 0 },
 339     { 0x00, 0x00, 0x00, M_TR, "\n" },
 340
 341     /* DRAMC -- DRAM Control Register */
 342     { 0x57, 0x07, 0x00, M_EQ, "Warning: refresh OFF!\n" },
 343     { 0x00, 0x00, 0x00, M_TR, "\tDRAM:" },
 344     { 0x57, 0xc0, 0x00, M_EQ, " no memory hole" },
 345     { 0x57, 0xc0, 0x40, M_EQ, " 512K-640K memory hole" },
 346     { 0x57, 0xc0, 0x80, M_EQ, " 15M-16M memory hole" },
 347     { 0x57, 0x07, 0x01, M_EQ, ", 50 MHz refresh" },
 348     { 0x57, 0x07, 0x02, M_EQ, ", 60 MHz refresh" },
 349     { 0x57, 0x07, 0x03, M_EQ, ", 66 MHz refresh" },
 350
 351     /* DRAMT = DRAM Timing Register */
 352     { 0x00, 0x00, 0x00, M_TR, "\n\tRead burst timing: " },
 353     { 0x58, 0x60, 0x00, M_EQ, "x-4-4-4/x-4-4-4" },
 354     { 0x58, 0x60, 0x20, M_EQ, "x-3-3-3/x-4-4-4" },
 355     { 0x58, 0x60, 0x40, M_EQ, "x-2-2-2/x-3-3-3" },
 356     { 0x58, 0x60, 0x60, M_EQ, "???" },
 357     { 0x00, 0x00, 0x00, M_TR, "\n\tWrite burst timing: " },
 358     { 0x58, 0x18, 0x00, M_EQ, "x-4-4-4" },
 359     { 0x58, 0x18, 0x08, M_EQ, "x-3-3-3" },
 360     { 0x58, 0x18, 0x10, M_EQ, "x-2-2-2" },
 361     { 0x58, 0x18, 0x18, M_EQ, "???" },
 362     { 0x00, 0x00, 0x00, M_TR, "\n\tRAS-CAS delay: " },
 363     { 0x58, 0x04, 0x00, M_EQ, "3" },
 364     { 0x58, 0x04, 0x04, M_EQ, "2" },
 365     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },
 366
 367     /* end marker */
 368     { 0 }
 369 };
 370
 371 static const struct condmsg conf82437vx[] =
 372 {
 373     /* PCON -- PCI Control Register */
 374     { 0x00, 0x00, 0x00, M_TR, "\n\tPCI Concurrency: " },
 375     { 0x50, 0x08, 0x08, M_EN, 0 },
 376
 377     /* CC -- Cache Control Regsiter */
 378     { 0x00, 0x00, 0x00, M_TR, "\n\tCache:" },
 379     { 0x52, 0xc0, 0x80, M_EQ, " 512K" },
 380     { 0x52, 0xc0, 0x40, M_EQ, " 256K" },
 381     { 0x52, 0xc0, 0x00, M_EQ, " NO" },
 382     { 0x52, 0x30, 0x00, M_EQ, " pipelined-burst" },
 383     { 0x52, 0x30, 0x10, M_EQ, " burst" },
 384     { 0x52, 0x30, 0x20, M_EQ, " asynchronous" },
 385     { 0x52, 0x30, 0x30, M_EQ, " dual-bank pipelined-burst" },
 386     { 0x00, 0x00, 0x00, M_TR, " secondary; L1 " },
 387     { 0x52, 0x01, 0x00, M_EN, 0 },
 388     { 0x00, 0x00, 0x00, M_TR, "\n" },
 389
 390     /* DRAMC -- DRAM Control Register */
 391     { 0x57, 0x07, 0x00, M_EQ, "Warning: refresh OFF!\n" },
 392     { 0x00, 0x00, 0x00, M_TR, "\tDRAM:" },
 393     { 0x57, 0xc0, 0x00, M_EQ, " no memory hole" },
 394     { 0x57, 0xc0, 0x40, M_EQ, " 512K-640K memory hole" },
 395     { 0x57, 0xc0, 0x80, M_EQ, " 15M-16M memory hole" },
 396     { 0x57, 0x07, 0x01, M_EQ, ", 50 MHz refresh" },
 397     { 0x57, 0x07, 0x02, M_EQ, ", 60 MHz refresh" },
 398     { 0x57, 0x07, 0x03, M_EQ, ", 66 MHz refresh" },
 399
 400     /* DRAMT = DRAM Timing Register */
 401     { 0x00, 0x00, 0x00, M_TR, "\n\tRead burst timing: " },
 402     { 0x58, 0x60, 0x00, M_EQ, "x-4-4-4/x-4-4-4" },
 403     { 0x58, 0x60, 0x20, M_EQ, "x-3-3-3/x-4-4-4" },
 404     { 0x58, 0x60, 0x40, M_EQ, "x-2-2-2/x-3-3-3" },
 405     { 0x58, 0x60, 0x60, M_EQ, "???" },
 406     { 0x00, 0x00, 0x00, M_TR, "\n\tWrite burst timing: " },
 407     { 0x58, 0x18, 0x00, M_EQ, "x-4-4-4" },
 408     { 0x58, 0x18, 0x08, M_EQ, "x-3-3-3" },
 409     { 0x58, 0x18, 0x10, M_EQ, "x-2-2-2" },
 410     { 0x58, 0x18, 0x18, M_EQ, "???" },
 411     { 0x00, 0x00, 0x00, M_TR, "\n\tRAS-CAS delay: " },
 412     { 0x58, 0x04, 0x00, M_EQ, "3" },
 413     { 0x58, 0x04, 0x04, M_EQ, "2" },
 414     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },
 415
 416     /* end marker */
 417     { 0 }
 418 };
 419
 420 static const struct condmsg conf82371fb[] =
 421 {
 422     /* IORT -- ISA I/O Recovery Timer Register */
 423     { 0x00, 0x00, 0x00, M_TR, "\tI/O Recovery Timing: 8-bit " },
 424     { 0x4c, 0x40, 0x00, M_EQ, "3.5" },
 425     { 0x4c, 0x78, 0x48, M_EQ, "1" },
 426     { 0x4c, 0x78, 0x50, M_EQ, "2" },
 427     { 0x4c, 0x78, 0x58, M_EQ, "3" },
 428     { 0x4c, 0x78, 0x60, M_EQ, "4" },
 429     { 0x4c, 0x78, 0x68, M_EQ, "5" },
 430     { 0x4c, 0x78, 0x70, M_EQ, "6" },
 431     { 0x4c, 0x78, 0x78, M_EQ, "7" },
 432     { 0x4c, 0x78, 0x40, M_EQ, "8" },
 433     { 0x00, 0x00, 0x00, M_TR, " clocks, 16-bit " },
 434     { 0x4c, 0x04, 0x00, M_EQ, "3.5" },
 435     { 0x4c, 0x07, 0x05, M_EQ, "1" },
 436     { 0x4c, 0x07, 0x06, M_EQ, "2" },
 437     { 0x4c, 0x07, 0x07, M_EQ, "3" },
 438     { 0x4c, 0x07, 0x04, M_EQ, "4" },
 439     { 0x00, 0x00, 0x00, M_TR, " clocks\n" },
 440
 441     /* XBCS -- X-Bus Chip Select Register */
 442     { 0x00, 0x00, 0x00, M_TR, "\tExtended BIOS: " },
 443     { 0x4e, 0x80, 0x80, M_EN, 0 },
 444     { 0x00, 0x00, 0x00, M_TR, "\n\tLower BIOS: " },
 445     { 0x4e, 0x40, 0x40, M_EN, 0 },
 446     { 0x00, 0x00, 0x00, M_TR, "\n\tCoprocessor IRQ13: " },
 447     { 0x4e, 0x20, 0x20, M_EN, 0 },
 448     { 0x00, 0x00, 0x00, M_TR, "\n\tMouse IRQ12: " },
 449     { 0x4e, 0x10, 0x10, M_EN, 0 },
 450     { 0x00, 0x00, 0x00, M_TR, "\n" },
 451
 452     { 0x00, 0x00, 0x00, M_TR, "\tInterrupt Routing: " },
 453 #define PIRQ(x, n) \
 454     { 0x00, 0x00, 0x00, M_TR, n ": " }, \
 455     { x, 0x80, 0x80, M_EQ, "disabled" }, \
 456     { x, 0xc0, 0x40, M_EQ, "[shared] " }, \
 457     { x, 0x8f, 0x03, M_EQ, "IRQ3" }, \
 458     { x, 0x8f, 0x04, M_EQ, "IRQ4" }, \
 459     { x, 0x8f, 0x05, M_EQ, "IRQ5" }, \
 460     { x, 0x8f, 0x06, M_EQ, "IRQ6" }, \
 461     { x, 0x8f, 0x07, M_EQ, "IRQ7" }, \
 462     { x, 0x8f, 0x09, M_EQ, "IRQ9" }, \
 463     { x, 0x8f, 0x0a, M_EQ, "IRQ10" }, \
 464     { x, 0x8f, 0x0b, M_EQ, "IRQ11" }, \
 465     { x, 0x8f, 0x0c, M_EQ, "IRQ12" }, \
 466     { x, 0x8f, 0x0e, M_EQ, "IRQ14" }, \
 467     { x, 0x8f, 0x0f, M_EQ, "IRQ15" }
 468
 469     /* Interrupt routing */
 470     PIRQ(0x60, "A"),
 471     PIRQ(0x61, ", B"),
 472     PIRQ(0x62, ", C"),
 473     PIRQ(0x63, ", D"),
 474     PIRQ(0x70, "\n\t\tMB0"),
 475     PIRQ(0x71, ", MB1"),
 476
 477     { 0x00, 0x00, 0x00, M_TR, "\n" },
 478
 479 #undef PIRQ
 480
 481     /* XXX - do DMA routing, too? */
 482     { 0 }
 483 };
 484
 485 static const struct condmsg conf82371fb2[] =
 486 {
 487     /* IDETM -- IDE Timing Register */
 488     { 0x00, 0x00, 0x00, M_TR, "\tPrimary IDE: " },
 489     { 0x41, 0x80, 0x80, M_EN, 0 },
 490     { 0x00, 0x00, 0x00, M_TR, "\n\tSecondary IDE: " },
 491     { 0x43, 0x80, 0x80, M_EN, 0 },
 492     { 0x00, 0x00, 0x00, M_TR, "\n" },
 493
 494     /* end of list */
 495     { 0 }
 496 };
 497
 498 static void
 499 writeconfig (device_t dev, const struct condmsg *tbl)
 500 {
 501     while (tbl->flags != M_XX) {
 502         const char *text = 0;
 503
 504         if (tbl->flags == M_TR) {
 505             text = tbl->text;
 506         } else {
 507             unsigned char v = pci_read_config(dev, tbl->port, 1);
 508             switch (tbl->flags) {
 509     case M_EQ:
 510                 if ((v & tbl->mask) == tbl->value) text = tbl->text;
 511                 break;
 512     case M_NE:
 513                 if ((v & tbl->mask) != tbl->value) text = tbl->text;
 514                 break;
 515     case M_EN:
 516                 text = (v & tbl->mask) ? "enabled" : "disabled";
 517                 break;
 518     case M_NN:
 519                 text = (v & tbl->mask) ? "disabled" : "enabled";
 520             }
 521         }
 522         if (text) printf ("%s", text);
 523         tbl++;
 524     }
 525 }
 526
 527 #endif /* PCI_QUIET */
 528
 529 static void
 530 chipset_attach (device_t dev, int unit)
 531 {
 532 #ifndef PCI_QUIET
 533         if (!bootverbose)
 534                 return;
 535
 536         switch (pci_get_devid(dev)) {
 537         case 0x04868086:
 538                 writeconfig (dev, conf82425ex);
 539                 break;
 540         case 0x04838086:
 541                 writeconfig (dev, conf82424zx);
 542                 break;
 543         case 0x04a38086:
 544                 writeconfig (dev, conf82434lx);
 545                 break;
 546         case 0x04848086:
 547                 writeconfig (dev, conf82378);
 548                 break;
 549         case 0x122d8086:
 550                 writeconfig (dev, conf82437fx);
 551                 break;
 552         case 0x70308086:
 553                 writeconfig (dev, conf82437vx);
 554                 break;
 555         case 0x70008086:
 556         case 0x122e8086:
 557                 writeconfig (dev, conf82371fb);
 558                 break;
 559         case 0x70108086:
 560         case 0x12308086:
 561                 writeconfig (dev, conf82371fb2);
 562                 break;
 563 #if 0
 564         case 0x00011011: /* DEC 21050 */
 565         case 0x00221014: /* IBM xxx */
 566                 writeconfig (dev, conf_pci2pci);
 567                 break;
 568 #endif
 569         };
 570 #endif /* PCI_QUIET */
 571 }
 572
 573 static const char *
 574 eisab_match(device_t dev)
 575 {
 576         switch (pci_get_devid(dev)) {
 577         case 0x04828086:
 578                 /* Recognize this specifically, it has PCI-HOST class (!) */
 579                 return ("Intel 82375EB PCI-EISA bridge");
 580         }
 581         if (pci_get_class(dev) == PCIC_BRIDGE
 582             && pci_get_subclass(dev) == PCIS_BRIDGE_EISA)
 583                 return pci_bridge_type(dev);
 584
 585         return NULL;
 586 }
 587
 588 static const char *
 589 isab_match(device_t dev)
 590 {
 591         unsigned        rev;
 592
 593         switch (pci_get_devid(dev)) {
 594         case 0x04848086:
 595                 rev = pci_get_revid(dev);
 596                 if (rev == 3)
 597                     return ("Intel 82378ZB PCI to ISA bridge");
 598                 return ("Intel 82378IB PCI to ISA bridge");
 599         case 0x122e8086:
 600                 return ("Intel 82371FB PCI to ISA bridge");
 601         case 0x70008086:
 602                 return ("Intel 82371SB PCI to ISA bridge");
 603         case 0x71108086:
 604                 return ("Intel 82371AB PCI to ISA bridge");
 605         case 0x71988086:
 606                 return ("Intel 82443MX PCI to ISA bridge");
 607         case 0x24108086:
 608                 return ("Intel 82801AA (ICH) PCI to LPC bridge");
 609         case 0x24208086:
 610                 return ("Intel 82801AB (ICH0) PCI to LPC bridge");
 611         case 0x24408086:
 612                 return ("Intel 82801BA/BAM (ICH2) PCI to LPC bridge");
 613         case 0x26408086:
 614                 return ("Intel 82801FB/FBW (ICH6) PCI to LPC bridge");
 615         case 0x26428086:
 616                 return ("Intel 82801FR/FRW (ICH6) PCI to LPC bridge");
 617
 618         /* NVIDIA -- vendor 0x10de */
 619         case 0x006010de:
 620                 return ("NVIDIA nForce2 PCI to ISA bridge");
 621
 622         /* VLSI -- vendor 0x1004 */
 623         case 0x00061004:
 624                 return ("VLSI 82C593 PCI to ISA bridge");
 625
 626         /* VIA Technologies -- vendor 0x1106 */
 627         case 0x05861106: /* south bridge section */
 628                 return ("VIA 82C586 PCI-ISA bridge");
 629         case 0x05961106:
 630                 return ("VIA 82C596B PCI-ISA bridge");
 631         case 0x06861106:
 632                 return ("VIA 82C686 PCI-ISA bridge");
 633
 634         /* AcerLabs -- vendor 0x10b9 */
 635         /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
 636         /* id is '10b9" but the register always shows "10b9". -Foxfair  */
 637         case 0x153310b9:
 638                 return ("AcerLabs M1533 portable PCI-ISA bridge");
 639         case 0x154310b9:
 640                 return ("AcerLabs M1543 desktop PCI-ISA bridge");
 641
 642         /* SiS -- vendor 0x1039 */
 643         case 0x00081039:
 644                 return ("SiS 85c503 PCI-ISA bridge");
 645
 646         /* Cyrix -- vendor 0x1078 */
 647         case 0x00001078:
 648                 return ("Cyrix Cx5510 PCI-ISA bridge");
 649         case 0x01001078:
 650                 return ("Cyrix Cx5530 PCI-ISA bridge");
 651
 652         /* NEC -- vendor 0x1033 */
 653         /* The "C-bus" is 16-bits bus on PC98. */
 654         case 0x00011033:
 655                 return ("NEC 0001 PCI to PC-98 C-bus bridge");
 656         case 0x002c1033:
 657                 return ("NEC 002C PCI to PC-98 C-bus bridge");
 658         case 0x003b1033:
 659                 return ("NEC 003B PCI to PC-98 C-bus bridge");
 660         /* UMC United Microelectronics 0x1060 */
 661         case 0x886a1060:
 662                 return ("UMC UM8886 ISA Bridge with EIDE");
 663
 664         /* Cypress -- vendor 0x1080 */
 665         case 0xc6931080:
 666                 if (pci_get_class(dev) == PCIC_BRIDGE
 667                     && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)
 668                         return ("Cypress 82C693 PCI-ISA bridge");
 669                 break;
 670
 671         /* ServerWorks -- vendor 0x1166 */
 672         case 0x02001166:
 673                 return ("ServerWorks IB6566 PCI to ISA bridge");
 674         }
 675
 676         if (pci_get_class(dev) == PCIC_BRIDGE
 677             && pci_get_subclass(dev) == PCIS_BRIDGE_ISA)
 678                 return pci_bridge_type(dev);
 679
 680         return NULL;
 681 }
 682
 683 static int
 684 isab_probe(device_t dev)
 685 {
 686         const char *desc;
 687         int     is_eisa;
 688
 689         is_eisa = 0;
 690         desc = eisab_match(dev);
 691         if (desc)
 692                 is_eisa = 1;
 693         else
 694                 desc = isab_match(dev);
 695         if (desc) {
 696                 /*
 697                  * For a PCI-EISA bridge, add both eisa and isa.
 698                  * Only add one instance of eisa or isa for now.
 699                  */
 700                 device_set_desc_copy(dev, desc);
 701                 if (is_eisa && !devclass_get_device(devclass_find("eisa"), 0))
 702                         device_add_child(dev, "eisa", -1);
 703
 704                 if (!devclass_get_device(devclass_find("isa"), 0))
 705                         device_add_child(dev, "isa", -1);
 706                 return -1000;
 707         }
 708         return ENXIO;
 709 }
 710
 711 static int
 712 isab_attach(device_t dev)
 713 {
 714         chipset_attach(dev, device_get_unit(dev));
 715         return bus_generic_attach(dev);
 716 }
 717
 718 static device_method_t isab_methods[] = {
 719         /* Device interface */
 720         DEVMETHOD(device_probe,         isab_probe),
 721         DEVMETHOD(device_attach,        isab_attach),
 722         DEVMETHOD(device_shutdown,      bus_generic_shutdown),
 723         DEVMETHOD(device_suspend,       bus_generic_suspend),
 724         DEVMETHOD(device_resume,        bus_generic_resume),
 725
 726         /* Bus interface */
 727         DEVMETHOD(bus_print_child,      bus_generic_print_child),
 728         DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
 729         DEVMETHOD(bus_release_resource, bus_generic_release_resource),
 730         DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
 731         DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
 732         DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
 733         DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
 734
 735         { 0, 0 }
 736 };
 737
 738 static driver_t isab_driver = {
 739         "isab",
 740         isab_methods,
 741         1,
 742 };
 743
 744 devclass_t isab_devclass;
 745
 746 DRIVER_MODULE(isab, pci, isab_driver, isab_devclass, 0, 0);