Add amd64 files for the ISA and PCI busses and adjust the header files
authorMatthew Dillon <dillon@dragonflybsd.org>
Sat, 2 Aug 2008 05:22:21 +0000 (05:22 +0000)
committerMatthew Dillon <dillon@dragonflybsd.org>
Sat, 2 Aug 2008 05:22:21 +0000 (05:22 +0000)
to operate in more of a machine-independant fashion.

12 files changed:
sys/bus/isa/amd64/isa.c [new file with mode: 0644]
sys/bus/isa/amd64/isa.h [new file with mode: 0644]
sys/bus/isa/amd64/isa_compat.c [new file with mode: 0644]
sys/bus/isa/amd64/isa_compat.h [new file with mode: 0644]
sys/bus/isa/amd64/isa_device.h [new file with mode: 0644]
sys/bus/isa/amd64/isa_dma.c [new file with mode: 0644]
sys/bus/pci/amd64/pci_cfgreg.c [copied from sys/bus/pci/i386/pci_cfgreg.c with 98% similarity]
sys/bus/pci/amd64/pci_cfgreg.h [new file with mode: 0644]
sys/bus/pci/amd64/pcibus.c [new file with mode: 0644]
sys/bus/pci/amd64/pcibus.h [new file with mode: 0644]
sys/bus/pci/i386/pci_cfgreg.c
sys/platform/vkernel/i386/vm_machdep.c

