Part two of this NEWCARD update:

Briefly, the significant changes include:
 * Way better resource management in pccbb, pccard and cardbus.
 * pccard hot-removal now appears to work.
 * support pre-fetchable memory in cardbus.
 * update cardbus to support new pci bus interface functions.
 * Fix CIS reading to no longer use rman_get_virtual().

What's not there, but in the works:
 * pccard needs to do interrupt properly and not read the ISR on single
   function cards.
 * real resource management for pccard
 * a complete implementation of CIS parsing
 * need to look into how to correctly use mutex in pccbb

1 files changed, 513 insertions, 116 deletions

diff --git a/sys/dev/cardbus/cardbus_cis.c b/sys/dev/cardbus/cardbus_cis.c
index 883beb8..f0b4274 100644
--- a/sys/dev/cardbus/cardbus_cis.c
+++ b/sys/dev/cardbus/cardbus_cis.c
@@ -44,9 +44,12 @@
 #include <machine/resource.h>
 #include <sys/rman.h>
 
-#include <pci/pcivar.h>
+#include <dev/pci/pcivar.h>
+#include <dev/pci/pcireg.h>
+#include <sys/pciio.h>
 
 #include <dev/cardbus/cardbusreg.h>
+#include <dev/cardbus/cardbusvar.h>
 #include <dev/cardbus/cardbus_cis.h>
 
 #include "card_if.h"
@@ -66,7 +69,7 @@ static const char rcsid[] =
 
 #define	DECODE_PARAMS							\
 		(device_t cbdev, device_t child, int id, int len,	\
-		 u_int8_t *tupledata, u_int32_t *start, u_int32_t *off,	\
+		 u_int8_t *tupledata, u_int32_t start, u_int32_t *off,	\
 		 struct tuple_callbacks *info)
 
 struct tuple_callbacks {
@@ -88,22 +91,28 @@ DECODE_PROTOTYPE(bar);
 DECODE_PROTOTYPE(unhandled);
 DECODE_PROTOTYPE(end);
 static int	cardbus_read_tuple_conf(device_t cbdev, device_t child,
-		    u_int32_t *start, u_int32_t *off, int *tupleid, int *len,
+		    u_int32_t start, u_int32_t *off, int *tupleid, int *len,
 		    u_int8_t *tupledata);
-static int	cardbus_read_tuple_exrom(device_t cbdev, struct resource *mem,
-		    u_int32_t *start, u_int32_t *off, int *tupleid, int *len,
-		    u_int8_t *tupledata);
-static int	cardbus_read_tuple_mem(device_t cbdev, device_t child,
-		    u_int32_t *start, u_int32_t *off, int *tupleid, int *len,
+static int	cardbus_read_tuple_mem(device_t cbdev, struct resource *res,
+		    u_int32_t start, u_int32_t *off, int *tupleid, int *len,
 		    u_int8_t *tupledata);
 static int	cardbus_read_tuple(device_t cbdev, device_t child,
-		    u_int32_t *start, u_int32_t *off, int *tupleid, int *len,
-		    u_int8_t *tupledata);
+		    struct resource *res, u_int32_t start, u_int32_t *off,
+		    int *tupleid, int *len, u_int8_t *tupledata);
+static void	cardbus_read_tuple_finish(device_t cbdev, device_t child,
+		    int rid, struct resource *res);
+static struct resource	*cardbus_read_tuple_init(device_t cbdev, device_t child,
+		    u_int32_t *start, int *rid);
 static int	decode_tuple(device_t cbdev, device_t child, int tupleid,
-		    int len, u_int8_t *tupledata, u_int32_t *start,
+		    int len, u_int8_t *tupledata, u_int32_t start,
 		    u_int32_t *off, struct tuple_callbacks *callbacks);
 static int	cardbus_parse_cis(device_t cbdev, device_t child,
 		    struct tuple_callbacks *callbacks);
+static int	barsort(const void *a, const void *b);
+static int	cardbus_alloc_resources(device_t cbdev, device_t child);
+static void	cardbus_add_map(device_t cbdev, device_t child, int reg);
+static void	cardbus_pickup_maps(device_t cbdev, device_t child);
+
 
 #define	MAKETUPLE(NAME,FUNC) { CISTPL_ ## NAME, #NAME, decode_tuple_ ## FUNC }
 
@@ -120,6 +129,18 @@ static char *funcnames[] = {
 	"Security"
 };
 
+struct cardbus_quirk {
+	u_int32_t devid;	/* Vendor/device of the card */
+	int	type;
+#define	CARDBUS_QUIRK_MAP_REG	1 /* PCI map register in weird place */
+	int	arg1;
+	int	arg2;
+};
+
+struct cardbus_quirk cardbus_quirks[] = {
+	{ 0 }
+};
+
 static struct cis_tupleinfo *cisread_buf;
 static int ncisread_buf;
 
@@ -258,11 +279,10 @@ DECODE_PROTOTYPE(bar)
 		printf("*** ERROR *** BAR length not 6 (%d)\n", len);
 		return EINVAL;
 	} else {
+		struct cardbus_devinfo *dinfo = device_get_ivars(child);
 		int type;
 		int reg;
 		u_int32_t bar;
-		u_int32_t len;
-		struct resource *res;
 
 		reg = *(u_int16_t*)tupledata;
 		len = *(u_int32_t*)(tupledata + 2);
@@ -279,13 +299,26 @@ DECODE_PROTOTYPE(bar)
 			return 0;
 		}
 		bar = CARDBUS_BASE0_REG + bar * 4;
