Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 759 insertions, 681 deletions

diff --git a/xorg-server/hw/xfree86/common/xf86pciBus.c b/xorg-server/hw/xfree86/common/xf86pciBus.c
index b95b25359..e52f1da84 100644
--- a/xorg-server/hw/xfree86/common/xf86pciBus.c
+++ b/xorg-server/hw/xfree86/common/xf86pciBus.c
@@ -41,7 +41,7 @@
 #include "Pci.h"
 #include "xf86.h"
 #include "xf86Priv.h"
-#include "dirent.h" /* DIR, FILE type definitions */
+#include "dirent.h"             /* DIR, FILE type definitions */
 
 /* Bus-specific headers */
 #include "xf86Bus.h"
@@ -77,7 +77,6 @@ Bool pciSlotClaimed = FALSE;
     (((c) & 0x00ffff00) \
 	 == ((PCI_CLASS_DISPLAY << 16) | (PCI_SUBCLASS_DISPLAY_VGA << 8)))
 
-
 static struct pci_slot_match xf86IsolateDevice = {
     PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, PCI_MATCH_ANY, 0
 };
@@ -93,108 +92,110 @@ xf86PciProbe(void)
     int num = 0;
     struct pci_device *info;
     struct pci_device_iterator *iter;
-    struct pci_device ** xf86PciVideoInfo = NULL;
-
+    struct pci_device **xf86PciVideoInfo = NULL;
 
     if (!xf86scanpci()) {
-	xf86PciVideoInfo = NULL;
-	return;
+        xf86PciVideoInfo = NULL;
+        return;
     }
 
-    iter = pci_slot_match_iterator_create(& xf86IsolateDevice);
+    iter = pci_slot_match_iterator_create(&xf86IsolateDevice);
     while ((info = pci_device_next(iter)) != NULL) {
-	if (PCIINFOCLASSES(info->device_class)) {
-	    num++;
-	    xf86PciVideoInfo = xnfrealloc(xf86PciVideoInfo,
-					  (sizeof(struct pci_device *)
-					   * (num + 1)));
-	    xf86PciVideoInfo[num] = NULL;
-	    xf86PciVideoInfo[num - 1] = info;
-
-	    pci_device_probe(info);
-	    if (pci_device_is_boot_vga(info)) {
+        if (PCIINFOCLASSES(info->device_class)) {
+            num++;
+            xf86PciVideoInfo = xnfrealloc(xf86PciVideoInfo,
+                                          (sizeof(struct pci_device *)
+                                           * (num + 1)));
+            xf86PciVideoInfo[num] = NULL;
+            xf86PciVideoInfo[num - 1] = info;
+
+            pci_device_probe(info);
+            if (pci_device_is_boot_vga(info)) {
                 primaryBus.type = BUS_PCI;
                 primaryBus.id.pci = info;
             }
-	    info->user_data = 0;
-	}
+            info->user_data = 0;
+        }
     }
     free(iter);
 
     /* If we haven't found a primary device try a different heuristic */
     if (primaryBus.type == BUS_NONE && num) {
-	for (i = 0; i < num; i++) {
-	    uint16_t  command;
-
-	    info = xf86PciVideoInfo[i];
-	    pci_device_cfg_read_u16(info, & command, 4);
-
-	    if ((command & PCI_CMD_MEM_ENABLE) 
-		&& ((num == 1) || IS_VGA(info->device_class))) {
-		if (primaryBus.type == BUS_NONE) {
-		    primaryBus.type = BUS_PCI;
-		    primaryBus.id.pci = info;
-		} else {
-		    xf86Msg(X_NOTICE,
-			    "More than one possible primary device found\n");
-		    primaryBus.type ^= (BusType)(-1);
-		}
-	    }
-	}
+        for (i = 0; i < num; i++) {
+            uint16_t command;
+
+            info = xf86PciVideoInfo[i];
+            pci_device_cfg_read_u16(info, &command, 4);
+
+            if ((command & PCI_CMD_MEM_ENABLE)
+                && ((num == 1) || IS_VGA(info->device_class))) {
+                if (primaryBus.type == BUS_NONE) {
+                    primaryBus.type = BUS_PCI;
+                    primaryBus.id.pci = info;
+                }
+                else {
+                    xf86Msg(X_NOTICE,
+                            "More than one possible primary device found\n");
+                    primaryBus.type ^= (BusType) (-1);
+                }
+            }
+        }
     }
-    
+
     /* Print a summary of the video devices found */
     for (k = 0; k < num; k++) {
-	const char *prim = " ";
-	Bool memdone = FALSE, iodone = FALSE;
-
+        const char *prim = " ";
+        Bool memdone = FALSE, iodone = FALSE;
 
-	info = xf86PciVideoInfo[k];
+        info = xf86PciVideoInfo[k];
 
-	if (!PCIALWAYSPRINTCLASSES(info->device_class))
-	    continue;
+        if (!PCIALWAYSPRINTCLASSES(info->device_class))
+            continue;
 
-	if (xf86IsPrimaryPci(info))
-	    prim = "*";
+        if (xf86IsPrimaryPci(info))
+            prim = "*";
 
-	xf86Msg(X_PROBED, "PCI:%s(%u:%u:%u:%u) %04x:%04x:%04x:%04x ", prim,
-		info->domain, info->bus, info->dev, info->func,
-		info->vendor_id, info->device_id,
-		info->subvendor_id, info->subdevice_id);
+        xf86Msg(X_PROBED, "PCI:%s(%u:%u:%u:%u) %04x:%04x:%04x:%04x ", prim,
+                info->domain, info->bus, info->dev, info->func,
+                info->vendor_id, info->device_id,
+                info->subvendor_id, info->subdevice_id);
 
-	xf86ErrorF("rev %d", info->revision);
+        xf86ErrorF("rev %d", info->revision);
 
-	for (i = 0; i < 6; i++) {
-	    struct pci_mem_region * r = & info->regions[i];
+        for (i = 0; i < 6; i++) {
+            struct pci_mem_region *r = &info->regions[i];
 
-	    if ( r->size && ! r->is_IO ) {
-		if (!memdone) {
-		    xf86ErrorF(", Mem @ ");
-		    memdone = TRUE;
-		} else
-		    xf86ErrorF(", ");
-		xf86ErrorF("0x%08lx/%ld", (long)r->base_addr, (long)r->size);
-	    }
-	}
+            if (r->size && !r->is_IO) {
+                if (!memdone) {
+                    xf86ErrorF(", Mem @ ");
+                    memdone = TRUE;
+                }
+                else
+                    xf86ErrorF(", ");
+                xf86ErrorF("0x%08lx/%ld", (long) r->base_addr, (long) r->size);
+            }
+        }
 
-	for (i = 0; i < 6; i++) {
-	    struct pci_mem_region * r = & info->regions[i];
+        for (i = 0; i < 6; i++) {
+            struct pci_mem_region *r = &info->regions[i];
 
-	    if ( r->size && r->is_IO ) {
-		if (!iodone) {
-		    xf86ErrorF(", I/O @ ");
-		    iodone = TRUE;
-		} else
-		    xf86ErrorF(", ");
-		xf86ErrorF("0x%08lx/%ld", (long)r->base_addr, (long)r->size);
-	    }
-	}
+            if (r->size && r->is_IO) {
+                if (!iodone) {
+                    xf86ErrorF(", I/O @ ");
+                    iodone = TRUE;
+                }
+                else
+                    xf86ErrorF(", ");
+                xf86ErrorF("0x%08lx/%ld", (long) r->base_addr, (long) r->size);
+            }
+        }
 
-	if ( info->rom_size ) {
-	    xf86ErrorF(", BIOS @ 0x\?\?\?\?\?\?\?\?/%ld", (long)info->rom_size);
-	}
+        if (info->rom_size) {
+            xf86ErrorF(", BIOS @ 0x\?\?\?\?\?\?\?\?/%ld",
+                       (long) info->rom_size);
+        }
 
-	xf86ErrorF("\n");
+        xf86ErrorF("\n");
     }
     free(xf86PciVideoInfo);
 }
@@ -205,28 +206,29 @@ xf86PciProbe(void)
  */
 
 int