diff --git a/sys/bus/isa/amd64/isa.c b/sys/bus/isa/amd64/isa.c
new file mode 100644 (file)
index 0000000..93de6c4
--- /dev/null
@@ -0,0 +1,164 @@
+/*-
+ * Copyright (c) 1998 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/i386/isa/isa.c,v 1.132.2.5 2002/03/03 05:42:50 nyan Exp $
+ * $DragonFly: src/sys/bus/isa/amd64/isa.c,v 1.1 2008/08/02 05:22:17 dillon Exp $
+ */
+
+/*
+ * Modifications for Intel architecture by Garrett A. Wollman.
+ * Copyright 1998 Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that both the above copyright notice and this
+ * permission notice appear in all copies, that both the above
+ * copyright notice and this permission notice appear in all
+ * supporting documentation, and that the name of M.I.T. not be used
+ * in advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.  M.I.T. makes
+ * no representations about the suitability of this software for any
+ * purpose.  It is provided "as is" without express or implied
+ * warranty.
+ * 
+ * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
+ * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
+ * SHALL M.I.T. BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/malloc.h>
+#include <sys/rman.h>
+
+#include "../isavar.h"
+#include "../isa_common.h"
+
+#include "opt_compat_oldisa.h"
+
+void
+isa_init(void)
+{
+#ifdef COMPAT_OLDISA
+       isa_wrap_old_drivers();
+#endif
+}
+
+/*
+ * This implementation simply passes the request up to the parent
+ * bus, which in our case is the special i386 nexus, substituting any
+ * configured values if the caller defaulted.  We can get away with
+ * this because there is no special mapping for ISA resources on an Intel
+ * platform.  When porting this code to another architecture, it may be
+ * necessary to interpose a mapping layer here.
+ */
+struct resource *
+isa_alloc_resource(device_t bus, device_t child, int type, int *rid,
+                  u_long start, u_long end, u_long count, u_int flags)
+{
+       /*
+        * Consider adding a resource definition. We allow rid 0-1 for
+        * irq and drq, 0-3 for memory and 0-7 for ports which is
+        * sufficient for isapnp.
+        */
+       int passthrough = (device_get_parent(child) != bus);
+       int isdefault = (start == 0UL && end == ~0UL);
+       struct isa_device* idev = DEVTOISA(child);
+       struct resource_list *rl = &idev->id_resources;
+       struct resource_list_entry *rle;
+       
+       if (!passthrough && !isdefault) {
+               rle = resource_list_find(rl, type, *rid);
+               if (!rle) {
+                       if (*rid < 0)
+                               return 0;
+                       switch (type) {
+                       case SYS_RES_IRQ:
+                               if (*rid >= ISA_NIRQ)
+                                       return 0;
+                               break;
+                       case SYS_RES_DRQ:
+                               if (*rid >= ISA_NDRQ)
+                                       return 0;
+                               break;
+                       case SYS_RES_MEMORY:
+                               if (*rid >= ISA_NMEM)
+                                       return 0;
+                               break;
+                       case SYS_RES_IOPORT:
+                               if (*rid >= ISA_NPORT)
+                                       return 0;
+                               break;
+                       default:
+                               return 0;
+                       }
+                       resource_list_add(rl, type, *rid, start, end, count);
+               }
+       }
+
+       return resource_list_alloc(rl, bus, child, type, rid,
+                                  start, end, count, flags);
+}
+
+int
+isa_release_resource(device_t bus, device_t child, int type, int rid,
+                    struct resource *r)
+{
+       struct isa_device* idev = DEVTOISA(child);
+       struct resource_list *rl = &idev->id_resources;
+
+       return resource_list_release(rl, bus, child, type, rid, r);
+}
+
+/*
+ * We can't use the bus_generic_* versions of these methods because those
+ * methods always pass the bus param as the requesting device, and we need
+ * to pass the child (the i386 nexus knows about this and is prepared to
+ * deal).
+ */
+int
+isa_setup_intr(device_t bus, device_t child, struct resource *r, int flags,
+              void (*ihand)(void *), void *arg,
+              void **cookiep, lwkt_serialize_t serializer)
+{
+       return (BUS_SETUP_INTR(device_get_parent(bus), child, r, flags,
+                              ihand, arg, cookiep, serializer));
+}
+
+int
+isa_teardown_intr(device_t bus, device_t child, struct resource *r,
+                 void *cookie)
+{
+       return (BUS_TEARDOWN_INTR(device_get_parent(bus), child, r, cookie));
+}
diff --git a/sys/bus/isa/amd64/isa.h b/sys/bus/isa/amd64/isa.h
new file mode 100644 (file)
index 0000000..8a60a0c
--- /dev/null
@@ -0,0 +1,199 @@
+/*-
+ * Copyright (c) 1990 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     from: @(#)isa.h 5.7 (Berkeley) 5/9/91
+ * $FreeBSD: src/sys/i386/isa/isa.h,v 1.23 1999/08/28 00:44:54 peter Exp $
+ * $DragonFly: src/sys/bus/isa/amd64/isa.h,v 1.1 2008/08/02 05:22:17 dillon Exp $
+ */
+
+#ifndef _BUS_ISA_ARCH_ISA_H_
+#define        _BUS_ISA_ARCH_ISA_H_
+
+/* BEWARE:  Included in both assembler and C code */
+
+/*
+ * ISA Bus conventions
+ */
+
+/*
+ * Input / Output Port Assignments
+ */
+#ifndef IO_ISABEGIN
+#define        IO_ISABEGIN     0x000           /* 0x000 - Beginning of I/O Registers */
+
+#define ICU_IMR_OFFSET 1               /* IO_ICU{1,2} + 1 */
+
+               /* CPU Board */
+#define        IO_DMA1         0x000           /* 8237A DMA Controller #1 */
+#define        IO_ICU1         0x020           /* 8259A Interrupt Controller #1 */
+#define        IO_PMP1         0x026           /* 82347 Power Management Peripheral */
+#define        IO_TIMER1       0x040           /* 8253 Timer #1 */
+#define        IO_TIMER2       0x048           /* 8253 Timer #2 */
+#define        IO_KBD          0x060           /* 8042 Keyboard */
+#define        IO_PPI          0x061           /* Programmable Peripheral Interface */
+#define        IO_RTC          0x070           /* RTC */
+#define        IO_NMI          IO_RTC          /* NMI Control */
+#define        IO_DMAPG        0x080           /* DMA Page Registers */
+#define        IO_ICU2         0x0A0           /* 8259A Interrupt Controller #2 */
+#define        IO_DMA2         0x0C0           /* 8237A DMA Controller #2 */
+#define        IO_NPX          0x0F0           /* Numeric Coprocessor */
+
+               /* Cards */
+                                       /* 0x100 - 0x16F Open */
+
+#define        IO_WD2          0x170           /* Secondary Fixed Disk Controller */
+
+#define        IO_PMP2         0x178           /* 82347 Power Management Peripheral */
+
+                                       /* 0x17A - 0x1EF Open */
+
+#define        IO_WD1          0x1F0           /* Primary Fixed Disk Controller */
+#define        IO_GAME         0x201           /* Game Controller */
+
+                                       /* 0x202 - 0x22A Open */
+
+#define        IO_ASC2         0x22B           /* AmiScan addr.grp. 2 */
+
+                                       /* 0x230 - 0x26A Open */
+
+#define        IO_ASC3         0x26B           /* AmiScan addr.grp. 3 */
+#define        IO_GSC1         0x270 /* -- 0x27B! GeniScan GS-4500 addr.grp. 1 */
+#define        IO_LPT2         0x278           /* Parallel Port #2 */
+
+                                       /* 0x280 - 0x2AA Open */
+
+#define        IO_ASC4         0x2AB           /* AmiScan addr.grp. 4 */
+
+                                       /* 0x2B0 - 0x2DF Open */
+
+#define        IO_GSC2         0x2E0           /* GeniScan GS-4500 addr.grp. 2 */
+#define        IO_COM4         0x2E8           /* COM4 i/o address */
+#define        IO_ASC5         0x2EB           /* AmiScan addr.grp. 5 */
+
+                                       /* 0x2F0 - 0x2F7 Open */
+
+#define        IO_COM2         0x2F8           /* COM2 i/o address */
+
+                                       /* 0x300 - 0x32A Open */
+
+#define        IO_ASC6         0x32B           /* AmiScan addr.grp. 6 */
+#define        IO_AHA0         0x330           /* adaptec 1542 default addr. */
+#define        IO_BT0          0x330           /* bustek 742a default addr. */
+#define        IO_UHA0         0x330           /* ultrastore 14f default addr. */
+#define        IO_AHA1         0x334           /* adaptec 1542 default addr. */
+#define        IO_BT1          0x334           /* bustek 742a default addr. */
+
+                                       /* 0x340 - 0x36A Open */
+
+#define        IO_ASC7         0x36B           /* AmiScan addr.grp. 7 */
+#define        IO_GSC3         0x370           /* GeniScan GS-4500 addr.grp. 3 */
+#define        IO_FD2          0x370           /* secondary base i/o address */
+#define        IO_LPT1         0x378           /* Parallel Port #1 */
+
+                                       /* 0x380 - 0x3AA Open */
+
+#define        IO_ASC8         0x3AB           /* AmiScan addr.grp. 8 */
+#define        IO_MDA          0x3B0           /* Monochome Adapter */
+#define        IO_LPT3         0x3BC           /* Monochome Adapter Printer Port */
+#define        IO_VGA          0x3C0           /* E/VGA Ports */
+#define        IO_CGA          0x3D0           /* CGA Ports */
+#define        IO_GSC4         0x3E0           /* GeniScan GS-4500 addr.grp. 4 */
+#define        IO_COM3         0x3E8           /* COM3 i/o address */
+#define        IO_ASC1         0x3EB           /* AmiScan addr.grp. 1 */
+#define        IO_FD1          0x3F0           /* primary base i/o address */
+#define        IO_COM1         0x3F8           /* COM1 i/o address */
+
+#define        IO_ISAEND       0x3FF           /* End (actually Max) of I/O Regs */
+#endif /* !IO_ISABEGIN */
+
+/*
+ * Input / Output Port Sizes - these are from several sources, and tend
+ * to be the larger of what was found.
+ */
+#ifndef        IO_ISASIZES
+#define        IO_ISASIZES
+
+#define        IO_ASCSIZE      5               /* AmiScan GI1904-based hand scanner */
+#define        IO_CGASIZE      12              /* CGA controllers */
+#define        IO_COMSIZE      8               /* 8250, 16x50 com controllers */
+#define        IO_DMASIZE      16              /* 8237 DMA controllers */
+#define        IO_DPGSIZE      32              /* 74LS612 DMA page registers */
+#define        IO_EISASIZE     256             /* EISA controllers */
+#define        IO_FDCSIZE      8               /* Nec765 floppy controllers */
+#define        IO_GAMSIZE      16              /* AT compatible game controllers */
+#define        IO_GSCSIZE      8               /* GeniScan GS-4500G hand scanner */
+#define        IO_ICUSIZE      16              /* 8259A interrupt controllers */
+#define        IO_KBDSIZE      16              /* 8042 Keyboard controllers */
+#define        IO_LPTSIZE      8               /* LPT controllers, some use only 4 */
+#define        IO_MDASIZE      12              /* Monochrome display controllers */
+#define        IO_NPXSIZE      16              /* 80387/80487 NPX registers */
+#define        IO_PMPSIZE      2               /* 82347 power management peripheral */
+#define        IO_PSMSIZE      5               /* 8042 Keyboard controllers */
+#define        IO_RTCSIZE      16              /* CMOS real time clock, NMI control */
+#define        IO_TMRSIZE      16              /* 8253 programmable timers */
+#define        IO_VGASIZE      16              /* VGA controllers */
+#define        IO_WDCSIZE      8               /* WD compatible disk controllers */
+
+#endif /* !IO_ISASIZES */
+
+/*
+ * Input / Output Memory Physical Addresses
+ */
+#ifndef        IOM_BEGIN
+#define        IOM_BEGIN       0x0A0000        /* Start of I/O Memory "hole" */
+#define        IOM_END         0x100000        /* End of I/O Memory "hole" */
+#define        IOM_SIZE        (IOM_END - IOM_BEGIN)
+#endif /* !IOM_BEGIN */
+
+/*
+ * RAM Physical Address Space (ignoring the above mentioned "hole")
+ */
+#ifndef        RAM_BEGIN
+#define        RAM_BEGIN       0x0000000       /* Start of RAM Memory */
+#define        RAM_END         0x1000000       /* End of RAM Memory */
+#define        RAM_SIZE        (RAM_END - RAM_BEGIN)
+#endif /* !RAM_BEGIN */
+
+/*
+ * Oddball Physical Memory Addresses
+ */
+#ifndef        COMPAQ_RAMRELOC
+#define        COMPAQ_RAMRELOC 0x80C00000      /* Compaq RAM relocation/diag */
+#define        COMPAQ_RAMSETUP 0x80C00002      /* Compaq RAM setup */
+#define        WEITEK_FPU      0xC0000000      /* WTL 2167 */
+#define        CYRIX_EMC       0xC0000000      /* Cyrix EMC */
+#endif /* !COMPAQ_RAMRELOC */
+
+#endif /* !_BUS_ISA_ARCH_ISA_H_ */
diff --git a/sys/bus/isa/amd64/isa_compat.c b/sys/bus/isa/amd64/isa_compat.c
new file mode 100644 (file)
index 0000000..ddd0c5d
--- /dev/null
@@ -0,0 +1,299 @@
+/*-
+ * Copyright (c) 1998 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/i386/isa/isa_compat.c,v 1.18.2.1 2001/05/17 23:05:06 imp Exp $
+ * $DragonFly: src/sys/bus/isa/amd64/isa_compat.c,v 1.1 2008/08/02 05:22:17 dillon Exp $
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/rman.h>
+
+#include <machine/vmparam.h>
+#include <vm/vm.h>
+#include <vm/pmap.h>
+#include <machine/pmap.h>
+#include <machine/md_var.h>
+
+#include "../isavar.h"
+#include "isa_compat.h"
+#include "isa_device.h"
+
+struct isa_compat_resources {
+    struct resource *ports;
+    struct resource *memory;
+    struct resource *drq;
+    struct resource *irq;
+};
+
+struct isa_compat_driver {
+       driver_t driver;
+       struct old_isa_driver *op;
+};
+
+int
+isa_compat_nextid(void)
+{
+       static int id = 2;      /* id_id of -1, 0 and 1 are "used" */
+
+       return id++;
+}
+
+static void
+isa_compat_alloc_resources(device_t dev, struct isa_compat_resources *res)
+{
+       int rid;
+       u_long start, count;
+
+       if (bus_get_resource(dev, SYS_RES_IOPORT, 0,
+                            &start, &count) == 0) {
+               rid = 0;
+               res->ports = bus_alloc_resource(dev, SYS_RES_IOPORT,
+                                               &rid, 0ul, ~0ul, 1,
+                                               RF_ACTIVE);
+               if (res->ports == NULL && bootverbose)
+                       kprintf("isa_compat: didn't get ports for %s\n",
+                              device_get_name(dev));
+       } else
+               res->ports = 0;
+
+       if (bus_get_resource(dev, SYS_RES_MEMORY, 0,
+                            &start, &count) == 0
+           && start != 0) {
+               rid = 0;
+               res->memory = bus_alloc_resource(dev, SYS_RES_MEMORY,
+                                                &rid, 0ul, ~0ul, 1,
+                                                RF_ACTIVE);
+               if (res->memory == NULL && bootverbose)
+                       kprintf("isa_compat: didn't get memory for %s\n",
+                              device_get_name(dev));
+       } else
+               res->memory = 0;
+
+       if (bus_get_resource(dev, SYS_RES_DRQ, 0,
+                            &start, &count) == 0) {
+               rid = 0;
+               res->drq = bus_alloc_resource(dev, SYS_RES_DRQ,
+                                             &rid, 0ul, ~0ul, 1,
+                                             RF_ACTIVE);
+               if (res->drq == NULL && bootverbose)
+                       kprintf("isa_compat: didn't get drq for %s\n",
+                              device_get_name(dev));
+       } else
+               res->drq = 0;
+
+       if (bus_get_resource(dev, SYS_RES_IRQ, 0,
+                            &start, &count) == 0) {
+               rid = 0;
+               res->irq = bus_alloc_resource(dev, SYS_RES_IRQ,
+                                             &rid, 0ul, ~0ul, 1,
+                                             RF_SHAREABLE | RF_ACTIVE);
+               if (res->irq == NULL && bootverbose)
+                       kprintf("isa_compat: didn't get irq for %s\n",
+                              device_get_name(dev));
+       } else
+               res->irq = 0;
+}
+
+static void
+isa_compat_release_resources(device_t dev, struct isa_compat_resources *res)
+{
+       if (res->ports) {
+               bus_release_resource(dev, SYS_RES_IOPORT, 0, res->ports);
+               res->ports = 0;
+       }
+       if (res->memory) {
+               bus_release_resource(dev, SYS_RES_MEMORY, 0, res->memory);
+               res->memory = 0;
+       }
+       if (res->drq) {
+               bus_release_resource(dev, SYS_RES_DRQ, 0, res->drq);
+               res->drq = 0;
+       }
+       if (res->irq) {
+               bus_release_resource(dev, SYS_RES_IRQ, 0, res->irq);
+               res->irq = 0;
+       }
+}
+
+#define        irqmask(x)      ((x) < 0 ? 0 : (1 << (x)))
+
+static int
+isa_compat_probe(device_t dev)
+{
+       struct isa_device *dvp = device_get_softc(dev);
+       struct isa_compat_resources res;
+       struct old_isa_driver *op;
+       u_long start, count;
+
+       /* No pnp support */
+       if (isa_get_vendorid(dev))
+               return (ENXIO);
+
+       bzero(&res, sizeof(res));
+       /*
+        * Fill in the isa_device fields.
+        */
+       op = ((struct isa_compat_driver *)device_get_driver(dev))->op;
+       dvp->id_id = isa_compat_nextid();
+       dvp->id_driver = op->driver;
+       if (bus_get_resource(dev, SYS_RES_IOPORT, 0,
+                            &start, &count) == 0)
+               dvp->id_iobase = start;
+       else
+               dvp->id_iobase = -1;
+       if (bus_get_resource(dev, SYS_RES_IRQ, 0,
+                            &start, &count) == 0)
+               dvp->id_irq = irqmask(start);
+       else
+               dvp->id_irq = 0;
+       if (bus_get_resource(dev, SYS_RES_DRQ, 0,
+                            &start, &count) == 0)
+               dvp->id_drq = start;
+       else
+               dvp->id_drq = -1;
+       if (bus_get_resource(dev, SYS_RES_MEMORY,
+                            0, &start, &count) == 0) {
+               dvp->id_maddr = (void *)(uintptr_t)start;
+               dvp->id_msize = count;
+       } else {
+               dvp->id_maddr = NULL;
+               dvp->id_msize = 0;
+       }
+       dvp->id_unit = device_get_unit(dev);
+       dvp->id_flags = device_get_flags(dev);
+       dvp->id_enabled = device_is_enabled(dev);       /* XXX unused */
+       dvp->id_device = dev;
+
+       /*
+        * Do the wrapped probe.
+        */
+       if (dvp->id_driver->probe) {
+               int portsize;
+               void *maddr;
+               struct isa_device old;
+
+               isa_compat_alloc_resources(dev, &res);
+               if (res.memory)
+                       maddr = rman_get_virtual(res.memory);
+               else
+                       maddr = 0;
+               dvp->id_maddr = maddr;
+               old = *dvp;
+               portsize = dvp->id_driver->probe(dvp);
+               isa_compat_release_resources(dev, &res);
+               if (portsize != 0) {
+                       if (portsize > 0 || dvp->id_iobase != old.id_iobase)
+                               bus_set_resource(dev, SYS_RES_IOPORT,
+                                                0, dvp->id_iobase, portsize);
+                       if (dvp->id_irq != old.id_irq)
+                               bus_set_resource(dev, SYS_RES_IRQ, 0,
+                                                ffs(dvp->id_irq) - 1, 1);
+                       if (dvp->id_drq != old.id_drq)
+                               bus_set_resource(dev, SYS_RES_DRQ, 0,
+                                                dvp->id_drq, 1);
+                       if (dvp->id_maddr != old.id_maddr
+                           || dvp->id_msize != old.id_msize) {
+                               maddr = dvp->id_maddr;
+                               if (maddr != NULL)
+                                       bus_set_resource(dev,
+                                                        SYS_RES_MEMORY,
+                                                        0,
+                                                        kvtop(maddr),
+                                                        dvp->id_msize);
+                               else
+                                       bus_delete_resource(dev,
+                                                           SYS_RES_MEMORY,
+                                                           0);
+                       }
+                       return 0;
+               }
+       }
+       return ENXIO;
+}
+
+static int
+isa_compat_attach(device_t dev)
+{
+       struct isa_device *dvp = device_get_softc(dev);
+       struct isa_compat_resources res;
+       int error;
+
+       bzero(&res, sizeof(res));
+       isa_compat_alloc_resources(dev, &res);
+       if (dvp->id_driver->attach)
+               dvp->id_driver->attach(dvp);
+       if (res.irq && dvp->id_irq && dvp->id_intr) {
+               struct old_isa_driver *op;
+               void *ih;
+
+               op = ((struct isa_compat_driver *)device_get_driver(dev))->op;
+               error = BUS_SETUP_INTR(device_get_parent(dev), dev,
+                                      res.irq, op->type,
+                                      dvp->id_intr,
+                                      (void *)(uintptr_t)dvp->id_unit,
+                                      &ih, NULL);
+               if (error)
+                       kprintf("isa_compat_attach: failed to setup intr: %d\n",
+                              error);
+       }
+       device_printf(dev, "driver is using old-style compatibility shims\n");
+       return 0;
+}
+
+static device_method_t isa_compat_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         isa_compat_probe),
+       DEVMETHOD(device_attach,        isa_compat_attach),
+
+       { 0, 0 }
+};
+
+/*
+ * Create a new style driver around each old isa driver.
+ */
+void
+isa_wrap_old_drivers(void)
+{
+       int i;
+       struct old_isa_driver *op;
+       devclass_t isa_devclass = devclass_find("isa");
+       struct isa_compat_driver *driver;
+
+       for (i = 0, op = &old_drivers[0]; i < old_drivers_count; i++, op++) {
+               driver = kmalloc(sizeof(struct isa_compat_driver), M_DEVBUF, M_WAITOK | M_ZERO);
+               driver->driver.name = op->driver->name;
+               driver->driver.methods = isa_compat_methods;
+               driver->driver.size = sizeof(struct isa_device);
+               driver->op = op;
+               if (op->driver->sensitive_hw)
+                       resource_set_int(op->driver->name, -1, "sensitive", 1);
+               devclass_add_driver(isa_devclass, (driver_t *)driver);
+       }
+}
diff --git a/sys/bus/isa/amd64/isa_compat.h b/sys/bus/isa/amd64/isa_compat.h
new file mode 100644 (file)
index 0000000..0f71ae4
--- /dev/null
@@ -0,0 +1,148 @@
+/*-
+ * Copyright (c) 1998 Doug Rabson
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/i386/isa/isa_compat.h,v 1.27.2.11 2002/10/05 18:31:48 scottl Exp $
+ * $DragonFly: src/sys/bus/isa/amd64/isa_compat.h,v 1.1 2008/08/02 05:22:17 dillon Exp $
+ */
+
+#include "use_cx.h"
+#include "use_el.h"
+#include "use_le.h"
+#include "use_rdp.h"
+#include "use_wt.h"
+#include "use_ctx.h"
+#include "use_spigot.h"
+#include "use_gp.h"
+#include "use_gsc.h"
+#include "use_cy.h"
+#include "use_dgb.h"
+#include "use_labpc.h"
+#include "use_rc.h"
+#include "use_tw.h"
+#include "use_asc.h"
+#include "use_stl.h"
+#include "use_stli.h"
+
+struct old_isa_driver {
+       int                     type;
+       struct isa_driver       *driver;
+};
+
+extern struct isa_driver  cxdriver;
+extern struct isa_driver  eldriver;
+extern struct isa_driver  ledriver;
+extern struct isa_driver rdpdriver;
+extern struct isa_driver  wtdriver;
+extern struct isa_driver ctxdriver;
+extern struct isa_driver spigotdriver;
+extern struct isa_driver  gpdriver;
+extern struct isa_driver gscdriver;
+extern struct isa_driver  cydriver;
+extern struct isa_driver dgbdriver;
+extern struct isa_driver labpcdriver;
+extern struct isa_driver  rcdriver;
+extern struct isa_driver  twdriver;
+extern struct isa_driver ascdriver;
+extern struct isa_driver stldriver;
+extern struct isa_driver stlidriver;
+
+
+static struct old_isa_driver old_drivers[] = {
+
+/* Sensitive TTY */
+
+/* Sensitive BIO */
+
+/* Sensitive NET */
+#if NRDP > 0
+       { 0, &rdpdriver },
+#endif
+
+/* Sensitive CAM */
+
+/* TTY */
+
+#if NGP > 0
+       { 0, &gpdriver },
+#endif
+#if NGSC > 0
+       { 0, &gscdriver },
+#endif
+#if NCY > 0
+       { INTR_FAST, &cydriver },
+#endif
+#if NDGB > 0
+       { 0, &dgbdriver },
+#endif
+#if NLABPC > 0
+       { 0, &labpcdriver },
+#endif
+#if NRC > 0
+       { 0, &rcdriver },
+#endif
+#if NTW > 0
+       { 0, &twdriver },
+#endif
+#if NASC > 0
+       { 0, &ascdriver },
+#endif
+#if NSTL > 0
+       { 0, &stldriver },
+#endif
+#if NSTLI > 0
+       { 0, &stlidriver },
+#endif
+
+/* BIO */
+
+#if NWT > 0
+       { 0, &wtdriver },
+#endif
+
+/* NET */
+
+#if NLE > 0
+       { 0, &ledriver },
+#endif
+#if NCX > 0
+       { 0, &cxdriver },
+#endif
+#if NEL > 0
+       { 0, &eldriver },
+#endif
+
+/* MISC */
+
+#if NCTX > 0
+       { 0, &ctxdriver },
+#endif
+#if NSPIGOT > 0
+       { 0, &spigotdriver },
+#endif
+
+};
+
+#define old_drivers_count (sizeof(old_drivers) / sizeof(old_drivers[0]))
+
diff --git a/sys/bus/isa/amd64/isa_device.h b/sys/bus/isa/amd64/isa_device.h
new file mode 100644 (file)
index 0000000..0124d5b
--- /dev/null
@@ -0,0 +1,89 @@
+/*-
+ * Copyright (c) 1991 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     from: @(#)isa_device.h  7.1 (Berkeley) 5/9/91
+ * $FreeBSD: src/sys/i386/isa/isa_device.h,v 1.68 2000/01/29 18:01:10 peter Exp $
+ * $DragonFly: src/sys/bus/isa/amd64/isa_device.h,v 1.1 2008/08/02 05:22:17 dillon Exp $
+ */
+
+#ifndef _BUS_ISA_ARCH_ISA_DEVICE_H_
+#define        _BUS_ISA_ARCH_ISA_DEVICE_H_
+
+#ifndef _SYS_INTERRUPT_H_
+#include <sys/interrupt.h>
+#endif
+
+/*
+ * ISA Bus Autoconfiguration
+ */
+
+/*
+ * Per device structure.
+ */
+struct isa_device {
+       int     id_id;          /* device id */
+       struct  isa_driver *id_driver;
+       int     id_iobase;      /* base i/o address */
+       int     id_iosize;      /* base i/o length */
+       u_int   id_irq;         /* interrupt request */
+       int     id_drq;         /* DMA request */
+       caddr_t id_maddr;       /* physical i/o memory address on bus (if any)*/
+       int     id_msize;       /* size of i/o memory */
+       inthand2_t *id_intr;
+       int     id_unit;        /* unit number */
+       int     id_flags;       /* flags */
+       int     id_enabled;     /* is device enabled */
+       struct isa_device *id_next; /* used in isa_devlist in userconfig() */
+       struct device *id_device; /* new-bus wrapper device */
+};
+
+/*
+ * Per-driver structure.
+ *
+ * Each device driver defines entries for a set of routines
+ * as well as an array of types which are acceptable to it.
+ * These are used at boot time by the configuration program.
+ */
+struct isa_driver {
+       int     (*probe) (struct isa_device *idp);
+                                       /* test whether device is present */
+       int     (*attach) (struct isa_device *idp);
+                                       /* setup driver for a device */
+       char    *name;                  /* device name */
+       int     sensitive_hw;           /* true if other probes confuse us */
+};
+
+#ifdef _KERNEL
+int    isa_compat_nextid (void);
+#endif
+
+#endif /* !_BUS_ISA_ARCH_ISA_DEVICE_H_ */
diff --git a/sys/bus/isa/amd64/isa_dma.c b/sys/bus/isa/amd64/isa_dma.c
new file mode 100644 (file)
index 0000000..0277fae
--- /dev/null
@@ -0,0 +1,515 @@
+/*-
+ * Copyright (c) 1991 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * William Jolitz.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *     This product includes software developed by the University of
+ *     California, Berkeley and its contributors.
+ * 4. Neither the name of the University nor the names of its contributors
+ *    may be used to endorse or promote products derived from this software
+ *    without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
+ * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+ * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+ * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
+ * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ *
+ *     from: @(#)isa.c 7.2 (Berkeley) 5/13/91
+ * $FreeBSD: src/sys/i386/isa/isa_dma.c,v 1.4.2.1 2000/08/08 19:49:53 peter Exp $
+ * $DragonFly: src/sys/bus/isa/amd64/isa_dma.c,v 1.1 2008/08/02 05:22:17 dillon Exp $
+ */
+
+/*
+ * code to manage AT bus
+ *
+ * 92/08/18  Frank P. MacLachlan (fpm@crash.cts.com):
+ * Fixed uninitialized variable problem and added code to deal
+ * with DMA page boundaries in isa_dmarangecheck().  Fixed word
+ * mode DMA count compution and reorganized DMA setup code in
+ * isa_dmastart()
+ */
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/buf.h>
+#include <vm/vm.h>
+#include <vm/vm_param.h>
+#include <vm/pmap.h>
+#include "isa.h"
+#include <machine_base/isa/ic/i8237.h>
+#include <machine/pmap.h>
+#include <bus/isa/isavar.h>
+
+/*
+**  Register definitions for DMA controller 1 (channels 0..3):
+*/
+#define        DMA1_CHN(c)     (IO_DMA1 + 1*(2*(c)))   /* addr reg for channel c */
+#define        DMA1_SMSK       (IO_DMA1 + 1*10)        /* single mask register */
+#define        DMA1_MODE       (IO_DMA1 + 1*11)        /* mode register */
+#define        DMA1_FFC        (IO_DMA1 + 1*12)        /* clear first/last FF */
+
+/*
+**  Register definitions for DMA controller 2 (channels 4..7):
+*/
+#define        DMA2_CHN(c)     (IO_DMA2 + 2*(2*(c)))   /* addr reg for channel c */
+#define        DMA2_SMSK       (IO_DMA2 + 2*10)        /* single mask register */
+#define        DMA2_MODE       (IO_DMA2 + 2*11)        /* mode register */
+#define        DMA2_FFC        (IO_DMA2 + 2*12)        /* clear first/last FF */
+
+static int isa_dmarangecheck (caddr_t va, u_int length, int chan);
+
+static caddr_t dma_bouncebuf[8];
+static u_int   dma_bouncebufsize[8];
+static u_int8_t        dma_bounced = 0;
+static u_int8_t        dma_busy = 0;           /* Used in isa_dmastart() */
+static u_int8_t        dma_inuse = 0;          /* User for acquire/release */
+static u_int8_t dma_auto_mode = 0;
+
+#define VALID_DMA_MASK (7)
+
+/* high byte of address is stored in this port for i-th dma channel */
+static int dmapageport[8] = { 0x87, 0x83, 0x81, 0x82, 0x8f, 0x8b, 0x89, 0x8a };
+
+/*
+ * Setup a DMA channel's bounce buffer.
+ */
+void
+isa_dmainit(int chan, u_int bouncebufsize)
+{
+       void *buf;
+
+#ifdef DIAGNOSTIC
+       if (chan & ~VALID_DMA_MASK)
+               panic("isa_dmainit: channel out of range");
+
+       if (dma_bouncebuf[chan] != NULL)
+               panic("isa_dmainit: impossible request"); 
+#endif
+
+       dma_bouncebufsize[chan] = bouncebufsize;
+
+       /* Try malloc() first.  It works better if it works. */
+       buf = kmalloc(bouncebufsize, M_DEVBUF, M_NOWAIT);
+       if (buf != NULL) {
+               if (isa_dmarangecheck(buf, bouncebufsize, chan) == 0) {
+                       dma_bouncebuf[chan] = buf;
+                       return;
+               }
+               kfree(buf, M_DEVBUF);
+       }
+       buf = contigmalloc(bouncebufsize, M_DEVBUF, M_NOWAIT, 0ul, 0xfffffful,
+                          1ul, chan & 4 ? 0x20000ul : 0x10000ul);
+       if (buf == NULL)
+               kprintf("isa_dmainit(%d, %d) failed\n", chan, bouncebufsize);
+       else
+               dma_bouncebuf[chan] = buf;
+}
+
+/*
+ * Register a DMA channel's usage.  Usually called from a device driver
+ * in open() or during its initialization.
+ */
+int
+isa_dma_acquire(int chan)
+{
+#ifdef DIAGNOSTIC
+       if (chan & ~VALID_DMA_MASK)
+               panic("isa_dma_acquire: channel out of range");
+#endif
+
+       if (dma_inuse & (1 << chan)) {
+               kprintf("isa_dma_acquire: channel %d already in use\n", chan);
+               return (EBUSY);
+       }
+       dma_inuse |= (1 << chan);
+       dma_auto_mode &= ~(1 << chan);
+
+       return (0);
+}
+
+/*
+ * Unregister a DMA channel's usage.  Usually called from a device driver
+ * during close() or during its shutdown.
+ */
+void
+isa_dma_release(int chan)
+{
+#ifdef DIAGNOSTIC
+       if (chan & ~VALID_DMA_MASK)
+               panic("isa_dma_release: channel out of range");
+
+       if ((dma_inuse & (1 << chan)) == 0)
+               kprintf("isa_dma_release: channel %d not in use\n", chan);
+#endif
+
+       if (dma_busy & (1 << chan)) {
+               dma_busy &= ~(1 << chan);
+               /* 
+                * XXX We should also do "dma_bounced &= (1 << chan);"
+                * because we are acting on behalf of isa_dmadone() which
+                * was not called to end the last DMA operation.  This does
+                * not matter now, but it may in the future.
+                */
+       }
+
+       dma_inuse &= ~(1 << chan);
+       dma_auto_mode &= ~(1 << chan);
+}
+
+/*
+ * isa_dmacascade(): program 8237 DMA controller channel to accept
+ * external dma control by a board.
+ */
+void
+isa_dmacascade(int chan)
+{
+#ifdef DIAGNOSTIC
+       if (chan & ~VALID_DMA_MASK)
+               panic("isa_dmacascade: channel out of range");
+#endif
+
+       /* set dma channel mode, and set dma channel mode */
+       if ((chan & 4) == 0) {
+               outb(DMA1_MODE, DMA37MD_CASCADE | chan);
+               outb(DMA1_SMSK, chan);
+       } else {
+               outb(DMA2_MODE, DMA37MD_CASCADE | (chan & 3));
+               outb(DMA2_SMSK, chan & 3);
+       }
+}
+
+/*
+ * isa_dmastart(): program 8237 DMA controller channel, avoid page alignment
+ * problems by using a bounce buffer.
+ */
+void
+isa_dmastart(int flags, caddr_t addr, u_int nbytes, int chan)
+{
+       vm_paddr_t phys;
+       int waport;
+       caddr_t newaddr;
+
+#ifdef DIAGNOSTIC
+       if (chan & ~VALID_DMA_MASK)
+               panic("isa_dmastart: channel out of range");
+
+       if ((chan < 4 && nbytes > (1<<16))
+           || (chan >= 4 && (nbytes > (1<<17) || (u_int)(uintptr_t)addr & 1)))
+               panic("isa_dmastart: impossible request");
+
+       if ((dma_inuse & (1 << chan)) == 0)
+               kprintf("isa_dmastart: channel %d not acquired\n", chan);
+#endif
+
+#if 0
+       /*
+        * XXX This should be checked, but drivers like ad1848 only call
+        * isa_dmastart() once because they use Auto DMA mode.  If we
+        * leave this in, drivers that do this will print this continuously.
+        */
+       if (dma_busy & (1 << chan))
+               kprintf("isa_dmastart: channel %d busy\n", chan);
+#endif
+
+       dma_busy |= (1 << chan);
+
+       if (isa_dmarangecheck(addr, nbytes, chan)) {
+               if (dma_bouncebuf[chan] == NULL
+                   || dma_bouncebufsize[chan] < nbytes)
+                       panic("isa_dmastart: bad bounce buffer"); 
+               dma_bounced |= (1 << chan);
+               newaddr = dma_bouncebuf[chan];
+
+               /* copy bounce buffer on write */
+               if (flags & ISADMA_WRITE)
+                       bcopy(addr, newaddr, nbytes);
+               addr = newaddr;
+       }
+
+       /* translate to physical */
+       phys = pmap_extract(&kernel_pmap, (vm_offset_t)addr);
+
+       if (flags & ISADMA_RAW) {
+           dma_auto_mode |= (1 << chan);
+       } else { 
+           dma_auto_mode &= ~(1 << chan);
+       }
+
+       if ((chan & 4) == 0) {
+               /*
+                * Program one of DMA channels 0..3.  These are
+                * byte mode channels.
+                */
+               /* set dma channel mode, and reset address ff */
+
+               /* If ISADMA_RAW flag is set, then use autoinitialise mode */
+               if (flags & ISADMA_RAW) {
+                 if (flags & ISADMA_READ)
+                       outb(DMA1_MODE, DMA37MD_AUTO|DMA37MD_WRITE|chan);
+                 else
+                       outb(DMA1_MODE, DMA37MD_AUTO|DMA37MD_READ|chan);
+               }
+               else
+               if (flags & ISADMA_READ)
+                       outb(DMA1_MODE, DMA37MD_SINGLE|DMA37MD_WRITE|chan);
+               else
+                       outb(DMA1_MODE, DMA37MD_SINGLE|DMA37MD_READ|chan);
+               outb(DMA1_FFC, 0);
+
+               /* send start address */
+               waport =  DMA1_CHN(chan);
+               outb(waport, phys);
+               outb(waport, phys>>8);
+               outb(dmapageport[chan], phys>>16);
+
+               /* send count */
+               outb(waport + 1, --nbytes);
+               outb(waport + 1, nbytes>>8);
+
+               /* unmask channel */
+               outb(DMA1_SMSK, chan);
+       } else {
+               /*
+                * Program one of DMA channels 4..7.  These are
+                * word mode channels.
+                */
+               /* set dma channel mode, and reset address ff */
+
+               /* If ISADMA_RAW flag is set, then use autoinitialise mode */
+               if (flags & ISADMA_RAW) {
+                 if (flags & ISADMA_READ)
+                       outb(DMA2_MODE, DMA37MD_AUTO|DMA37MD_WRITE|(chan&3));
+                 else
+                       outb(DMA2_MODE, DMA37MD_AUTO|DMA37MD_READ|(chan&3));
+               }
+               else
+               if (flags & ISADMA_READ)
+                       outb(DMA2_MODE, DMA37MD_SINGLE|DMA37MD_WRITE|(chan&3));
+               else
+                       outb(DMA2_MODE, DMA37MD_SINGLE|DMA37MD_READ|(chan&3));
+               outb(DMA2_FFC, 0);
+
+               /* send start address */
+               waport = DMA2_CHN(chan - 4);
+               outb(waport, phys>>1);
+               outb(waport, phys>>9);
+               outb(dmapageport[chan], phys>>16);
+
+               /* send count */
+               nbytes >>= 1;
+               outb(waport + 2, --nbytes);
+               outb(waport + 2, nbytes>>8);
+
+               /* unmask channel */
+               outb(DMA2_SMSK, chan & 3);
+       }
+}
+
+void
+isa_dmadone(int flags, caddr_t addr, int nbytes, int chan)
+{  
+#ifdef DIAGNOSTIC
+       if (chan & ~VALID_DMA_MASK)
+               panic("isa_dmadone: channel out of range");
+
+       if ((dma_inuse & (1 << chan)) == 0)
+               kprintf("isa_dmadone: channel %d not acquired\n", chan);
+#endif
+
+       if (((dma_busy & (1 << chan)) == 0) && 
+           (dma_auto_mode & (1 << chan)) == 0 )
+               kprintf("isa_dmadone: channel %d not busy\n", chan);
+
+       if ((dma_auto_mode & (1 << chan)) == 0)
+               outb(chan & 4 ? DMA2_SMSK : DMA1_SMSK, (chan & 3) | 4);
+
+       if (dma_bounced & (1 << chan)) {
+               /* copy bounce buffer on read */
+               if (flags & ISADMA_READ)
+                       bcopy(dma_bouncebuf[chan], addr, nbytes);
+
+               dma_bounced &= ~(1 << chan);
+       }
+       dma_busy &= ~(1 << chan);
+}
+
+/*
+ * Check for problems with the address range of a DMA transfer
+ * (non-contiguous physical pages, outside of bus address space,
+ * crossing DMA page boundaries).
+ * Return true if special handling needed.
+ */
+
+static int
+isa_dmarangecheck(caddr_t va, u_int length, int chan)
+{
+       vm_paddr_t phys, priorpage = 0;
+       vm_offset_t endva;
+       u_int dma_pgmsk = (chan & 4) ?  ~(128*1024-1) : ~(64*1024-1);
+
+       endva = (vm_offset_t)round_page((vm_offset_t)va + length);
+       for (; va < (caddr_t) endva ; va += PAGE_SIZE) {
+               phys = trunc_page(pmap_extract(&kernel_pmap, (vm_offset_t)va));
+#define ISARAM_END     RAM_END
+               if (phys == 0)
+                       panic("isa_dmacheck: no physical page present");
+               if (phys >= ISARAM_END)
+                       return (1);
+               if (priorpage) {
+                       if (priorpage + PAGE_SIZE != phys)
+                               return (1);
+                       /* check if crossing a DMA page boundary */
+                       if (((u_int)priorpage ^ (u_int)phys) & dma_pgmsk)
+                               return (1);
+               }
+               priorpage = phys;
+       }
+       return (0);
+}
+
+/*
+ * Query the progress of a transfer on a DMA channel.
+ *
+ * To avoid having to interrupt a transfer in progress, we sample
+ * each of the high and low databytes twice, and apply the following
+ * logic to determine the correct count.
+ *
+ * Reads are performed with interrupts disabled, thus it is to be
+ * expected that the time between reads is very small.  At most
+ * one rollover in the low count byte can be expected within the
+ * four reads that are performed.
+ *
+ * There are three gaps in which a rollover can occur :
+ *
+ * - read low1
+ *              gap1
+ * - read high1
+ *              gap2
+ * - read low2
+ *              gap3
+ * - read high2
+ *
+ * If a rollover occurs in gap1 or gap2, the low2 value will be
+ * greater than the low1 value.  In this case, low2 and high2 are a
+ * corresponding pair. 
+ *
+ * In any other case, low1 and high1 can be considered to be correct.
+ *
+ * The function returns the number of bytes remaining in the transfer,
+ * or -1 if the channel requested is not active.
+ *
+ */
+int
+isa_dmastatus(int chan)
+{
+       u_long  cnt = 0;
+       int     ffport, waport;
+       u_long  low1, high1, low2, high2;
+
+       /* channel active? */
+       if ((dma_inuse & (1 << chan)) == 0) {
+               kprintf("isa_dmastatus: channel %d not active\n", chan);
+               return(-1);
+       }
+       /* channel busy? */
+
+       if (((dma_busy & (1 << chan)) == 0) &&
+           (dma_auto_mode & (1 << chan)) == 0 ) {
+           kprintf("chan %d not busy\n", chan);
+           return -2 ;
+       }       
+       if (chan < 4) {                 /* low DMA controller */
+               ffport = DMA1_FFC;
+               waport = DMA1_CHN(chan) + 1;
+       } else {                        /* high DMA controller */
+               ffport = DMA2_FFC;
+               waport = DMA2_CHN(chan - 4) + 2;
+       }
+
+       cpu_disable_intr();             /* YYY *//* no interrupts Mr Jones! */
+       outb(ffport, 0);                /* clear register LSB flipflop */
+       low1 = inb(waport);
+       high1 = inb(waport);
+       outb(ffport, 0);                /* clear again */
+       low2 = inb(waport);
+       high2 = inb(waport);
+       cpu_enable_intr();              /* enable interrupts again */
+
+       /* 
+        * Now decide if a wrap has tried to skew our results.
+        * Note that after TC, the count will read 0xffff, while we want 
+        * to return zero, so we add and then mask to compensate.
+        */
+       if (low1 >= low2) {
+               cnt = (low1 + (high1 << 8) + 1) & 0xffff;
+       } else {
+               cnt = (low2 + (high2 << 8) + 1) & 0xffff;
+       }
+
+       if (chan >= 4)                  /* high channels move words */
+               cnt *= 2;
+       return(cnt);
+}
+
+/*
+ * Stop a DMA transfer currently in progress.
+ */
+int
+isa_dmastop(int chan) 
+{
+       if ((dma_inuse & (1 << chan)) == 0)
+               kprintf("isa_dmastop: channel %d not acquired\n", chan);  
+
+       if (((dma_busy & (1 << chan)) == 0) &&
+           ((dma_auto_mode & (1 << chan)) == 0)) {
+               kprintf("chan %d not busy\n", chan);
+               return -2 ;
+       }
+    
+       if ((chan & 4) == 0) {
+               outb(DMA1_SMSK, (chan & 3) | 4 /* disable mask */);
+       } else {
+               outb(DMA2_SMSK, (chan & 3) | 4 /* disable mask */);
+       }
+       return(isa_dmastatus(chan));
+}
+
+unsigned
+isa_dmabp(struct buf *bp)
+{
+       unsigned flags = 0;
+
+       KKASSERT(bp->b_cmd != BUF_CMD_DONE);
+       if (bp->b_flags & B_RAW)
+               flags |= ISADMA_RAW;
+       if (bp->b_cmd == BUF_CMD_READ) {
+               flags |= ISADMA_READ;
+       } else  {
+               /* BUF_CMD_WRITE, BUF_CMD_FORMAT */
+               flags |= ISADMA_WRITE;
+       }
+       return(flags);
+}
+
similarity index 98%
copy from sys/bus/pci/i386/pci_cfgreg.c
copy to sys/bus/pci/amd64/pci_cfgreg.c
index 423bf2c..03f7a05 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/isa/pci_cfgreg.c,v 1.1.2.7 2001/11/28 05:47:03 imp Exp $
- * $DragonFly: src/sys/bus/pci/i386/pci_cfgreg.c,v 1.14 2008/08/02 01:14:41 dillon Exp $
+ * $DragonFly: src/sys/bus/pci/amd64/pci_cfgreg.c,v 1.1 2008/08/02 05:22:19 dillon Exp $
  *
  */
 
