root/dev/isa/isadma.c

DEFINITIONS

1. isadmamatch
2. isadmaattach
3. isa_dmaunmask
4. isa_dmamask
5. isa_dmacascade
6. isa_dmamap_create
7. isa_dmamap_destroy
8. isa_dmastart
9. isa_dmaabort
10. isa_dmacount
11. isa_dmafinished
12. isa_dmadone
13. isa_dmamem_alloc
14. isa_dmamem_free
15. isa_dmamem_map
16. isa_dmamem_unmap
17. isa_dmamem_mmap
18. isa_drq_isfree
19. isa_malloc
20. isa_free
21. isa_mappage

    1 /*      $OpenBSD: isadma.c,v 1.30 2006/04/27 15:17:19 mickey Exp $      */
    2 /*      $NetBSD: isadma.c,v 1.32 1997/09/05 01:48:33 thorpej Exp $      */
    4 /*-
    5  * Copyright (c) 1997 The NetBSD Foundation, Inc.
    6  * All rights reserved.
    7  *
    8  * This code is derived from software contributed to The NetBSD Foundation
    9  * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
   10  * NASA Ames Research Center.
   11  *
   12  * Redistribution and use in source and binary forms, with or without
   13  * modification, are permitted provided that the following conditions
   14  * are met:
   15  * 1. Redistributions of source code must retain the above copyright
   16  *    notice, this list of conditions and the following disclaimer.
   17  * 2. Redistributions in binary form must reproduce the above copyright
   18  *    notice, this list of conditions and the following disclaimer in the
   19  *    documentation and/or other materials provided with the distribution.
   20  * 3. All advertising materials mentioning features or use of this software
   21  *    must display the following acknowledgement:
   22  *      This product includes software developed by the NetBSD
   23  *      Foundation, Inc. and its contributors.
   24  * 4. Neither the name of The NetBSD Foundation nor the names of its
   25  *    contributors may be used to endorse or promote products derived
   26  *    from this software without specific prior written permission.
   27  *
   28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
   29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
   30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
   31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
   32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
   33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
   34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
   35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
   36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
   37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
   38  * POSSIBILITY OF SUCH DAMAGE.
   39  */
   41 /*
   42  * Device driver for the ISA on-board DMA controller.
   43  */
   45 #include <sys/param.h>
   46 #include <sys/systm.h>
   47 #include <sys/proc.h>
   48 #include <sys/device.h>
   50 #include <uvm/uvm_extern.h>
   52 #include <machine/bus.h>
   54 #include <dev/isa/isareg.h>
   55 #include <dev/isa/isavar.h>
   56 #include <dev/isa/isadmavar.h>
   57 #include <dev/isa/isadmareg.h>
   59 #ifdef __ISADMA_COMPAT
   60 /* XXX ugly, but will go away soon... */
   61 struct device *isa_dev;
bus_dmamap_t isadma_dmam[8];
   64 #endif
   66 /* Used by isa_malloc() */
   67 #include <sys/malloc.h>
   68 struct isa_mem {
   69         struct device *isadev;
   70         int chan;
bus_size_t size;
bus_addr_t addr;
caddr_t kva;
   74         struct isa_mem *next;
   75 } *isa_mem_head = 0;
   77 /*
   78  * High byte of DMA address is stored in this DMAPG register for
   79  * the Nth DMA channel.
   80  */
   81 static int dmapageport[2][4] = {
   82         {0x7, 0x3, 0x1, 0x2},
   83         {0xf, 0xb, 0x9, 0xa}
   84 };
   86 static u_int8_t dmamode[4] = {
DMA37MD_READ | DMA37MD_SINGLE,
DMA37MD_WRITE | DMA37MD_SINGLE,
DMA37MD_READ | DMA37MD_SINGLE | DMA37MD_LOOP,
DMA37MD_WRITE | DMA37MD_SINGLE | DMA37MD_LOOP
   91 };
   93 int isadmamatch(struct device *, void *, void *);
   94 void isadmaattach(struct device *, struct device *, void *);
   96 struct cfattach isadma_ca = {
   97         sizeof(struct device), isadmamatch, isadmaattach
   98 };
  100 struct cfdriver isadma_cd = {
NULL, "isadma", DV_DULL, 1
  102 };
  104 int
