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