-xf86ClaimPciSlot(struct pci_device * d, DriverPtr drvp,
-		 int chipset, GDevPtr dev, Bool active)
+xf86ClaimPciSlot(struct pci_device *d, DriverPtr drvp,
+                 int chipset, GDevPtr dev, Bool active)
 {
     EntityPtr p = NULL;
     int num;
-    
+
     if (xf86CheckPciSlot(d)) {
-	num = xf86AllocateEntity();
-	p = xf86Entities[num];
-	p->driver = drvp;
-	p->chipset = chipset;
-	p->bus.type = BUS_PCI;
-	p->bus.id.pci = d;
-	p->active = active;
-	p->inUse = FALSE;
-	if (dev)
+        num = xf86AllocateEntity();
+        p = xf86Entities[num];
+        p->driver = drvp;
+        p->chipset = chipset;
+        p->bus.type = BUS_PCI;
+        p->bus.id.pci = d;
+        p->active = active;
+        p->inUse = FALSE;
+        if (dev)
             xf86AddDevToEntity(num, dev);
-	pciSlotClaimed = TRUE;
+        pciSlotClaimed = TRUE;
 
- 	return num;
-    } else
- 	return -1;
+        return num;
+    }
+    else
+        return -1;
 }
 
 /*
@@ -238,13 +240,13 @@ xf86UnclaimPciSlot(struct pci_device *d)
     int i;
 
     for (i = 0; i < xf86NumEntities; i++) {
-	const EntityPtr p = xf86Entities[i];
+        const EntityPtr p = xf86Entities[i];
 
-	if ((p->bus.type == BUS_PCI) && (p->bus.id.pci == d)) {
-	    /* Probably the slot should be deallocated? */
-	    p->bus.type = BUS_NONE;
-	    return;
-	}
+        if ((p->bus.type == BUS_PCI) && (p->bus.id.pci == d)) {
+            /* Probably the slot should be deallocated? */
+            p->bus.type = BUS_NONE;
+            return;
+        }
     }
 }
 
@@ -267,56 +269,56 @@ xf86ParsePciBusString(const char *busID, int *bus, int *device, int *func)
     int i;
 
     if (StringToBusType(busID, &id) != BUS_PCI)
-	return FALSE;
+        return FALSE;
 
     s = xstrdup(id);
     p = strtok(s, ":");
     if (p == NULL || *p == 0) {
-	free(s);
-	return FALSE;
+        free(s);
+        return FALSE;
     }
     d = strpbrk(p, "@");
     if (d != NULL) {
-	*(d++) = 0;
-	for (i = 0; d[i] != 0; i++) {
-	    if (!isdigit(d[i])) {
-		free(s);
-		return FALSE;
-	    }
-	}
+        *(d++) = 0;
+        for (i = 0; d[i] != 0; i++) {
+            if (!isdigit(d[i])) {
+                free(s);
+                return FALSE;
+            }
+        }
     }
     for (i = 0; p[i] != 0; i++) {
-	if (!isdigit(p[i])) {
-	    free(s);
-	    return FALSE;
-	}
+        if (!isdigit(p[i])) {
+            free(s);
+            return FALSE;
+        }
     }
     *bus = atoi(p);
     if (d != NULL && *d != 0)
-	*bus += atoi(d) << 8;
+        *bus += atoi(d) << 8;
     p = strtok(NULL, ":");
     if (p == NULL || *p == 0) {
-	free(s);
-	return FALSE;
+        free(s);
+        return FALSE;
     }
     for (i = 0; p[i] != 0; i++) {
-	if (!isdigit(p[i])) {
-	    free(s);
-	    return FALSE;
-	}
+        if (!isdigit(p[i])) {
+            free(s);
+            return FALSE;
+        }
     }
     *device = atoi(p);
     *func = 0;
     p = strtok(NULL, ":");
     if (p == NULL || *p == 0) {
-	free(s);
-	return TRUE;
+        free(s);
+        return TRUE;
     }
     for (i = 0; p[i] != 0; i++) {
-	if (!isdigit(p[i])) {
-	    free(s);
-	    return FALSE;
-	}
+        if (!isdigit(p[i])) {
+            free(s);
+            return FALSE;
+        }
     }
     *func = atoi(p);
     free(s);
@@ -333,9 +335,10 @@ xf86ComparePciBusString(const char *busID, int bus, int device, int func)
     int ibus, idevice, ifunc;
 
     if (xf86ParsePciBusString(busID, &ibus, &idevice, &ifunc)) {
-	return bus == ibus && device == idevice && func == ifunc;
-    } else {
-	return FALSE;
+        return bus == ibus && device == idevice && func == ifunc;
+    }
+    else {
+        return FALSE;
     }
 }
 
@@ -343,7 +346,7 @@ xf86ComparePciBusString(const char *busID, int bus, int device, int func)
  * xf86IsPrimaryPci() -- return TRUE if primary device
  * is PCI and bus, dev and func numbers match.
  */