isadmamatch(parent, match, aux)
  106         struct device *parent;
  107         void *match, *aux;
  108 {
  109         struct isa_attach_args *ia = aux;
  111         /* Sure we exist */
ia->ia_iosize = 0;
  113         return (1);
  114 }
  116 void
isadmaattach(parent, self, aux)
  118         struct device *parent, *self;
  119         void *aux;
  120 {
  121 #ifdef __ISADMA_COMPAT
  122         int i, sz;
  123         struct isa_softc *sc = (struct isa_softc *)parent;
  125         /* XXX ugly, but will go away soon... */
isa_dev = parent;
  128         for (i = 0; i < 8; i++) {
sz = (i & 4) ? 1 << 17 : 1 << 16;
  130                 if ((bus_dmamap_create(sc->sc_dmat, sz, 1, sz, sz,
BUS_DMA_24BIT|BUS_DMA_NOWAIT|BUS_DMA_ALLOCNOW,
  132                     &isadma_dmam[i])) != 0)
panic("isadmaattach: can not create DMA map");
  134         }
  135 #endif
  137         /* XXX I'd like to map the DMA ports here, see isa.c why not... */
printf("\n");
  140 }
  142 static inline void isa_dmaunmask(struct isa_softc *, int);
  143 static inline void isa_dmamask(struct isa_softc *, int);
  145 static inline void
isa_dmaunmask(sc, chan)
  147         struct isa_softc *sc;
  148         int chan;
  149 {
  150         int ochan = chan & 3;
  152         /* set dma channel mode, and set dma channel mode */
  153         if ((chan & 4) == 0)
bus_space_write_1(sc->sc_iot, sc->sc_dma1h,
DMA1_SMSK, ochan | DMA37SM_CLEAR);
  156         else
bus_space_write_1(sc->sc_iot, sc->sc_dma2h,
DMA2_SMSK, ochan | DMA37SM_CLEAR);
  159 }
  161 static inline void
isa_dmamask(sc, chan)
  163         struct isa_softc *sc;
  164         int chan;
  165 {
  166         int ochan = chan & 3;
  168         /* set dma channel mode, and set dma channel mode */
  169         if ((chan & 4) == 0) {
bus_space_write_1(sc->sc_iot, sc->sc_dma1h,
DMA1_SMSK, ochan | DMA37SM_SET);
bus_space_write_1(sc->sc_iot, sc->sc_dma1h,
DMA1_FFC, 0);
  174         } else {
bus_space_write_1(sc->sc_iot, sc->sc_dma2h,
DMA2_SMSK, ochan | DMA37SM_SET);
bus_space_write_1(sc->sc_iot, sc->sc_dma2h,
DMA2_FFC, 0);
  179         }
  180 }
  182 /*
  183  * isa_dmacascade(): program 8237 DMA controller channel to accept
  184  * external dma control by a board.
  185  */
  186 void
isa_dmacascade(isadev, chan)
  188         struct device *isadev;
  189         int chan;
  190 {
  191         struct isa_softc *sc = (struct isa_softc *)isadev;
  192         int ochan = chan & 3;
  194         if (chan < 0 || chan > 7) {
printf("%s: bogus drq %d\n", sc->sc_dev.dv_xname, chan);
  196                 goto lose;
  197         }
  199         if (ISA_DRQ_ISFREE(sc, chan) == 0) {
printf("%s: DRQ %d is not free\n", sc->sc_dev.dv_xname, chan);
  201                 goto lose;
  202         }
ISA_DRQ_ALLOC(sc, chan);
  206         /* set dma channel mode, and set dma channel mode */
  207         if ((chan & 4) == 0)
bus_space_write_1(sc->sc_iot, sc->sc_dma1h,
DMA1_MODE, ochan | DMA37MD_CASCADE);
  210         else
bus_space_write_1(sc->sc_iot, sc->sc_dma2h,
DMA2_MODE, ochan | DMA37MD_CASCADE);
isa_dmaunmask(sc, chan);
  215         return;
lose:
panic("isa_dmacascade");
  219 }
  221 int
isa_dmamap_create(isadev, chan, size, flags)
  223         struct device *isadev;
  224         int chan;
