6/sys/alpha/alpha/busdma_machdep.c

   1 /*-
   2  * Copyright (c) 1997 Justin T. Gibbs.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification, immediately at the beginning of the file.
  11  * 2. The name of the author may not be used to endorse or promote products
  12  *    derived from this software without specific prior written permission.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE FOR
  18  * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <sys/cdefs.h>
  28 __FBSDID("$FreeBSD$");
  29
  30 #include <sys/param.h>
  31 #include <sys/bus.h>
  32 #include <sys/systm.h>
  33 #include <sys/interrupt.h>
  34 #include <sys/kernel.h>
  35 #include <sys/lock.h>
  36 #include <sys/malloc.h>
  37 #include <sys/mbuf.h>
  38 #include <sys/mutex.h>
  39 #include <sys/proc.h>
  40 #include <sys/uio.h>
  41
  42 #include <vm/vm.h>
  43 #include <vm/vm_page.h>
  44 #include <vm/vm_map.h>
  45
  46 #include <machine/atomic.h>
  47 #include <machine/bus.h>
  48 #include <machine/sgmap.h>
  49 #include <machine/md_var.h>
  50
  51 #define MAX_BPAGES 128
  52
  53 struct bus_dma_tag {
  54         bus_dma_tag_t     parent;
  55         bus_size_t        alignment;
  56         bus_size_t        boundary;
  57         bus_addr_t        lowaddr;
  58         bus_addr_t        highaddr;
  59         bus_dma_filter_t *filter;
  60         void             *filterarg;
  61         bus_size_t        maxsize;
  62         u_int             nsegments;
  63         bus_size_t        maxsegsz;
  64         int               flags;
  65         int               ref_count;
  66         int               map_count;
  67         bus_dma_lock_t   *lockfunc;
  68         void             *lockfuncarg;
  69         bus_dma_segment_t *segments;
  70 };
  71
  72 struct bounce_page {
  73         vm_offset_t     vaddr;          /* kva of bounce buffer */
  74         bus_addr_t      busaddr;        /* Physical address */
  75         vm_offset_t     datavaddr;      /* kva of client data */
  76         bus_size_t      datacount;      /* client data count */
  77         STAILQ_ENTRY(bounce_page) links;
  78 };
  79
  80 int busdma_pyxis_bug, busdma_swi_pending;
  81 TUNABLE_INT("machdep.busdma_pyxis_bug", &busdma_pyxis_bug);
  82
  83 static struct mtx bounce_lock;
  84 static STAILQ_HEAD(bp_list, bounce_page) bounce_page_list;
  85 static int free_bpages;
  86 static int reserved_bpages;
  87 static int active_bpages;
  88 static int total_bpages;
  89
  90 struct bus_dmamap {
  91         struct bp_list         bpages;
  92         int                    pagesneeded;
  93         int                    pagesreserved;
  94         bus_dma_tag_t          dmat;
  95         void                  *buf;             /* unmapped buffer pointer */
  96         bus_size_t             buflen;          /* unmapped buffer length */
  97         vm_offset_t            busaddress;      /* address in bus space */
  98         bus_dmamap_callback_t *callback;
  99         void                  *callback_arg;
 100         void                  *sgmaphandle;     /* handle into sgmap */
 101         STAILQ_ENTRY(bus_dmamap) links;
 102 };
 103
 104 static STAILQ_HEAD(, bus_dmamap) bounce_map_waitinglist;
 105 static STAILQ_HEAD(, bus_dmamap) bounce_map_callbacklist;
 106 static struct bus_dmamap nobounce_dmamap;
 107
 108 static void init_bounce_pages(void *dummy);
 109 static int alloc_bounce_pages(bus_dma_tag_t dmat, u_int numpages);
 110 static int reserve_bounce_pages(bus_dma_tag_t dmat, bus_dmamap_t map,
 111                                 int commit);
 112 static bus_addr_t add_bounce_page(bus_dma_tag_t dmat, bus_dmamap_t map,
 113                                    vm_offset_t vaddr, bus_size_t size);
 114 static void free_bounce_page(bus_dma_tag_t dmat, struct bounce_page *bpage);
 115 static __inline int run_filter(bus_dma_tag_t dmat, bus_addr_t paddr);
 116
 117 /*
 118  * Return true if a match is made.
 119  *
 120  * To find a match walk the chain of bus_dma_tag_t's looking for 'paddr'.
 121  *
 122  * If paddr is within the bounds of the dma tag then call the filter callback
 123  * to check for a match, if there is no filter callback then assume a match.
 124  */
 125 static __inline int
 126 run_filter(bus_dma_tag_t dmat, bus_addr_t paddr)
 127 {
 128         int retval;
 129
 130         retval = 0;
 131         do {
 132                 if (((paddr > dmat->lowaddr && paddr <= dmat->highaddr)
 133                  || ((paddr & (dmat->alignment - 1)) != 0))
 134                  && (dmat->filter == NULL
 135                   || (*dmat->filter)(dmat->filterarg, paddr) != 0))
 136                         retval = 1;
 137
 138                 dmat = dmat->parent;
 139         } while (retval == 0 && dmat != NULL);
 140         return (retval);
 141 }
 142
 143 /*
 144  * Convenience function for manipulating driver locks from busdma (during
 145  * busdma_swi, for example).  Drivers that don't provide their own locks
 146  * should specify &Giant to dmat->lockfuncarg.  Drivers that use their own
 147  * non-mutex locking scheme don't have to use this at all.
 148  */
 149 void
 150 busdma_lock_mutex(void *arg, bus_dma_lock_op_t op)
 151 {
 152         struct mtx *dmtx;
 153
 154         dmtx = (struct mtx *)arg;
 155         switch (op) {
 156         case BUS_DMA_LOCK:
 157                 mtx_lock(dmtx);
 158                 break;
 159         case BUS_DMA_UNLOCK:
 160                 mtx_unlock(dmtx);
 161                 break;
 162         default:
 163                 panic("Unknown operation 0x%x for busdma_lock_mutex!", op);
 164         }
 165 }
 166
 167 /*
 168  * dflt_lock should never get called.  It gets put into the dma tag when
 169  * lockfunc == NULL, which is only valid if the maps that are associated
 170  * with the tag are meant to never be defered.
 171  * XXX Should have a way to identify which driver is responsible here.
 172  */
 173 static void
 174 dflt_lock(void *arg, bus_dma_lock_op_t op)
 175 {
 176 #ifdef INVARIANTS
 177         panic("driver error: busdma dflt_lock called");
 178 #else
 179         printf("DRIVER_ERROR: busdma dflt_lock called\n");
 180 #endif
 181 }
 182
 183 #define BUS_DMA_COULD_BOUNCE    BUS_DMA_BUS3
 184 #define BUS_DMA_MIN_ALLOC_COMP  BUS_DMA_BUS4
 185 /*
 186  * Allocate a device specific dma_tag.
 187  */
 188 int
 189 bus_dma_tag_create(bus_dma_tag_t parent, bus_size_t alignment,
 190                    bus_size_t boundary, bus_addr_t lowaddr,
 191                    bus_addr_t highaddr, bus_dma_filter_t *filter,
 192                    void *filterarg, bus_size_t maxsize, int nsegments,
 193                    bus_size_t maxsegsz, int flags, bus_dma_lock_t *lockfunc,
 194                    void *lockfuncarg, bus_dma_tag_t *dmat)
 195 {
 196         bus_dma_tag_t newtag;
 197         int error = 0;
 198
 199         /* Basic sanity checking */
 200         if (boundary != 0 && boundary < maxsegsz)
 201                 maxsegsz = boundary;
 202
 203         /* Return a NULL tag on failure */
 204         *dmat = NULL;
 205
 206         newtag = (bus_dma_tag_t)malloc(sizeof(*newtag), M_DEVBUF,
 207             M_ZERO | M_NOWAIT);
 208         if (newtag == NULL)
 209                 return (ENOMEM);
 210
 211         newtag->parent = parent;
 212         newtag->alignment = alignment;
 213         newtag->boundary = boundary;
 214         newtag->lowaddr = trunc_page(lowaddr) + (PAGE_SIZE - 1);
 215         newtag->highaddr = trunc_page(highaddr) + (PAGE_SIZE - 1);
 216         newtag->filter = filter;
 217         newtag->filterarg = filterarg;
 218         newtag->maxsize = maxsize;
 219         newtag->nsegments = nsegments;
 220         newtag->maxsegsz = maxsegsz;
 221         newtag->flags = flags;
 222         newtag->ref_count = 1; /* Count ourself */
 223         newtag->map_count = 0;
 224         if (lockfunc != NULL) {
 225                 newtag->lockfunc = lockfunc;
 226                 newtag->lockfuncarg = lockfuncarg;
 227         } else {
 228                 newtag->lockfunc = dflt_lock;
 229                 newtag->lockfuncarg = NULL;
 230         }
 231         newtag->segments = NULL;
 232
 233         /* Take into account any restrictions imposed by our parent tag */
 234         if (parent != NULL) {
 235                 newtag->lowaddr = MIN(parent->lowaddr, newtag->lowaddr);
 236                 newtag->highaddr = MAX(parent->highaddr, newtag->highaddr);
 237                 if (newtag->boundary == 0)
 238                         newtag->boundary = parent->boundary;
 239                 else if (parent->boundary != 0)
 240                         newtag->boundary = MIN(parent->boundary,
 241                                                newtag->boundary);
 242                 if (newtag->filter == NULL) {
 243                         /*
 244                          * Short circuit looking at our parent directly
 245                          * since we have encapsulated all of its information
 246                          */
 247                         newtag->filter = parent->filter;
 248                         newtag->filterarg = parent->filterarg;
 249                         newtag->parent = parent->parent;
 250                 }
 251                 if (newtag->parent != NULL)
 252                         atomic_add_int(&parent->ref_count, 1);
 253         }
 254
 255         if (newtag->lowaddr < ptoa(Maxmem) || newtag->alignment > 1)
 256                 newtag->flags |= BUS_DMA_COULD_BOUNCE;
 257
 258         if (((newtag->flags & BUS_DMA_COULD_BOUNCE) != 0) &&
 259             (flags & BUS_DMA_ALLOCNOW) != 0) {
 260                 /* Must bounce */
 261
 262                 if (ptoa(total_bpages) < maxsize) {
 263                         int pages;
 264
 265                         pages = atop(maxsize) - total_bpages;
 266
 267                         /* Add pages to our bounce pool */
 268                         if (alloc_bounce_pages(newtag, pages) < pages)
 269                                 error = ENOMEM;
 270                 }
 271                 /* Performed initial allocation */
 272                 newtag->flags |= BUS_DMA_MIN_ALLOC_COMP;
 273         }
 274
 275         if (error != 0) {
 276                 free(newtag, M_DEVBUF);
 277         } else {
 278                 *dmat = newtag;
 279         }
 280         return (error);
 281 }
 282
 283 int
 284 bus_dma_tag_destroy(bus_dma_tag_t dmat)
 285 {
 286         if (dmat != NULL) {
 287
 288                 if (dmat->map_count != 0)
 289                         return (EBUSY);
 290
 291                 while (dmat != NULL) {
 292                         bus_dma_tag_t parent;
 293
 294                         parent = dmat->parent;
 295                         atomic_subtract_int(&dmat->ref_count, 1);
 296                         if (dmat->ref_count == 0) {
 297                                 if (dmat->segments != NULL)
 298                                         free(dmat->segments, M_DEVBUF);
 299                                 free(dmat, M_DEVBUF);
 300                                 /*
 301                                  * Last reference count, so
 302                                  * release our reference
 303                                  * count on our parent.
 304                                  */
 305                                 dmat = parent;
 306                         } else
 307                                 dmat = NULL;
 308                 }
 309         }
 310         return (0);
 311 }
 312
 313 /*
 314  * Allocate a handle for mapping from kva/uva/physical
 315  * address space into bus device space.
 316  */
 317 int
 318 bus_dmamap_create(bus_dma_tag_t dmat, int flags, bus_dmamap_t *mapp)
 319 {
 320         int error;
 321
 322         error = 0;
 323
 324         if ((dmat->flags & BUS_DMA_ISA) && chipset.sgmap != NULL) {
 325                 bus_dmamap_t map;
 326                 map = (bus_dmamap_t)malloc(sizeof(*map), M_DEVBUF,
 327                                              M_NOWAIT | M_ZERO);
 328                 if (map == NULL)
 329                         return (ENOMEM);
 330
 331                 map->busaddress =
 332                         sgmap_alloc_region(chipset.sgmap,
 333                                            dmat->maxsize,
 334                                            dmat->boundary,
 335                                            &map->sgmaphandle);
 336                 dmat->map_count++;
 337                 *mapp = map;
 338                 return (0);
 339         }
 340
 341         if (dmat->segments == NULL) {
 342                 dmat->segments = (bus_dma_segment_t *)malloc(
 343                     sizeof(bus_dma_segment_t) * dmat->nsegments, M_DEVBUF,
 344                     M_NOWAIT);
 345                 if (dmat->segments == NULL)
 346                         return (ENOMEM);
 347         }
 348
 349         /*
 350          * Bouncing might be required if the driver asks for an active
 351          * exclusion region, a data alignment that is stricter than 1, and/or
 352          * an active address boundary.
 353          */
 354         if (dmat->flags & BUS_DMA_COULD_BOUNCE) {
 355
 356                 /* Must bounce */
 357                 int maxpages;
 358
 359                 *mapp = (bus_dmamap_t)malloc(sizeof(**mapp), M_DEVBUF,
 360                                              M_NOWAIT | M_ZERO);
 361                 if (*mapp == NULL)
 362                         return (ENOMEM);
 363
 364                 /* Initialize the new map */
 365                 STAILQ_INIT(&((*mapp)->bpages));
 366
 367                 /*
 368                  * Attempt to add pages to our pool on a per-instance
 369                  * basis up to a sane limit.
 370                  */
 371                 if (dmat->alignment > 1)
 372                         maxpages = MAX_BPAGES;
 373                 else
 374                         maxpages = MIN(MAX_BPAGES,
 375                             Maxmem - atop(dmat->lowaddr));
 376                 if ((dmat->flags & BUS_DMA_MIN_ALLOC_COMP) == 0
 377                  || (dmat->map_count > 0 && total_bpages < maxpages)) {
 378                         int pages;
 379
 380                         pages = MAX(atop(dmat->maxsize), 1);
 381                         pages = MIN(maxpages - total_bpages, pages);
 382                         pages = MAX(pages, 1);
 383                         if (alloc_bounce_pages(dmat, pages) < pages)
 384                                 error = ENOMEM;
 385
 386                         if ((dmat->flags & BUS_DMA_MIN_ALLOC_COMP) == 0) {
 387                                 if (error == 0)
 388                                         dmat->flags |= BUS_DMA_MIN_ALLOC_COMP;
 389                         } else {
 390                                 error = 0;
 391                         }
 392                 }
 393         } else {
 394                 *mapp = &nobounce_dmamap;
 395         }
 396         if (error == 0)
 397                 dmat->map_count++;
 398         return (error);
 399 }
 400
 401 /*
 402  * Destroy a handle for mapping from kva/uva/physical
 403  * address space into bus device space.
 404  */
 405 int
 406 bus_dmamap_destroy(bus_dma_tag_t dmat, bus_dmamap_t map)
 407 {
 408         if ((dmat->flags & BUS_DMA_ISA) && chipset.sgmap != NULL) {
 409                 sgmap_free_region(chipset.sgmap, map->sgmaphandle);
 410         }
 411
 412         if (map != NULL && map != &nobounce_dmamap) {
 413                 if (STAILQ_FIRST(&map->bpages) != NULL)
 414                         return (EBUSY);
 415                 free(map, M_DEVBUF);
 416         }
 417         dmat->map_count--;
 418         return (0);
 419 }
 420
 421
 422 /*
 423  * Allocate a piece of memory that can be efficiently mapped into
 424  * bus device space based on the constraints lited in the dma tag.
 425  * A dmamap to for use with dmamap_load is also allocated.
 426  */
 427 int
 428 bus_dmamem_alloc(bus_dma_tag_t dmat, void** vaddr, int flags,
 429                  bus_dmamap_t *mapp)
 430 {
 431         int mflags;
 432
 433         if (flags & BUS_DMA_NOWAIT)
 434                 mflags = M_NOWAIT;
 435         else
 436                 mflags = M_WAITOK;
 437         if (flags & BUS_DMA_ZERO)
 438                 mflags |= M_ZERO;
 439
 440         /* If we succeed, no mapping/bouncing will be required */
 441         *mapp = &nobounce_dmamap;
 442
 443         if (dmat->segments == NULL) {
 444                 dmat->segments = (bus_dma_segment_t *)malloc(
 445                     sizeof(bus_dma_segment_t) * dmat->nsegments, M_DEVBUF,
 446                     M_NOWAIT);
 447                 if (dmat->segments == NULL)
 448                         return (ENOMEM);
 449         }
 450
 451         if ((dmat->maxsize <= PAGE_SIZE) &&
 452            (dmat->alignment < dmat->maxsize) &&
 453             dmat->lowaddr >= ptoa(Maxmem)) {
 454                 *vaddr = malloc(dmat->maxsize, M_DEVBUF, mflags);
 455         } else {
 456                 /*
 457                  * XXX Use Contigmalloc until it is merged into this facility
 458                  *     and handles multi-seg allocations.  Nobody is doing
 459                  *     multi-seg allocations yet though.
 460                  */
 461                 *vaddr = contigmalloc(dmat->maxsize, M_DEVBUF, mflags,
 462                     0ul, dmat->lowaddr, dmat->alignment? dmat->alignment : 1ul,
 463                     dmat->boundary);
 464         }
 465         if (*vaddr == NULL)
 466                 return (ENOMEM);
 467         return (0);
 468 }
 469
 470 /*
 471  * Free a piece of memory and it's allociated dmamap, that was allocated
 472  * via bus_dmamem_alloc.  Make the same choice for free/contigfree.
 473  */
 474 void
 475 bus_dmamem_free(bus_dma_tag_t dmat, void *vaddr, bus_dmamap_t map)
 476 {
 477         /*
 478          * dmamem does not need to be bounced, so the map should be
 479          * NULL
 480          */
 481         if (map != &nobounce_dmamap)
 482                 panic("bus_dmamem_free: Invalid map freed\n");
 483         if ((dmat->maxsize <= PAGE_SIZE) &&
 484            (dmat->alignment < dmat->maxsize) &&
 485             dmat->lowaddr >= ptoa(Maxmem))
 486                 free(vaddr, M_DEVBUF);
 487         else {
 488                 contigfree(vaddr, dmat->maxsize, M_DEVBUF);
 489         }
 490 }
 491
 492 #define BUS_DMAMAP_NSEGS ((64 * 1024 / PAGE_SIZE) + 1)
 493
 494 vm_offset_t alpha_XXX_dmamap_or = 1024UL*1024UL*1024UL;  /*XXX */
 495
 496 /*
 497  * Utility function to load a linear buffer.  lastaddrp holds state
 498  * between invocations (for multiple-buffer loads).  segp contains
 499  * the starting segment on entrace, and the ending segment on exit.
 500  * first indicates if this is the first invocation of this function.
 501  */
 502 static int
 503 _bus_dmamap_load_buffer(bus_dma_tag_t dmat,
 504                         bus_dmamap_t map,
 505                         void *buf, bus_size_t buflen,
 506                         pmap_t pmap,
 507                         int flags,
 508                         bus_addr_t *lastaddrp,
 509                         bus_dma_segment_t *segs,
 510                         int *segp,
 511                         int first)
 512 {
 513         bus_size_t sgsize;
 514         bus_addr_t curaddr, lastaddr, baddr, bmask;
 515         vm_offset_t vaddr;
 516         bus_addr_t paddr;
 517         int seg;
 518         bus_size_t boundary;
 519         bus_size_t maxsegsz;
 520
 521         /*
 522          * Enforce a boundary of 8k for buffers that aren't allocated
 523          * via bus_dmamem_alloc() on systems with the Pyxis pass 1 DMA
 524          * bug.  This is somewhat gross.
 525          */
 526         boundary = dmat->boundary;
 527         maxsegsz = dmat->maxsegsz;
 528         if (busdma_pyxis_bug && map != &nobounce_dmamap) {
 529                 if (boundary == 0 || boundary > 8192)
 530                         boundary = 8192;
 531                 if (boundary < maxsegsz)
 532                         maxsegsz = boundary;
 533         }
 534
 535         /*
 536          * If we are being called during a callback, pagesneeded will
 537          * be non-zero, so we can avoid doing the work twice.
 538          */
 539         if ((map != &nobounce_dmamap && map->pagesneeded == 0)
 540          && ((dmat->flags & BUS_DMA_COULD_BOUNCE) != 0)) {
 541                 vm_offset_t     vendaddr;
 542
 543                 /*
 544                  * Count the number of bounce pages
 545                  * needed in order to complete this transfer
 546                  */
 547                 vaddr = trunc_page(buf);
 548                 vendaddr = (vm_offset_t)buf + buflen;
 549
 550                 while (vaddr < vendaddr) {
 551                         if (pmap)
 552                                 paddr = pmap_extract(pmap, vaddr);
 553                         else
 554                                 paddr = pmap_kextract(vaddr);
 555                         if (run_filter(dmat, paddr) != 0)
 556                                 map->pagesneeded++;
 557                         vaddr += PAGE_SIZE;
 558                 }
 559         }
 560
 561         /* Reserve Necessary Bounce Pages */
 562         if (map->pagesneeded != 0) {
 563                 mtx_lock(&bounce_lock);
 564                 if (flags & BUS_DMA_NOWAIT) {
 565                         if (reserve_bounce_pages(dmat, map, 0) != 0) {
 566                                 mtx_unlock(&bounce_lock);
 567                                 return (ENOMEM);
 568                         }
 569                 } else {
 570                         if (reserve_bounce_pages(dmat, map, 1) != 0) {
 571                                 /* Queue us for resources */
 572                                 map->dmat = dmat;
 573                                 map->buf = buf;
 574                                 map->buflen = buflen;
 575                                 STAILQ_INSERT_TAIL(&bounce_map_waitinglist,
 576                                     map, links);
 577                                 mtx_unlock(&bounce_lock);
 578                                 return (EINPROGRESS);
 579                         }
 580                 }
 581                 mtx_unlock(&bounce_lock);
 582         }
 583
 584         vaddr = (vm_offset_t)buf;
 585         lastaddr = *lastaddrp;
 586         bmask = ~(boundary - 1);
 587
 588         for (seg = *segp; buflen > 0 ; ) {
 589                 /*
 590                  * Get the physical address for this segment.
 591                  */
 592                 if (pmap)
 593                         curaddr = pmap_extract(pmap, vaddr);
 594                 else
 595                         curaddr = pmap_kextract(vaddr);
 596
 597                 /*
 598                  * Compute the segment size, and adjust counts.
 599                  */
 600                 sgsize = PAGE_SIZE - ((u_long)curaddr & PAGE_MASK);
 601                 if (buflen < sgsize)
 602                         sgsize = buflen;
 603
 604                 /*
 605                  * Make sure we don't cross any boundaries.
 606                  */
 607                 if (boundary > 0) {
 608                         baddr = (curaddr + boundary) & bmask;
 609                         if (sgsize > (baddr - curaddr))
 610                                 sgsize = (baddr - curaddr);
 611                 }
 612
 613                 if (map->pagesneeded != 0 && run_filter(dmat, curaddr))
 614                         curaddr = add_bounce_page(dmat, map, vaddr, sgsize);
 615
 616                 /*
 617                  * Convert the physical address into an IO address.
 618                  */
 619                 curaddr |= alpha_XXX_dmamap_or;
 620
 621                 /*
 622                  * Insert chunk into a segment, coalescing with
 623                  * previous segment if possible.
 624                  */
 625                 if (first) {
 626                         segs[seg].ds_addr = curaddr;
 627                         segs[seg].ds_len = sgsize;
 628                         first = 0;
 629                 } else {
 630                         if (curaddr == lastaddr &&
 631                             (segs[seg].ds_len + sgsize) <= maxsegsz &&
 632                             (boundary == 0 ||
 633                              (segs[seg].ds_addr & bmask) == (curaddr & bmask)))
 634                                 segs[seg].ds_len += sgsize;
 635                         else {
 636                                 if (++seg >= dmat->nsegments)
 637                                         break;
 638                                 segs[seg].ds_addr = curaddr;
 639                                 segs[seg].ds_len = sgsize;
 640                         }
 641                 }
 642
 643                 lastaddr = curaddr + sgsize;
 644                 vaddr += sgsize;
 645                 buflen -= sgsize;
 646         }
 647
 648         *segp = seg;
 649         *lastaddrp = lastaddr;
 650
 651         /*
 652          * Did we fit?
 653          */
 654         return (buflen != 0 ? EFBIG : 0); /* XXX better return value here? */
 655 }
 656
 657 /*
 658  * Map the buffer buf into bus space using the dmamap map.
 659  */
 660 int
 661 bus_dmamap_load(bus_dma_tag_t dmat, bus_dmamap_t map, void *buf,
 662                 bus_size_t buflen, bus_dmamap_callback_t *callback,
 663                 void *callback_arg, int flags)
 664 {
 665         bus_addr_t              lastaddr = 0;
 666         int                     error, nsegs = 0;
 667
 668         if ((dmat->flags & BUS_DMA_ISA) && chipset.sgmap != NULL) {
 669                 bus_dma_segment_t segment;
 670                 vm_offset_t vaddr;
 671
 672                 /*
 673                  * For ISA dma, we use the chipset's scatter-gather
 674                  * map to map the tranfer into the ISA reachable range
 675                  * of the bus address space.
 676                  */
 677                 vaddr = trunc_page((vm_offset_t) buf);
 678                 dmat->segments = &segment;
 679                 dmat->segments[0].ds_addr =
 680                         map->busaddress + (vm_offset_t) buf - vaddr;
 681                 dmat->segments[0].ds_len = buflen;
 682                 buflen = round_page((vm_offset_t) buf + buflen) - vaddr;
 683                 sgmap_load_region(chipset.sgmap,
 684                                   map->busaddress,
 685                                   vaddr,
 686                                   buflen);
 687                 map->buflen = buflen;
 688                 (*callback)(callback_arg, dmat->segments, 1, 0);
 689                 dmat->segments = NULL;
 690
 691                 return (0);
 692         }
 693
 694         if (map != &nobounce_dmamap) {
 695                 flags |= BUS_DMA_WAITOK;
 696                 map->callback = callback;
 697                 map->callback_arg = callback_arg;
 698         }
 699
 700         error = _bus_dmamap_load_buffer(dmat, map, buf, buflen, NULL, flags,
 701              &lastaddr, dmat->segments, &nsegs, 1);
 702
 703         if (error == EINPROGRESS) {
 704                 return (error);
 705         }
 706
 707         if (error)
 708                 (*callback)(callback_arg, dmat->segments, 0, error);
 709         else
 710                 (*callback)(callback_arg, dmat->segments, nsegs + 1, 0);
 711
 712         /*
 713          * Return ENOMEM to the caller so that it can pass it up the stack.
 714          * This error only happens when NOWAIT is set, so deferal is disabled.
 715          */
 716         if (error == ENOMEM)
 717                 return (error);
 718
 719         return (0);
 720 }
 721
 722 /*
 723  * Like _bus_dmamap_load(), but for mbufs.
 724  */
 725 int
 726 bus_dmamap_load_mbuf(bus_dma_tag_t dmat, bus_dmamap_t map,
 727                      struct mbuf *m0,
 728                      bus_dmamap_callback2_t *callback, void *callback_arg,
 729                      int flags)
 730 {
 731         int nsegs, error;
 732
 733         M_ASSERTPKTHDR(m0);
 734
 735         flags |= BUS_DMA_NOWAIT;
 736         nsegs = 0;
 737         error = 0;
 738         if (m0->m_pkthdr.len <= dmat->maxsize) {
 739                 int first = 1;
 740                 bus_addr_t lastaddr = 0;
 741                 struct mbuf *m;
 742
 743                 for (m = m0; m != NULL && error == 0; m = m->m_next) {
 744                         if (m->m_len > 0) {
 745                                 error = _bus_dmamap_load_buffer(dmat, map,
 746                                                 m->m_data, m->m_len,
 747                                                 NULL, flags, &lastaddr,
 748                                                 dmat->segments, &nsegs, first);
 749                                 first = 0;
 750                         }
 751                 }
 752         } else {
 753                 error = EINVAL;
 754         }
 755
 756         if (error) {
 757                 /* force "no valid mappings" in callback */
 758                 (*callback)(callback_arg, dmat->segments, 0, 0, error);
 759         } else {
 760                 (*callback)(callback_arg, dmat->segments,
 761                             nsegs+1, m0->m_pkthdr.len, error);
 762         }
 763         return (error);
 764 }
 765
 766 int
 767 bus_dmamap_load_mbuf_sg(bus_dma_tag_t dmat, bus_dmamap_t map,
 768                         struct mbuf *m0, bus_dma_segment_t *segs,
 769                         int *nsegs, int flags)
 770 {
 771         int error;
 772
 773         M_ASSERTPKTHDR(m0);
 774
 775         flags |= BUS_DMA_NOWAIT;
 776         *nsegs = 0;
 777         error = 0;
 778         if (m0->m_pkthdr.len <= dmat->maxsize) {
 779                 int first = 1;
 780                 bus_addr_t lastaddr = 0;
 781                 struct mbuf *m;
 782
 783                 for (m = m0; m != NULL && error == 0; m = m->m_next) {
 784                         if (m->m_len > 0) {
 785                                 error = _bus_dmamap_load_buffer(dmat, map,
 786                                                 m->m_data, m->m_len,
 787                                                 NULL, flags, &lastaddr,
 788                                                 segs, nsegs, first);
 789                                 first = 0;
 790                         }
 791                 }
 792                 ++*nsegs;
 793         } else {
 794                 error = EINVAL;
 795         }
 796
 797         return (error);
 798 }
 799
 800 /*
 801  * Like _bus_dmamap_load(), but for uios.
 802  */
 803 int
 804 bus_dmamap_load_uio(bus_dma_tag_t dmat, bus_dmamap_t map,
 805                     struct uio *uio,
 806                     bus_dmamap_callback2_t *callback, void *callback_arg,
 807                     int flags)
 808 {
 809         bus_addr_t lastaddr;
 810         int nsegs, error, first, i;
 811         bus_size_t resid;
 812         struct iovec *iov;
 813         pmap_t pmap;
 814
 815         flags |= BUS_DMA_NOWAIT;
 816         resid = uio->uio_resid;
 817         iov = uio->uio_iov;
 818
 819         if (uio->uio_segflg == UIO_USERSPACE) {
 820                 KASSERT(uio->uio_td != NULL,
 821                         ("bus_dmamap_load_uio: USERSPACE but no proc"));
 822                 pmap = vmspace_pmap(uio->uio_td->td_proc->p_vmspace);
 823         } else
 824                 pmap = NULL;
 825
 826         nsegs = 0;
 827         error = 0;
 828         first = 1;
 829         for (i = 0; i < uio->uio_iovcnt && resid != 0 && !error; i++) {
 830                 /*
 831                  * Now at the first iovec to load.  Load each iovec
 832                  * until we have exhausted the residual count.
 833                  */
 834                 bus_size_t minlen =
 835                         resid < iov[i].iov_len ? resid : iov[i].iov_len;
 836                 caddr_t addr = (caddr_t) iov[i].iov_base;
 837
 838                 if (minlen > 0) {
 839                         error = _bus_dmamap_load_buffer(dmat, map,
 840                             addr, minlen, pmap, flags, &lastaddr,
 841                             dmat->segments, &nsegs, first);
 842                         first = 0;
 843
 844                         resid -= minlen;
 845                 }
 846         }
 847
 848         if (error) {
 849                 /* force "no valid mappings" in callback */
 850                 (*callback)(callback_arg, dmat->segments, 0, 0, error);
 851         } else {
 852                 (*callback)(callback_arg, dmat->segments,
 853                             nsegs+1, uio->uio_resid, error);
 854         }
 855         return (error);
 856 }
 857
 858 /*
 859  * Release the mapping held by map.
 860  */
 861 void
 862 _bus_dmamap_unload(bus_dma_tag_t dmat, bus_dmamap_t map)
 863 {
 864         struct bounce_page *bpage;
 865
 866         if ((dmat->flags & BUS_DMA_ISA) && chipset.sgmap != NULL) {
 867                 sgmap_unload_region(chipset.sgmap,
 868                                     map->busaddress,
 869                                     map->buflen);
 870                 return;
 871         }
 872
 873         while ((bpage = STAILQ_FIRST(&map->bpages)) != NULL) {
 874                 STAILQ_REMOVE_HEAD(&map->bpages, links);
 875                 free_bounce_page(dmat, bpage);
 876         }
 877 }
 878
 879 void
 880 _bus_dmamap_sync(bus_dma_tag_t dmat, bus_dmamap_t map, bus_dmasync_op_t op)
 881 {
 882         struct bounce_page *bpage;
 883
 884         if ((bpage = STAILQ_FIRST(&map->bpages)) != NULL) {
 885                 /*
 886                  * Handle data bouncing.  We might also
 887                  * want to add support for invalidating
 888                  * the caches on broken hardware
 889                  */
 890                 if (op & BUS_DMASYNC_PREWRITE) {
 891                         while (bpage != NULL) {
 892                                 bcopy((void *)bpage->datavaddr,
 893                                       (void *)bpage->vaddr,
 894                                       bpage->datacount);
 895                                 bpage = STAILQ_NEXT(bpage, links);
 896                         }
 897                 }
 898
 899                 if (op & BUS_DMASYNC_POSTREAD) {
 900                         while (bpage != NULL) {
 901                                 bcopy((void *)bpage->vaddr,
 902                                       (void *)bpage->datavaddr,
 903                                       bpage->datacount);
 904                                 bpage = STAILQ_NEXT(bpage, links);
 905                         }
 906                 }
 907         }
 908
 909         /* Ensure any pending writes have drained. */
 910         if (op & (BUS_DMASYNC_PREWRITE))
 911                 alpha_mb();
 912 }
 913
 914 static void
 915 init_bounce_pages(void *dummy __unused)
 916 {
 917
 918         free_bpages = 0;
 919         reserved_bpages = 0;
 920         active_bpages = 0;
 921         total_bpages = 0;
 922         STAILQ_INIT(&bounce_page_list);
 923         STAILQ_INIT(&bounce_map_waitinglist);
 924         STAILQ_INIT(&bounce_map_callbacklist);
 925         mtx_init(&bounce_lock, "bounce pages lock", NULL, MTX_DEF);
 926 }
 927 SYSINIT(bpages, SI_SUB_LOCK, SI_ORDER_ANY, init_bounce_pages, NULL);
 928
 929 static int
 930 alloc_bounce_pages(bus_dma_tag_t dmat, u_int numpages)
 931 {
 932         int count;
 933
 934         count = 0;
 935         while (numpages > 0) {
 936                 struct bounce_page *bpage;
 937
 938                 bpage = (struct bounce_page *)malloc(sizeof(*bpage), M_DEVBUF,
 939                                                      M_NOWAIT | M_ZERO);
 940
 941                 if (bpage == NULL)
 942                         break;
 943                 bpage->vaddr = (vm_offset_t)contigmalloc(PAGE_SIZE, M_DEVBUF,
 944                                                          M_NOWAIT, 0ul,
 945                                                          dmat->lowaddr,
 946                                                          PAGE_SIZE,
 947                                                          dmat->boundary);
 948                 if (bpage->vaddr == 0) {
 949                         free(bpage, M_DEVBUF);
 950                         break;
 951                 }
 952                 bpage->busaddr = pmap_kextract(bpage->vaddr);
 953                 mtx_lock(&bounce_lock);
 954                 STAILQ_INSERT_TAIL(&bounce_page_list, bpage, links);
 955                 total_bpages++;
 956                 free_bpages++;
 957                 mtx_unlock(&bounce_lock);
 958                 count++;
 959                 numpages--;
 960         }
 961         return (count);
 962 }
 963
 964 static int
 965 reserve_bounce_pages(bus_dma_tag_t dmat, bus_dmamap_t map, int commit)
 966 {
 967         int pages;
 968
 969         mtx_assert(&bounce_lock, MA_OWNED);
 970         pages = MIN(free_bpages, map->pagesneeded - map->pagesreserved);
 971         if (commit == 0 && map->pagesneeded > (map->pagesreserved + pages))
 972                 return (map->pagesneeded - (map->pagesreserved + pages));
 973         free_bpages -= pages;
 974         reserved_bpages += pages;
 975         map->pagesreserved += pages;
 976         pages = map->pagesneeded - map->pagesreserved;
 977
 978         return (pages);
 979 }
 980
 981 static bus_addr_t
 982 add_bounce_page(bus_dma_tag_t dmat, bus_dmamap_t map, vm_offset_t vaddr,
 983                 bus_size_t size)
 984 {
 985         struct bounce_page *bpage;
 986
 987         if (map->pagesneeded == 0)
 988                 panic("add_bounce_page: map doesn't need any pages");
 989         map->pagesneeded--;
 990
 991         if (map->pagesreserved == 0)
 992                 panic("add_bounce_page: map doesn't need any pages");
 993         map->pagesreserved--;
 994
 995         mtx_lock(&bounce_lock);
 996         bpage = STAILQ_FIRST(&bounce_page_list);
 997         if (bpage == NULL)
 998                 panic("add_bounce_page: free page list is empty");
 999
1000         STAILQ_REMOVE_HEAD(&bounce_page_list, links);
1001         reserved_bpages--;
1002         active_bpages++;
1003         mtx_unlock(&bounce_lock);
1004
1005         bpage->datavaddr = vaddr;
1006         bpage->datacount = size;
1007         STAILQ_INSERT_TAIL(&(map->bpages), bpage, links);
1008         return (bpage->busaddr);
1009 }
1010
1011 static void
1012 free_bounce_page(bus_dma_tag_t dmat, struct bounce_page *bpage)
1013 {
1014         struct bus_dmamap *map;
1015
1016         bpage->datavaddr = 0;
1017         bpage->datacount = 0;
1018
1019         mtx_lock(&bounce_lock);
1020         STAILQ_INSERT_HEAD(&bounce_page_list, bpage, links);
1021         free_bpages++;
1022         active_bpages--;
1023         if ((map = STAILQ_FIRST(&bounce_map_waitinglist)) != NULL) {
1024                 if (reserve_bounce_pages(map->dmat, map, 1) == 0) {
1025                         STAILQ_REMOVE_HEAD(&bounce_map_waitinglist, links);
1026                         STAILQ_INSERT_TAIL(&bounce_map_callbacklist,
1027                                            map, links);
1028                         busdma_swi_pending = 1;
1029                         swi_sched(vm_ih, 0);
1030                 }
1031         }
1032         mtx_unlock(&bounce_lock);
1033 }
1034
1035 void
1036 busdma_swi(void)
1037 {
1038         bus_dma_tag_t dmat;
1039         struct bus_dmamap *map;
1040
1041         mtx_lock(&bounce_lock);
1042         while ((map = STAILQ_FIRST(&bounce_map_callbacklist)) != NULL) {
1043                 STAILQ_REMOVE_HEAD(&bounce_map_callbacklist, links);
1044                 mtx_unlock(&bounce_lock);
1045                 dmat = map->dmat;
1046                 (dmat->lockfunc)(dmat->lockfuncarg, BUS_DMA_LOCK);
1047                 bus_dmamap_load(map->dmat, map, map->buf, map->buflen,
1048                                 map->callback, map->callback_arg, /*flags*/0);
1049                 (dmat->lockfunc)(dmat->lockfuncarg, BUS_DMA_UNLOCK);
1050                 mtx_lock(&bounce_lock);
1051         }
1052         mtx_unlock(&bounce_lock);
1053 }