@@ -62,14 +62,18 @@ TUNABLE_INT("hw.pci_disable_bios_route", &pci_disable_bios_route);
 static int cfgmech;
 static int devmax;
 
+#if 0
 static int     pci_cfgintr_valid(struct PIR_entry *pe, int pin, int irq);
 static int     pci_cfgintr_unique(struct PIR_entry *pe, int pin);
 static int     pci_cfgintr_linked(struct PIR_entry *pe, int pin);
 static int     pci_cfgintr_search(struct PIR_entry *pe, int bus, int device, int matchpin, int pin);
 static int     pci_cfgintr_virgin(struct PIR_entry *pe, int pin);
+#endif
 
 static void    pci_print_irqmask(u_int16_t irqs);
+#if 0
 static void    pci_print_route_table(struct PIR_table *prt, int size);
+#endif
 static int     pcireg_cfgread(int bus, int slot, int func, int reg, int bytes);
 static void    pcireg_cfgwrite(int bus, int slot, int func, int reg, int data, int bytes);
 static int     pcireg_cfgopen(void);
@@ -85,13 +89,15 @@ static int          pci_route_count;
  * and map them to 255, which means "none".
  */
 static int
-pci_i386_map_intline(int line)
+pci_map_intline(int line)
 {
        if (line == 0 || line >= 128)
                return (PCI_INVALID_IRQ);
        return (line);
 }
 