bus_size_t size;
  226         int flags;
  227 {
  228         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_size_t maxsize;
  231         if (chan < 0 || chan > 7) {
printf("%s: bogus drq %d\n", sc->sc_dev.dv_xname, chan);
  233                 goto lose;
  234         }
  236         if (chan & 4)
maxsize = (1 << 17);
  238         else
maxsize = (1 << 16);
  241         if (size > maxsize)
  242                 return (EINVAL);
  244         if (ISA_DRQ_ISFREE(sc, chan) == 0) {
printf("%s: drq %d is not free\n", sc->sc_dev.dv_xname, chan);
  246                 goto lose;
  247         }
ISA_DRQ_ALLOC(sc, chan);
  251         return (bus_dmamap_create(sc->sc_dmat, size, 1, size, maxsize,
flags, &sc->sc_dmamaps[chan]));
lose:
panic("isa_dmamap_create");
  256 }
  258 void
isa_dmamap_destroy(isadev, chan)
  260         struct device *isadev;
  261         int chan;
  262 {
  263         struct isa_softc *sc = (struct isa_softc *)isadev;
  265         if (chan < 0 || chan > 7) {
printf("%s: bogus drq %d\n", sc->sc_dev.dv_xname, chan);
  267                 goto lose;
  268         }
  270         if (ISA_DRQ_ISFREE(sc, chan)) {
printf("%s: drq %d is already free\n",
sc->sc_dev.dv_xname, chan);
  273                 goto lose;
  274         }
ISA_DRQ_FREE(sc, chan);
bus_dmamap_destroy(sc->sc_dmat, sc->sc_dmamaps[chan]);
  279         return;
lose:
panic("isa_dmamap_destroy");
  283 }
  285 /*
  286  * isa_dmastart(): program 8237 DMA controller channel and set it
  287  * in motion.
  288  */
  289 int
isa_dmastart(isadev, chan, addr, nbytes, p, flags, busdmaflags)
  291         struct device *isadev;
  292         int chan;
  293         void *addr;