-		DEVPRINTF((cbdev, "Opening BAR: type=%s, bar=%02x, len=%04x\n",
-		    (type==SYS_RES_MEMORY)?"MEM":"IO", bar, len));
-		res = bus_generic_alloc_resource(child, child, type, &bar, 0,
-		    ~0, len, rman_make_alignment_flags(len) | RF_ACTIVE);
-		if (res == NULL) {
-			device_printf(cbdev, "Cannot allocate BAR %02x\n", bar);
+		if (type == SYS_RES_MEMORY) {
+			if (bar & TPL_BAR_REG_PREFETCHABLE)
+				dinfo->mprefetchable |= BARBIT(bar);
+			if (bar & TPL_BAR_REG_BELOW1MB)
+				dinfo->mbelow1mb |= BARBIT(bar);
+		} else if (type == SYS_RES_IOPORT) {
+			if (bar & TPL_BAR_REG_BELOW1MB)
+				dinfo->ibelow1mb |= BARBIT(bar);
 		}
+		DEVPRINTF((cbdev, "Opening BAR: type=%s, bar=%02x, "
+		    "len=%04x%s%s\n",
+		    (type==SYS_RES_MEMORY)?"MEM":"IO", bar, len,
+		    (type==SYS_RES_MEMORY&&dinfo->mprefetchable&BARBIT(bar))?
+		    " (Prefetchable)":"",
+		    type==SYS_RES_MEMORY?
+		    ((dinfo->mbelow1mb&BARBIT(bar))?" (Below 1Mb)":"")
+		    :(dinfo->ibelow1mb&BARBIT(bar))?" (Below 1Mb)":""
+		    ));
+
+		resource_list_add(&dinfo->resources, type, bar, 0UL, ~0UL, len);
 	}
 	return 0;
 }
@@ -307,14 +340,14 @@ DECODE_PROTOTYPE(end)
  */
 
 static int