+#if 0
+
 static u_int16_t
 pcibios_get_version(void)
 {
@@ -113,6 +119,8 @@ pcibios_get_version(void)
        return (args.ebx & 0xffff);
 }
 
+#endif
+
 /* 
  * Initialise access to PCI configuration space 
  */
@@ -132,11 +140,11 @@ pci_cfgregopen(void)
        if (pcireg_cfgopen() == 0)
                return (0);
 
+#if 0
        v = pcibios_get_version();
        if (v > 0)
                kprintf("pcibios: BIOS version %x.%02x\n", (v & 0xff00) >> 8,
                       v & 0xff);
-
        /*
         * Look for the interrupt routing table.
         *
@@ -169,6 +177,7 @@ pci_cfgregopen(void)
                        }
                }
        }
+#endif
        opened = 1;
        return (1);     
 }
@@ -229,7 +238,7 @@ pci_cfgregread(int bus, int slot, int func, int reg, int bytes)
         */
        if (reg == PCIR_INTLINE && bytes == 1) {
                line = pcireg_cfgread(bus, slot, func, PCIR_INTLINE, 1);
-               return pci_i386_map_intline(line);
+               return pci_map_intline(line);
        }
 #endif /* APIC_IO */
        return (pcireg_cfgread(bus, slot, func, reg, bytes));