bus_size_t nbytes;
  295         struct proc *p;
  296         int flags;
  297         int busdmaflags;
  298 {
  299         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_dmamap_t dmam;
bus_addr_t dmaaddr;
  302         int waport;
  303         int ochan = chan & 3;
  304         int error;
  305 #ifdef __ISADMA_COMPAT
  306         int compat = busdmaflags & BUS_DMA_BUS1;
busdmaflags &= ~BUS_DMA_BUS1;
  309 #endif /* __ISADMA_COMPAT */
  311         if (chan < 0 || chan > 7) {
printf("%s: bogus drq %d\n", sc->sc_dev.dv_xname, chan);
  313                 goto lose;
  314         }
  316 #ifdef ISADMA_DEBUG
printf("isa_dmastart: drq %d, addr %p, nbytes 0x%lx, p %p, "
  318             "flags 0x%x, dmaflags 0x%x\n",
chan, addr, nbytes, p, flags, busdmaflags);
  320 #endif
  322         if (chan & 4) {
  323                 if (nbytes > (1 << 17) || nbytes & 1 || (u_long)addr & 1) {
printf("%s: drq %d, nbytes 0x%lx, addr %p\n",
sc->sc_dev.dv_xname, chan, nbytes, addr);
  326                         goto lose;
  327                 }
  328         } else {
  329                 if (nbytes > (1 << 16)) {
printf("%s: drq %d, nbytes 0x%lx\n",
sc->sc_dev.dv_xname, chan, nbytes);
  332                         goto lose;
  333                 }
  334         }
dmam = sc->sc_dmamaps[chan];
  337         if (dmam == NULL) {
  338 #ifdef __ISADMA_COMPAT
  339                 if (compat)
dmam = sc->sc_dmamaps[chan] = isadma_dmam[chan];
  341                 else
  342 #endif /* __ISADMA_COMPAT */
panic("isa_dmastart: no DMA map for chan %d", chan);
  344         }
error = bus_dmamap_load(sc->sc_dmat, dmam, addr, nbytes, p,
busdmaflags);
  348         if (error)
  349                 return (error);
  351 #ifdef ISADMA_DEBUG
  352         __asm(".globl isa_dmastart_afterload ; isa_dmastart_afterload:");
  353 #endif
  355         if (flags & DMAMODE_READ) {
bus_dmamap_sync(sc->sc_dmat, dmam, 0, dmam->dm_mapsize,
BUS_DMASYNC_PREREAD);
sc->sc_dmareads |= (1 << chan);
  359         } else {
bus_dmamap_sync(sc->sc_dmat, dmam, 0, dmam->dm_mapsize,
BUS_DMASYNC_PREWRITE);
sc->sc_dmareads &= ~(1 << chan);
  363         }
dmaaddr = dmam->dm_segs[0].ds_addr;
  367 #ifdef ISADMA_DEBUG
printf("     dmaaddr 0x%lx\n", dmaaddr);
  370         __asm(".globl isa_dmastart_aftersync ; isa_dmastart_aftersync:");
  371 #endif
sc->sc_dmalength[chan] = nbytes;
isa_dmamask(sc, chan);
sc->sc_dmafinished &= ~(1 << chan);
  378         if ((chan & 4) == 0) {
  379                 /* set dma channel mode */
bus_space_write_1(sc->sc_iot, sc->sc_dma1h, DMA1_MODE,
ochan | dmamode[flags]);
  383                 /* send start address */
waport = DMA1_CHN(ochan);
bus_space_write_1(sc->sc_iot, sc->sc_dmapgh,
dmapageport[0][ochan], (dmaaddr >> 16) & 0xff);
bus_space_write_1(sc->sc_iot, sc->sc_dma1h, waport,
dmaaddr & 0xff);
bus_space_write_1(sc->sc_iot, sc->sc_dma1h, waport,
  390                     (dmaaddr >> 8) & 0xff);
  392                 /* send count */
bus_space_write_1(sc->sc_iot, sc->sc_dma1h, waport + 1,
  394                     (--nbytes) & 0xff);
bus_space_write_1(sc->sc_iot, sc->sc_dma1h, waport + 1,
  396                     (nbytes >> 8) & 0xff);
  397         } else {
  398                 /* set dma channel mode */
bus_space_write_1(sc->sc_iot, sc->sc_dma2h, DMA2_MODE,
ochan | dmamode[flags]);
  402                 /* send start address */
waport = DMA2_CHN(ochan);
bus_space_write_1(sc->sc_iot, sc->sc_dmapgh,
dmapageport[1][ochan], (dmaaddr >> 16) & 0xff);
dmaaddr >>= 1;
bus_space_write_1(sc->sc_iot, sc->sc_dma2h, waport,
dmaaddr & 0xff);
bus_space_write_1(sc->sc_iot, sc->sc_dma2h, waport,
  410                     (dmaaddr >> 8) & 0xff);
  412                 /* send count */
nbytes >>= 1;
bus_space_write_1(sc->sc_iot, sc->sc_dma2h, waport + 2,
  415                     (--nbytes) & 0xff);
bus_space_write_1(sc->sc_iot, sc->sc_dma2h, waport + 2,
  417                     (nbytes >> 8) & 0xff);
  418         }
isa_dmaunmask(sc, chan);
  421         return (0);
lose:
panic("isa_dmastart");
  425 }
  427 void
