SAFE public projects git trees. - safe/jmp/linux-2.6/blob - arch/alpha/kernel/pci_iommu.c

   1 /*
   2  *      linux/arch/alpha/kernel/pci_iommu.c
   3  */
   4
   5 #include <linux/kernel.h>
   6 #include <linux/mm.h>
   7 #include <linux/pci.h>
   8 #include <linux/slab.h>
   9 #include <linux/bootmem.h>
  10 #include <linux/scatterlist.h>
  11 #include <linux/log2.h>
  12 #include <linux/dma-mapping.h>
  13
  14 #include <asm/io.h>
  15 #include <asm/hwrpb.h>
  16
  17 #include "proto.h"
  18 #include "pci_impl.h"
  19
  20
  21 #define DEBUG_ALLOC 0
  22 #if DEBUG_ALLOC > 0
  23 # define DBGA(args...)          printk(KERN_DEBUG args)
  24 #else
  25 # define DBGA(args...)
  26 #endif
  27 #if DEBUG_ALLOC > 1
  28 # define DBGA2(args...)         printk(KERN_DEBUG args)
  29 #else
  30 # define DBGA2(args...)
  31 #endif
  32
  33 #define DEBUG_NODIRECT 0
  34
  35 #define ISA_DMA_MASK            0x00ffffff
  36
  37 static inline unsigned long
  38 mk_iommu_pte(unsigned long paddr)
  39 {
  40         return (paddr >> (PAGE_SHIFT-1)) | 1;
  41 }
  42
  43 static inline long
  44 calc_npages(long bytes)
  45 {
  46         return (bytes + PAGE_SIZE - 1) >> PAGE_SHIFT;
  47 }
  48 \f
  49
  50 /* Return the minimum of MAX or the first power of two larger
  51    than main memory.  */
  52
  53 unsigned long
  54 size_for_memory(unsigned long max)
  55 {
  56         unsigned long mem = max_low_pfn << PAGE_SHIFT;
  57         if (mem < max)
  58                 max = roundup_pow_of_two(mem);
  59         return max;
  60 }
  61 \f
  62 struct pci_iommu_arena * __init
  63 iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base,
  64                      unsigned long window_size, unsigned long align)
  65 {
  66         unsigned long mem_size;
  67         struct pci_iommu_arena *arena;
  68
  69         mem_size = window_size / (PAGE_SIZE / sizeof(unsigned long));
  70
  71         /* Note that the TLB lookup logic uses bitwise concatenation,
  72            not addition, so the required arena alignment is based on
  73            the size of the window.  Retain the align parameter so that
  74            particular systems can over-align the arena.  */
  75         if (align < mem_size)
  76                 align = mem_size;
  77
  78
  79 #ifdef CONFIG_DISCONTIGMEM
  80
  81         if (!NODE_DATA(nid) ||
  82             (NULL == (arena = alloc_bootmem_node(NODE_DATA(nid),
  83                                                  sizeof(*arena))))) {
  84                 printk("%s: couldn't allocate arena from node %d\n"
  85                        "    falling back to system-wide allocation\n",
  86                        __FUNCTION__, nid);
  87                 arena = alloc_bootmem(sizeof(*arena));
  88         }
  89
  90         if (!NODE_DATA(nid) ||
  91             (NULL == (arena->ptes = __alloc_bootmem_node(NODE_DATA(nid),
  92                                                          mem_size,
  93                                                          align,
  94                                                          0)))) {
  95                 printk("%s: couldn't allocate arena ptes from node %d\n"
  96                        "    falling back to system-wide allocation\n",
  97                        __FUNCTION__, nid);
  98                 arena->ptes = __alloc_bootmem(mem_size, align, 0);
  99         }
 100
 101 #else /* CONFIG_DISCONTIGMEM */
 102
 103         arena = alloc_bootmem(sizeof(*arena));
 104         arena->ptes = __alloc_bootmem(mem_size, align, 0);
 105
 106 #endif /* CONFIG_DISCONTIGMEM */
 107
 108         spin_lock_init(&arena->lock);
 109         arena->hose = hose;
 110         arena->dma_base = base;
 111         arena->size = window_size;
 112         arena->next_entry = 0;
 113
 114         /* Align allocations to a multiple of a page size.  Not needed
 115            unless there are chip bugs.  */
 116         arena->align_entry = 1;
 117
 118         return arena;
 119 }
 120
 121 struct pci_iommu_arena * __init
 122 iommu_arena_new(struct pci_controller *hose, dma_addr_t base,
 123                 unsigned long window_size, unsigned long align)
 124 {
 125         return iommu_arena_new_node(0, hose, base, window_size, align);
 126 }
 127
 128 static inline int is_span_boundary(unsigned int index, unsigned int nr,
 129                                    unsigned long shift,
 130                                    unsigned long boundary_size)
 131 {
 132         shift = (shift + index) & (boundary_size - 1);
 133         return shift + nr > boundary_size;
 134 }
 135
 136 /* Must be called with the arena lock held */
 137 static long
 138 iommu_arena_find_pages(struct device *dev, struct pci_iommu_arena *arena,
 139                        long n, long mask)
 140 {
 141         unsigned long *ptes;
 142         long i, p, nent;
 143         int pass = 0;
 144         unsigned long base;
 145         unsigned long boundary_size;
 146
 147         BUG_ON(arena->dma_base & ~PAGE_MASK);
 148         base = arena->dma_base >> PAGE_SHIFT;
 149         if (dev)
 150                 boundary_size = ALIGN(dma_get_max_seg_size(dev) + 1, PAGE_SIZE)
 151                         >> PAGE_SHIFT;
 152         else
 153                 boundary_size = ALIGN(1UL << 32, PAGE_SIZE) >> PAGE_SHIFT;
 154
 155         BUG_ON(!is_power_of_2(boundary_size));
 156
 157         /* Search forward for the first mask-aligned sequence of N free ptes */
 158         ptes = arena->ptes;
 159         nent = arena->size >> PAGE_SHIFT;
 160         p = ALIGN(arena->next_entry, mask + 1);
 161         i = 0;
 162
 163 again:
 164         while (i < n && p+i < nent) {
 165                 if (!i && is_span_boundary(p, n, base, boundary_size)) {
 166                         p = ALIGN(p + 1, mask + 1);
 167                         goto again;
 168                 }
 169
 170                 if (ptes[p+i])
 171                         p = ALIGN(p + i + 1, mask + 1), i = 0;
 172                 else
 173                         i = i + 1;
 174         }
 175
 176         if (i < n) {
 177                 if (pass < 1) {
 178                         /*
 179                          * Reached the end.  Flush the TLB and restart
 180                          * the search from the beginning.
 181                         */
 182                         alpha_mv.mv_pci_tbi(arena->hose, 0, -1);
 183
 184                         pass++;
 185                         p = 0;
 186                         i = 0;
 187                         goto again;
 188                 } else
 189                         return -1;
 190         }
 191
 192         /* Success. It's the responsibility of the caller to mark them
 193            in use before releasing the lock */
 194         return p;
 195 }
 196
 197 static long
 198 iommu_arena_alloc(struct device *dev, struct pci_iommu_arena *arena, long n,
 199                   unsigned int align)
 200 {
 201         unsigned long flags;
 202         unsigned long *ptes;
 203         long i, p, mask;
 204
 205         spin_lock_irqsave(&arena->lock, flags);
 206
 207         /* Search for N empty ptes */
 208         ptes = arena->ptes;
 209         mask = max(align, arena->align_entry) - 1;
 210         p = iommu_arena_find_pages(dev, arena, n, mask);
 211         if (p < 0) {
 212                 spin_unlock_irqrestore(&arena->lock, flags);
 213                 return -1;
 214         }
 215
 216         /* Success.  Mark them all in use, ie not zero and invalid
 217            for the iommu tlb that could load them from under us.
 218            The chip specific bits will fill this in with something
 219            kosher when we return.  */
 220         for (i = 0; i < n; ++i)
 221                 ptes[p+i] = IOMMU_INVALID_PTE;
 222
 223         arena->next_entry = p + n;
 224         spin_unlock_irqrestore(&arena->lock, flags);
 225
 226         return p;
 227 }
 228
 229 static void
 230 iommu_arena_free(struct pci_iommu_arena *arena, long ofs, long n)
 231 {
 232         unsigned long *p;
 233         long i;
 234
 235         p = arena->ptes + ofs;
 236         for (i = 0; i < n; ++i)
 237                 p[i] = 0;
 238 }
 239 \f
 240 /* True if the machine supports DAC addressing, and DEV can
 241    make use of it given MASK.  */
 242 static int pci_dac_dma_supported(struct pci_dev *hwdev, u64 mask);
 243
 244 /* Map a single buffer of the indicated size for PCI DMA in streaming
 245    mode.  The 32-bit PCI bus mastering address to use is returned.
 246    Once the device is given the dma address, the device owns this memory
 247    until either pci_unmap_single or pci_dma_sync_single is performed.  */
 248
 249 static dma_addr_t
 250 pci_map_single_1(struct pci_dev *pdev, void *cpu_addr, size_t size,
 251                  int dac_allowed)
 252 {
 253         struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;
 254         dma_addr_t max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
 255         struct pci_iommu_arena *arena;
 256         long npages, dma_ofs, i;
 257         unsigned long paddr;
 258         dma_addr_t ret;
 259         unsigned int align = 0;
 260         struct device *dev = pdev ? &pdev->dev : NULL;
 261
 262         paddr = __pa(cpu_addr);
 263
 264 #if !DEBUG_NODIRECT
 265         /* First check to see if we can use the direct map window.  */
 266         if (paddr + size + __direct_map_base - 1 <= max_dma
 267             && paddr + size <= __direct_map_size) {
 268                 ret = paddr + __direct_map_base;
 269
 270                 DBGA2("pci_map_single: [%p,%lx] -> direct %lx from %p\n",
 271                       cpu_addr, size, ret, __builtin_return_address(0));
 272
 273                 return ret;
 274         }
 275 #endif
 276
 277         /* Next, use DAC if selected earlier.  */
 278         if (dac_allowed) {
 279                 ret = paddr + alpha_mv.pci_dac_offset;
 280
 281                 DBGA2("pci_map_single: [%p,%lx] -> DAC %lx from %p\n",
 282                       cpu_addr, size, ret, __builtin_return_address(0));
 283
 284                 return ret;
 285         }
 286
 287         /* If the machine doesn't define a pci_tbi routine, we have to
 288            assume it doesn't support sg mapping, and, since we tried to
 289            use direct_map above, it now must be considered an error. */
 290         if (! alpha_mv.mv_pci_tbi) {
 291                 static int been_here = 0; /* Only print the message once. */
 292                 if (!been_here) {
 293                     printk(KERN_WARNING "pci_map_single: no HW sg\n");
 294                     been_here = 1;
 295                 }
 296                 return 0;
 297         }
 298
 299         arena = hose->sg_pci;
 300         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
 301                 arena = hose->sg_isa;
 302
 303         npages = calc_npages((paddr & ~PAGE_MASK) + size);
 304
 305         /* Force allocation to 64KB boundary for ISA bridges. */
 306         if (pdev && pdev == isa_bridge)
 307                 align = 8;
 308         dma_ofs = iommu_arena_alloc(dev, arena, npages, align);
 309         if (dma_ofs < 0) {
 310                 printk(KERN_WARNING "pci_map_single failed: "
 311                        "could not allocate dma page tables\n");
 312                 return 0;
 313         }
 314
 315         paddr &= PAGE_MASK;
 316         for (i = 0; i < npages; ++i, paddr += PAGE_SIZE)
 317                 arena->ptes[i + dma_ofs] = mk_iommu_pte(paddr);
 318
 319         ret = arena->dma_base + dma_ofs * PAGE_SIZE;
 320         ret += (unsigned long)cpu_addr & ~PAGE_MASK;
 321
 322         DBGA2("pci_map_single: [%p,%lx] np %ld -> sg %lx from %p\n",
 323               cpu_addr, size, npages, ret, __builtin_return_address(0));
 324
 325         return ret;
 326 }
 327
 328 dma_addr_t
 329 pci_map_single(struct pci_dev *pdev, void *cpu_addr, size_t size, int dir)
 330 {
 331         int dac_allowed;
 332
 333         if (dir == PCI_DMA_NONE)
 334                 BUG();
 335
 336         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
 337         return pci_map_single_1(pdev, cpu_addr, size, dac_allowed);
 338 }
 339 EXPORT_SYMBOL(pci_map_single);
 340
 341 dma_addr_t
 342 pci_map_page(struct pci_dev *pdev, struct page *page, unsigned long offset,
 343              size_t size, int dir)
 344 {
 345         int dac_allowed;
 346
 347         if (dir == PCI_DMA_NONE)
 348                 BUG();
 349
 350         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
 351         return pci_map_single_1(pdev, (char *)page_address(page) + offset,
 352                                 size, dac_allowed);
 353 }
 354 EXPORT_SYMBOL(pci_map_page);
 355
 356 /* Unmap a single streaming mode DMA translation.  The DMA_ADDR and
 357    SIZE must match what was provided for in a previous pci_map_single
 358    call.  All other usages are undefined.  After this call, reads by
 359    the cpu to the buffer are guaranteed to see whatever the device
 360    wrote there.  */
 361
 362 void
 363 pci_unmap_single(struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
 364                  int direction)
 365 {
 366         unsigned long flags;
 367         struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;
 368         struct pci_iommu_arena *arena;
 369         long dma_ofs, npages;
 370
 371         if (direction == PCI_DMA_NONE)
 372                 BUG();
 373
 374         if (dma_addr >= __direct_map_base
 375             && dma_addr < __direct_map_base + __direct_map_size) {
 376                 /* Nothing to do.  */
 377
 378                 DBGA2("pci_unmap_single: direct [%lx,%lx] from %p\n",
 379                       dma_addr, size, __builtin_return_address(0));
 380
 381                 return;
 382         }
 383
 384         if (dma_addr > 0xffffffff) {
 385                 DBGA2("pci64_unmap_single: DAC [%lx,%lx] from %p\n",
 386                       dma_addr, size, __builtin_return_address(0));
 387                 return;
 388         }
 389
 390         arena = hose->sg_pci;
 391         if (!arena || dma_addr < arena->dma_base)
 392                 arena = hose->sg_isa;
 393
 394         dma_ofs = (dma_addr - arena->dma_base) >> PAGE_SHIFT;
 395         if (dma_ofs * PAGE_SIZE >= arena->size) {
 396                 printk(KERN_ERR "Bogus pci_unmap_single: dma_addr %lx "
 397                        " base %lx size %x\n", dma_addr, arena->dma_base,
 398                        arena->size);
 399                 return;
 400                 BUG();
 401         }
 402
 403         npages = calc_npages((dma_addr & ~PAGE_MASK) + size);
 404
 405         spin_lock_irqsave(&arena->lock, flags);
 406
 407         iommu_arena_free(arena, dma_ofs, npages);
 408
 409         /* If we're freeing ptes above the `next_entry' pointer (they
 410            may have snuck back into the TLB since the last wrap flush),
 411            we need to flush the TLB before reallocating the latter.  */
 412         if (dma_ofs >= arena->next_entry)
 413                 alpha_mv.mv_pci_tbi(hose, dma_addr, dma_addr + size - 1);
 414
 415         spin_unlock_irqrestore(&arena->lock, flags);
 416
 417         DBGA2("pci_unmap_single: sg [%lx,%lx] np %ld from %p\n",
 418               dma_addr, size, npages, __builtin_return_address(0));
 419 }
 420 EXPORT_SYMBOL(pci_unmap_single);
 421
 422 void
 423 pci_unmap_page(struct pci_dev *pdev, dma_addr_t dma_addr,
 424                size_t size, int direction)
 425 {
 426         pci_unmap_single(pdev, dma_addr, size, direction);
 427 }
 428 EXPORT_SYMBOL(pci_unmap_page);
 429
 430 /* Allocate and map kernel buffer using consistent mode DMA for PCI
 431    device.  Returns non-NULL cpu-view pointer to the buffer if
 432    successful and sets *DMA_ADDRP to the pci side dma address as well,
 433    else DMA_ADDRP is undefined.  */
 434
 435 void *
 436 pci_alloc_consistent(struct pci_dev *pdev, size_t size, dma_addr_t *dma_addrp)
 437 {
 438         void *cpu_addr;
 439         long order = get_order(size);
 440         gfp_t gfp = GFP_ATOMIC;
 441
 442 try_again:
 443         cpu_addr = (void *)__get_free_pages(gfp, order);
 444         if (! cpu_addr) {
 445                 printk(KERN_INFO "pci_alloc_consistent: "
 446                        "get_free_pages failed from %p\n",
 447                         __builtin_return_address(0));
 448                 /* ??? Really atomic allocation?  Otherwise we could play
 449                    with vmalloc and sg if we can't find contiguous memory.  */
 450                 return NULL;
 451         }
 452         memset(cpu_addr, 0, size);
 453
 454         *dma_addrp = pci_map_single_1(pdev, cpu_addr, size, 0);
 455         if (*dma_addrp == 0) {
 456                 free_pages((unsigned long)cpu_addr, order);
 457                 if (alpha_mv.mv_pci_tbi || (gfp & GFP_DMA))
 458                         return NULL;
 459                 /* The address doesn't fit required mask and we
 460                    do not have iommu. Try again with GFP_DMA. */
 461                 gfp |= GFP_DMA;
 462                 goto try_again;
 463         }
 464
 465         DBGA2("pci_alloc_consistent: %lx -> [%p,%x] from %p\n",
 466               size, cpu_addr, *dma_addrp, __builtin_return_address(0));
 467
 468         return cpu_addr;
 469 }
 470 EXPORT_SYMBOL(pci_alloc_consistent);
 471
 472 /* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must
 473    be values that were returned from pci_alloc_consistent.  SIZE must
 474    be the same as what as passed into pci_alloc_consistent.
 475    References to the memory and mappings associated with CPU_ADDR or
 476    DMA_ADDR past this call are illegal.  */
 477
 478 void
 479 pci_free_consistent(struct pci_dev *pdev, size_t size, void *cpu_addr,
 480                     dma_addr_t dma_addr)
 481 {
 482         pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL);
 483         free_pages((unsigned long)cpu_addr, get_order(size));
 484
 485         DBGA2("pci_free_consistent: [%x,%lx] from %p\n",
 486               dma_addr, size, __builtin_return_address(0));
 487 }
 488 EXPORT_SYMBOL(pci_free_consistent);
 489
 490 /* Classify the elements of the scatterlist.  Write dma_address
 491    of each element with:
 492         0   : Followers all physically adjacent.
 493         1   : Followers all virtually adjacent.
 494         -1  : Not leader, physically adjacent to previous.
 495         -2  : Not leader, virtually adjacent to previous.
 496    Write dma_length of each leader with the combined lengths of
 497    the mergable followers.  */
 498
 499 #define SG_ENT_VIRT_ADDRESS(SG) (sg_virt((SG)))
 500 #define SG_ENT_PHYS_ADDRESS(SG) __pa(SG_ENT_VIRT_ADDRESS(SG))
 501
 502 static void
 503 sg_classify(struct device *dev, struct scatterlist *sg, struct scatterlist *end,
 504             int virt_ok)
 505 {
 506         unsigned long next_paddr;
 507         struct scatterlist *leader;
 508         long leader_flag, leader_length;
 509         unsigned int max_seg_size;
 510
 511         leader = sg;
 512         leader_flag = 0;
 513         leader_length = leader->length;
 514         next_paddr = SG_ENT_PHYS_ADDRESS(leader) + leader_length;
 515
 516         /* we will not marge sg without device. */
 517         max_seg_size = dev ? dma_get_max_seg_size(dev) : 0;
 518         for (++sg; sg < end; ++sg) {
 519                 unsigned long addr, len;
 520                 addr = SG_ENT_PHYS_ADDRESS(sg);
 521                 len = sg->length;
 522
 523                 if (leader_length + len > max_seg_size)
 524                         goto new_segment;
 525
 526                 if (next_paddr == addr) {
 527                         sg->dma_address = -1;
 528                         leader_length += len;
 529                 } else if (((next_paddr | addr) & ~PAGE_MASK) == 0 && virt_ok) {
 530                         sg->dma_address = -2;
 531                         leader_flag = 1;
 532                         leader_length += len;
 533                 } else {
 534 new_segment:
 535                         leader->dma_address = leader_flag;
 536                         leader->dma_length = leader_length;
 537                         leader = sg;
 538                         leader_flag = 0;
 539                         leader_length = len;
 540                 }
 541
 542                 next_paddr = addr + len;
 543         }
 544
 545         leader->dma_address = leader_flag;
 546         leader->dma_length = leader_length;
 547 }
 548
 549 /* Given a scatterlist leader, choose an allocation method and fill
 550    in the blanks.  */
 551
 552 static int
 553 sg_fill(struct device *dev, struct scatterlist *leader, struct scatterlist *end,
 554         struct scatterlist *out, struct pci_iommu_arena *arena,
 555         dma_addr_t max_dma, int dac_allowed)
 556 {
 557         unsigned long paddr = SG_ENT_PHYS_ADDRESS(leader);
 558         long size = leader->dma_length;
 559         struct scatterlist *sg;
 560         unsigned long *ptes;
 561         long npages, dma_ofs, i;
 562
 563 #if !DEBUG_NODIRECT
 564         /* If everything is physically contiguous, and the addresses
 565            fall into the direct-map window, use it.  */
 566         if (leader->dma_address == 0
 567             && paddr + size + __direct_map_base - 1 <= max_dma
 568             && paddr + size <= __direct_map_size) {
 569                 out->dma_address = paddr + __direct_map_base;
 570                 out->dma_length = size;
 571
 572                 DBGA("    sg_fill: [%p,%lx] -> direct %lx\n",
 573                      __va(paddr), size, out->dma_address);
 574
 575                 return 0;
 576         }
 577 #endif
 578
 579         /* If physically contiguous and DAC is available, use it.  */
 580         if (leader->dma_address == 0 && dac_allowed) {
 581                 out->dma_address = paddr + alpha_mv.pci_dac_offset;
 582                 out->dma_length = size;
 583
 584                 DBGA("    sg_fill: [%p,%lx] -> DAC %lx\n",
 585                      __va(paddr), size, out->dma_address);
 586
 587                 return 0;
 588         }
 589
 590         /* Otherwise, we'll use the iommu to make the pages virtually
 591            contiguous.  */
 592
 593         paddr &= ~PAGE_MASK;
 594         npages = calc_npages(paddr + size);
 595         dma_ofs = iommu_arena_alloc(dev, arena, npages, 0);
 596         if (dma_ofs < 0) {
 597                 /* If we attempted a direct map above but failed, die.  */
 598                 if (leader->dma_address == 0)
 599                         return -1;
 600
 601                 /* Otherwise, break up the remaining virtually contiguous
 602                    hunks into individual direct maps and retry.  */
 603                 sg_classify(dev, leader, end, 0);
 604                 return sg_fill(dev, leader, end, out, arena, max_dma, dac_allowed);
 605         }
 606
 607         out->dma_address = arena->dma_base + dma_ofs*PAGE_SIZE + paddr;
 608         out->dma_length = size;
 609
 610         DBGA("    sg_fill: [%p,%lx] -> sg %lx np %ld\n",
 611              __va(paddr), size, out->dma_address, npages);
 612
 613         /* All virtually contiguous.  We need to find the length of each
 614            physically contiguous subsegment to fill in the ptes.  */
 615         ptes = &arena->ptes[dma_ofs];
 616         sg = leader;
 617         do {
 618 #if DEBUG_ALLOC > 0
 619                 struct scatterlist *last_sg = sg;
 620 #endif
 621
 622                 size = sg->length;
 623                 paddr = SG_ENT_PHYS_ADDRESS(sg);
 624
 625                 while (sg+1 < end && (int) sg[1].dma_address == -1) {
 626                         size += sg[1].length;
 627                         sg++;
 628                 }
 629
 630                 npages = calc_npages((paddr & ~PAGE_MASK) + size);
 631
 632                 paddr &= PAGE_MASK;
 633                 for (i = 0; i < npages; ++i, paddr += PAGE_SIZE)
 634                         *ptes++ = mk_iommu_pte(paddr);
 635
 636 #if DEBUG_ALLOC > 0
 637                 DBGA("    (%ld) [%p,%x] np %ld\n",
 638                      last_sg - leader, SG_ENT_VIRT_ADDRESS(last_sg),
 639                      last_sg->length, npages);
 640                 while (++last_sg <= sg) {
 641                         DBGA("        (%ld) [%p,%x] cont\n",
 642                              last_sg - leader, SG_ENT_VIRT_ADDRESS(last_sg),
 643                              last_sg->length);
 644                 }
 645 #endif
 646         } while (++sg < end && (int) sg->dma_address < 0);
 647
 648         return 1;
 649 }
 650
 651 int
 652 pci_map_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
 653            int direction)
 654 {
 655         struct scatterlist *start, *end, *out;
 656         struct pci_controller *hose;
 657         struct pci_iommu_arena *arena;
 658         dma_addr_t max_dma;
 659         int dac_allowed;
 660         struct device *dev;
 661
 662         if (direction == PCI_DMA_NONE)
 663                 BUG();
 664
 665         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
 666
 667         dev = pdev ? &pdev->dev : NULL;
 668
 669         /* Fast path single entry scatterlists.  */
 670         if (nents == 1) {
 671                 sg->dma_length = sg->length;
 672                 sg->dma_address
 673                   = pci_map_single_1(pdev, SG_ENT_VIRT_ADDRESS(sg),
 674                                      sg->length, dac_allowed);
 675                 return sg->dma_address != 0;
 676         }
 677
 678         start = sg;
 679         end = sg + nents;
 680
 681         /* First, prepare information about the entries.  */
 682         sg_classify(dev, sg, end, alpha_mv.mv_pci_tbi != 0);
 683
 684         /* Second, figure out where we're going to map things.  */
 685         if (alpha_mv.mv_pci_tbi) {
 686                 hose = pdev ? pdev->sysdata : pci_isa_hose;
 687                 max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
 688                 arena = hose->sg_pci;
 689                 if (!arena || arena->dma_base + arena->size - 1 > max_dma)
 690                         arena = hose->sg_isa;
 691         } else {
 692                 max_dma = -1;
 693                 arena = NULL;
 694                 hose = NULL;
 695         }
 696
 697         /* Third, iterate over the scatterlist leaders and allocate
 698            dma space as needed.  */
 699         for (out = sg; sg < end; ++sg) {
 700                 if ((int) sg->dma_address < 0)
 701                         continue;
 702                 if (sg_fill(dev, sg, end, out, arena, max_dma, dac_allowed) < 0)
 703                         goto error;
 704                 out++;
 705         }
 706
 707         /* Mark the end of the list for pci_unmap_sg.  */
 708         if (out < end)
 709                 out->dma_length = 0;
 710
 711         if (out - start == 0)
 712                 printk(KERN_WARNING "pci_map_sg failed: no entries?\n");
 713         DBGA("pci_map_sg: %ld entries\n", out - start);
 714
 715         return out - start;
 716
 717  error:
 718         printk(KERN_WARNING "pci_map_sg failed: "
 719                "could not allocate dma page tables\n");
 720
 721         /* Some allocation failed while mapping the scatterlist
 722            entries.  Unmap them now.  */
 723         if (out > start)
 724                 pci_unmap_sg(pdev, start, out - start, direction);
 725         return 0;
 726 }
 727 EXPORT_SYMBOL(pci_map_sg);
 728
 729 /* Unmap a set of streaming mode DMA translations.  Again, cpu read
 730    rules concerning calls here are the same as for pci_unmap_single()
 731    above.  */
 732
 733 void
 734 pci_unmap_sg(struct pci_dev *pdev, struct scatterlist *sg, int nents,
 735              int direction)
 736 {
 737         unsigned long flags;
 738         struct pci_controller *hose;
 739         struct pci_iommu_arena *arena;
 740         struct scatterlist *end;
 741         dma_addr_t max_dma;
 742         dma_addr_t fbeg, fend;
 743
 744         if (direction == PCI_DMA_NONE)
 745                 BUG();
 746
 747         if (! alpha_mv.mv_pci_tbi)
 748                 return;
 749
 750         hose = pdev ? pdev->sysdata : pci_isa_hose;
 751         max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
 752         arena = hose->sg_pci;
 753         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
 754                 arena = hose->sg_isa;
 755
 756         fbeg = -1, fend = 0;
 757
 758         spin_lock_irqsave(&arena->lock, flags);
 759
 760         for (end = sg + nents; sg < end; ++sg) {
 761                 dma64_addr_t addr;
 762                 size_t size;
 763                 long npages, ofs;
 764                 dma_addr_t tend;
 765
 766                 addr = sg->dma_address;
 767                 size = sg->dma_length;
 768                 if (!size)
 769                         break;
 770
 771                 if (addr > 0xffffffff) {
 772                         /* It's a DAC address -- nothing to do.  */
 773                         DBGA("    (%ld) DAC [%lx,%lx]\n",
 774                               sg - end + nents, addr, size);
 775                         continue;
 776                 }
 777
 778                 if (addr >= __direct_map_base
 779                     && addr < __direct_map_base + __direct_map_size) {
 780                         /* Nothing to do.  */
 781                         DBGA("    (%ld) direct [%lx,%lx]\n",
 782                               sg - end + nents, addr, size);
 783                         continue;
 784                 }
 785
 786                 DBGA("    (%ld) sg [%lx,%lx]\n",
 787                      sg - end + nents, addr, size);
 788
 789                 npages = calc_npages((addr & ~PAGE_MASK) + size);
 790                 ofs = (addr - arena->dma_base) >> PAGE_SHIFT;
 791                 iommu_arena_free(arena, ofs, npages);
 792
 793                 tend = addr + size - 1;
 794                 if (fbeg > addr) fbeg = addr;
 795                 if (fend < tend) fend = tend;
 796         }
 797
 798         /* If we're freeing ptes above the `next_entry' pointer (they
 799            may have snuck back into the TLB since the last wrap flush),
 800            we need to flush the TLB before reallocating the latter.  */
 801         if ((fend - arena->dma_base) >> PAGE_SHIFT >= arena->next_entry)
 802                 alpha_mv.mv_pci_tbi(hose, fbeg, fend);
 803
 804         spin_unlock_irqrestore(&arena->lock, flags);
 805
 806         DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg));
 807 }
 808 EXPORT_SYMBOL(pci_unmap_sg);
 809
 810
 811 /* Return whether the given PCI device DMA address mask can be
 812    supported properly.  */
 813
 814 int
 815 pci_dma_supported(struct pci_dev *pdev, u64 mask)
 816 {
 817         struct pci_controller *hose;
 818         struct pci_iommu_arena *arena;
 819
 820         /* If there exists a direct map, and the mask fits either
 821            the entire direct mapped space or the total system memory as
 822            shifted by the map base */
 823         if (__direct_map_size != 0
 824             && (__direct_map_base + __direct_map_size - 1 <= mask ||
 825                 __direct_map_base + (max_low_pfn << PAGE_SHIFT) - 1 <= mask))
 826                 return 1;
 827
 828         /* Check that we have a scatter-gather arena that fits.  */
 829         hose = pdev ? pdev->sysdata : pci_isa_hose;
 830         arena = hose->sg_isa;
 831         if (arena && arena->dma_base + arena->size - 1 <= mask)
 832                 return 1;
 833         arena = hose->sg_pci;
 834         if (arena && arena->dma_base + arena->size - 1 <= mask)
 835                 return 1;
 836
 837         /* As last resort try ZONE_DMA.  */
 838         if (!__direct_map_base && MAX_DMA_ADDRESS - IDENT_ADDR - 1 <= mask)
 839                 return 1;
 840
 841         return 0;
 842 }
 843 EXPORT_SYMBOL(pci_dma_supported);
 844
 845 \f
 846 /*
 847  * AGP GART extensions to the IOMMU
 848  */
 849 int
 850 iommu_reserve(struct pci_iommu_arena *arena, long pg_count, long align_mask)
 851 {
 852         unsigned long flags;
 853         unsigned long *ptes;
 854         long i, p;
 855
 856         if (!arena) return -EINVAL;
 857
 858         spin_lock_irqsave(&arena->lock, flags);
 859
 860         /* Search for N empty ptes.  */
 861         ptes = arena->ptes;
 862         p = iommu_arena_find_pages(NULL, arena, pg_count, align_mask);
 863         if (p < 0) {
 864                 spin_unlock_irqrestore(&arena->lock, flags);
 865                 return -1;
 866         }
 867
 868         /* Success.  Mark them all reserved (ie not zero and invalid)
 869            for the iommu tlb that could load them from under us.
 870            They will be filled in with valid bits by _bind() */
 871         for (i = 0; i < pg_count; ++i)
 872                 ptes[p+i] = IOMMU_RESERVED_PTE;
 873
 874         arena->next_entry = p + pg_count;
 875         spin_unlock_irqrestore(&arena->lock, flags);
 876
 877         return p;
 878 }
 879
 880 int
 881 iommu_release(struct pci_iommu_arena *arena, long pg_start, long pg_count)
 882 {
 883         unsigned long *ptes;
 884         long i;
 885
 886         if (!arena) return -EINVAL;
 887
 888         ptes = arena->ptes;
 889
 890         /* Make sure they're all reserved first... */
 891         for(i = pg_start; i < pg_start + pg_count; i++)
 892                 if (ptes[i] != IOMMU_RESERVED_PTE)
 893                         return -EBUSY;
 894
 895         iommu_arena_free(arena, pg_start, pg_count);
 896         return 0;
 897 }
 898
 899 int
 900 iommu_bind(struct pci_iommu_arena *arena, long pg_start, long pg_count,
 901            unsigned long *physaddrs)
 902 {
 903         unsigned long flags;
 904         unsigned long *ptes;
 905         long i, j;
 906
 907         if (!arena) return -EINVAL;
 908
 909         spin_lock_irqsave(&arena->lock, flags);
 910
 911         ptes = arena->ptes;
 912
 913         for(j = pg_start; j < pg_start + pg_count; j++) {
 914                 if (ptes[j] != IOMMU_RESERVED_PTE) {
 915                         spin_unlock_irqrestore(&arena->lock, flags);
 916                         return -EBUSY;
 917                 }
 918         }
 919
 920         for(i = 0, j = pg_start; i < pg_count; i++, j++)
 921                 ptes[j] = mk_iommu_pte(physaddrs[i]);
 922
 923         spin_unlock_irqrestore(&arena->lock, flags);
 924
 925         return 0;
 926 }
 927
 928 int
 929 iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count)
 930 {
 931         unsigned long *p;
 932         long i;
 933
 934         if (!arena) return -EINVAL;
 935
 936         p = arena->ptes + pg_start;
 937         for(i = 0; i < pg_count; i++)
 938                 p[i] = IOMMU_RESERVED_PTE;
 939
 940         return 0;
 941 }
 942
 943 /* True if the machine supports DAC addressing, and DEV can
 944    make use of it given MASK.  */
 945
 946 static int
 947 pci_dac_dma_supported(struct pci_dev *dev, u64 mask)
 948 {
 949         dma64_addr_t dac_offset = alpha_mv.pci_dac_offset;
 950         int ok = 1;
 951
 952         /* If this is not set, the machine doesn't support DAC at all.  */
 953         if (dac_offset == 0)
 954                 ok = 0;
 955
 956         /* The device has to be able to address our DAC bit.  */
 957         if ((dac_offset & dev->dma_mask) != dac_offset)
 958                 ok = 0;
 959
 960         /* If both conditions above are met, we are fine. */
 961         DBGA("pci_dac_dma_supported %s from %p\n",
 962              ok ? "yes" : "no", __builtin_return_address(0));
 963
 964         return ok;
 965 }
 966
 967 /* Helper for generic DMA-mapping functions. */
 968
 969 struct pci_dev *
 970 alpha_gendev_to_pci(struct device *dev)
 971 {
 972         if (dev && dev->bus == &pci_bus_type)
 973                 return to_pci_dev(dev);
 974
 975         /* Assume that non-PCI devices asking for DMA are either ISA or EISA,
 976            BUG() otherwise. */
 977         BUG_ON(!isa_bridge);
 978
 979         /* Assume non-busmaster ISA DMA when dma_mask is not set (the ISA
 980            bridge is bus master then). */
 981         if (!dev || !dev->dma_mask || !*dev->dma_mask)
 982                 return isa_bridge;
 983
 984         /* For EISA bus masters, return isa_bridge (it might have smaller
 985            dma_mask due to wiring limitations). */
 986         if (*dev->dma_mask >= isa_bridge->dma_mask)
 987                 return isa_bridge;
 988
 989         /* This assumes ISA bus master with dma_mask 0xffffff. */
 990         return NULL;
 991 }
 992 EXPORT_SYMBOL(alpha_gendev_to_pci);
 993
 994 int
 995 dma_set_mask(struct device *dev, u64 mask)
 996 {
 997         if (!dev->dma_mask ||
 998             !pci_dma_supported(alpha_gendev_to_pci(dev), mask))
 999                 return -EIO;
1000
1001         *dev->dma_mask = mask;
1002
1003         return 0;
1004 }
1005 EXPORT_SYMBOL(dma_set_mask);