@@ -256,6 +265,16 @@ pci_cfgwrite(pcicfgregs *cfg, int reg, int data, int bytes)
        pci_cfgregwrite(cfg->bus, cfg->slot, cfg->func, reg, data, bytes);
 }
 
+/*
+ * XXX
+ */
+int
+pci_cfgintr(int bus, int device, int pin, int oldirq)
+{
+       return (PCI_INVALID_IRQ);
+}
+
+#if 0
 
 /*
  * Route a PCI interrupt
@@ -484,7 +503,7 @@ pci_cfgintr_search(struct PIR_entry *pe, int bus, int device, int matchpin, int
                        if ((pci_get_bus(*childp) == bus) &&
                            (pci_get_slot(*childp) == device) &&
                            (pci_get_intpin(*childp) == matchpin)) {
-                               irq = pci_i386_map_intline(pci_get_irq(*childp));
+                               irq = pci_map_intline(pci_get_irq(*childp));
                                if (irq != PCI_INVALID_IRQ)
                                        PRVERB(("pci_cfgintr_search: linked (%x) to configured irq %d at %d:%d:%d\n",
                                            pe->pe_intpin[pin - 1].link, irq,
@@ -607,6 +626,8 @@ pci_probe_route_table(int bus)
        return (0);
 }
 
+#endif
+
 /* 
  * Configuration space access using direct register operations
  */