- 
+
 Bool
 xf86IsPrimaryPci(struct pci_device *pPci)
 {
@@ -357,9 +360,9 @@ struct pci_device *
 xf86GetPciInfoForEntity(int entityIndex)
 {
     EntityPtr p;
-    
+
     if (entityIndex >= xf86NumEntities)
-	return NULL;
+        return NULL;
 
     p = xf86Entities[entityIndex];
     return (p->bus.type == BUS_PCI) ? p->bus.id.pci : NULL;
@@ -370,13 +373,13 @@ xf86GetPciInfoForEntity(int entityIndex)
  * PCI base address register values for the given PCI device.
  */
 Bool
-xf86CheckPciMemBase( struct pci_device * pPci, memType base )
+xf86CheckPciMemBase(struct pci_device *pPci, memType base)
 {
     int i;
 
     for (i = 0; i < 6; i++)
-	if (base == pPci->regions[i].base_addr)
-	    return TRUE;
+        if (base == pPci->regions[i].base_addr)
+            return TRUE;
     return FALSE;
 }
 
@@ -390,11 +393,11 @@ xf86CheckPciSlot(const struct pci_device *d)
     int i;
 
     for (i = 0; i < xf86NumEntities; i++) {
-	const EntityPtr p = xf86Entities[i];
+        const EntityPtr p = xf86Entities[i];
 
-	if ((p->bus.type == BUS_PCI) && (p->bus.id.pci == d)) {
-	    return FALSE;
-	}
+        if ((p->bus.type == BUS_PCI) && (p->bus.id.pci == d)) {
+            return FALSE;
+        }
     }
     return TRUE;
 }
@@ -405,41 +408,41 @@ xf86CheckPciSlot(const struct pci_device *d)
 Bool
 xf86PciAddMatchingDev(DriverPtr drvp)
 {
-    const struct pci_id_match * const devices = drvp->supported_devices;
+    const struct pci_id_match *const devices = drvp->supported_devices;
     int j;
     struct pci_device *pPci;
     struct pci_device_iterator *iter;
     int numFound = 0;
 
-
     iter = pci_id_match_iterator_create(NULL);
     while ((pPci = pci_device_next(iter)) != NULL) {
-    /* Determine if this device is supported by the driver.  If it is,
-     * add it to the list of devices to configure.
-     */
-    for (j = 0 ; ! END_OF_MATCHES(devices[j]) ; j++) {
-        if ( PCI_ID_COMPARE( devices[j].vendor_id, pPci->vendor_id )
-         && PCI_ID_COMPARE( devices[j].device_id, pPci->device_id )
-         && ((devices[j].device_class_mask & pPci->device_class)
-             == devices[j].device_class) ) {
-        if (xf86CheckPciSlot(pPci)) {
-            GDevPtr pGDev = xf86AddBusDeviceToConfigure(
-                    drvp->driverName, BUS_PCI, pPci, -1);
-            if (pGDev != NULL) {
-            /* After configure pass 1, chipID and chipRev are
-             * treated as over-rides, so clobber them here.
-             */
-            pGDev->chipID = -1;
-            pGDev->chipRev = -1;
-            }
+        /* Determine if this device is supported by the driver.  If it is,
+         * add it to the list of devices to configure.
+         */
+        for (j = 0; !END_OF_MATCHES(devices[j]); j++) {
+            if (PCI_ID_COMPARE(devices[j].vendor_id, pPci->vendor_id)
+                && PCI_ID_COMPARE(devices[j].device_id, pPci->device_id)
+                && ((devices[j].device_class_mask & pPci->device_class)
+                    == devices[j].device_class)) {
+                if (xf86CheckPciSlot(pPci)) {
+                    GDevPtr pGDev =
+                        xf86AddBusDeviceToConfigure(drvp->driverName, BUS_PCI,
+                                                    pPci, -1);
+                    if (pGDev != NULL) {
+                        /* After configure pass 1, chipID and chipRev are
+                         * treated as over-rides, so clobber them here.
+                         */
+                        pGDev->chipID = -1;
+                        pGDev->chipRev = -1;
+                    }
 
-            numFound++;
-        }
+                    numFound++;
+                }
 
-        break;
+                break;
+            }
         }
     }
-    }
 
     pci_iterator_destroy(iter);
 
@@ -450,97 +453,96 @@ Bool
 xf86PciProbeDev(DriverPtr drvp)
 {
     int i, j;
-    struct pci_device * pPci;
+    struct pci_device *pPci;
     Bool foundScreen = FALSE;
-    const struct pci_id_match * const devices = drvp->supported_devices;
+    const struct pci_id_match *const devices = drvp->supported_devices;
     GDevPtr *devList;
-    const unsigned numDevs = xf86MatchDevice(drvp->driverName, & devList);
-
-    for ( i = 0 ; i < numDevs ; i++ ) {
-       struct pci_device_iterator *iter;
-       unsigned device_id;
-
-
-       /* Find the pciVideoRec associated with this device section.
-        */
-       iter = pci_id_match_iterator_create(NULL);
-       while ((pPci = pci_device_next(iter)) != NULL) {
-           if (devList[i]->busID && *devList[i]->busID) {
-               if (xf86ComparePciBusString(devList[i]->busID,
-                                           ((pPci->domain << 8)
-                                            | pPci->bus),
-                                           pPci->dev,
-                                           pPci->func)) {
-                   break;
-               }
-           }
-           else if (xf86IsPrimaryPci(pPci)) {
-               break;
-           }
-       }
-
-       pci_iterator_destroy(iter);
-
-       if (pPci == NULL) {
-           continue;
-       }
-       device_id = (devList[i]->chipID > 0)
-         ? devList[i]->chipID : pPci->device_id;
-
-
-       /* Once the pciVideoRec is found, determine if the device is supported
-        * by the driver.  If it is, probe it!
-        */
-       for ( j = 0 ; ! END_OF_MATCHES( devices[j] ) ; j++ ) {
-           if ( PCI_ID_COMPARE( devices[j].vendor_id, pPci->vendor_id )
-                && PCI_ID_COMPARE( devices[j].device_id, device_id )
+    const unsigned numDevs = xf86MatchDevice(drvp->driverName, &devList);
+
+    for (i = 0; i < numDevs; i++) {
+        struct pci_device_iterator *iter;
+        unsigned device_id;
+
+        /* Find the pciVideoRec associated with this device section.
+         */
+        iter = pci_id_match_iterator_create(NULL);
+        while ((pPci = pci_device_next(iter)) != NULL) {
+            if (devList[i]->busID && *devList[i]->busID) {
+                if (xf86ComparePciBusString(devList[i]->busID,
+                                            ((pPci->domain << 8)
+                                             | pPci->bus),
+                                            pPci->dev, pPci->func)) {
+                    break;
+                }
+            }
+            else if (xf86IsPrimaryPci(pPci)) {
+                break;
+            }
+        }
+
+        pci_iterator_destroy(iter);
+
+        if (pPci == NULL) {
+            continue;
+        }
+        device_id = (devList[i]->chipID > 0)
+            ? devList[i]->chipID : pPci->device_id;
+
+        /* Once the pciVideoRec is found, determine if the device is supported
+         * by the driver.  If it is, probe it!
+         */
+        for (j = 0; !END_OF_MATCHES(devices[j]); j++) {
+            if (PCI_ID_COMPARE(devices[j].vendor_id, pPci->vendor_id)
+                && PCI_ID_COMPARE(devices[j].device_id, device_id)
                 && ((devices[j].device_class_mask & pPci->device_class)
-                     == devices[j].device_class) ) {
-               int  entry;
-
-               /* Allow the same entity to be used more than once for
-                * devices with multiple screens per entity.  This assumes
-                * implicitly that there will be a screen == 0 instance.
-                *
-                * FIXME Need to make sure that two different drivers don't
-                * FIXME claim the same screen > 0 instance.
-                */
-               if ((devList[i]->screen == 0) && !xf86CheckPciSlot(pPci))
-                   continue;
-
-               DebugF("%s: card at %d:%d:%d is claimed by a Device section\n",
-                      drvp->driverName, pPci->bus, pPci->dev, pPci->func);
-
-               /* Allocate an entry in the lists to be returned */
-               entry = xf86ClaimPciSlot(pPci, drvp, device_id,
+                    == devices[j].device_class)) {
+                int entry;
+
+                /* Allow the same entity to be used more than once for
+                 * devices with multiple screens per entity.  This assumes
+                 * implicitly that there will be a screen == 0 instance.
+                 *
+                 * FIXME Need to make sure that two different drivers don't
+                 * FIXME claim the same screen > 0 instance.
+                 */
+                if ((devList[i]->screen == 0) && !xf86CheckPciSlot(pPci))
+                    continue;
+
+                DebugF("%s: card at %d:%d:%d is claimed by a Device section\n",
+                       drvp->driverName, pPci->bus, pPci->dev, pPci->func);
+
+                /* Allocate an entry in the lists to be returned */
+                entry = xf86ClaimPciSlot(pPci, drvp, device_id,
                                          devList[i], devList[i]->active);
 
-               if ((entry == -1) && (devList[i]->screen > 0)) {
-                   unsigned k;
-
-                   for (k = 0; k < xf86NumEntities; k++ ) {
-                       EntityPtr pEnt = xf86Entities[k];
-                       if (pEnt->bus.type != BUS_PCI)
-                           continue;
-                       if (pEnt->bus.id.pci == pPci) {
-                           entry = k;
-                           xf86AddDevToEntity(k, devList[i]);
-                           break;
-                       }
-                   }
-               }
-
-               if (entry != -1) {
-                   if ((*drvp->PciProbe)(drvp, entry, pPci,
-                                         devices[j].match_data)) {
-                       foundScreen = TRUE;
-                   } else
-                       xf86UnclaimPciSlot(pPci);
-               }
-
-               break;
-           }
-       }
+                if ((entry == -1) && (devList[i]->screen > 0)) {
+                    unsigned k;
+
+                    for (k = 0; k < xf86NumEntities; k++) {
+                        EntityPtr pEnt = xf86Entities[k];
+
+                        if (pEnt->bus.type != BUS_PCI)
+                            continue;
+                        if (pEnt->bus.id.pci == pPci) {
+                            entry = k;
+                            xf86AddDevToEntity(k, devList[i]);
+                            break;
+                        }
+                    }
+                }
+
+                if (entry != -1) {
+                    if ((*drvp->PciProbe) (drvp, entry, pPci,
+                                           devices[j].match_data)) {
+                        foundScreen = TRUE;
+                    }
+                    else
+                        xf86UnclaimPciSlot(pPci);
+                }
+
+                break;
+            }
+        }
     }
     free(devList);
 
@@ -557,7 +559,8 @@ xf86PciIsolateDevice(char *argument)
         xf86IsolateDevice.bus = PCI_BUS_NO_DOMAIN(bus);
         xf86IsolateDevice.dev = device;
         xf86IsolateDevice.func = func;
-    } else
+    }
+    else
         FatalError("Invalid isolated device specification\n");
 }
 
@@ -567,25 +570,24 @@ pciDeviceHasBars(struct pci_device *pci)
     int i;
 
     for (i = 0; i < 6; i++)
-	if (pci->regions[i].size)
-	    return TRUE;
+        if (pci->regions[i].size)
+            return TRUE;
 
     if (pci->rom_size)
-	return TRUE;
+        return TRUE;
 
     return FALSE;
 }
 
 struct Inst {
-    struct pci_device *	pci;
-    GDevPtr		dev;
-    Bool		foundHW;  /* PCIid in list of supported chipsets */
-    Bool		claimed;  /* BusID matches with a device section */
-    int 		chip;
-    int 		screen;
+    struct pci_device *pci;
+    GDevPtr dev;
+    Bool foundHW;               /* PCIid in list of supported chipsets */
+    Bool claimed;               /* BusID matches with a device section */
+    int chip;
+    int screen;
 };
 
-
 /**
  * Find set of unclaimed devices matching a given vendor ID.
  *
@@ -620,12 +622,12 @@ struct Inst {
  */
 int
 xf86MatchPciInstances(const char *driverName, int vendorID,
-		      SymTabPtr chipsets, PciChipsets *PCIchipsets,
-		      GDevPtr *devList, int numDevs, DriverPtr drvp,
-		      int **foundEntities)
+                      SymTabPtr chipsets, PciChipsets * PCIchipsets,
+                      GDevPtr * devList, int numDevs, DriverPtr drvp,
+                      int **foundEntities)
 {
-    int i,j;
-    struct pci_device * pPci;
+    int i, j;
+    struct pci_device *pPci;
     struct pci_device_iterator *iter;
     struct Inst *instances = NULL;
     int numClaimedInstances = 0;
@@ -637,7 +639,6 @@ xf86MatchPciInstances(const char *driverName, int vendorID,
 
     *foundEntities = NULL;
 
-
     /* Each PCI device will contribute at least one entry.  Each device
      * section can contribute at most one entry.  The sum of the two is
      * guaranteed to be larger than the maximum possible number of entries.
@@ -645,199 +646,199 @@ xf86MatchPciInstances(const char *driverName, int vendorID,
      * need for realloc calls inside the loop.
      */
     if (!(xf86DoConfigure && xf86DoConfigurePass1)) {
-	unsigned max_entries = numDevs;
+        unsigned max_entries = numDevs;
 
-	iter = pci_slot_match_iterator_create(NULL);
-	while ((pPci = pci_device_next(iter)) != NULL) {
-	    max_entries++;
-	}
+        iter = pci_slot_match_iterator_create(NULL);
+        while ((pPci = pci_device_next(iter)) != NULL) {
+            max_entries++;
+        }
 
-	pci_iterator_destroy(iter);
-	instances = xnfalloc(max_entries * sizeof(struct Inst));
+        pci_iterator_destroy(iter);
+        instances = xnfalloc(max_entries * sizeof(struct Inst));
     }
 
     iter = pci_slot_match_iterator_create(NULL);
     while ((pPci = pci_device_next(iter)) != NULL) {
-	unsigned device_class = pPci->device_class;
-	Bool foundVendor = FALSE;
-
-
-	/* Convert the pre-PCI 2.0 device class for a VGA adapter to the
-	 * 2.0 version of the same class.
-	 */
-	if ( device_class == 0x00000101 ) {
-	    device_class = 0x00030000;
-	}
-
-
-	/* Find PCI devices that match the given vendor ID.  The vendor ID is
-	 * either specified explicitly as a parameter to the function or
-	 * implicitly encoded in the high bits of id->PCIid.
-	 *
-	 * The first device with a matching vendor is recorded, even if the
-	 * device ID doesn't match.  This is done because the Device section
-	 * in the xorg.conf file can over-ride the device ID.  A matching PCI
-	 * ID might not be found now, but after the device ID over-ride is
-	 * applied there /might/ be a match.
-	 */
-	for (id = PCIchipsets; id->PCIid != -1; id++) {
-	    const unsigned vendor_id = ((id->PCIid & 0xFFFF0000) >> 16)
-		| vendorID;
-	    const unsigned device_id = (id->PCIid & 0x0000FFFF);
-	    const unsigned match_class = 0x00030000 | id->PCIid;
-
-	    if ((vendor_id == pPci->vendor_id)
-		|| ((vendorID == PCI_VENDOR_GENERIC) && (match_class == device_class))) {
-		if (!foundVendor && (instances != NULL)) {
-		    ++allocatedInstances;
-		    instances[allocatedInstances - 1].pci = pPci;
-		    instances[allocatedInstances - 1].dev = NULL;
-		    instances[allocatedInstances - 1].claimed = FALSE;
-		    instances[allocatedInstances - 1].foundHW = FALSE;
-		    instances[allocatedInstances - 1].screen = 0;
-		}
-
-		foundVendor = TRUE;
-
-		if ( (device_id == pPci->device_id)
-		     || ((vendorID == PCI_VENDOR_GENERIC)
-			 && (match_class == device_class)) ) {
-		    if ( instances != NULL ) {
-			instances[allocatedInstances - 1].foundHW = TRUE;
-			instances[allocatedInstances - 1].chip = id->numChipset;
-		    }
-
-
-		    if ( xf86DoConfigure && xf86DoConfigurePass1 ) {
-			if (xf86CheckPciSlot(pPci)) {
-			    GDevPtr pGDev =
-			      xf86AddBusDeviceToConfigure(drvp->driverName,
-							  BUS_PCI, pPci, -1);
-			    if (pGDev) {
-				/* After configure pass 1, chipID and chipRev
-				 * are treated as over-rides, so clobber them
-				 * here.
-				 */
-				pGDev->chipID = -1;
-				pGDev->chipRev = -1;
-			    }
-
-			    numFound++;
-			}
-		    }
-		    else {
-			numFound++;
-		    }
-
-		    break;
-		}
-	    }
-	}
+        unsigned device_class = pPci->device_class;
+        Bool foundVendor = FALSE;
+
+        /* Convert the pre-PCI 2.0 device class for a VGA adapter to the
+         * 2.0 version of the same class.
+         */
+        if (device_class == 0x00000101) {
+            device_class = 0x00030000;
+        }
+
+        /* Find PCI devices that match the given vendor ID.  The vendor ID is
+         * either specified explicitly as a parameter to the function or
+         * implicitly encoded in the high bits of id->PCIid.
+         *
+         * The first device with a matching vendor is recorded, even if the
+         * device ID doesn't match.  This is done because the Device section
+         * in the xorg.conf file can over-ride the device ID.  A matching PCI
+         * ID might not be found now, but after the device ID over-ride is
+         * applied there /might/ be a match.
+         */
+        for (id = PCIchipsets; id->PCIid != -1; id++) {
+            const unsigned vendor_id = ((id->PCIid & 0xFFFF0000) >> 16)
+                | vendorID;
+            const unsigned device_id = (id->PCIid & 0x0000FFFF);
+            const unsigned match_class = 0x00030000 | id->PCIid;
+
+            if ((vendor_id == pPci->vendor_id)
+                || ((vendorID == PCI_VENDOR_GENERIC) &&
+                    (match_class == device_class))) {
+                if (!foundVendor && (instances != NULL)) {
+                    ++allocatedInstances;
+                    instances[allocatedInstances - 1].pci = pPci;
+                    instances[allocatedInstances - 1].dev = NULL;
+                    instances[allocatedInstances - 1].claimed = FALSE;
+                    instances[allocatedInstances - 1].foundHW = FALSE;
+                    instances[allocatedInstances - 1].screen = 0;
+                }
+
+                foundVendor = TRUE;
+
+                if ((device_id == pPci->device_id)
+                    || ((vendorID == PCI_VENDOR_GENERIC)
+                        && (match_class == device_class))) {
+                    if (instances != NULL) {
+                        instances[allocatedInstances - 1].foundHW = TRUE;
+                        instances[allocatedInstances - 1].chip = id->numChipset;
+                    }
+
+                    if (xf86DoConfigure && xf86DoConfigurePass1) {
+                        if (xf86CheckPciSlot(pPci)) {
+                            GDevPtr pGDev =
+                                xf86AddBusDeviceToConfigure(drvp->driverName,
+                                                            BUS_PCI, pPci, -1);
+
+                            if (pGDev) {
+                                /* After configure pass 1, chipID and chipRev
+                                 * are treated as over-rides, so clobber them
+                                 * here.
+                                 */
+                                pGDev->chipID = -1;
+                                pGDev->chipRev = -1;
+                            }
+
+                            numFound++;
+                        }
+                    }
+                    else {
+                        numFound++;
+                    }
+
+                    break;
+                }
+            }
+        }
     }
 
     pci_iterator_destroy(iter);
 
-
     /* In "probe only" or "configure" mode (signaled by instances being NULL),
      * our work is done.  Return the number of detected devices.
      */
-    if ( instances == NULL ) {
-	return numFound;
+    if (instances == NULL) {
+        return numFound;
     }
 
-
     /*
      * This may be debatable, but if no PCI devices with a matching vendor
      * type is found, return zero now.  It is probably not desirable to
      * allow the config file to override this.
      */
     if (allocatedInstances <= 0) {
-	free(instances);
-	return 0;
+        free(instances);
+        return 0;
     }
 
-
     DebugF("%s instances found: %d\n", driverName, allocatedInstances);
 
-   /*
-    * Check for devices that need duplicated instances.  This is required
-    * when there is more than one screen per entity.
-    *
-    * XXX This currently doesn't work for cases where the BusID isn't
-    * specified explicitly in the config file.
-    */
+    /*
+     * Check for devices that need duplicated instances.  This is required
+     * when there is more than one screen per entity.
+     *
+     * XXX This currently doesn't work for cases where the BusID isn't
+     * specified explicitly in the config file.
+     */
 
     for (j = 0; j < numDevs; j++) {
-        if (devList[j]->screen > 0 && devList[j]->busID
-	    && *devList[j]->busID) {
-	    for (i = 0; i < allocatedInstances; i++) {
-	        pPci = instances[i].pci;
-	        if (xf86ComparePciBusString(devList[j]->busID,
-					    PCI_MAKE_BUS( pPci->domain, pPci->bus ),
-					    pPci->dev,
-					    pPci->func)) {
-		    allocatedInstances++;
-		    instances[allocatedInstances - 1] = instances[i];
-		    instances[allocatedInstances - 1].screen = devList[j]->screen;
-		    numFound++;
-		    break;
-		}
-	    }
-	}
+        if (devList[j]->screen > 0 && devList[j]->busID && *devList[j]->busID) {
+            for (i = 0; i < allocatedInstances; i++) {
+                pPci = instances[i].pci;
+                if (xf86ComparePciBusString(devList[j]->busID,
+                                            PCI_MAKE_BUS(pPci->domain,
+                                                         pPci->bus), pPci->dev,
+                                            pPci->func)) {
+                    allocatedInstances++;
+                    instances[allocatedInstances - 1] = instances[i];
+                    instances[allocatedInstances - 1].screen =
+                        devList[j]->screen;
+                    numFound++;
+                    break;
+                }
+            }
+        }
     }
 
     for (i = 0; i < allocatedInstances; i++) {
-	GDevPtr dev = NULL;
-	GDevPtr devBus = NULL;
-
-	pPci = instances[i].pci;
-	for (j = 0; j < numDevs; j++) {
-	    if (devList[j]->busID && *devList[j]->busID) {
-		if (xf86ComparePciBusString(devList[j]->busID,
-					    PCI_MAKE_BUS( pPci->domain, pPci->bus ),
-					    pPci->dev,
-					    pPci->func) &&
-		    devList[j]->screen == instances[i].screen) {
-
-		    if (devBus)
-                        xf86MsgVerb(X_WARNING,0,
-			    "%s: More than one matching Device section for "
-			    "instances\n\t(BusID: %s) found: %s\n",
-			    driverName, devList[j]->busID,
-			    devList[j]->identifier);
-		    else
-			devBus = devList[j];
-		}
-	    } else {
-		/*
-		 * if device section without BusID is found
-		 * only assign to it to the primary device.
-		 */
-		if (xf86IsPrimaryPci(pPci)) {
-		    xf86Msg(X_PROBED, "Assigning device section with no busID"
-			    " to primary device\n");
-		    if (dev || devBus)
-			xf86MsgVerb(X_WARNING, 0,
-			    "%s: More than one matching Device section "
-			    "found: %s\n", driverName, devList[j]->identifier);
-		    else
-			dev = devList[j];
-		}
-	    }
-	}
-	if (devBus) dev = devBus;  /* busID preferred */
-	if (!dev) {
-	    if (xf86CheckPciSlot(pPci) && pciDeviceHasBars(pPci)) {
-		xf86MsgVerb(X_WARNING, 0, "%s: No matching Device section "
-			    "for instance (BusID PCI:%u@%u:%u:%u) found\n",
-			    driverName, pPci->domain, pPci->bus, pPci->dev,
-			    pPci->func);
-	    }
-	} else {
-	    numClaimedInstances++;
-	    instances[i].claimed = TRUE;
-	    instances[i].dev = dev;
-	}
+        GDevPtr dev = NULL;
+        GDevPtr devBus = NULL;
+
+        pPci = instances[i].pci;
+        for (j = 0; j < numDevs; j++) {
+            if (devList[j]->busID && *devList[j]->busID) {
+                if (xf86ComparePciBusString(devList[j]->busID,
+                                            PCI_MAKE_BUS(pPci->domain,
+                                                         pPci->bus), pPci->dev,
+                                            pPci->func) &&
+                    devList[j]->screen == instances[i].screen) {
+
+                    if (devBus)
+                        xf86MsgVerb(X_WARNING, 0,
+                                    "%s: More than one matching Device section for "
+                                    "instances\n\t(BusID: %s) found: %s\n",
+                                    driverName, devList[j]->busID,
+                                    devList[j]->identifier);
+                    else
+                        devBus = devList[j];
+                }
+            }
+            else {
+                /*
+                 * if device section without BusID is found
+                 * only assign to it to the primary device.
+                 */
+                if (xf86IsPrimaryPci(pPci)) {
+                    xf86Msg(X_PROBED, "Assigning device section with no busID"
+                            " to primary device\n");
+                    if (dev || devBus)
+                        xf86MsgVerb(X_WARNING, 0,
+                                    "%s: More than one matching Device section "
+                                    "found: %s\n", driverName,
+                                    devList[j]->identifier);
+                    else
+                        dev = devList[j];
+                }
+            }
+        }
+        if (devBus)
+            dev = devBus;       /* busID preferred */
+        if (!dev) {
+            if (xf86CheckPciSlot(pPci) && pciDeviceHasBars(pPci)) {
+                xf86MsgVerb(X_WARNING, 0, "%s: No matching Device section "
+                            "for instance (BusID PCI:%u@%u:%u:%u) found\n",
+                            driverName, pPci->domain, pPci->bus, pPci->dev,
+                            pPci->func);
+            }
+        }
+        else {
+            numClaimedInstances++;
+            instances[i].claimed = TRUE;
+            instances[i].dev = dev;
+        }
     }
     DebugF("%s instances found: %d\n", driverName, numClaimedInstances);
     /*
@@ -846,78 +847,82 @@ xf86MatchPciInstances(const char *driverName, int vendorID,
      * If chipset is not valid ignore BusSlot completely.
      */
     for (i = 0; i < allocatedInstances && numClaimedInstances > 0; i++) {
-	MessageType from = X_PROBED;
-
-	if (!instances[i].claimed) {
-	    continue;
-	}
-	if (instances[i].dev->chipset) {
-	    for (c = chipsets; c->token >= 0; c++) {
-		if (xf86NameCmp(c->name, instances[i].dev->chipset) == 0)
-		    break;
-	    }
-	    if (c->token == -1) {
-		instances[i].claimed = FALSE;
-		numClaimedInstances--;
-		xf86MsgVerb(X_WARNING, 0, "%s: Chipset \"%s\" in Device "
-			    "section \"%s\" isn't valid for this driver\n",
-			    driverName, instances[i].dev->chipset,
-			    instances[i].dev->identifier);
-	    } else {
-		instances[i].chip = c->token;
-
-		for (id = PCIchipsets; id->numChipset >= 0; id++) {
-		    if (id->numChipset == instances[i].chip)
-			break;
-		}
-		if(id->numChipset >=0){
-		    xf86Msg(X_CONFIG,"Chipset override: %s\n",
-			     instances[i].dev->chipset);
-		    from = X_CONFIG;
-		} else {
-		    instances[i].claimed = FALSE;
-		    numClaimedInstances--;
-		    xf86MsgVerb(X_WARNING, 0, "%s: Chipset \"%s\" in Device "
-				"section \"%s\" isn't a valid PCI chipset\n",
-				driverName, instances[i].dev->chipset,
-				instances[i].dev->identifier);
-		}
-	    }
-	} else if (instances[i].dev->chipID > 0) {
-	    for (id = PCIchipsets; id->numChipset >= 0; id++) {
-		if (id->PCIid == instances[i].dev->chipID)
-		    break;
-	    }
-	    if (id->numChipset == -1) {
-		instances[i].claimed = FALSE;
-		numClaimedInstances--;
-		xf86MsgVerb(X_WARNING, 0, "%s: ChipID 0x%04X in Device "
-			    "section \"%s\" isn't valid for this driver\n",
-			    driverName, instances[i].dev->chipID,
-			    instances[i].dev->identifier);
-	    } else {
-		instances[i].chip = id->numChipset;
-
-		xf86Msg( X_CONFIG,"ChipID override: 0x%04X\n",
-			 instances[i].dev->chipID);
-		from = X_CONFIG;
-	    }
-	} else if (!instances[i].foundHW) {
-	    /*
-	     * This means that there was no override and the PCI chipType
-	     * doesn't match one that is supported
-	     */
-	    instances[i].claimed = FALSE;
-	    numClaimedInstances--;
-	}
-	if (instances[i].claimed == TRUE){
-	    for (c = chipsets; c->token >= 0; c++) {
-		if (c->token == instances[i].chip)
-		    break;
-	    }
-	    xf86Msg(from,"Chipset %s found\n",
-		    c->name);
-	}
+        MessageType from = X_PROBED;
+
+        if (!instances[i].claimed) {
+            continue;
+        }
+        if (instances[i].dev->chipset) {
+            for (c = chipsets; c->token >= 0; c++) {
+                if (xf86NameCmp(c->name, instances[i].dev->chipset) == 0)
+                    break;
+            }
+            if (c->token == -1) {
+                instances[i].claimed = FALSE;
+                numClaimedInstances--;
+                xf86MsgVerb(X_WARNING, 0, "%s: Chipset \"%s\" in Device "
+                            "section \"%s\" isn't valid for this driver\n",
+                            driverName, instances[i].dev->chipset,
+                            instances[i].dev->identifier);
+            }
+            else {
+                instances[i].chip = c->token;
+
+                for (id = PCIchipsets; id->numChipset >= 0; id++) {
+                    if (id->numChipset == instances[i].chip)
+                        break;
+                }
+                if (id->numChipset >= 0) {
+                    xf86Msg(X_CONFIG, "Chipset override: %s\n",
+                            instances[i].dev->chipset);
+                    from = X_CONFIG;
+                }
+                else {
+                    instances[i].claimed = FALSE;
+                    numClaimedInstances--;
+                    xf86MsgVerb(X_WARNING, 0, "%s: Chipset \"%s\" in Device "
+                                "section \"%s\" isn't a valid PCI chipset\n",
+                                driverName, instances[i].dev->chipset,
+                                instances[i].dev->identifier);
+                }
+            }
+        }
+        else if (instances[i].dev->chipID > 0) {
+            for (id = PCIchipsets; id->numChipset >= 0; id++) {
+                if (id->PCIid == instances[i].dev->chipID)
+                    break;
+            }
+            if (id->numChipset == -1) {
+                instances[i].claimed = FALSE;
+                numClaimedInstances--;
+                xf86MsgVerb(X_WARNING, 0, "%s: ChipID 0x%04X in Device "
+                            "section \"%s\" isn't valid for this driver\n",
+                            driverName, instances[i].dev->chipID,
+                            instances[i].dev->identifier);
+            }
+            else {
+                instances[i].chip = id->numChipset;
+
+                xf86Msg(X_CONFIG, "ChipID override: 0x%04X\n",
+                        instances[i].dev->chipID);
+                from = X_CONFIG;
+            }
+        }
+        else if (!instances[i].foundHW) {
+            /*
+             * This means that there was no override and the PCI chipType
+             * doesn't match one that is supported
+             */
+            instances[i].claimed = FALSE;
+            numClaimedInstances--;
+        }
+        if (instances[i].claimed == TRUE) {
+            for (c = chipsets; c->token >= 0; c++) {
+                if (c->token == instances[i].chip)
+                    break;
+            }
+            xf86Msg(from, "Chipset %s found\n", c->name);
+        }
     }
 
     /*
@@ -926,48 +931,48 @@ xf86MatchPciInstances(const char *driverName, int vendorID,
      */
     numFound = 0;
     for (i = 0; i < allocatedInstances && numClaimedInstances > 0; i++) {
-	if (!instances[i].claimed)
-	    continue;
-	pPci = instances[i].pci;
-
+        if (!instances[i].claimed)
+            continue;
+        pPci = instances[i].pci;
 
         /*
-	 * Allow the same entity to be used more than once for devices with
-	 * multiple screens per entity.  This assumes implicitly that there
-	 * will be a screen == 0 instance.
-	 *
-	 * XXX Need to make sure that two different drivers don't claim
-	 * the same screen > 0 instance.
-	 */
-        if (instances[i].screen == 0 && !xf86CheckPciSlot( pPci ))
-	    continue;
-
-	DebugF("%s: card at %d:%d:%d is claimed by a Device section\n",
-	       driverName, pPci->bus, pPci->dev, pPci->func);
-
-	/* Allocate an entry in the lists to be returned */
-	numFound++;
-	retEntities = xnfrealloc(retEntities, numFound * sizeof(int));
-	retEntities[numFound - 1] = xf86ClaimPciSlot( pPci, drvp,
-						      instances[i].chip,
-						      instances[i].dev,
-						      instances[i].dev->active);
+         * Allow the same entity to be used more than once for devices with
+         * multiple screens per entity.  This assumes implicitly that there
+         * will be a screen == 0 instance.
+         *
+         * XXX Need to make sure that two different drivers don't claim
+         * the same screen > 0 instance.
+         */
+        if (instances[i].screen == 0 && !xf86CheckPciSlot(pPci))
+            continue;
+
+        DebugF("%s: card at %d:%d:%d is claimed by a Device section\n",
+               driverName, pPci->bus, pPci->dev, pPci->func);
+
+        /* Allocate an entry in the lists to be returned */
+        numFound++;
+        retEntities = xnfrealloc(retEntities, numFound * sizeof(int));
+        retEntities[numFound - 1] = xf86ClaimPciSlot(pPci, drvp,
+                                                     instances[i].chip,
+                                                     instances[i].dev,
+                                                     instances[i].dev->active);
         if (retEntities[numFound - 1] == -1 && instances[i].screen > 0) {
-	    for (j = 0; j < xf86NumEntities; j++) {
-	        EntityPtr pEnt = xf86Entities[j];
-	        if (pEnt->bus.type != BUS_PCI)
-		    continue;
-	        if (pEnt->bus.id.pci == pPci) {
-		    retEntities[numFound - 1] = j;
-		    xf86AddDevToEntity(j, instances[i].dev);
-		    break;
-		}
-	    }
-	}
+            for (j = 0; j < xf86NumEntities; j++) {
+                EntityPtr pEnt = xf86Entities[j];
+
+                if (pEnt->bus.type != BUS_PCI)
+                    continue;
+                if (pEnt->bus.id.pci == pPci) {
+                    retEntities[numFound - 1] = j;
+                    xf86AddDevToEntity(j, instances[i].dev);
+                    break;
+                }
+            }
+        }
     }
     free(instances);
     if (numFound > 0) {
-	*foundEntities = retEntities;
+        *foundEntities = retEntities;
     }
 
     return numFound;
@@ -981,51 +986,52 @@ xf86MatchPciInstances(const char *driverName, int vendorID,
  * non-NULL all static resources listed there will be registered.
  */
 static void
-xf86ConfigPciEntityInactive(EntityInfoPtr pEnt, PciChipsets *p_chip,
-			    EntityProc init, EntityProc enter,
-			    EntityProc leave, pointer private)
+xf86ConfigPciEntityInactive(EntityInfoPtr pEnt, PciChipsets * p_chip,
+                            EntityProc init, EntityProc enter,
+                            EntityProc leave, pointer private)
 {
     ScrnInfoPtr pScrn;
 
     if ((pScrn = xf86FindScreenForEntity(pEnt->index)))
-	xf86RemoveEntityFromScreen(pScrn,pEnt->index);
+        xf86RemoveEntityFromScreen(pScrn, pEnt->index);
 
     /* shared resources are only needed when entity is active: remove */
-    xf86SetEntityFuncs(pEnt->index,init,enter,leave,private);
+    xf86SetEntityFuncs(pEnt->index, init, enter, leave, private);
 }
 
 ScrnInfoPtr
 xf86ConfigPciEntity(ScrnInfoPtr pScrn, int scrnFlag, int entityIndex,
-			  PciChipsets *p_chip, void *dummy, EntityProc init,
-			  EntityProc enter, EntityProc leave, pointer private)
+                    PciChipsets * p_chip, void *dummy, EntityProc init,
+                    EntityProc enter, EntityProc leave, pointer private)
 {
     EntityInfoPtr pEnt = xf86GetEntityInfo(entityIndex);
-    if (!pEnt) return pScrn;
+
+    if (!pEnt)
+        return pScrn;
 
     if (!(pEnt->location.type == BUS_PCI)
-	|| !xf86GetPciInfoForEntity(entityIndex)) {
-	free(pEnt);
-	return pScrn;
+        || !xf86GetPciInfoForEntity(entityIndex)) {
+        free(pEnt);
+        return pScrn;
     }
     if (!pEnt->active) {
-	xf86ConfigPciEntityInactive(pEnt, p_chip, init,  enter,
-				    leave,  private);
-	free(pEnt);
-	return pScrn;
+        xf86ConfigPciEntityInactive(pEnt, p_chip, init, enter, leave, private);
+        free(pEnt);
+        return pScrn;
     }
 
     if (!pScrn)
-	pScrn = xf86AllocateScreen(pEnt->driver,scrnFlag);
+        pScrn = xf86AllocateScreen(pEnt->driver, scrnFlag);
     if (xf86IsEntitySharable(entityIndex)) {
         xf86SetEntityShared(entityIndex);
     }
-    xf86AddEntityToScreen(pScrn,entityIndex);
+    xf86AddEntityToScreen(pScrn, entityIndex);
     if (xf86IsEntityShared(entityIndex)) {
         return pScrn;
     }
     free(pEnt);
 
-    xf86SetEntityFuncs(entityIndex,init,enter,leave,private);
+    xf86SetEntityFuncs(entityIndex, init, enter, leave, private);
 
     return pScrn;
 }
@@ -1036,20 +1042,22 @@ xf86ConfigPciEntity(ScrnInfoPtr pScrn, int scrnFlag, int entityIndex,
  */
 Bool
 xf86ConfigActivePciEntity(ScrnInfoPtr pScrn, int entityIndex,
-                          PciChipsets *p_chip, void *dummy, EntityProc init,
+                          PciChipsets * p_chip, void *dummy, EntityProc init,
                           EntityProc enter, EntityProc leave, pointer private)
 {
     EntityInfoPtr pEnt = xf86GetEntityInfo(entityIndex);
-    if (!pEnt) return FALSE;
+
+    if (!pEnt)
+        return FALSE;
 
     if (!pEnt->active || !(pEnt->location.type == BUS_PCI)) {
         free(pEnt);
         return FALSE;
     }
-    xf86AddEntityToScreen(pScrn,entityIndex);
+    xf86AddEntityToScreen(pScrn, entityIndex);
 
     free(pEnt);
-    if (!xf86SetEntityFuncs(entityIndex,init,enter,leave,private))
+    if (!xf86SetEntityFuncs(entityIndex, init, enter, leave, private))
         return FALSE;
 
     return TRUE;
@@ -1057,106 +1065,165 @@ xf86ConfigActivePciEntity(ScrnInfoPtr pScrn, int entityIndex,
 
 static int
 videoPtrToDriverList(struct pci_device *dev,
-		     char *returnList[], int returnListMax)
+                     char *returnList[], int returnListMax)
 {
     int i;
+
     /* Add more entries here if we ever return more than 4 drivers for
        any device */
     const char *driverList[5] = { NULL, NULL, NULL, NULL, NULL };
 
-    switch (dev->vendor_id)
+    switch (dev->vendor_id) {
+        /* AMD Geode LX */
+    case 0x1022:
+        if (dev->device_id == 0x2081)
+            driverList[0] = "geode";
+        break;
+        /* older Geode products acquired by AMD still carry an NSC vendor_id */
+    case 0x100b:
+        if (dev->device_id == 0x0030) {
+            /* NSC Geode GX2 specifically */
+            driverList[0] = "geode";
+            /* GX2 support started its life in the NSC tree and was later
+               forked by AMD for GEODE so we keep it as a backup */
+            driverList[1] = "nsc";
+        }
+        else
+            /* other NSC variant e.g. 0x0104 (SC1400), 0x0504 (SCx200) */
+            driverList[0] = "nsc";
+        break;
+        /* Cyrix Geode GX1 */
+    case 0x1078:
+        if (dev->device_id == 0x0104)
+            driverList[0] = "cyrix";
+        break;
+    case 0x1142:
+        driverList[0] = "apm";
+        break;
+    case 0xedd8:
+        driverList[0] = "ark";
+        break;
+    case 0x1a03:
+        driverList[0] = "ast";
+        break;
+    case 0x1002:
+        driverList[0] = "ati";
+        break;
+    case 0x102c:
+        driverList[0] = "chips";
+        break;
+    case 0x1013:
+        driverList[0] = "cirrus";
+        break;
+    case 0x3d3d:
+        driverList[0] = "glint";
+        break;
+    case 0x105d:
+        driverList[0] = "i128";
+        break;
+    case 0x8086:
+        if ((dev->device_id == 0x00d1) || (dev->device_id == 0x7800)) {
+            driverList[0] = "i740";
+        }
+        else if (dev->device_id == 0x8108) {
+            break;              /* "hooray" for poulsbo */
+        }
+        else {
+            driverList[0] = "intel";
+        }
+        break;
+    case 0x102b:
+        driverList[0] = "mga";
+        break;
+    case 0x10c8:
+        driverList[0] = "neomagic";
+        break;
+    case 0x10de:
+    case 0x12d2:
     {
-	/* AMD Geode LX */
-	case 0x1022:
-	    if (dev->device_id == 0x2081)
-		driverList[0] = "geode";
-	    break;
-	/* older Geode products acquired by AMD still carry an NSC vendor_id */
-	case 0x100b:
-	    if (dev->device_id == 0x0030) {
-		/* NSC Geode GX2 specifically */
-		driverList[0] = "geode";
-		/* GX2 support started its life in the NSC tree and was later
-		   forked by AMD for GEODE so we keep it as a backup */
-		driverList[1] = "nsc";
-	    } else
-		/* other NSC variant e.g. 0x0104 (SC1400), 0x0504 (SCx200) */
-		driverList[0] = "nsc";
-	    break;
-	/* Cyrix Geode GX1 */
-	case 0x1078:
-	    if (dev->device_id == 0x0104)
-		driverList[0] = "cyrix";
-	    break;
-	case 0x1142:		    driverList[0] = "apm"; break;
-	case 0xedd8:		    driverList[0] = "ark"; break;
-	case 0x1a03:		    driverList[0] = "ast"; break;
-	case 0x1002:		    driverList[0] = "ati"; break;
-	case 0x102c:		    driverList[0] = "chips"; break;
-	case 0x1013:		    driverList[0] = "cirrus"; break;
-	case 0x3d3d:		    driverList[0] = "glint"; break;
-	case 0x105d:		    driverList[0] = "i128"; break;
-	case 0x8086:
-	    if ((dev->device_id == 0x00d1) || (dev->device_id == 0x7800)) {
-		driverList[0] = "i740";
-            } else if (dev->device_id == 0x8108) {
-                break; /* "hooray" for poulsbo */
-	    } else {
-		driverList[0] = "intel";
-	    }
-	    break;
-	case 0x102b:		    driverList[0] = "mga";	break;
-	case 0x10c8:		    driverList[0] = "neomagic"; break;
-	case 0x10de: case 0x12d2:
-	{
-	    int idx = 0;
+        int idx = 0;
+
 #ifdef __linux__
-	    driverList[idx++] = "nouveau";
+        driverList[idx++] = "nouveau";
 #endif
-	    driverList[idx++] = "nv";
-	    break;
-	}
-	case 0x1106:		    driverList[0] = "openchrome"; break;
-        case 0x1b36:		    driverList[0] = "qxl"; break;
-	case 0x1163:		    driverList[0] = "rendition"; break;
-	case 0x5333:
-	    switch (dev->device_id)
-	    {
-		case 0x88d0: case 0x88d1: case 0x88f0: case 0x8811:
-		case 0x8812: case 0x8814: case 0x8901:
-		    driverList[0] = "s3"; break;
-		case 0x5631: case 0x883d: case 0x8a01: case 0x8a10:
-		case 0x8c01: case 0x8c03: case 0x8904: case 0x8a13:
-		    driverList[0] = "s3virge"; break;
-		default:
-		    driverList[0] = "savage"; break;
-	    }
-	    break;
-	case 0x1039:		    driverList[0] = "sis";	break;
-	case 0x126f:		    driverList[0] = "siliconmotion"; break;
-	case 0x121a:
-	    if (dev->device_id < 0x0003)
-	        driverList[0] = "voodoo";
-	    else
-	        driverList[0] = "tdfx";
-	    break;
-	case 0x1011:		    driverList[0] = "tga"; break;
-	case 0x1023:		    driverList[0] = "trident"; break;
-	case 0x100c:		    driverList[0] = "tseng"; break;
-	case 0x80ee:		    driverList[0] = "vboxvideo"; break;
-	case 0x15ad:		    driverList[0] = "vmware"; break;
-	case 0x18ca:
-	    if (dev->device_id == 0x47)
-		driverList[0] = "xgixp";
-	    else
-		driverList[0] = "xgi";
-	    break;
-	default: break;
+        driverList[idx++] = "nv";
+        break;
+    }
+    case 0x1106:
+        driverList[0] = "openchrome";
+        break;
+    case 0x1b36:
+        driverList[0] = "qxl";
+        break;
+    case 0x1163:
+        driverList[0] = "rendition";
+        break;
+    case 0x5333:
+        switch (dev->device_id) {
+        case 0x88d0:
+        case 0x88d1:
+        case 0x88f0:
+        case 0x8811:
+        case 0x8812:
+        case 0x8814:
+        case 0x8901:
+            driverList[0] = "s3";
+            break;
+        case 0x5631:
+        case 0x883d:
+        case 0x8a01:
+        case 0x8a10:
+        case 0x8c01:
+        case 0x8c03:
+        case 0x8904:
+        case 0x8a13:
+            driverList[0] = "s3virge";
+            break;
+        default:
+            driverList[0] = "savage";
+            break;
+        }
+        break;
+    case 0x1039:
+        driverList[0] = "sis";
+        break;
+    case 0x126f:
+        driverList[0] = "siliconmotion";
+        break;
+    case 0x121a:
+        if (dev->device_id < 0x0003)
+            driverList[0] = "voodoo";
+        else
+            driverList[0] = "tdfx";
+        break;
+    case 0x1011:
+        driverList[0] = "tga";
+        break;
+    case 0x1023:
+        driverList[0] = "trident";
+        break;
+    case 0x100c:
+        driverList[0] = "tseng";
+        break;
+    case 0x80ee:
+        driverList[0] = "vboxvideo";
+        break;
+    case 0x15ad:
+        driverList[0] = "vmware";
+        break;
+    case 0x18ca:
+        if (dev->device_id == 0x47)
+            driverList[0] = "xgixp";
+        else
+            driverList[0] = "xgi";
+        break;
+    default:
+        break;
     }
     for (i = 0; (i < returnListMax) && (driverList[i] != NULL); i++) {
-	returnList[i] = xnfstrdup(driverList[i]);
+        returnList[i] = xnfstrdup(driverList[i]);
     }
-    return i;	/* Number of entries added */
+    return i;                   /* Number of entries added */
 }
 
 #ifdef __linux__
@@ -1181,7 +1248,7 @@ xchomp(char *line)
  * feature it can and should be removed because the symbol-based resolution
  * scheme should be the primary one */
 static void
-matchDriverFromFiles (char** matches, uint16_t match_vendor, uint16_t match_chip)
+matchDriverFromFiles(char **matches, uint16_t match_vendor, uint16_t match_chip)
 {
     DIR *idsdir;
     FILE *fp;
@@ -1197,7 +1264,9 @@ matchDriverFromFiles (char** matches, uint16_t match_vendor, uint16_t match_chip
     if (!idsdir)
         return;
 
-    xf86Msg(X_INFO, "Scanning %s directory for additional PCI ID's supported by the drivers\n", PCI_TXT_IDS_PATH);
+    xf86Msg(X_INFO,
+            "Scanning %s directory for additional PCI ID's supported by the drivers\n",
+            PCI_TXT_IDS_PATH);
     direntry = readdir(idsdir);
     /* Read the directory */
     while (direntry) {
@@ -1207,63 +1276,72 @@ matchDriverFromFiles (char** matches, uint16_t match_vendor, uint16_t match_chip
         }
         len = strlen(direntry->d_name);
         /* A tiny bit of sanity checking. We should probably do better */
-        if (strncmp(&(direntry->d_name[len-4]), ".ids", 4) == 0) {
+        if (strncmp(&(direntry->d_name[len - 4]), ".ids", 4) == 0) {
             /* We need the full path name to open the file */
             snprintf(path_name, sizeof(path_name), "%s/%s",
                      PCI_TXT_IDS_PATH, direntry->d_name);
             fp = fopen(path_name, "r");
             if (fp == NULL) {
-                xf86Msg(X_ERROR, "Could not open %s for reading. Exiting.\n", path_name);
+                xf86Msg(X_ERROR, "Could not open %s for reading. Exiting.\n",
+                        path_name);
                 goto end;
             }
             /* Read the file */
 #ifdef __GLIBC__
             while ((read = getline(&line, &len, fp)) != -1) {
 #else
-            while ((line = fgetln(fp, &len)) != (char *)NULL) {
-#endif /* __GLIBC __ */
+            while ((line = fgetln(fp, &len)) != (char *) NULL) {
+#endif                          /* __GLIBC __ */
                 xchomp(line);
                 if (isdigit(line[0])) {
                     strlcpy(vendor_str, line, sizeof(vendor_str));
-                    vendor = (int)strtol(vendor_str, NULL, 16);
+                    vendor = (int) strtol(vendor_str, NULL, 16);
                     if ((strlen(&line[4])) == 0) {
                         chip_str[0] = '\0';
                         chip = -1;
-                    } else {
+                    }
+                    else {
                         /* Handle trailing whitespace */
                         if (isspace(line[4])) {
                             chip_str[0] = '\0';
                             chip = -1;
-                        } else {
+                        }
+                        else {
                             /* Ok, it's a real ID */
                             strlcpy(chip_str, &line[4], sizeof(chip_str));
-                            chip = (int)strtol(chip_str, NULL, 16);
+                            chip = (int) strtol(chip_str, NULL, 16);
                         }
                     }
-                    if (vendor == match_vendor && chip == match_chip ) {
+                    if (vendor == match_vendor && chip == match_chip) {
                         i = 0;
                         while (matches[i]) {
                             i++;
                         }
-                        matches[i] = (char*)malloc(sizeof(char) * strlen(direntry->d_name) -  3);
+                        matches[i] =
+                            (char *) malloc(sizeof(char) *
+                                            strlen(direntry->d_name) - 3);
                         if (!matches[i]) {
-                            xf86Msg(X_ERROR, "Could not allocate space for the module name. Exiting.\n");
+                            xf86Msg(X_ERROR,
+                                    "Could not allocate space for the module name. Exiting.\n");
                             goto end;
                         }
                         /* hack off the .ids suffix. This should guard
                          * against other problems, but it will end up
                          * taking off anything after the first '.' */
-                        for (j = 0; j < (strlen(direntry->d_name) - 3) ; j++) {
+                        for (j = 0; j < (strlen(direntry->d_name) - 3); j++) {
                             if (direntry->d_name[j] == '.') {
                                 matches[i][j] = '\0';
                                 break;
-                            } else {
+                            }
+                            else {
                                 matches[i][j] = direntry->d_name[j];
                             }
                         }
-                        xf86Msg(X_INFO, "Matched %s from file name %s\n", matches[i], direntry->d_name);
+                        xf86Msg(X_INFO, "Matched %s from file name %s\n",
+                                matches[i], direntry->d_name);
                     }
-                } else {
+                }
+                else {
                     /* TODO Handle driver overrides here */
                 }
             }
@@ -1275,38 +1353,39 @@ matchDriverFromFiles (char** matches, uint16_t match_vendor, uint16_t match_chip
     free(line);
     closedir(idsdir);
 }
-#endif /* __linux__ */
+#endif                          /* __linux__ */
 
 /**
  *  @return The numbers of found devices that match with the current system
  *  drivers.
  */
 int
-xf86PciMatchDriver(char* matches[], int nmatches) {
+xf86PciMatchDriver(char *matches[], int nmatches)
+{
     int i;
-    struct pci_device * info = NULL;
+    struct pci_device *info = NULL;
     struct pci_device_iterator *iter;
 
     /* Find the primary device, and get some information about it. */
     iter = pci_slot_match_iterator_create(NULL);
     while ((info = pci_device_next(iter)) != NULL) {
-	if (xf86IsPrimaryPci(info)) {
-	    break;
-	}
+        if (xf86IsPrimaryPci(info)) {
+            break;
+        }
     }
 
     pci_iterator_destroy(iter);
 #ifdef __linux__
     if (info)
-	matchDriverFromFiles(matches, info->vendor_id, info->device_id);
+        matchDriverFromFiles(matches, info->vendor_id, info->device_id);
 #endif
 
     for (i = 0; (i < nmatches) && (matches[i]); i++) {
-	/* find end of matches list */
+        /* find end of matches list */
     }
 
     if ((info != NULL) && (i < nmatches)) {
-	i += videoPtrToDriverList(info, &(matches[i]), nmatches - i);
+        i += videoPtrToDriverList(info, &(matches[i]), nmatches - i);
     }
 
     return i;
@@ -1315,14 +1394,13 @@ xf86PciMatchDriver(char* matches[], int nmatches) {
 Bool
 xf86PciConfigure(void *busData, struct pci_device *pDev)
 {
-    struct pci_device * pVideo = NULL;
+    struct pci_device *pVideo = NULL;
 
     pVideo = (struct pci_device *) busData;
     if (pDev &&
         (pDev->domain == pVideo->domain) &&
         (pDev->bus == pVideo->bus) &&
-        (pDev->dev == pVideo->dev) &&
-        (pDev->func == pVideo->func))
+        (pDev->dev == pVideo->dev) && (pDev->func == pVideo->func))
         return 0;
 
     return 1;
@@ -1330,20 +1408,20 @@ xf86PciConfigure(void *busData, struct pci_device *pDev)
 
 void
 xf86PciConfigureNewDev(void *busData, struct pci_device *pVideo,
-                         GDevRec *GDev, int *chipset)
+                       GDevRec * GDev, int *chipset)
 {
     char busnum[8];
 
     pVideo = (struct pci_device *) busData;
 
     if (pVideo->bus < 256)
-	snprintf(busnum, sizeof(busnum), "%d", pVideo->bus);
+        snprintf(busnum, sizeof(busnum), "%d", pVideo->bus);
     else
-	snprintf(busnum, sizeof(busnum), "%d@%d",
-		 pVideo->bus & 0x00ff, pVideo->bus >> 8);
+        snprintf(busnum, sizeof(busnum), "%d@%d",
+                 pVideo->bus & 0x00ff, pVideo->bus >> 8);
 
     XNFasprintf(&GDev->busID, "PCI:%s:%d:%d",
-		busnum, pVideo->dev, pVideo->func);
+                busnum, pVideo->dev, pVideo->func);
 
     GDev->chipID = pVideo->device_id;
     GDev->chipRev = pVideo->revision;