isa_dmaabort(isadev, chan)
  429         struct device *isadev;
  430         int chan;
  431 {
  432         struct isa_softc *sc = (struct isa_softc *)isadev;
  434         if (chan < 0 || chan > 7) {
panic("isa_dmaabort: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  437         }
isa_dmamask(sc, chan);
bus_dmamap_unload(sc->sc_dmat, sc->sc_dmamaps[chan]);
sc->sc_dmareads &= ~(1 << chan);
  442 }
bus_size_t
isa_dmacount(isadev, chan)
  446         struct device *isadev;
  447         int chan;
  448 {
  449         struct isa_softc *sc = (struct isa_softc *)isadev;
  450         int waport;
bus_size_t nbytes;
  452         int ochan = chan & 3;
  454         if (chan < 0 || chan > 7) {
panic("isa_dmacount: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  457         }
isa_dmamask(sc, chan);
  461         /*
  462          * We have to shift the byte count by 1.  If we're in auto-initialize
  463          * mode, the count may have wrapped around to the initial value.  We
  464          * can't use the TC bit to check for this case, so instead we compare
  465          * against the original byte count.
  466          * If we're not in auto-initialize mode, then the count will wrap to
  467          * -1, so we also handle that case.
  468          */
  469         if ((chan & 4) == 0) {
waport = DMA1_CHN(ochan);
nbytes = bus_space_read_1(sc->sc_iot, sc->sc_dma1h,
waport + 1) + 1;
nbytes += bus_space_read_1(sc->sc_iot, sc->sc_dma1h,
waport + 1) << 8;
nbytes &= 0xffff;
  476         } else {
waport = DMA2_CHN(ochan);
nbytes = bus_space_read_1(sc->sc_iot, sc->sc_dma2h,
waport + 2) + 1;
nbytes += bus_space_read_1(sc->sc_iot, sc->sc_dma2h,
waport + 2) << 8;
nbytes <<= 1;
nbytes &= 0x1ffff;
  484         }
  486         if (nbytes == sc->sc_dmalength[chan])
nbytes = 0;
isa_dmaunmask(sc, chan);
  490         return (nbytes);
  491 }
  493 int
isa_dmafinished(isadev, chan)
  495         struct device *isadev;
  496         int chan;
  497 {
  498         struct isa_softc *sc = (struct isa_softc *)isadev;
  500         if (chan < 0 || chan > 7) {
panic("isa_dmafinished: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  503         }
  505         /* check that the terminal count was reached */
  506         if ((chan & 4) == 0)
sc->sc_dmafinished |= bus_space_read_1(sc->sc_iot,
sc->sc_dma1h, DMA1_SR) & 0x0f;
  509         else
sc->sc_dmafinished |= (bus_space_read_1(sc->sc_iot,
sc->sc_dma2h, DMA2_SR) & 0x0f) << 4;
  513         return ((sc->sc_dmafinished & (1 << chan)) != 0);
  514 }
  516 void
isa_dmadone(isadev, chan)
  518         struct device *isadev;
  519         int chan;
  520 {
  521         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_dmamap_t dmam;
  524         if (chan < 0 || chan > 7) {
panic("isa_dmadone: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  527         }
dmam = sc->sc_dmamaps[chan];
isa_dmamask(sc, chan);
  533         if (isa_dmafinished(isadev, chan) == 0)
printf("%s: isa_dmadone: channel %d not finished\n",
sc->sc_dev.dv_xname, chan);
bus_dmamap_sync(sc->sc_dmat, dmam, 0, dmam->dm_mapsize,
  538             (sc->sc_dmareads & (1 << chan)) ? BUS_DMASYNC_POSTREAD :
BUS_DMASYNC_POSTWRITE);
bus_dmamap_unload(sc->sc_dmat, dmam);
sc->sc_dmareads &= ~(1 << chan);
  543 }
  545 int
isa_dmamem_alloc(isadev, chan, size, addrp, flags)
  547         struct device *isadev;
  548         int chan;
bus_size_t size;
bus_addr_t *addrp;
  551         int flags;
  552 {
  553         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_dma_segment_t seg;
  555         int error, boundary, rsegs;
  557         if (chan < 0 || chan > 7) {
panic("isa_dmamem_alloc: %s: bogus drq %d",
sc->sc_dev.dv_xname, chan);
  560         }
boundary = (chan & 4) ? (1 << 17) : (1 << 16);
size = round_page(size);
error = bus_dmamem_alloc(sc->sc_dmat, size, NBPG, boundary,
  567             &seg, 1, &rsegs, flags);
  568         if (error)
  569                 return (error);
  571         *addrp = seg.ds_addr;
  572         return (0);
  573 }
  575 void
isa_dmamem_free(isadev, chan, addr, size)
  577         struct device *isadev;
  578         int chan;
bus_addr_t addr;
bus_size_t size;
  581 {
  582         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_dma_segment_t seg;
  585         if (chan < 0 || chan > 7) {
panic("isa_dmamem_free: %s: bogus drq %d",
sc->sc_dev.dv_xname, chan);
  588         }
seg.ds_addr = addr;
seg.ds_len = size;
bus_dmamem_free(sc->sc_dmat, &seg, 1);
  594 }
  596 int
isa_dmamem_map(isadev, chan, addr, size, kvap, flags)
  598         struct device *isadev;
  599         int chan;
bus_addr_t addr;
bus_size_t size;
caddr_t *kvap;
  603         int flags;
  604 {
  605         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_dma_segment_t seg;
  608         if (chan < 0 || chan > 7) {
panic("isa_dmamem_map: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  611         }
seg.ds_addr = addr;
seg.ds_len = size;
  616         return (bus_dmamem_map(sc->sc_dmat, &seg, 1, size, kvap, flags));
  617 }
  619 void
isa_dmamem_unmap(isadev, chan, kva, size)
  621         struct device *isadev;
  622         int chan;
caddr_t kva;
size_t size;
  625 {
  626         struct isa_softc *sc = (struct isa_softc *)isadev;
  628         if (chan < 0 || chan > 7) {
panic("isa_dmamem_unmap: %s: bogus drq %d",
sc->sc_dev.dv_xname, chan);
  631         }
bus_dmamem_unmap(sc->sc_dmat, kva, size);
  634 }
  636 int
isa_dmamem_mmap(isadev, chan, addr, size, off, prot, flags)
  638         struct device *isadev;
  639         int chan;
bus_addr_t addr;
bus_size_t size;
  642         int off, prot, flags;
  643 {
  644         struct isa_softc *sc = (struct isa_softc *)isadev;
bus_dma_segment_t seg;
  647         if (chan < 0 || chan > 7) {
panic("isa_dmamem_mmap: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  650         }
  652         if (off < 0)
  653                 return (-1);
seg.ds_addr = addr;
seg.ds_len = size;
  658         return (bus_dmamem_mmap(sc->sc_dmat, &seg, 1, off, prot, flags));
  659 }
  661 int
isa_drq_isfree(isadev, chan)
  663         struct device *isadev;
  664         int chan;
  665 {
  666         struct isa_softc *sc = (struct isa_softc *)isadev;
  667         if (chan < 0 || chan > 7) {
panic("isa_drq_isfree: %s: bogus drq %d", sc->sc_dev.dv_xname,
chan);
  670         }
  671         return ISA_DRQ_ISFREE(sc, chan);
  672 }
  674 void *
isa_malloc(isadev, chan, size, pool, flags)
  676         struct device *isadev;
  677         int chan;
size_t size;
  679         int pool;
  680         int flags;
  681 {
bus_addr_t addr;
caddr_t kva;
  684         int bflags;
  685         struct isa_mem *m;
bflags = flags & M_NOWAIT ? BUS_DMA_NOWAIT : BUS_DMA_WAITOK;
  689         if (isa_dmamem_alloc(isadev, chan, size, &addr, bflags))
  690                 return 0;
  691         if (isa_dmamem_map(isadev, chan, addr, size, &kva, bflags)) {
isa_dmamem_free(isadev, chan, addr, size);
  693                 return 0;
  694         }
m = malloc(sizeof(*m), pool, flags);
  696         if (m == 0) {
isa_dmamem_unmap(isadev, chan, kva, size);
isa_dmamem_free(isadev, chan, addr, size);
  699                 return 0;
  700         }
m->isadev = isadev;
m->chan = chan;
m->size = size;
m->addr = addr;
m->kva = kva;
m->next = isa_mem_head;
isa_mem_head = m;
  708         return (void *)kva;
  709 }
  711 void
isa_free(addr, pool)
  713         void *addr;
  714         int pool;
  715 {
  716         struct isa_mem **mp, *m;
caddr_t kva = (caddr_t)addr;
  719         for(mp = &isa_mem_head; *mp && (*mp)->kva != kva; mp = &(*mp)->next)
  720                 ;
m = *mp;
  722         if (!m) {
printf("isa_free: freeing unallocated memory\n");
  724                 return;
  725         }
  726         *mp = m->next;
isa_dmamem_unmap(m->isadev, m->chan, kva, m->size);
isa_dmamem_free(m->isadev, m->chan, m->addr, m->size);
free(m, pool);
  730 }
paddr_t
isa_mappage(mem, off, prot)
  734         void *mem;
off_t off;
  736         int prot;
  737 {
  738         struct isa_mem *m;
  740         for(m = isa_mem_head; m && m->kva != (caddr_t)mem; m = m->next)
  741                 ;
  742         if (!m) {
printf("isa_mappage: mapping unallocated memory\n");
  744                 return -1;
  745         }
  746         return (isa_dmamem_mmap(m->isadev, m->chan, m->addr, m->size, off,
prot, BUS_DMA_WAITOK));
  748 }