sys/arch/prep/pnpbus/pnpbus.c

   1 /*      $NetBSD: pnpbus.c,v 1.8 2008/04/28 19:01:45 garbled Exp $       */
   2
   3 /*-
   4  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   5  * All rights reserved.
   6  *
   7  * This code is derived from software contributed to The NetBSD Foundation
   8  * by Tim Rightnour
   9  *
  10  * Redistribution and use in source and binary forms, with or without
  11  * modification, are permitted provided that the following conditions
  12  * are met:
  13  * 1. Redistributions of source code must retain the above copyright
  14  *    notice, this list of conditions and the following disclaimer.
  15  * 2. Redistributions in binary form must reproduce the above copyright
  16  *    notice, this list of conditions and the following disclaimer in the
  17  *    documentation and/or other materials provided with the distribution.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  20  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  22  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  23  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  24  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  25  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  26  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  27  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  28  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  29  * POSSIBILITY OF SUCH DAMAGE.
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __KERNEL_RCSID(0, "$NetBSD: pnpbus.c,v 1.8 2008/04/28 19:01:45 garbled Exp $");
  34
  35 #include <sys/param.h>
  36 #include <sys/systm.h>
  37 #include <sys/device.h>
  38 #include <sys/extent.h>
  39 #include <sys/malloc.h>
  40
  41 #include <machine/bus.h>
  42 #include <machine/pio.h>
  43 #include <machine/intr.h>
  44 #include <machine/platform.h>
  45 #include <machine/residual.h>
  46 #include <machine/pnp.h>
  47 #include <machine/isa_machdep.h>
  48 #include <machine/chpidpnp.h>
  49
  50 #include <dev/isa/isareg.h>
  51
  52 #include <prep/pnpbus/pnpbusvar.h>
  53
  54 #include "isadma.h"
  55
  56 static int      pnpbus_match(struct device *, struct cfdata *, void *);
  57 static void     pnpbus_attach(struct device *, struct device *, void *);
  58 static int      pnpbus_print(void *, const char *);
  59 static int      pnpbus_search(struct device *, struct cfdata *,
  60                               const int *, void *);
  61
  62 CFATTACH_DECL(pnpbus, sizeof(struct pnpbus_softc),
  63     pnpbus_match, pnpbus_attach, NULL, NULL);
  64
  65 struct pnpbus_softc *pnpbus_softc;
  66 extern struct cfdriver pnpbus_cd;
  67
  68 static int
  69 pnpbus_match(struct device *parent, struct cfdata *cf, void *aux)
  70 {
  71         struct pnpbus_attach_args *paa = aux;
  72
  73         if (paa->paa_name != NULL && strcmp(paa->paa_name, "pnpbus") == 0)
  74                 return 1;
  75         return 0;
  76 }
  77
  78 static void
  79 pnpbus_attach(struct device *parent, struct device *self, void *aux)
  80 {
  81         struct pnpbus_softc *sc = (struct pnpbus_softc *)self;
  82         struct pnpbus_attach_args *paa = aux;
  83
  84         aprint_normal("\n");
  85
  86         pnpbus_softc = sc;
  87         sc->sc_ic = paa->paa_ic;
  88         sc->sc_iot = paa->paa_iot;
  89         sc->sc_memt = paa->paa_memt;
  90         sc->sc_dmat = paa->paa_dmat;
  91
  92 #if NISADMA > 0
  93         isa_dmainit(sc->sc_ic, sc->sc_iot, sc->sc_dmat, self);
  94 #endif
  95
  96         (void)config_search_ia(pnpbus_search, self, "pnpbus", aux);
  97 }
  98
  99 static int
 100 pnp_newirq(void *v, struct pnpresources *r, int size)
 101 {
 102         struct _S4_Pack *p = v;
 103         struct pnpbus_irq *irq;
 104
 105         irq = malloc(sizeof(struct pnpbus_irq), M_DEVBUF, M_NOWAIT);
 106
 107         irq->mask = le16dec(&p->IRQMask[0]);
 108
 109         if (size > 2)
 110                 irq->flags = p->IRQInfo;
 111         else
 112                 irq->flags = 0x1;
 113
 114         SIMPLEQ_INSERT_TAIL(&r->irq, irq, next);
 115         r->numirq++;
 116
 117         return 0;
 118 }
 119
 120 static int
 121 pnp_newdma(void *v, struct pnpresources *r, int size)
 122 {
 123         struct _S5_Pack *p = v;
 124         struct pnpbus_dma *dma;
 125
 126         dma = malloc(sizeof(struct pnpbus_dma), M_DEVBUF, M_NOWAIT);
 127
 128         dma->mask = le16dec(&p->DMAMask);
 129         if (size > 2)
 130                 dma->flags = p->DMAInfo;
 131         else
 132                 dma->flags = 0x01;
 133
 134         SIMPLEQ_INSERT_TAIL(&r->dma, dma, next);
 135         r->numdma++;
 136
 137         return 0;
 138 }
 139
 140 static int
 141 pnp_newioport(void *v, struct pnpresources *r, int size)
 142 {
 143         struct _S8_Pack *p = v;
 144         struct pnpbus_io *io;
 145         uint16_t mask;
 146
 147         io = malloc(sizeof(struct pnpbus_io), M_DEVBUF, M_NOWAIT);
 148         mask = p->IOInfo & ISAAddr16bit ? 0xffff : 0x03ff;
 149         io->minbase = (p->RangeMin[0] | (p->RangeMin[1] << 8)) & mask;
 150         io->maxbase = (p->RangeMax[0] | (p->RangeMax[1] << 8)) & mask;
 151         io->align = p->IOAlign;
 152         io->len = p->IONum;
 153         io->flags = p->IOInfo;
 154
 155         SIMPLEQ_INSERT_TAIL(&r->io, io, next);
 156         r->numio++;
 157
 158         return 0;
 159 }
 160
 161 static int
 162 pnp_newfixedioport(void *v, struct pnpresources *r, int size)
 163 {
 164         struct _S9_Pack *p = v;
 165         struct pnpbus_io *io;
 166
 167         io = malloc(sizeof(struct pnpbus_io), M_DEVBUF, M_NOWAIT);
 168         io->minbase = (p->Range[0] | (p->Range[1] << 8)) & 0x3ff;
 169         io->len = p->IONum;
 170         io->maxbase = -1;
 171         io->flags = 0;
 172         io->align = 1;
 173
 174         SIMPLEQ_INSERT_TAIL(&r->io, io, next);
 175         r->numio++;
 176
 177         return 0;
 178 }
 179
 180 static int
 181 pnp_newiomem(void *v, struct pnpresources *r, int size)
 182 {
 183         struct pnpbus_mem *mem;
 184         struct _L1_Pack *pack = v;
 185
 186         if (pack->Count0 >= 0x9) {
 187                 mem = malloc(sizeof(struct pnpbus_mem), M_DEVBUF, M_NOWAIT);
 188                 mem->minbase = (pack->Data[2] << 16) | (pack->Data[1] << 8);
 189                 mem->maxbase = (pack->Data[4] << 16) | (pack->Data[3] << 8);
 190                 mem->align = (pack->Data[6] << 8) | pack->Data[5];
 191                 mem->len = (pack->Data[8] << 16) | (pack->Data[7] << 8);
 192                 mem->flags = pack->Data[0];
 193                 SIMPLEQ_INSERT_TAIL(&r->iomem, mem, next);
 194                 r->numiomem++;
 195                 return 0;
 196         }
 197         return -1;
 198 }
 199
 200 static int
 201 pnp_newaddr(void *v, struct pnpresources *r, int size)
 202 {
 203         struct pnpbus_io *io;
 204         struct pnpbus_mem *mem;
 205         struct _L4_Pack *pack = v;
 206         struct _L4_PPCPack *p =  &pack->L4_Data.L4_PPCPack;
 207
 208         if (p->PPCData[0] == 1) {/* type IO */
 209                 io = malloc(sizeof(struct pnpbus_io), M_DEVBUF, M_NOWAIT);
 210                 io->minbase = (uint16_t)le64dec(&p->PPCData[4]);
 211                 io->maxbase = -1;
 212                 io->align = p->PPCData[1];
 213                 io->len = (uint16_t)le64dec(&p->PPCData[12]);
 214                 io->flags = 0;
 215                 SIMPLEQ_INSERT_TAIL(&r->io, io, next);
 216                 r->numio++;
 217
 218                 return 0;
 219         } else if (p->PPCData[0] == 2) {
 220                 mem = malloc(sizeof(struct pnpbus_mem), M_DEVBUF, M_NOWAIT);
 221                 mem->minbase = (uint32_t)le64dec(&p->PPCData[4]);
 222                 mem->maxbase = -1;
 223                 mem->align = p->PPCData[1];
 224                 mem->len = (uint32_t)le64dec(&p->PPCData[12]);
 225                 mem->flags = 0;
 226                 SIMPLEQ_INSERT_TAIL(&r->mem, mem, next);
 227                 r->nummem++;
 228
 229                 return 0;
 230         } else
 231                 return -1;
 232 }
 233
 234 static int
 235 pnp_newcompatid(void *v, struct pnpresources *r, int size)
 236 {
 237         struct _S3_Pack *p = v;
 238         struct pnpbus_compatid *id;
 239         uint32_t cid;
 240
 241         id = malloc(sizeof(*id), M_DEVBUF, M_NOWAIT);
 242         cid = le32dec(p->CompatId);
 243         pnp_devid_to_string(cid, id->idstr);
 244         id->next = r->compatids;
 245         r->compatids = id;
 246
 247         return 0;
 248 }
 249
 250 /*
 251  * Call if match succeeds.  This way we don't allocate lots of ram
 252  * for structures we never use if the device isn't attached.
 253  */
 254
 255 int
 256 pnpbus_scan(struct pnpbus_dev_attach_args *pna, PPC_DEVICE *dev)
 257 {
 258         struct pnpresources *r = &pna->pna_res;
 259         uint32_t l;
 260         uint8_t *p, *q;
 261         void *v;
 262         int tag, size, item;
 263
 264         l = be32toh(dev->AllocatedOffset);
 265         p = res->DevicePnPHeap + l;
 266
 267         if (p == NULL)
 268                 return -1;
 269
 270         for (; p[0] != END_TAG; p += size) {
 271                 tag = *p;
 272                 v = p;
 273                 if (tag_type(p[0]) == PNP_SMALL) {
 274                         size = tag_small_count(tag) + 1;
 275                         item = tag_small_item_name(tag);
 276                         switch (item) {
 277                         case IRQFormat:
 278                                 pnp_newirq(v, r, size);
 279                                 break;
 280                         case DMAFormat:
 281                                 pnp_newdma(v, r, size);
 282                                 break;
 283                         case IOPort:
 284                                 pnp_newioport(v, r, size);
 285                                 break;
 286                         case FixedIOPort:
 287                                 pnp_newfixedioport(v, r, size);
 288                                 break;
 289                         }
 290                 } else {
 291                         struct _L4_Pack *pack = v;
 292                         struct _L4_PPCPack *pa = &pack->L4_Data.L4_PPCPack;
 293
 294                         q = p;
 295                         size = (q[1] | (q[2] << 8)) + 3 /* tag + length */;
 296                         item = tag_large_item_name(tag);
 297                         if (item == LargeVendorItem &&
 298                             pa->Type == LV_GenericAddress)
 299                                 pnp_newaddr(v, r, size);
 300                         else if (item == MemoryRange)
 301                                 pnp_newiomem(v, r, size);
 302                 }
 303         }
 304
 305         /* scan for compatid's */
 306
 307         l = be32toh(dev->CompatibleOffset);
 308         p = res->DevicePnPHeap + l;
 309
 310         if (p == NULL)
 311                 return -1;
 312
 313         for (; p[0] != END_TAG; p += size) {
 314                 tag = *p;
 315                 v = p;
 316                 if (tag_type(p[0]) == PNP_SMALL) {
 317                         size = tag_small_count(tag) + 1;
 318                         item = tag_small_item_name(tag);
 319                         switch (item) {
 320                         case CompatibleDevice:
 321                                 pnp_newcompatid(v, r, size);
 322                                 break;
 323                         }
 324                 } else {
 325                         q = p;
 326                         size = (q[1] | (q[2] << 8)) + 3 /* tag + length */;
 327                 }
 328         }
 329         return 0;
 330 }
 331
 332 /*
 333  * Setup the basic pna structure.
 334  */
 335
 336 static void
 337 pnp_getpna(struct pnpbus_dev_attach_args *pna, struct pnpbus_attach_args *paa,
 338         PPC_DEVICE *dev)
 339 {
 340         DEVICE_ID *id = &dev->DeviceId;
 341         struct pnpresources *r = &pna->pna_res;
 342         ChipIDPack *pack;
 343         uint32_t l;
 344         uint8_t *p;
 345         void *v;
 346         int tag, size, item;
 347
 348         l = be32toh(dev->AllocatedOffset);
 349         p = res->DevicePnPHeap + l;
 350
 351         pna->pna_iot = paa->paa_iot;
 352         pna->pna_memt = paa->paa_memt;
 353         pna->pna_ic = paa->paa_ic;
 354         pna->pna_dmat = paa->paa_dmat;
 355         pnp_devid_to_string(id->DevId, pna->pna_devid);
 356         pna->basetype = id->BaseType;
 357         pna->subtype = id->SubType;
 358         pna->interface = id->Interface;
 359         pna->pna_ppc_dev = dev;
 360         memset(r, 0, sizeof(*r));
 361         SIMPLEQ_INIT(&r->mem);
 362         SIMPLEQ_INIT(&r->io);
 363         SIMPLEQ_INIT(&r->irq);
 364         SIMPLEQ_INIT(&r->dma);
 365         SIMPLEQ_INIT(&r->iomem);
 366         if (p == NULL)
 367                 return;
 368         /* otherwise, we start looking for chipid's */
 369         for (; p[0] != END_TAG; p += size) {
 370                 tag = *p;
 371                 v = p;
 372                 if (tag_type(p[0]) == PNP_SMALL) {
 373                         size = tag_small_count(tag) + 1;
 374                         item = tag_small_item_name(tag);
 375                         if (item != SmallVendorItem || p[1] != 1)
 376                                 continue;
 377                         pack = v;
 378                         pna->chipid = le16dec(&pack->Name[0]);
 379                         pna->chipmfg0 = pack->VendorID0;
 380                         pna->chipmfg1 = pack->VendorID1;
 381                         break;
 382                 } else {
 383                         /* Large */
 384                         size = (p[1] | (p[2] << 8)) + 3 /* tag + length */;
 385                 }
 386         }
 387 }
 388
 389 static int
 390 pnpbus_search(struct device *parent, struct cfdata *cf,
 391             const int *ldesc, void *aux)
 392 {
 393         struct pnpbus_dev_attach_args pna;
 394         struct pnpbus_attach_args *paa = aux;
 395         PPC_DEVICE *ppc_dev;
 396         int i;
 397         uint32_t ndev;
 398
 399         ndev = be32toh(res->ActualNumDevices);
 400         ppc_dev = res->Devices;
 401
 402         for (i = 0; i < ((ndev > MAX_DEVICES) ? MAX_DEVICES : ndev); i++) {
 403                 pnp_getpna(&pna, paa, &ppc_dev[i]);
 404                 if (config_match(parent, cf, &pna) > 0)
 405                         config_attach(parent, cf, &pna, pnpbus_print);
 406         }
 407
 408         return 0;
 409 }
 410
 411 static void
 412 pnpbus_printres(struct pnpresources *r)
 413 {
 414         struct pnpbus_io *io;
 415         struct pnpbus_mem *mem;
 416         struct pnpbus_irq *irq;
 417         struct pnpbus_dma *dma;
 418         int p = 0;
 419
 420         if (!SIMPLEQ_EMPTY(&r->mem)) {
 421                 aprint_normal("mem");
 422                 SIMPLEQ_FOREACH(mem, &r->mem, next) {
 423                         aprint_normal(" 0x%x", mem->minbase);
 424                         if (mem->len > 1)
 425                                 aprint_normal("-0x%x",
 426                                     mem->minbase + mem->len - 1);
 427                 }
 428                 p++;
 429         }
 430         if (!SIMPLEQ_EMPTY(&r->io)) {
 431                 if (p++)
 432                         aprint_normal(", ");
 433                 aprint_normal("port");
 434                 SIMPLEQ_FOREACH(io, &r->io, next) {
 435                         aprint_normal(" 0x%x", io->minbase);
 436                         if (io->len > 1)
 437                                 aprint_normal("-0x%x",
 438                                     io->minbase + io->len - 1);
 439                 }
 440         }
 441         if (!SIMPLEQ_EMPTY(&r->iomem)) {
 442                 if (p++)
 443                         aprint_normal(", ");
 444                 aprint_normal("iomem");
 445                 SIMPLEQ_FOREACH(mem, &r->iomem, next) {
 446                         aprint_normal(" 0x%x", mem->minbase);
 447                         if (mem->len > 1)
 448                                 aprint_normal("-0x%x",
 449                                     mem->minbase + mem->len - 1);
 450                 }
 451                 p++;
 452         }
 453         if (!SIMPLEQ_EMPTY(&r->irq)) {
 454                 if (p++)
 455                         aprint_normal(", ");
 456                 aprint_normal("irq");
 457                 SIMPLEQ_FOREACH(irq, &r->irq, next) {
 458                         aprint_normal(" %d", ffs(irq->mask) - 1);
 459                 }
 460         }
 461         if (!SIMPLEQ_EMPTY(&r->dma)) {
 462                 if (p++)
 463                         aprint_normal(", ");
 464                 aprint_normal("DMA");
 465                 SIMPLEQ_FOREACH(dma, &r->dma, next) {
 466                         aprint_normal(" %d", ffs(dma->mask) - 1);
 467                 }
 468         }
 469 }
 470
 471 void
 472 pnpbus_print_devres(struct pnpbus_dev_attach_args *pna)
 473 {
 474         aprint_normal(": ");
 475         pnpbus_printres(&pna->pna_res);
 476 }
 477
 478 static int
 479 pnpbus_print(void *args, const char *name)
 480 {
 481         struct pnpbus_dev_attach_args *pna = args;
 482
 483         pnpbus_print_devres(pna);
 484         return (UNCONF);
 485 }
 486
 487 /*
 488  * Set up an interrupt handler to start being called.
 489  */
 490 void *
 491 pnpbus_intr_establish(int idx, int level, int tover, int (*ih_fun)(void *),
 492     void *ih_arg, struct pnpresources *r)
 493 {
 494         struct pnpbus_irq *irq;
 495         int irqnum, type;
 496
 497         if (idx >= r->numirq)
 498                 return 0;
 499
 500         irq = SIMPLEQ_FIRST(&r->irq);
 501         while (idx--)
 502                 irq = SIMPLEQ_NEXT(irq, next);
 503
 504         irqnum = ffs(irq->mask) - 1;
 505         type = (irq->flags & 0x0c) ? IST_LEVEL : IST_EDGE;
 506         if (tover != IST_PNP)
 507                 type = tover;
 508
 509         return (void *)intr_establish(irqnum, type, level, ih_fun, ih_arg);
 510 }
 511
 512 /*
 513  * Deregister an interrupt handler.
 514  */
 515 void
 516 pnpbus_intr_disestablish(void *arg)
 517 {
 518
 519         intr_disestablish(arg);
 520 }
 521
 522 int
 523 pnpbus_getirqnum(struct pnpresources *r, int idx, int *irqp, int *istp)
 524 {
 525         struct pnpbus_irq *irq;
 526
 527         if (idx >= r->numirq)
 528                 return EINVAL;
 529
 530         irq = SIMPLEQ_FIRST(&r->irq);
 531         while (idx--)
 532                 irq = SIMPLEQ_NEXT(irq, next);
 533
 534         if (irqp != NULL)
 535                 *irqp = ffs(irq->mask) - 1;
 536         if (istp != NULL)
 537                 *istp = (irq->flags &0x0c) ? IST_LEVEL : IST_EDGE;
 538         return 0;
 539 }
 540
 541 int
 542 pnpbus_getdmachan(struct pnpresources *r, int idx, int *chanp)
 543 {
 544         struct pnpbus_dma *dma;
 545
 546         if (idx >= r->numdma)
 547                 return EINVAL;
 548
 549         dma = SIMPLEQ_FIRST(&r->dma);
 550         while (idx--)
 551                 dma = SIMPLEQ_NEXT(dma, next);
 552
 553         if (chanp != NULL)
 554                 *chanp = ffs(dma->mask) - 1;
 555         return 0;
 556 }
 557
 558 int
 559 pnpbus_getioport(struct pnpresources *r, int idx, int *basep, int *sizep)
 560 {
 561         struct pnpbus_io *io;
 562
 563         if (idx >= r->numio)
 564                 return EINVAL;
 565
 566         io = SIMPLEQ_FIRST(&r->io);
 567         while (idx--)
 568                 io = SIMPLEQ_NEXT(io, next);
 569
 570         if (basep)
 571                 *basep = io->minbase;
 572         if (sizep)
 573                 *sizep = io->len;
 574         return 0;
 575 }
 576
 577 int
 578 pnpbus_io_map(struct pnpresources *r, int idx, bus_space_tag_t *tagp,
 579     bus_space_handle_t *hdlp)
 580 {
 581         struct pnpbus_io *io;
 582
 583         if (idx >= r->numio)
 584                 return EINVAL;
 585
 586         io = SIMPLEQ_FIRST(&r->io);
 587         while (idx--)
 588                 io = SIMPLEQ_NEXT(io, next);
 589
 590         *tagp = &genppc_isa_io_space_tag;
 591         return (bus_space_map(&genppc_isa_io_space_tag, io->minbase, io->len,
 592             0, hdlp));
 593 }
 594
 595 void
 596 pnpbus_io_unmap(struct pnpresources *r, int idx, bus_space_tag_t tag,
 597     bus_space_handle_t hdl)
 598 {
 599         struct pnpbus_io *io;
 600
 601         if (idx >= r->numio)
 602                 return;
 603
 604         io = SIMPLEQ_FIRST(&r->io);
 605         while (idx--)
 606                 io = SIMPLEQ_NEXT(io, next);
 607
 608         bus_space_unmap(tag, hdl, io->len);
 609 }
 610
 611 int
 612 pnpbus_getiomem(struct pnpresources *r, int idx, int *basep, int *sizep)
 613 {
 614         struct pnpbus_mem *mem;
 615
 616         if (idx >= r->numiomem)
 617                 return EINVAL;
 618
 619         mem = SIMPLEQ_FIRST(&r->iomem);
 620         while (idx--)
 621                 mem = SIMPLEQ_NEXT(mem, next);
 622
 623         if (basep)
 624                 *basep = mem->minbase;
 625         if (sizep)
 626                 *sizep = mem->len;
 627         return 0;
 628 }
 629
 630 int
 631 pnpbus_iomem_map(struct pnpresources *r, int idx, bus_space_tag_t *tagp,
 632     bus_space_handle_t *hdlp)
 633 {
 634         struct pnpbus_mem *mem;
 635
 636         if (idx >= r->numiomem)
 637                 return EINVAL;
 638
 639         mem = SIMPLEQ_FIRST(&r->iomem);
 640         while (idx--)
 641                 mem = SIMPLEQ_NEXT(mem, next);
 642
 643         *tagp = &genppc_isa_mem_space_tag;
 644         return (bus_space_map(&genppc_isa_mem_space_tag, mem->minbase, mem->len,
 645             0, hdlp));
 646 }
 647
 648 void
 649 pnpbus_iomem_unmap(struct pnpresources *r, int idx, bus_space_tag_t tag,
 650     bus_space_handle_t hdl)
 651 {
 652         struct pnpbus_mem *mem;
 653
 654         if (idx >= r->numiomem)
 655                 return;
 656
 657         mem = SIMPLEQ_FIRST(&r->mem);
 658         while (idx--)
 659                 mem = SIMPLEQ_NEXT(mem, next);
 660
 661         bus_space_unmap(tag, hdl, mem->len);
 662 }