diff --git a/sys/bus/pci/amd64/pci_cfgreg.h b/sys/bus/pci/amd64/pci_cfgreg.h
new file mode 100644 (file)
index 0000000..3fe6b44
--- /dev/null
@@ -0,0 +1,59 @@
+/*
+ * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/i386/include/pci_cfgreg.h,v 1.4.2.1 2001/07/28 05:55:07 imp Exp $
+ * $DragonFly: src/sys/bus/pci/amd64/pci_cfgreg.h,v 1.1 2008/08/02 05:22:19 dillon Exp $
+ *
+ */
+
+#ifndef _MACHINE_PCI_CFGREG_H_
+#define _MACHINE_PCI_CFGREG_H_
+
+#define CONF1_ADDR_PORT    0x0cf8
+#define CONF1_DATA_PORT    0x0cfc
+
+#define CONF1_ENABLE       0x80000000ul
+#define CONF1_ENABLE_CHK   0x80000000ul
+#define CONF1_ENABLE_MSK   0x7f000000ul
+#define CONF1_ENABLE_CHK1  0xff000001ul
+#define CONF1_ENABLE_MSK1  0x80000001ul
+#define CONF1_ENABLE_RES1  0x80000000ul
+
+#define CONF2_ENABLE_PORT  0x0cf8
+#define CONF2_FORWARD_PORT 0x0cfa
+
+#define CONF2_ENABLE_CHK   0x0e
+#define CONF2_ENABLE_RES   0x0e
+
+int            pci_cfgregopen(void);
+u_int32_t      pci_cfgregread(int bus, int slot, int func, int reg, int bytes);
+void           pci_cfgregwrite(int bus, int slot, int func, int reg, u_int32_t data, int bytes);
+int            pci_cfgintr(int bus, int device, int pin, int oldirq);
+int            pci_probe_route_table(int bus);
+
+#define PCI_INVALID_IRQ                255
+#define PCI_INTERRUPT_VALID(x) ((x) != PCI_INVALID_IRQ)
+
+#endif
diff --git a/sys/bus/pci/amd64/pcibus.c b/sys/bus/pci/amd64/pcibus.c
new file mode 100644 (file)
index 0000000..3b8d49b
--- /dev/null
@@ -0,0 +1,721 @@
+/*
+ * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/i386/isa/pcibus.c,v 1.57.2.12 2003/08/07 06:19:26 imp Exp $
+ * $DragonFly: src/sys/bus/pci/amd64/pcibus.c,v 1.1 2008/08/02 05:22:19 dillon Exp $
+ *
+ */
+
+#include "opt_pci.h"
+
+#include <sys/param.h>
+#include <sys/systm.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/sysctl.h>
+
+#include <bus/pci/pcivar.h>
+#include <bus/pci/pcireg.h>
+#include "pcibus.h"
+#include <bus/isa/isavar.h>
+#include "pci_cfgreg.h"
+#include <machine/md_var.h>
+#include <machine/nexusvar.h>
+
+#include "pcib_if.h"
+
+static u_int32_t nexus_pcib_read_config(device_t, int, int, int, int, int);
+
+/*
+ * Figure out if a PCI entity is a host bridge, return its name or NULL.
+ */
+static const char *
+nexus_legacypci_is_host_bridge(int bus, int slot, int func,
+                         u_int32_t id, u_int8_t class, u_int8_t subclass,
+                         u_int8_t *busnum)
+{
+       const char *s = NULL;
+       static u_int8_t pxb[4]; /* hack for 450nx */
+
+       *busnum = 0;
+
+       switch (id) {
+       case 0x12258086:
+               s = "Intel 824?? host to PCI bridge";
+               /* XXX This is a guess */
+               /* *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x41, 1); */
+               *busnum = bus;
+               break;
+       case 0x71208086:
+               s = "Intel 82810 (i810 GMCH) Host To Hub bridge";
+               break;
+       case 0x71228086:
+               s = "Intel 82810-DC100 (i810-DC100 GMCH) Host To Hub bridge";
+               break;
+       case 0x71248086:
+               s = "Intel 82810E (i810E GMCH) Host To Hub bridge";
+               break;
+       case 0x71808086:
+               s = "Intel 82443LX (440 LX) host to PCI bridge";
+               break;
+       case 0x71908086:
+               s = "Intel 82443BX (440 BX) host to PCI bridge";
+               break;
+       case 0x71928086:
+               s = "Intel 82443BX host to PCI bridge (AGP disabled)";
+               break;
+       case 0x71948086:
+               s = "Intel 82443MX host to PCI bridge";
+               break;
+       case 0x71a08086:
+               s = "Intel 82443GX host to PCI bridge";
+               break;
+       case 0x71a18086:
+               s = "Intel 82443GX host to AGP bridge";
+               break;
+       case 0x71a28086:
+               s = "Intel 82443GX host to PCI bridge (AGP disabled)";
+               break;
+       case 0x84c48086:
+               s = "Intel 82454KX/GX (Orion) host to PCI bridge";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x4a, 1);
+               break;
+       case 0x84ca8086:
+               /*
+                * For the 450nx chipset, there is a whole bundle of
+                * things pretending to be host bridges. The MIOC will 
+                * be seen first and isn't really a pci bridge (the
+                * actual busses are attached to the PXB's). We need to 
+                * read the registers of the MIOC to figure out the
+                * bus numbers for the PXB channels.
+                *
+                * Since the MIOC doesn't have a pci bus attached, we
+                * pretend it wasn't there.
+                */
+               pxb[0] = nexus_pcib_read_config(0, bus, slot, func,
+                                               0xd0, 1); /* BUSNO[0] */
+               pxb[1] = nexus_pcib_read_config(0, bus, slot, func,
+                                               0xd1, 1) + 1;   /* SUBA[0]+1 */
+               pxb[2] = nexus_pcib_read_config(0, bus, slot, func,
+                                               0xd3, 1); /* BUSNO[1] */
+               pxb[3] = nexus_pcib_read_config(0, bus, slot, func,
+                                               0xd4, 1) + 1;   /* SUBA[1]+1 */
+               return NULL;
+       case 0x84cb8086:
+               switch (slot) {
+               case 0x12:
+                       s = "Intel 82454NX PXB#0, Bus#A";
+                       *busnum = pxb[0];
+                       break;
+               case 0x13:
+                       s = "Intel 82454NX PXB#0, Bus#B";
+                       *busnum = pxb[1];
+                       break;
+               case 0x14:
+                       s = "Intel 82454NX PXB#1, Bus#A";
+                       *busnum = pxb[2];
+                       break;
+               case 0x15:
+                       s = "Intel 82454NX PXB#1, Bus#B";
+                       *busnum = pxb[3];
+                       break;
+               }
+               break;
+       case 0x1A308086:
+               s = "Intel 82845 Host to PCI bridge";
+               break;
+
+               /* AMD -- vendor 0x1022 */
+       case 0x30001022:
+               s = "AMD Elan SC520 host to PCI bridge";
+#ifdef CPU_ELAN
+               init_AMD_Elan_sc520();
+#else
+               kprintf("*** WARNING: kernel option CPU_ELAN missing");
+               kprintf("-- timekeeping may be wrong\n");
+#endif
+               break;
+       case 0x70061022:
+               s = "AMD-751 host to PCI bridge";
+               break;
+       case 0x700e1022:
+               s = "AMD-761 host to PCI bridge";
+               break;
+
+               /* SiS -- vendor 0x1039 */
+       case 0x04961039:
+               s = "SiS 85c496";
+               break;
+       case 0x04061039:
+               s = "SiS 85c501";
+               break;
+       case 0x06011039:
+               s = "SiS 85c601";
+               break;
+       case 0x55911039:
+               s = "SiS 5591 host to PCI bridge";
+               break;
+       case 0x00011039:
+               s = "SiS 5591 host to AGP bridge";
+               break;
+
+               /* VLSI -- vendor 0x1004 */
+       case 0x00051004:
+               s = "VLSI 82C592 Host to PCI bridge";
+               break;
+
+               /* XXX Here is MVP3, I got the datasheet but NO M/B to test it  */
+               /* totally. Please let me know if anything wrong.            -F */
+               /* XXX need info on the MVP3 -- any takers? */
+       case 0x05981106:
+               s = "VIA 82C598MVP (Apollo MVP3) host bridge";
+               break;
+
+               /* AcerLabs -- vendor 0x10b9 */
+               /* Funny : The datasheet told me vendor id is "10b8",sub-vendor */
+               /* id is '10b9" but the register always shows "10b9". -Foxfair  */
+       case 0x154110b9:
+               s = "AcerLabs M1541 (Aladdin-V) PCI host bridge";
+               break;
+
+               /* OPTi -- vendor 0x1045 */
+       case 0xc7011045:
+               s = "OPTi 82C700 host to PCI bridge";
+               break;
+       case 0xc8221045:
+               s = "OPTi 82C822 host to PCI Bridge";
+               break;
+
+               /* ServerWorks -- vendor 0x1166 */
+       case 0x00051166:
+               s = "ServerWorks NB6536 2.0HE host to PCI bridge";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x44, 1);
+               break;
+       
+       case 0x00061166:
+               /* FALLTHROUGH */
+       case 0x00081166:
+               /* FALLTHROUGH */
+       case 0x02011166:
+               /* FALLTHROUGH */
+       case 0x010f1014: /* IBM re-badged ServerWorks chipset */
+               /* FALLTHROUGH */
+               s = "ServerWorks host to PCI bridge";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x44, 1);
+               break;
+
+       case 0x00091166:
+               s = "ServerWorks NB6635 3.0LE host to PCI bridge";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x44, 1);
+               break;
+
+       case 0x00101166:
+               s = "ServerWorks CIOB30 host to PCI bridge";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x44, 1);
+               break;
+
+       case 0x00111166:
+               /* FALLTHROUGH */
+       case 0x03021014: /* IBM re-badged ServerWorks chipset */
+               s = "ServerWorks CMIC-HE host to PCI-X bridge";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x44, 1);
+               break;
+
+               /* XXX unknown chipset, but working */
+       case 0x00171166:
+               /* FALLTHROUGH */
+       case 0x01011166:
+               s = "ServerWorks host to PCI bridge(unknown chipset)";
+               *busnum = nexus_pcib_read_config(0, bus, slot, func, 0x44, 1);
+               break;
+
+               /* Integrated Micro Solutions -- vendor 0x10e0 */
+       case 0x884910e0:
+               s = "Integrated Micro Solutions VL Bridge";
+               break;
+
+       default:
+               if (class == PCIC_BRIDGE && subclass == PCIS_BRIDGE_HOST)
+                       s = "Host to PCI bridge";
+               break;
+       }
+
+       return s;
+}
+
+/*
+ * Identify the existance of the first pci bus and install a child to
+ * nexus if we find it.  Use an order of 1 so it gets probed after
+ * any ACPI device installed under nexus.  To avoid boot-time confusion,
+ * we do not install any 'pcib' devices at this time.
+ *
+ * The identify method coupled with the driver spec of the same name
+ * automatically installs it under the nexus.
+ */
+static int
+nexus_legacypci_identify(driver_t *driver, device_t parent)
+{
+       /*
+        * Basically a static device, there's no point reinstalling it
+        * on rescan.
+        */
+       if (device_get_state(parent) == DS_ATTACHED)
+               return (0);
+       if (device_get_state(parent) == DS_INPROGRESS)
+               return (0);
+
+       if (pci_cfgregopen() == 0)
+               return (ENXIO);
+
+       BUS_ADD_CHILD(parent, parent, 100, "legacypci", 0);
+       return (0);
+}
+
+/*
+ * Scan the first pci bus for host-pci bridges and add pcib instances
+ * to the nexus for each bridge.
+ */
+static int
+nexus_legacypci_probe(device_t dev)
+{
+       int bus, slot, func;
+       u_int8_t  hdrtype;
+       int found = 0;
+       int pcifunchigh;
+       int found824xx = 0;
+       device_t child;
+
+       /*
+        * Do not install any pci busses ('pcib' devices) if the PCI
+        * subsystem has already been claimed by someone else.
+        */
+       if (pcib_owner != NULL) {
+               device_printf(dev, "PCI subsystem owned by %s, skipping scan\n",
+                             pcib_owner);
+               return (ENXIO);
+       }
+       pcib_owner = "legacypci";
+
+       if (pci_cfgregopen() == 0)
+               return (ENXIO);
+
+       /*
+        * Scan away!
+        */
+       bus = 0;
+ retry:
+       for (slot = 0; slot <= PCI_SLOTMAX; slot++) {
+               func = 0;
+               hdrtype = nexus_pcib_read_config(0, bus, slot, func,
+                                                PCIR_HDRTYPE, 1);
+               if ((hdrtype & ~PCIM_MFDEV) > 2)
+                       continue;
+               if (hdrtype & PCIM_MFDEV)
+                       pcifunchigh = 7;
+               else
+                       pcifunchigh = 0;
+               for (func = 0; func <= pcifunchigh; func++) {
+                       /*
+                        * Read the IDs and class from the device.
+                        */
+                       u_int32_t id;
+                       u_int8_t class, subclass, busnum;
+                       const char *s;
+                       device_t *devs;
+                       int ndevs, i;
+
+                       id = nexus_pcib_read_config(0, bus, slot, func,
+                                                   PCIR_DEVVENDOR, 4);
+                       if (id == -1)
+                               continue;
+                       class = nexus_pcib_read_config(0, bus, slot, func,
+                                                      PCIR_CLASS, 1);
+                       subclass = nexus_pcib_read_config(0, bus, slot, func,
+                                                         PCIR_SUBCLASS, 1);
+
+                       s = nexus_legacypci_is_host_bridge(bus, slot, func,
+                                                     id, class, subclass,
+                                                     &busnum);
+                       if (s == NULL)
+                               continue;
+
+                       /*
+                        * Check to see if the physical bus has already
+                        * been seen. Eg: hybrid 32 and 64 bit host
+                        * bridges to the same logical bus.
+                        */
+                       if (device_get_children(dev, &devs, &ndevs) == 0) {
+                               for (i = 0; s != NULL && i < ndevs; i++) {
+                                       if (strcmp(device_get_name(devs[i]),
+                                           "pcib") != 0)
+                                               continue;
+                                       if (nexus_get_pcibus(devs[i]) == busnum)
+                                               s = NULL;
+                               }
+                               kfree(devs, M_TEMP);
+                       }
+
+                       if (s == NULL)
+                               continue;
+                       /*
+                        * Add at priority 100+busnum to keep the scanning
+                        * order sane in the boot dmesg output.
+                        */
+                       child = BUS_ADD_CHILD(dev, dev, 100 + busnum, 
+                                             "pcib", busnum);
+                       device_set_desc(child, s);
+                       nexus_set_pcibus(child, busnum);
+
+                       found = 1;
+                       if (id == 0x12258086)
+                               found824xx = 1;
+               }
+       }
+       if (found824xx && bus == 0) {
+               bus++;
+               goto retry;
+       }
+
+#if 0
+       /*
+        * Now that we have installed the main PCI bridges, go
+        * probe and attach each one.
+        */
+       bus_generic_attach(dev);
+#endif
+
+       /*
+        * Make sure we add at least one bridge since some old
+        * hardware doesn't actually have a host-pci bridge device.
+        * Note that pci_cfgregopen() thinks we have PCI devices..
+        */
+       if (!found) {
+               if (bootverbose) {
+                       kprintf("nexus_pcib_identify: no bridge found, "
+                              "adding pcib0 anyway\n");
+               }
+               child = BUS_ADD_CHILD(dev, dev, 100, "pcib", 0);
+               nexus_set_pcibus(child, 0);
+       }
+       return (0);
+}
+
+static int
+nexus_legacypci_attach(device_t dev)
+{
+       bus_generic_attach(dev);
+       return (0);
+}
+
+#ifdef PCI_MAP_FIXUP
+
+SYSCTL_NODE(_hw, OID_AUTO, pci, CTLFLAG_RD, 0, "pci parameters");
+
+static unsigned long legacy_host_mem_start = 0xffffffff80000000;
+/* XXX need TUNABLE_ULONG? */
+TUNABLE_INT("hw.pci.host_mem_start", (int *)&legacy_host_mem_start);
+SYSCTL_ULONG(_hw_pci, OID_AUTO, host_mem_start, CTLFLAG_RD,
+            &legacy_host_mem_start, 0x80000000,
+            "Limit the host bridge memory to being above this address.  "
+            "Must be\n"
+            "set at boot via hw.pci.host_mem_start tunable.");
+
+static struct resource *
+nexus_legacypci_alloc_resource(device_t dev, device_t child, int type, int *rid,
+                              u_long start, u_long end, u_long count,
+                              u_int flags)
+{
+       /*
+        * If no memory preference is given, use upper 32MB slot most
+        * bioses use for their memory window.  Typically other bridges
+        * before us get in the way to assert their preferences on memory.
+        * Hardcoding like this sucks, so a more MD/MI way needs to be
+        * found to do it.  This is typically only used on older laptops
+        * that don't have pci busses behind pci bridge, so assuming > 32MB
+        * is likely OK.
+        *
+        * However, this can cause problems for other chipsets, so we make
+        * this tunable by hw.pci.host_mem_start.
+        */
+       if (type == SYS_RES_MEMORY && start == 0UL && end == ~0UL)
+               start = legacy_host_mem_start;
+       if (type == SYS_RES_IOPORT && start == 0UL && end == ~0UL)
+               start = 0x1000;
+       return bus_generic_alloc_resource(dev, child, type, rid,
+                                         start, end, count, flags);
+}
+
+#endif /* PCI_MAP_FIXUP */
+
+static device_method_t legacypci_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_identify,      nexus_legacypci_identify),
+       DEVMETHOD(device_probe,         nexus_legacypci_probe),
+       DEVMETHOD(device_attach,        nexus_legacypci_attach),
+       DEVMETHOD(device_shutdown,      bus_generic_shutdown),
+       DEVMETHOD(device_suspend,       bus_generic_suspend),
+       DEVMETHOD(device_resume,        bus_generic_resume),
+
+       /*
+        * Bus interface - propogate through to the nexus.  Note that
+        * this means devices under us will have nexus ivars.
+        */
+       DEVMETHOD(bus_add_child,        bus_generic_add_child),
+       DEVMETHOD(bus_print_child,      bus_generic_print_child),
+       DEVMETHOD(bus_read_ivar,        bus_generic_read_ivar),
+       DEVMETHOD(bus_write_ivar,       bus_generic_write_ivar),
+#ifdef PCI_MAP_FIXUP
+       DEVMETHOD(bus_alloc_resource,   nexus_legacypci_alloc_resource),
+#else
+       DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
+#endif
+       DEVMETHOD(bus_release_resource, bus_generic_release_resource),
+       DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
+       DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
+       DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
+       DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
+        DEVMETHOD(bus_set_resource,     bus_generic_set_resource),
+        DEVMETHOD(bus_get_resource,     bus_generic_get_resource),
+        DEVMETHOD(bus_delete_resource,  bus_generic_delete_resource),
+       { 0, 0 }
+};
+
+static driver_t legacypci_driver = {
+       "legacypci",
+       legacypci_methods,
+       1,
+};
+
+static devclass_t legacypci_devclass;
+
+DRIVER_MODULE(legacypci, nexus, legacypci_driver, legacypci_devclass, 0, 0);
+
+/*
+ * Legacypci Host-Bridge PCI BUS support.  The underlying pcib devices
+ * will only exist if we actually control the PCI bus.  The actual PCI
+ * bus driver is attached in our attach routine.
+ *
+ * There is no identify function because the legacypci placeholder will
+ * have already scanned and added PCIB devices for the host-bridges found.
+ */
+static int
+nexus_pcib_maxslots(device_t dev)
+{
+       return 31;
+}
+
+/*
+ * Read configuration space register.
+ */
+static u_int32_t
+nexus_pcib_read_config(device_t dev, int bus, int slot, int func,
+                      int reg, int bytes)
+{
+       return (pci_cfgregread(bus, slot, func, reg, bytes));
+}
+
+/*
+ * Write configuration space register.
+ */
+static void
+nexus_pcib_write_config(device_t dev, int bus, int slot, int func,
+                       int reg, u_int32_t data, int bytes)
+{
+       pci_cfgregwrite(bus, slot, func, reg, data, bytes);
+}
+
+/*
+ * Stack a pci device on top of the pci bridge bus device.
+ */
+static int
+nexus_pcib_probe(device_t dev)
+{
+       BUS_ADD_CHILD(dev, dev, 0, "pci", device_get_unit(dev));
+       return (0);
+}
+
+static int
+nexus_pcib_attach(device_t dev)
+{
+       int error;
+
+       error = bus_generic_attach(dev);
+       return (error);
+}
+
+/* route interrupt */
+
+static int
+nexus_pcib_route_interrupt(device_t pcib, device_t dev, int pin)
+{
+       return(pci_cfgintr(pci_get_bus(dev), pci_get_slot(dev), pin, 
+                          pci_get_irq(dev)));
+}
+
+static device_method_t nexus_pcib_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         nexus_pcib_probe),
+       DEVMETHOD(device_attach,        nexus_pcib_attach),
+       DEVMETHOD(device_shutdown,      bus_generic_shutdown),
+       DEVMETHOD(device_suspend,       bus_generic_suspend),
+       DEVMETHOD(device_resume,        bus_generic_resume),
+
+       /*
+        * Bus interface - propogate through to the nexus.  Note
+        * that this means we will get nexus-managed ivars.
+        */
+       DEVMETHOD(bus_add_child,        bus_generic_add_child),
+       DEVMETHOD(bus_print_child,      bus_generic_print_child),
+       DEVMETHOD(bus_read_ivar,        bus_generic_read_ivar),
+       DEVMETHOD(bus_write_ivar,       bus_generic_write_ivar),
+       DEVMETHOD(bus_alloc_resource,   bus_generic_alloc_resource),
+       DEVMETHOD(bus_release_resource, bus_generic_release_resource),
+       DEVMETHOD(bus_activate_resource, bus_generic_activate_resource),
+       DEVMETHOD(bus_deactivate_resource, bus_generic_deactivate_resource),
+       DEVMETHOD(bus_setup_intr,       bus_generic_setup_intr),
+       DEVMETHOD(bus_teardown_intr,    bus_generic_teardown_intr),
+
+       /* pcib interface */
+       DEVMETHOD(pcib_maxslots,        nexus_pcib_maxslots),
+       DEVMETHOD(pcib_read_config,     nexus_pcib_read_config),
+       DEVMETHOD(pcib_write_config,    nexus_pcib_write_config),
+       DEVMETHOD(pcib_route_interrupt, nexus_pcib_route_interrupt),
+
+       { 0, 0 }
+};
+
+static driver_t nexus_pcib_driver = {
+       "pcib",
+       nexus_pcib_methods,
+       1,
+};
+
+static devclass_t      pcib_devclass;
+
+DRIVER_MODULE(pcib, legacypci, nexus_pcib_driver, pcib_devclass, 0, 0);
+
+
+/*
+ * Provide a device to "eat" the host->pci bridges that we dug up above
+ * and stop them showing up twice on the probes.  This also stops them
+ * showing up as 'none' in pciconf -l.
+ *
+ * Return an ultra-low priority so other devices can attach the bus before
+ * our dummy attach.
+ *
+ * XXX may have to disable the registration entirely to support module-loaded
+ * bridges such as agp.ko.
+ */
+static int
+pci_hostb_probe(device_t dev)
+{
+       if (pci_get_class(dev) == PCIC_BRIDGE &&
+           pci_get_subclass(dev) == PCIS_BRIDGE_HOST) {
+               device_set_desc(dev, "Host to PCI bridge");
+               device_quiet(dev);
+               return -10000;
+       }
+       return (ENXIO);
+}
+
+static int
+pci_hostb_attach(device_t dev)
+{
+       return (0);
+}
+
+static device_method_t pci_hostb_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         pci_hostb_probe),
+       DEVMETHOD(device_attach,        pci_hostb_attach),
+       DEVMETHOD(device_shutdown,      bus_generic_shutdown),
+       DEVMETHOD(device_suspend,       bus_generic_suspend),
+       DEVMETHOD(device_resume,        bus_generic_resume),
+
+       { 0, 0 }
+};
+static driver_t pci_hostb_driver = {
+       "hostb",
+       pci_hostb_methods,
+       1,
+};
+static devclass_t pci_hostb_devclass;
+
+DRIVER_MODULE(hostb, pci, pci_hostb_driver, pci_hostb_devclass, 0, 0);
+
+
+/*
+ * Install placeholder to claim the resources owned by the
+ * PCI bus interface.  This could be used to extract the 
+ * config space registers in the extreme case where the PnP
+ * ID is available and the PCI BIOS isn't, but for now we just
+ * eat the PnP ID and do nothing else.
+ *
+ * XXX we should silence this probe, as it will generally confuse 
+ * people.
+ */
+static struct isa_pnp_id pcibus_pnp_ids[] = {
+       { 0x030ad041 /* PNP030A */, "PCI Bus" },
+       { 0 }
+};
+
+static int
+pcibus_pnp_probe(device_t dev)
+{
+       int result;
+       
+       if ((result = ISA_PNP_PROBE(device_get_parent(dev), dev, pcibus_pnp_ids)) <= 0)
+               device_quiet(dev);
+       return (result);
+}
+
+static int
+pcibus_pnp_attach(device_t dev)
+{
+       return(0);
+}
+
+static device_method_t pcibus_pnp_methods[] = {
+       /* Device interface */
+       DEVMETHOD(device_probe,         pcibus_pnp_probe),
+       DEVMETHOD(device_attach,        pcibus_pnp_attach),
+       DEVMETHOD(device_detach,        bus_generic_detach),
+       DEVMETHOD(device_shutdown,      bus_generic_shutdown),
+       DEVMETHOD(device_suspend,       bus_generic_suspend),
+       DEVMETHOD(device_resume,        bus_generic_resume),
+       { 0, 0 }
+};
+
+static driver_t pcibus_pnp_driver = {
+       "pcibus_pnp",
+       pcibus_pnp_methods,
+       1,              /* no softc */
+};
+
+static devclass_t pcibus_pnp_devclass;
+
+DRIVER_MODULE(pcibus_pnp, isa, pcibus_pnp_driver, pcibus_pnp_devclass, 0, 0);
+
diff --git a/sys/bus/pci/amd64/pcibus.h b/sys/bus/pci/amd64/pcibus.h
new file mode 100644 (file)
index 0000000..6b5a362
--- /dev/null
@@ -0,0 +1,45 @@
+/*
+ * Copyright (c) 1997, Stefan Esser <se@freebsd.org>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice unmodified, this list of conditions, and the following
+ *    disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+ * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+ * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+ * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+ * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ * $FreeBSD: src/sys/i386/isa/pcibus.h,v 1.2 1999/08/28 00:44:59 peter Exp $
+ * $DragonFly: src/sys/bus/pci/amd64/pcibus.h,v 1.1 2008/08/02 05:22:19 dillon Exp $
+ *
+ */
+
+#define CONF1_ADDR_PORT    0x0cf8
+#define CONF1_DATA_PORT    0x0cfc
+
+#define CONF1_ENABLE       0x80000000ul
+#define CONF1_ENABLE_CHK   0x80000000ul
+#define CONF1_ENABLE_MSK   0x7f000000ul
+#define CONF1_ENABLE_CHK1  0xff000001ul
+#define CONF1_ENABLE_MSK1  0x80000001ul
+#define CONF1_ENABLE_RES1  0x80000000ul
+
+#define CONF2_ENABLE_PORT  0x0cf8
+#define CONF2_FORWARD_PORT 0x0cfa
+
+#define CONF2_ENABLE_CHK   0x0e
+#define CONF2_ENABLE_RES   0x0e
index 423bf2c..596dd9e 100644 (file)
@@ -26,7 +26,7 @@
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  *
  * $FreeBSD: src/sys/i386/isa/pci_cfgreg.c,v 1.1.2.7 2001/11/28 05:47:03 imp Exp $