-cardbus_read_tuple_conf(device_t cbdev, device_t child, u_int32_t *start,
+cardbus_read_tuple_conf(device_t cbdev, device_t child, u_int32_t start,
     u_int32_t *off, int *tupleid, int *len, u_int8_t *tupledata)
 {
 	int i, j;
 	u_int32_t e;
 	u_int32_t loc;
 
-	loc = CARDBUS_CIS_ADDR(*start) + *off;
+	loc = start + *off;
 
 	e = pci_read_config(child, loc - loc % 4, 4);
 	for (j = loc % 4; j > 0; j--)
@@ -336,120 +369,159 @@ cardbus_read_tuple_conf(device_t cbdev, device_t child, u_int32_t *start,
 }
 
 static int
-cardbus_read_tuple_exrom(device_t cbdev, struct resource *mem, u_int32_t *start,
+cardbus_read_tuple_mem(device_t cbdev, struct resource *res, u_int32_t start,
     u_int32_t *off, int *tupleid, int *len, u_int8_t *tupledata)
 {
-#define	READROM(rom, type, offset)				       \
-	(*((u_int ## type ##_t *)(((unsigned char*)rom) + offset)))
+	bus_space_tag_t bt;
+	bus_space_handle_t bh;
+	int ret;
 
-	int romnum = 0;
-	unsigned char *data;
-	u_int32_t imagesize;
-	unsigned char *image;
-	int imagenum;
+	bt = rman_get_bustag(res);
+	bh = rman_get_bushandle(res);
 
-	image = (unsigned char*)rman_get_virtual(mem);
-	imagenum = CARDBUS_CIS_ASI_ROM_IMAGE(*start);
-	do {
-		if (READROM(image, 16, CARDBUS_EXROM_SIGNATURE) != 0xaa55) {
-			device_printf(cbdev, "Bad header in rom %d: %04x\n",
-				       romnum, *(u_int16_t*)(image +
-				       CARDBUS_EXROM_SIGNATURE));
-			return ENXIO;
-		}
-		data = image + READROM(image, 16, CARDBUS_EXROM_DATA_PTR);
-		imagesize = READROM(data, 16, CARDBUS_EXROM_DATA_IMAGE_LENGTH);
-
-		if (imagesize == 0) {
-			/*
-			 * XXX some ROMs seem to have this as zero,
-			 * can we assume this means 1 block?
-			 */
-			imagesize = 1;
-		}
-		imagesize <<= 9;
-
-		if (imagenum == romnum) {
-			image += CARDBUS_CIS_ADDR(*start) + *off;
-			*tupleid = image[0];
-			*len = image[1];
-			memcpy(tupledata, image+2, *len);
-			*off += *len+2;
-			return 0;
-		}
-		image += imagesize;
-		romnum++;
-	} while ((READROM(data, 8, CARDBUS_EXROM_DATA_INDICATOR) & 0x80) == 0);
-	device_printf(cbdev, "Cannot read CIS: Not enough images of rom\n");
-	return ENOENT;
-#undef READROM
+	*tupleid = bus_space_read_1(bt, bh, start + *off);
+	*len = bus_space_read_1(bt, bh, start + *off + 1);
+	bus_space_read_region_1(bt, bh, *off + start + 2, tupledata, *len);
+	ret = 0;
+	*off += *len + 2;
+	return ret;
 }
 
 static int
-cardbus_read_tuple_mem(device_t cbdev, device_t child, u_int32_t *start,
-    u_int32_t *off, int *tupleid, int *len, u_int8_t *tupledata)
+cardbus_read_tuple(device_t cbdev, device_t child, struct resource *res,
+    u_int32_t start, u_int32_t *off, int *tupleid, int *len,
+    u_int8_t *tupledata)
 {
-	struct resource *mem;
-	bus_space_tag_t bt;
-	bus_space_handle_t bh;
-	int rid;
-	int ret;
-
-	if (CARDBUS_CIS_SPACE(*start) == CARDBUS_CIS_ASI_ROM) {
-		rid = CARDBUS_ROM_REG;
+	if (res == (struct resource*)~0UL) {
+		return cardbus_read_tuple_conf(cbdev, child, start, off,
+		    tupleid, len, tupledata);
 	} else {
-		rid = CARDBUS_BASE0_REG + (CARDBUS_CIS_SPACE(*start) - 1) * 4;
-	}
-
-	mem = bus_alloc_resource(child, SYS_RES_MEMORY, &rid, 0, ~0,
-				 1, RF_ACTIVE);
-	bt = rman_get_bustag(mem);
-	bh = rman_get_bushandle(mem);
-	if (mem == NULL) {
-		device_printf(cbdev, "Failed to get memory for CIS reading\n");
-		return ENOMEM;
+		return cardbus_read_tuple_mem(cbdev, res, start, off,
+		    tupleid, len, tupledata);
 	}
+}
 
-	if(CARDBUS_CIS_SPACE(*start) == CARDBUS_CIS_ASI_ROM) {
-		ret = cardbus_read_tuple_exrom(cbdev, mem, start, off, tupleid,
-					       len, tupledata);
-	} else {
-		*tupleid = bus_space_read_1(bt, bh,
-		    CARDBUS_CIS_ADDR(*start) + *off);
-		*len = bus_space_read_1(bt, bh,
-		    CARDBUS_CIS_ADDR(*start) + *off + 1);
-		bus_space_read_multi_1(rman_get_bustag(mem),
-		    rman_get_bushandle(mem),
-		    *off + CARDBUS_CIS_ADDR(*start), tupledata, *len);
-		ret = 0;
-		*off += *len+2;
+static void
+cardbus_read_tuple_finish(device_t cbdev, device_t child, int rid,
+    struct resource *res)
+{
+	if (res != (struct resource*)~0UL) {
+		bus_release_resource(cbdev, SYS_RES_MEMORY, rid, res);
+		pci_write_config(child, rid, 0, 4);
+		PCI_DISABLE_IO(cbdev, child, SYS_RES_MEMORY);
 	}
-	bus_release_resource(child, SYS_RES_MEMORY, rid, mem);
-	return ret;
 }
 
-static int
-cardbus_read_tuple(device_t cbdev, device_t child, u_int32_t *start,
-    u_int32_t *off, int *tupleid, int *len, u_int8_t *tupledata)
+static struct resource *
+cardbus_read_tuple_init(device_t cbdev, device_t child, u_int32_t *start,
+    int *rid)
 {
-	switch(CARDBUS_CIS_SPACE(*start)) {
+	u_int32_t testval;
+	u_int32_t size;
+	struct resource *res;
+
+	switch (CARDBUS_CIS_SPACE(*start)) {
 	case CARDBUS_CIS_ASI_TUPLE:
-		return cardbus_read_tuple_conf(cbdev, child, start, off,
-		    tupleid, len, tupledata);
+		/* CIS in tuple space need no initialization */
+		return (struct resource*)~0UL;
 	case CARDBUS_CIS_ASI_BAR0:
 	case CARDBUS_CIS_ASI_BAR1:
 	case CARDBUS_CIS_ASI_BAR2:
 	case CARDBUS_CIS_ASI_BAR3:
 	case CARDBUS_CIS_ASI_BAR4:
 	case CARDBUS_CIS_ASI_BAR5:
+		*rid = CARDBUS_BASE0_REG + (CARDBUS_CIS_SPACE(*start) - 1) * 4;
+		pci_write_config(child, *rid, ~0UL, 4);
+		break;
 	case CARDBUS_CIS_ASI_ROM:
-		return cardbus_read_tuple_mem(cbdev, child, start, off,
-		    tupleid, len, tupledata);
+		*rid = CARDBUS_ROM_REG;
+		pci_write_config(child, *rid, CARDBUS_ROM_ADDRMASK, 4);
+		break;
 	default:
 		device_printf(cbdev, "Unable to read CIS: Unknown space: %d\n",
 		    CARDBUS_CIS_SPACE(*start));
-		return EINVAL;
+		return NULL;
+	}
+
+	/* figure out how much space we need */
+	testval = pci_read_config(child, *rid, 4);
+	if (testval & 1) {
+		device_printf(cbdev, "CIS Space is IO, expecting memory.\n");
+		return NULL;
+	}
+	size = CARDBUS_MAPREG_MEM_SIZE(testval);
+	if (size < 4096)
+		size = 4096;
+	/* allocate the memory space to read CIS */
+	res = bus_alloc_resource(cbdev, SYS_RES_MEMORY, rid, 0, ~0, size,
+	    rman_make_alignment_flags(size) | RF_ACTIVE);
+	if (res == NULL) {
+		device_printf(cbdev, "Unable to allocate resource "
+		    "to read CIS.\n");
+		return NULL;
 	}
+	pci_write_config(child, *rid,
+	    rman_get_start(res) | ((*rid == CARDBUS_ROM_REG)?
+		CARDBUS_ROM_ENABLE : 0),
+	    4);
+	PCI_ENABLE_IO(cbdev, child, SYS_RES_MEMORY);
+
+	/* Flip to the right ROM image if CIS is in ROM */
+	if (CARDBUS_CIS_SPACE(*start) == CARDBUS_CIS_ASI_ROM) {
+		bus_space_tag_t bt;
+		bus_space_handle_t bh;
+		int imagenum;
+		u_int32_t imagesize;
+		int mystart = 0;
+		int romnum = 0;
+		int dataptr;
+
+		bt = rman_get_bustag(res);
+		bh = rman_get_bushandle(res);
+
+		imagenum = CARDBUS_CIS_ASI_ROM_IMAGE(*start);
+		for (romnum = 0;; romnum++) {
+			if (bus_space_read_2(bt, bh,
+			    mystart+CARDBUS_EXROM_SIGNATURE) != 0xaa55) {
+				device_printf(cbdev, "Bad header in rom %d: "
+				    "[%x] %04x\n", romnum, mystart + 
+				    CARDBUS_EXROM_SIGNATURE,
+				    bus_space_read_2(bt, bh,
+				    mystart+CARDBUS_EXROM_SIGNATURE));
+				bus_release_resource(cbdev, SYS_RES_MEMORY,
+				    *rid, res);
+				*rid = 0;
+				return NULL;
+			}
+			dataptr = mystart + bus_space_read_2(bt, bh,
+			    mystart + CARDBUS_EXROM_DATA_PTR);
+			imagesize = bus_space_read_2(bt, bh,
+			    dataptr + CARDBUS_EXROM_DATA_IMAGE_LENGTH);
+
+			if (imagesize == 0) {
+				/*
+				 * XXX some ROMs seem to have this as zero,
+				 * can we assume this means 1 block?
+				 */
+				imagesize = 1;
+			}
+			imagesize <<= 9;
+
+			if (romnum == imagenum)
+				break;
+			if ((bus_space_read_1(bt, bh, mystart + 
+			    CARDBUS_EXROM_DATA_INDICATOR) & 0x80) == 0) {
+				device_printf(cbdev, "Cannot read CIS: "
+				    "Not enough images of rom\n");
+				return NULL;
+			}
+			mystart += imagesize;
+		}
+		*start = mystart + CARDBUS_CIS_ADDR(*start);
+	} else {
+		*start = CARDBUS_CIS_SPACE(*start);
+	}
+	return res;
 }
 
 /*
@@ -458,7 +530,7 @@ cardbus_read_tuple(device_t cbdev, device_t child, u_int32_t *start,
 
 static int
 decode_tuple(device_t cbdev, device_t child, int tupleid, int len,
-    u_int8_t *tupledata, u_int32_t *start, u_int32_t *off,
+    u_int8_t *tupledata, u_int32_t start, u_int32_t *off,
     struct tuple_callbacks *callbacks)
 {
 	int i;
@@ -486,29 +558,348 @@ cardbus_parse_cis(device_t cbdev, device_t child,
 	int len;
 	int expect_linktarget;
 	u_int32_t start, off;
+	struct resource *res;
+	int rid;
 
 	bzero(tupledata, MAXTUPLESIZE);
 	expect_linktarget = TRUE;
 	start = pci_read_config(child, CARDBUS_CIS_REG, 4);
 	off = 0;
+	res = cardbus_read_tuple_init(cbdev, child, &start, &rid);
+	if (res == NULL)
+		return ENXIO;
 	do {
-		cardbus_read_tuple(cbdev, child, &start, &off, &tupleid, &len,
-				   tupledata);
+		if (0 != cardbus_read_tuple(cbdev, child, res, start, &off,
+		    &tupleid, &len, tupledata)) {
+			device_printf(cbdev, "Failed to read CIS.\n");
+			cardbus_read_tuple_finish(cbdev, child, rid, res);
+			return ENXIO;
+		}
 
 		if (expect_linktarget && tupleid != CISTPL_LINKTARGET) {
 			device_printf(cbdev, "Expecting link target, got 0x%x\n",
 			    tupleid);
+			cardbus_read_tuple_finish(cbdev, child, rid, res);
 			return EINVAL;
 		}
 		expect_linktarget = decode_tuple(cbdev, child, tupleid, len,
-						 tupledata, &start, &off,
-						 callbacks);
-		if (expect_linktarget != 0)
+		    tupledata, start, &off, callbacks);
+		if (expect_linktarget != 0) {
+			cardbus_read_tuple_finish(cbdev, child, rid, res);
 			return expect_linktarget;
+		}
 	} while (tupleid != CISTPL_END);
+	cardbus_read_tuple_finish(cbdev, child, rid, res);
 	return 0;
 }
 
+static int
+barsort(const void *a, const void *b)
+{
+	return (*(const struct resource_list_entry **)b)->count -
+	    (*(const struct resource_list_entry **)a)->count;
+}
+
+static int
+cardbus_alloc_resources(device_t cbdev, device_t child)
+{
+	struct cardbus_devinfo *dinfo = device_get_ivars(child);
+	int count;
+	struct resource_list_entry *rle;
+	struct resource_list_entry **barlist;
+	int tmp;
+	u_int32_t mem_psize = 0, mem_nsize = 0, io_size = 0;
+	struct resource *res;
+	u_int32_t start,end;
+	int rid, flags;
+
+	count = 0;
+	SLIST_FOREACH(rle, &dinfo->resources, link) {
+		count++;
+	}
+	if (count == 0)
+		return 0;
+	barlist = malloc(sizeof(struct resource_list_entry*) * count, M_DEVBUF,
+	    M_WAITOK);
+	count = 0;
+	SLIST_FOREACH(rle, &dinfo->resources, link) {
+		barlist[count] = rle;
+		if (rle->type == SYS_RES_IOPORT) {
+			io_size += rle->count;
+		} else if (rle->type == SYS_RES_MEMORY) {
+			if (dinfo->mprefetchable & BARBIT(rle->rid))
+				mem_psize += rle->count;
+			else
+				mem_nsize += rle->count;
+		}
+		count++;
+	}
+
+	/*
+	 * We want to allocate the largest resource first, so that our
+	 * allocated memory is packed.
+	 */
+	qsort(barlist, count, sizeof(struct resource_list_entry*), barsort);
+
+	/* Allocate prefetchable memory */
+	flags = 0;
+	for (tmp = 0; tmp < count; tmp++) {
+		if (barlist[tmp]->res == NULL &&
+		    barlist[tmp]->type == SYS_RES_MEMORY &&
+		    dinfo->mprefetchable & BARBIT(barlist[tmp]->rid)) {
+			flags = rman_make_alignment_flags(barlist[tmp]->count);
+			break;
+		}
+	}
+	if (flags > 0) { /* If any prefetchable memory is requested... */
+		/*
+		 * First we allocate one big space for all resources of this
+		 * type.  We do this because our parent, pccbb, needs to open
+		 * a window to forward all addresses within the window, and
+		 * it would be best if nobody else has resources allocated
+		 * within the window.
+		 * (XXX: Perhaps there might be a better way to do this?)
+		 */
+		rid = 0;
+		res = bus_alloc_resource(cbdev, SYS_RES_MEMORY, &rid, 0,
+		    (dinfo->mprefetchable & dinfo->mbelow1mb)?0xFFFFF:~0UL,
+		    mem_psize, flags);
+		start = rman_get_start(res);
+		end = rman_get_end(res);
+		DEVPRINTF((cbdev, "Prefetchable memory at %x-%x\n", start, end));
+		/*
+		 * Now that we know the region is free, release it and hand it
+		 * out piece by piece.
+		 */
+		bus_release_resource(cbdev, SYS_RES_MEMORY, rid, res);
+		for (tmp = 0; tmp < count; tmp++) {
+			if (barlist[tmp]->res == NULL &&
+			    barlist[tmp]->type == SYS_RES_MEMORY &&
+			    dinfo->mprefetchable & BARBIT(barlist[tmp]->rid)) {
+				barlist[tmp]->res = bus_alloc_resource(cbdev,
+				    barlist[tmp]->type,
+				    &barlist[tmp]->rid, start, end,
+				    barlist[tmp]->count,
+				    rman_make_alignment_flags(
+				    barlist[tmp]->count));
+				if (barlist[tmp]->res == NULL) {
+					mem_nsize += barlist[tmp]->count;
+					dinfo->mprefetchable &=
+					    ~BARBIT(barlist[tmp]->rid);
+					DEVPRINTF((cbdev, "Cannot pre-allocate "
+					    "prefetchable memory, will try as "
+					    "non-prefetchable.\n"));
+				} else {
+					barlist[tmp]->start =
+					    rman_get_start(barlist[tmp]->res);
+					barlist[tmp]->end =
+					    rman_get_end(barlist[tmp]->res);
+					pci_write_config(child,
+					    barlist[tmp]->rid,
+					    barlist[tmp]->start, 4);
+					DEVPRINTF((cbdev, "Prefetchable memory "
+					    "rid=%x at %lx-%lx\n",
+					    barlist[tmp]->rid,
+					    barlist[tmp]->start,
+					    barlist[tmp]->end));
+				}
+			}
+		}
+	}
+
+	/* Allocate non-prefetchable memory */
+	flags = 0;
+	for (tmp = 0; tmp < count; tmp++) {
+		if (barlist[tmp]->res == NULL &&
+		    barlist[tmp]->type == SYS_RES_MEMORY) {
+			flags = rman_make_alignment_flags(barlist[tmp]->count);
+			break;
+		}
+	}
+	if (flags > 0) { /* If any non-prefetchable memory is requested... */
+		/*
+		 * First we allocate one big space for all resources of this
+		 * type.  We do this because our parent, pccbb, needs to open
+		 * a window to forward all addresses within the window, and
+		 * it would be best if nobody else has resources allocated
+		 * within the window.
+		 * (XXX: Perhaps there might be a better way to do this?)
+		 */
+		rid = 0;
+		res = bus_alloc_resource(cbdev, SYS_RES_MEMORY, &rid, 0,
+		    ((~dinfo->mprefetchable) & dinfo->mbelow1mb)?0xFFFFF:~0UL,
+		    mem_nsize, flags);
+		start = rman_get_start(res);
+		end = rman_get_end(res);
+		DEVPRINTF((cbdev, "Non-prefetchable memory at %x-%x\n",
+		    start, end));
+		/*
+		 * Now that we know the region is free, release it and hand it
+		 * out piece by piece.
+		 */
+		bus_release_resource(cbdev, SYS_RES_MEMORY, rid, res);
+		for (tmp = 0; tmp < count; tmp++) {
+			if (barlist[tmp]->res == NULL &&
+			    barlist[tmp]->type == SYS_RES_MEMORY) {
+				barlist[tmp]->res = bus_alloc_resource(cbdev,
+				    barlist[tmp]->type, &barlist[tmp]->rid,
+				    start, end, barlist[tmp]->count,
+				    rman_make_alignment_flags(
+				    barlist[tmp]->count));
+				if (barlist[tmp]->res == NULL) {
+					DEVPRINTF((cbdev, "Cannot pre-allocate "
+					    "memory for cardbus device\n"));
+					return ENOMEM;
+				}
+				barlist[tmp]->start =
+				    rman_get_start(barlist[tmp]->res);
+				barlist[tmp]->end = rman_get_end(
+					barlist[tmp]->res);
+				pci_write_config(child, barlist[tmp]->rid,
+				    barlist[tmp]->start, 4);
+				DEVPRINTF((cbdev, "Non-prefetchable memory "
+				    "rid=%x at %lx-%lx (%lx)\n",
+				    barlist[tmp]->rid, barlist[tmp]->start,
+				    barlist[tmp]->end, barlist[tmp]->count));
+			}
+		}
+	}
+
+	/* Allocate IO ports */
+	flags = 0;
+	for (tmp = 0; tmp < count; tmp++) {
+		if (barlist[tmp]->res == NULL &&
+		    barlist[tmp]->type == SYS_RES_IOPORT) {
+			flags = rman_make_alignment_flags(barlist[tmp]->count);
+			break;
+		}
+	}
+	if (flags > 0) { /* If any IO port is requested... */
+		/*
+		 * First we allocate one big space for all resources of this
+		 * type.  We do this because our parent, pccbb, needs to open
+		 * a window to forward all addresses within the window, and
+		 * it would be best if nobody else has resources allocated
+		 * within the window.
+		 * (XXX: Perhaps there might be a better way to do this?)
+		 */
+		rid = 0;
+		res = bus_alloc_resource(cbdev, SYS_RES_IOPORT, &rid, 0,
+		    (dinfo->ibelow1mb)?0xFFFFF:~0UL, io_size, flags);
+		start = rman_get_start(res);
+		end = rman_get_end(res);
+		DEVPRINTF((cbdev, "IO port at %x-%x\n", start, end));
+		/*
+		 * Now that we know the region is free, release it and hand it
+		 * out piece by piece.
+		 */
+		bus_release_resource(cbdev, SYS_RES_IOPORT, rid, res);
+		for (tmp = 0; tmp < count; tmp++) {
+			if (barlist[tmp]->res == NULL &&
+			    barlist[tmp]->type == SYS_RES_IOPORT) {
+				barlist[tmp]->res = bus_alloc_resource(cbdev,
+				    barlist[tmp]->type, &barlist[tmp]->rid,
+				    start, end, barlist[tmp]->count,
+				    rman_make_alignment_flags(
+				    barlist[tmp]->count));
+				if (barlist[tmp]->res == NULL) {
+					DEVPRINTF((cbdev, "Cannot pre-allocate "
+					    "IO port for cardbus device\n"));
+					return ENOMEM;
+				}
+				barlist[tmp]->start =
+				    rman_get_start(barlist[tmp]->res);
+				barlist[tmp]->end =
+				    rman_get_end(barlist[tmp]->res);
+			pci_write_config(child, barlist[tmp]->rid,
+			    barlist[tmp]->start, 4);
+			DEVPRINTF((cbdev, "IO port rid=%x at %lx-%lx\n",
+			    barlist[tmp]->rid, barlist[tmp]->start,
+			    barlist[tmp]->end));
+			}
+		}
+	}
+
+	/* Allocate IRQ */
+	/* XXX: Search CIS for IRQ description */
+	rid = 0;
+	res = bus_alloc_resource(cbdev, SYS_RES_IRQ, &rid, 0, ~0UL, 1,
+	    RF_SHAREABLE);
+	resource_list_add(&dinfo->resources, SYS_RES_IRQ, rid,
+	    rman_get_start(res), rman_get_end(res), 1);
+	rle = resource_list_find(&dinfo->resources, SYS_RES_IRQ, rid);
+	rle->res = res;
+	dinfo->cfg.intline = rman_get_start(res);
+	pci_write_config(child, PCIR_INTLINE, rman_get_start(res), 1);
+
+	return 0;
+}
+
+/*
+ * Adding a memory/io resource (sans CIS)
+ */
+
+static void
+cardbus_add_map(device_t cbdev, device_t child, int reg)
+{
+	struct cardbus_devinfo *dinfo = device_get_ivars(child);
+	struct resource_list_entry *rle;
+	u_int32_t size;
+	u_int32_t testval;
+	int type;
+
+	SLIST_FOREACH(rle, &dinfo->resources, link) {
+		if (rle->rid == reg)
+			return;
+	}
+
+	if (reg == CARDBUS_ROM_REG)
+		testval = CARDBUS_ROM_ADDRMASK;
+	else
+		testval = ~0;
+
+	pci_write_config(child, reg, testval, 4);
+	testval = pci_read_config(child, reg, 4);
+
+	if (testval == ~0 || testval == 0)
+		return;
+
+	if ((testval & 1) == 0)
+		type = SYS_RES_MEMORY;
+	else
+		type = SYS_RES_IOPORT;
+
+	size = CARDBUS_MAPREG_MEM_SIZE(testval);
+	device_printf(cbdev, "Resource not specified in CIS: id=%x, size=%x\n",
+	    reg, size);
+	resource_list_add(&dinfo->resources, type, reg, 0UL, ~0UL, size);
+}
+
+static void
+cardbus_pickup_maps(device_t cbdev, device_t child)
+{
+	struct cardbus_devinfo *dinfo = device_get_ivars(child);
+	struct cardbus_quirk *q;
+	int reg;
+
+	/*
+	 * Try to pick up any resources that was not specified in CIS.
+	 * Some devices (eg, 3c656) does not list all resources required by
+	 * the driver in its CIS.
+	 * XXX: should we do this or use quirks?
+	 */
+	for (reg = 0; reg < dinfo->cfg.nummaps; reg++) {
+		cardbus_add_map(cbdev, child, PCIR_MAPS + reg * 4);
+	}
+
+	for (q = &cardbus_quirks[0]; q->devid; q++) {
+		if (q->devid == ((dinfo->cfg.device << 16) | dinfo->cfg.vendor)
+		    && q->type == CARDBUS_QUIRK_MAP_REG) {
+			cardbus_add_map(cbdev, child, q->arg1);
+		}
+	}
+}
+
 int
 cardbus_cis_read(device_t cbdev, device_t child, u_int8_t id,
     struct cis_tupleinfo **buff, int *nret)
@@ -571,7 +962,7 @@ cardbus_cis_read(device_t cbdev, device_t child, u_int8_t id,
 }
 
 void
-cardbus_cis_free(device_t cbdev, struct cis_tupleinfo *buff, int* nret)
+cardbus_cis_free(device_t cbdev, struct cis_tupleinfo *buff, int *nret)
 {
 	int i;
 	for (i = 0; i < *nret; i++)
@@ -583,6 +974,7 @@ cardbus_cis_free(device_t cbdev, struct cis_tupleinfo *buff, int* nret)
 int
 cardbus_do_cis(device_t cbdev, device_t child)
 {
+	int ret;
 	struct tuple_callbacks init_callbacks[] = {
 		MAKETUPLE(NULL,			generic),
 		MAKETUPLE(DEVICE,		generic),
@@ -624,5 +1016,10 @@ cardbus_do_cis(device_t cbdev, device_t child)
 		MAKETUPLE(END,			end),
 		MAKETUPLE(GENERIC,		generic),
 	};
-	return cardbus_parse_cis(cbdev, child, init_callbacks);
+
+	ret = cardbus_parse_cis(cbdev, child, init_callbacks);
+	if (ret < 0)
+		return ret;
+	cardbus_pickup_maps(cbdev, child);
+	return cardbus_alloc_resources(cbdev, child);
 }