- * $DragonFly: src/sys/bus/pci/i386/pci_cfgreg.c,v 1.14 2008/08/02 01:14:41 dillon Exp $
+ * $DragonFly: src/sys/bus/pci/i386/pci_cfgreg.c,v 1.15 2008/08/02 05:22:20 dillon Exp $
  *
  */
 
@@ -85,7 +85,7 @@ static int            pci_route_count;
  * and map them to 255, which means "none".
  */
 static int
-pci_i386_map_intline(int line)
+pci_map_intline(int line)
 {
        if (line == 0 || line >= 128)
                return (PCI_INVALID_IRQ);
@@ -229,7 +229,7 @@ pci_cfgregread(int bus, int slot, int func, int reg, int bytes)
         */
        if (reg == PCIR_INTLINE && bytes == 1) {
                line = pcireg_cfgread(bus, slot, func, PCIR_INTLINE, 1);
-               return pci_i386_map_intline(line);
+               return pci_map_intline(line);
        }
 #endif /* APIC_IO */
        return (pcireg_cfgread(bus, slot, func, reg, bytes));
@@ -484,7 +484,7 @@ pci_cfgintr_search(struct PIR_entry *pe, int bus, int device, int matchpin, int
                        if ((pci_get_bus(*childp) == bus) &&
                            (pci_get_slot(*childp) == device) &&
                            (pci_get_intpin(*childp) == matchpin)) {
-                               irq = pci_i386_map_intline(pci_get_irq(*childp));
+                               irq = pci_map_intline(pci_get_irq(*childp));
                                if (irq != PCI_INVALID_IRQ)
                                        PRVERB(("pci_cfgintr_search: linked (%x) to configured irq %d at %d:%d:%d\n",
                                            pe->pe_intpin[pin - 1].link, irq,
index 4cf4b9a..8fcdba8 100644 (file)
@@ -39,7 +39,7 @@
  *     from: @(#)vm_machdep.c  7.3 (Berkeley) 5/13/91
  *     Utah $Hdr: vm_machdep.c 1.16.1.1 89/06/23$
  * $FreeBSD: src/sys/i386/i386/vm_machdep.c,v 1.132.2.9 2003/01/25 19:02:23 dillon Exp $
- * $DragonFly: src/sys/platform/vkernel/i386/vm_machdep.c,v 1.9 2007/03/01 01:46:52 corecode Exp $
+ * $DragonFly: src/sys/platform/vkernel/i386/vm_machdep.c,v 1.10 2008/08/02 05:22:21 dillon Exp $
  */
 
 #include "use_npx.h"
@@ -78,7 +78,7 @@
 #include <sys/user.h>
 #include <sys/thread2.h>
 
-#include <bus/isa/i386/isa.h>
+#include <bus/isa/isa.h>
 
 #include <stdio.h>
 #include <stdlib.h>