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/gfp.h>
   9 #include <linux/bootmem.h>
  10 #include <linux/scatterlist.h>
  11 #include <linux/log2.h>
  12 #include <linux/dma-mapping.h>
  13 #include <linux/iommu-helper.h>
  14
  15 #include <asm/io.h>
  16 #include <asm/hwrpb.h>
  17
  18 #include "proto.h"
  19 #include "pci_impl.h"
  20
  21
  22 #define DEBUG_ALLOC 0
  23 #if DEBUG_ALLOC > 0
  24 # define DBGA(args...)          printk(KERN_DEBUG args)
  25 #else
  26 # define DBGA(args...)
  27 #endif
  28 #if DEBUG_ALLOC > 1
  29 # define DBGA2(args...)         printk(KERN_DEBUG args)
  30 #else
  31 # define DBGA2(args...)
  32 #endif
  33
  34 #define DEBUG_NODIRECT 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 /* Return the minimum of MAX or the first power of two larger
  45    than main memory.  */
  46
  47 unsigned long
  48 size_for_memory(unsigned long max)
  49 {
  50         unsigned long mem = max_low_pfn << PAGE_SHIFT;
  51         if (mem < max)
  52                 max = roundup_pow_of_two(mem);
  53         return max;
  54 }
  55 \f
  56 struct pci_iommu_arena * __init
  57 iommu_arena_new_node(int nid, struct pci_controller *hose, dma_addr_t base,
  58                      unsigned long window_size, unsigned long align)
  59 {
  60         unsigned long mem_size;
  61         struct pci_iommu_arena *arena;
  62
  63         mem_size = window_size / (PAGE_SIZE / sizeof(unsigned long));
  64
  65         /* Note that the TLB lookup logic uses bitwise concatenation,
  66            not addition, so the required arena alignment is based on
  67            the size of the window.  Retain the align parameter so that
  68            particular systems can over-align the arena.  */
  69         if (align < mem_size)
  70                 align = mem_size;
  71
  72
  73 #ifdef CONFIG_DISCONTIGMEM
  74
  75         arena = alloc_bootmem_node(NODE_DATA(nid), sizeof(*arena));
  76         if (!NODE_DATA(nid) || !arena) {
  77                 printk("%s: couldn't allocate arena from node %d\n"
  78                        "    falling back to system-wide allocation\n",
  79                        __func__, nid);
  80                 arena = alloc_bootmem(sizeof(*arena));
  81         }
  82
  83         arena->ptes = __alloc_bootmem_node(NODE_DATA(nid), mem_size, align, 0);
  84         if (!NODE_DATA(nid) || !arena->ptes) {
  85                 printk("%s: couldn't allocate arena ptes from node %d\n"
  86                        "    falling back to system-wide allocation\n",
  87                        __func__, nid);
  88                 arena->ptes = __alloc_bootmem(mem_size, align, 0);
  89         }
  90
  91 #else /* CONFIG_DISCONTIGMEM */
  92
  93         arena = alloc_bootmem(sizeof(*arena));
  94         arena->ptes = __alloc_bootmem(mem_size, align, 0);
  95
  96 #endif /* CONFIG_DISCONTIGMEM */
  97
  98         spin_lock_init(&arena->lock);
  99         arena->hose = hose;
 100         arena->dma_base = base;
 101         arena->size = window_size;
 102         arena->next_entry = 0;
 103
 104         /* Align allocations to a multiple of a page size.  Not needed
 105            unless there are chip bugs.  */
 106         arena->align_entry = 1;
 107
 108         return arena;
 109 }
 110
 111 struct pci_iommu_arena * __init
 112 iommu_arena_new(struct pci_controller *hose, dma_addr_t base,
 113                 unsigned long window_size, unsigned long align)
 114 {
 115         return iommu_arena_new_node(0, hose, base, window_size, align);
 116 }
 117
 118 /* Must be called with the arena lock held */
 119 static long
 120 iommu_arena_find_pages(struct device *dev, struct pci_iommu_arena *arena,
 121                        long n, long mask)
 122 {
 123         unsigned long *ptes;
 124         long i, p, nent;
 125         int pass = 0;
 126         unsigned long base;
 127         unsigned long boundary_size;
 128
 129         base = arena->dma_base >> PAGE_SHIFT;
 130         if (dev) {
 131                 boundary_size = dma_get_seg_boundary(dev) + 1;
 132                 boundary_size >>= PAGE_SHIFT;
 133         } else {
 134                 boundary_size = 1UL << (32 - PAGE_SHIFT);
 135         }
 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 (!i && iommu_is_span_boundary(p, n, base, boundary_size)) {
 146                         p = ALIGN(p + 1, mask + 1);
 147                         goto again;
 148                 }
 149
 150                 if (ptes[p+i])
 151                         p = ALIGN(p + i + 1, mask + 1), i = 0;
 152                 else
 153                         i = i + 1;
 154         }
 155
 156         if (i < n) {
 157                 if (pass < 1) {
 158                         /*
 159                          * Reached the end.  Flush the TLB and restart
 160                          * the search from the beginning.
 161                         */
 162                         alpha_mv.mv_pci_tbi(arena->hose, 0, -1);
 163
 164                         pass++;
 165                         p = 0;
 166                         i = 0;
 167                         goto again;
 168                 } else
 169                         return -1;
 170         }
 171
 172         /* Success. It's the responsibility of the caller to mark them
 173            in use before releasing the lock */
 174         return p;
 175 }
 176
 177 static long
 178 iommu_arena_alloc(struct device *dev, struct pci_iommu_arena *arena, long n,
 179                   unsigned int align)
 180 {
 181         unsigned long flags;
 182         unsigned long *ptes;
 183         long i, p, mask;
 184
 185         spin_lock_irqsave(&arena->lock, flags);
 186
 187         /* Search for N empty ptes */
 188         ptes = arena->ptes;
 189         mask = max(align, arena->align_entry) - 1;
 190         p = iommu_arena_find_pages(dev, arena, n, mask);
 191         if (p < 0) {
 192                 spin_unlock_irqrestore(&arena->lock, flags);
 193                 return -1;
 194         }
 195
 196         /* Success.  Mark them all in use, ie not zero and invalid
 197            for the iommu tlb that could load them from under us.
 198            The chip specific bits will fill this in with something
 199            kosher when we return.  */
 200         for (i = 0; i < n; ++i)
 201                 ptes[p+i] = IOMMU_INVALID_PTE;
 202
 203         arena->next_entry = p + n;
 204         spin_unlock_irqrestore(&arena->lock, flags);
 205
 206         return p;
 207 }
 208
 209 static void
 210 iommu_arena_free(struct pci_iommu_arena *arena, long ofs, long n)
 211 {
 212         unsigned long *p;
 213         long i;
 214
 215         p = arena->ptes + ofs;
 216         for (i = 0; i < n; ++i)
 217                 p[i] = 0;
 218 }
 219
 220 /*
 221  * True if the machine supports DAC addressing, and DEV can
 222  * make use of it given MASK.
 223  */
 224 static int pci_dac_dma_supported(struct pci_dev *dev, u64 mask)
 225 {
 226         dma64_addr_t dac_offset = alpha_mv.pci_dac_offset;
 227         int ok = 1;
 228
 229         /* If this is not set, the machine doesn't support DAC at all.  */
 230         if (dac_offset == 0)
 231                 ok = 0;
 232
 233         /* The device has to be able to address our DAC bit.  */
 234         if ((dac_offset & dev->dma_mask) != dac_offset)
 235                 ok = 0;
 236
 237         /* If both conditions above are met, we are fine. */
 238         DBGA("pci_dac_dma_supported %s from %p\n",
 239              ok ? "yes" : "no", __builtin_return_address(0));
 240
 241         return ok;
 242 }
 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,%zx] -> direct %llx 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,%zx] -> DAC %llx 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                 printk_once(KERN_WARNING "pci_map_single: no HW sg\n");
 292                 return 0;
 293         }
 294
 295         arena = hose->sg_pci;
 296         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
 297                 arena = hose->sg_isa;
 298
 299         npages = iommu_num_pages(paddr, size, PAGE_SIZE);
 300
 301         /* Force allocation to 64KB boundary for ISA bridges. */
 302         if (pdev && pdev == isa_bridge)
 303                 align = 8;
 304         dma_ofs = iommu_arena_alloc(dev, arena, npages, align);
 305         if (dma_ofs < 0) {
 306                 printk(KERN_WARNING "pci_map_single failed: "
 307                        "could not allocate dma page tables\n");
 308                 return 0;
 309         }
 310
 311         paddr &= PAGE_MASK;
 312         for (i = 0; i < npages; ++i, paddr += PAGE_SIZE)
 313                 arena->ptes[i + dma_ofs] = mk_iommu_pte(paddr);
 314
 315         ret = arena->dma_base + dma_ofs * PAGE_SIZE;
 316         ret += (unsigned long)cpu_addr & ~PAGE_MASK;
 317
 318         DBGA2("pci_map_single: [%p,%zx] np %ld -> sg %llx from %p\n",
 319               cpu_addr, size, npages, ret, __builtin_return_address(0));
 320
 321         return ret;
 322 }
 323
 324 /* Helper for generic DMA-mapping functions. */
 325 static struct pci_dev *alpha_gendev_to_pci(struct device *dev)
 326 {
 327         if (dev && dev->bus == &pci_bus_type)
 328                 return to_pci_dev(dev);
 329
 330         /* Assume that non-PCI devices asking for DMA are either ISA or EISA,
 331            BUG() otherwise. */
 332         BUG_ON(!isa_bridge);
 333
 334         /* Assume non-busmaster ISA DMA when dma_mask is not set (the ISA
 335            bridge is bus master then). */
 336         if (!dev || !dev->dma_mask || !*dev->dma_mask)
 337                 return isa_bridge;
 338
 339         /* For EISA bus masters, return isa_bridge (it might have smaller
 340            dma_mask due to wiring limitations). */
 341         if (*dev->dma_mask >= isa_bridge->dma_mask)
 342                 return isa_bridge;
 343
 344         /* This assumes ISA bus master with dma_mask 0xffffff. */
 345         return NULL;
 346 }
 347
 348 static dma_addr_t alpha_pci_map_page(struct device *dev, struct page *page,
 349                                      unsigned long offset, size_t size,
 350                                      enum dma_data_direction dir,
 351                                      struct dma_attrs *attrs)
 352 {
 353         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 354         int dac_allowed;
 355
 356         if (dir == PCI_DMA_NONE)
 357                 BUG();
 358
 359         dac_allowed = pdev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
 360         return pci_map_single_1(pdev, (char *)page_address(page) + offset,
 361                                 size, dac_allowed);
 362 }
 363
 364 /* Unmap a single streaming mode DMA translation.  The DMA_ADDR and
 365    SIZE must match what was provided for in a previous pci_map_single
 366    call.  All other usages are undefined.  After this call, reads by
 367    the cpu to the buffer are guaranteed to see whatever the device
 368    wrote there.  */
 369
 370 static void alpha_pci_unmap_page(struct device *dev, dma_addr_t dma_addr,
 371                                  size_t size, enum dma_data_direction dir,
 372                                  struct dma_attrs *attrs)
 373 {
 374         unsigned long flags;
 375         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 376         struct pci_controller *hose = pdev ? pdev->sysdata : pci_isa_hose;
 377         struct pci_iommu_arena *arena;
 378         long dma_ofs, npages;
 379
 380         if (dir == PCI_DMA_NONE)
 381                 BUG();
 382
 383         if (dma_addr >= __direct_map_base
 384             && dma_addr < __direct_map_base + __direct_map_size) {
 385                 /* Nothing to do.  */
 386
 387                 DBGA2("pci_unmap_single: direct [%llx,%zx] from %p\n",
 388                       dma_addr, size, __builtin_return_address(0));
 389
 390                 return;
 391         }
 392
 393         if (dma_addr > 0xffffffff) {
 394                 DBGA2("pci64_unmap_single: DAC [%llx,%zx] from %p\n",
 395                       dma_addr, size, __builtin_return_address(0));
 396                 return;
 397         }
 398
 399         arena = hose->sg_pci;
 400         if (!arena || dma_addr < arena->dma_base)
 401                 arena = hose->sg_isa;
 402
 403         dma_ofs = (dma_addr - arena->dma_base) >> PAGE_SHIFT;
 404         if (dma_ofs * PAGE_SIZE >= arena->size) {
 405                 printk(KERN_ERR "Bogus pci_unmap_single: dma_addr %llx "
 406                        " base %llx size %x\n",
 407                        dma_addr, arena->dma_base, arena->size);
 408                 return;
 409                 BUG();
 410         }
 411
 412         npages = iommu_num_pages(dma_addr, size, PAGE_SIZE);
 413
 414         spin_lock_irqsave(&arena->lock, flags);
 415
 416         iommu_arena_free(arena, dma_ofs, npages);
 417
 418         /* If we're freeing ptes above the `next_entry' pointer (they
 419            may have snuck back into the TLB since the last wrap flush),
 420            we need to flush the TLB before reallocating the latter.  */
 421         if (dma_ofs >= arena->next_entry)
 422                 alpha_mv.mv_pci_tbi(hose, dma_addr, dma_addr + size - 1);
 423
 424         spin_unlock_irqrestore(&arena->lock, flags);
 425
 426         DBGA2("pci_unmap_single: sg [%llx,%zx] np %ld from %p\n",
 427               dma_addr, size, npages, __builtin_return_address(0));
 428 }
 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 static void *alpha_pci_alloc_coherent(struct device *dev, size_t size,
 436                                       dma_addr_t *dma_addrp, gfp_t gfp)
 437 {
 438         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 439         void *cpu_addr;
 440         long order = get_order(size);
 441
 442         gfp &= ~GFP_DMA;
 443
 444 try_again:
 445         cpu_addr = (void *)__get_free_pages(gfp, order);
 446         if (! cpu_addr) {
 447                 printk(KERN_INFO "pci_alloc_consistent: "
 448                        "get_free_pages failed from %p\n",
 449                         __builtin_return_address(0));
 450                 /* ??? Really atomic allocation?  Otherwise we could play
 451                    with vmalloc and sg if we can't find contiguous memory.  */
 452                 return NULL;
 453         }
 454         memset(cpu_addr, 0, size);
 455
 456         *dma_addrp = pci_map_single_1(pdev, cpu_addr, size, 0);
 457         if (*dma_addrp == 0) {
 458                 free_pages((unsigned long)cpu_addr, order);
 459                 if (alpha_mv.mv_pci_tbi || (gfp & GFP_DMA))
 460                         return NULL;
 461                 /* The address doesn't fit required mask and we
 462                    do not have iommu. Try again with GFP_DMA. */
 463                 gfp |= GFP_DMA;
 464                 goto try_again;
 465         }
 466
 467         DBGA2("pci_alloc_consistent: %zx -> [%p,%llx] from %p\n",
 468               size, cpu_addr, *dma_addrp, __builtin_return_address(0));
 469
 470         return cpu_addr;
 471 }
 472
 473 /* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must
 474    be values that were returned from pci_alloc_consistent.  SIZE must
 475    be the same as what as passed into pci_alloc_consistent.
 476    References to the memory and mappings associated with CPU_ADDR or
 477    DMA_ADDR past this call are illegal.  */
 478
 479 static void alpha_pci_free_coherent(struct device *dev, size_t size,
 480                                     void *cpu_addr, dma_addr_t dma_addr)
 481 {
 482         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 483         pci_unmap_single(pdev, dma_addr, size, PCI_DMA_BIDIRECTIONAL);
 484         free_pages((unsigned long)cpu_addr, get_order(size));
 485
 486         DBGA2("pci_free_consistent: [%llx,%zx] from %p\n",
 487               dma_addr, size, __builtin_return_address(0));
 488 }
 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 %llx\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 %llx\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 = iommu_num_pages(paddr, size, PAGE_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 %llx 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 = iommu_num_pages(paddr, size, PAGE_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 static int alpha_pci_map_sg(struct device *dev, struct scatterlist *sg,
 652                             int nents, enum dma_data_direction dir,
 653                             struct dma_attrs *attrs)
 654 {
 655         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 656         struct scatterlist *start, *end, *out;
 657         struct pci_controller *hose;
 658         struct pci_iommu_arena *arena;
 659         dma_addr_t max_dma;
 660         int dac_allowed;
 661
 662         if (dir == PCI_DMA_NONE)
 663                 BUG();
 664
 665         dac_allowed = dev ? pci_dac_dma_supported(pdev, pdev->dma_mask) : 0;
 666
 667         /* Fast path single entry scatterlists.  */
 668         if (nents == 1) {
 669                 sg->dma_length = sg->length;
 670                 sg->dma_address
 671                   = pci_map_single_1(pdev, SG_ENT_VIRT_ADDRESS(sg),
 672                                      sg->length, dac_allowed);
 673                 return sg->dma_address != 0;
 674         }
 675
 676         start = sg;
 677         end = sg + nents;
 678
 679         /* First, prepare information about the entries.  */
 680         sg_classify(dev, sg, end, alpha_mv.mv_pci_tbi != 0);
 681
 682         /* Second, figure out where we're going to map things.  */
 683         if (alpha_mv.mv_pci_tbi) {
 684                 hose = pdev ? pdev->sysdata : pci_isa_hose;
 685                 max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
 686                 arena = hose->sg_pci;
 687                 if (!arena || arena->dma_base + arena->size - 1 > max_dma)
 688                         arena = hose->sg_isa;
 689         } else {
 690                 max_dma = -1;
 691                 arena = NULL;
 692                 hose = NULL;
 693         }
 694
 695         /* Third, iterate over the scatterlist leaders and allocate
 696            dma space as needed.  */
 697         for (out = sg; sg < end; ++sg) {
 698                 if ((int) sg->dma_address < 0)
 699                         continue;
 700                 if (sg_fill(dev, sg, end, out, arena, max_dma, dac_allowed) < 0)
 701                         goto error;
 702                 out++;
 703         }
 704
 705         /* Mark the end of the list for pci_unmap_sg.  */
 706         if (out < end)
 707                 out->dma_length = 0;
 708
 709         if (out - start == 0)
 710                 printk(KERN_WARNING "pci_map_sg failed: no entries?\n");
 711         DBGA("pci_map_sg: %ld entries\n", out - start);
 712
 713         return out - start;
 714
 715  error:
 716         printk(KERN_WARNING "pci_map_sg failed: "
 717                "could not allocate dma page tables\n");
 718
 719         /* Some allocation failed while mapping the scatterlist
 720            entries.  Unmap them now.  */
 721         if (out > start)
 722                 pci_unmap_sg(pdev, start, out - start, dir);
 723         return 0;
 724 }
 725
 726 /* Unmap a set of streaming mode DMA translations.  Again, cpu read
 727    rules concerning calls here are the same as for pci_unmap_single()
 728    above.  */
 729
 730 static void alpha_pci_unmap_sg(struct device *dev, struct scatterlist *sg,
 731                                int nents, enum dma_data_direction dir,
 732                                struct dma_attrs *attrs)
 733 {
 734         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 735         unsigned long flags;
 736         struct pci_controller *hose;
 737         struct pci_iommu_arena *arena;
 738         struct scatterlist *end;
 739         dma_addr_t max_dma;
 740         dma_addr_t fbeg, fend;
 741
 742         if (dir == PCI_DMA_NONE)
 743                 BUG();
 744
 745         if (! alpha_mv.mv_pci_tbi)
 746                 return;
 747
 748         hose = pdev ? pdev->sysdata : pci_isa_hose;
 749         max_dma = pdev ? pdev->dma_mask : ISA_DMA_MASK;
 750         arena = hose->sg_pci;
 751         if (!arena || arena->dma_base + arena->size - 1 > max_dma)
 752                 arena = hose->sg_isa;
 753
 754         fbeg = -1, fend = 0;
 755
 756         spin_lock_irqsave(&arena->lock, flags);
 757
 758         for (end = sg + nents; sg < end; ++sg) {
 759                 dma64_addr_t addr;
 760                 size_t size;
 761                 long npages, ofs;
 762                 dma_addr_t tend;
 763
 764                 addr = sg->dma_address;
 765                 size = sg->dma_length;
 766                 if (!size)
 767                         break;
 768
 769                 if (addr > 0xffffffff) {
 770                         /* It's a DAC address -- nothing to do.  */
 771                         DBGA("    (%ld) DAC [%llx,%zx]\n",
 772                               sg - end + nents, addr, size);
 773                         continue;
 774                 }
 775
 776                 if (addr >= __direct_map_base
 777                     && addr < __direct_map_base + __direct_map_size) {
 778                         /* Nothing to do.  */
 779                         DBGA("    (%ld) direct [%llx,%zx]\n",
 780                               sg - end + nents, addr, size);
 781                         continue;
 782                 }
 783
 784                 DBGA("    (%ld) sg [%llx,%zx]\n",
 785                      sg - end + nents, addr, size);
 786
 787                 npages = iommu_num_pages(addr, size, PAGE_SIZE);
 788                 ofs = (addr - arena->dma_base) >> PAGE_SHIFT;
 789                 iommu_arena_free(arena, ofs, npages);
 790
 791                 tend = addr + size - 1;
 792                 if (fbeg > addr) fbeg = addr;
 793                 if (fend < tend) fend = tend;
 794         }
 795
 796         /* If we're freeing ptes above the `next_entry' pointer (they
 797            may have snuck back into the TLB since the last wrap flush),
 798            we need to flush the TLB before reallocating the latter.  */
 799         if ((fend - arena->dma_base) >> PAGE_SHIFT >= arena->next_entry)
 800                 alpha_mv.mv_pci_tbi(hose, fbeg, fend);
 801
 802         spin_unlock_irqrestore(&arena->lock, flags);
 803
 804         DBGA("pci_unmap_sg: %ld entries\n", nents - (end - sg));
 805 }
 806
 807 /* Return whether the given PCI device DMA address mask can be
 808    supported properly.  */
 809
 810 static int alpha_pci_supported(struct device *dev, u64 mask)
 811 {
 812         struct pci_dev *pdev = alpha_gendev_to_pci(dev);
 813         struct pci_controller *hose;
 814         struct pci_iommu_arena *arena;
 815
 816         /* If there exists a direct map, and the mask fits either
 817            the entire direct mapped space or the total system memory as
 818            shifted by the map base */
 819         if (__direct_map_size != 0
 820             && (__direct_map_base + __direct_map_size - 1 <= mask ||
 821                 __direct_map_base + (max_low_pfn << PAGE_SHIFT) - 1 <= mask))
 822                 return 1;
 823
 824         /* Check that we have a scatter-gather arena that fits.  */
 825         hose = pdev ? pdev->sysdata : pci_isa_hose;
 826         arena = hose->sg_isa;
 827         if (arena && arena->dma_base + arena->size - 1 <= mask)
 828                 return 1;
 829         arena = hose->sg_pci;
 830         if (arena && arena->dma_base + arena->size - 1 <= mask)
 831                 return 1;
 832
 833         /* As last resort try ZONE_DMA.  */
 834         if (!__direct_map_base && MAX_DMA_ADDRESS - IDENT_ADDR - 1 <= mask)
 835                 return 1;
 836
 837         return 0;
 838 }
 839
 840 \f
 841 /*
 842  * AGP GART extensions to the IOMMU
 843  */
 844 int
 845 iommu_reserve(struct pci_iommu_arena *arena, long pg_count, long align_mask)
 846 {
 847         unsigned long flags;
 848         unsigned long *ptes;
 849         long i, p;
 850
 851         if (!arena) return -EINVAL;
 852
 853         spin_lock_irqsave(&arena->lock, flags);
 854
 855         /* Search for N empty ptes.  */
 856         ptes = arena->ptes;
 857         p = iommu_arena_find_pages(NULL, arena, pg_count, align_mask);
 858         if (p < 0) {
 859                 spin_unlock_irqrestore(&arena->lock, flags);
 860                 return -1;
 861         }
 862
 863         /* Success.  Mark them all reserved (ie not zero and invalid)
 864            for the iommu tlb that could load them from under us.
 865            They will be filled in with valid bits by _bind() */
 866         for (i = 0; i < pg_count; ++i)
 867                 ptes[p+i] = IOMMU_RESERVED_PTE;
 868
 869         arena->next_entry = p + pg_count;
 870         spin_unlock_irqrestore(&arena->lock, flags);
 871
 872         return p;
 873 }
 874
 875 int
 876 iommu_release(struct pci_iommu_arena *arena, long pg_start, long pg_count)
 877 {
 878         unsigned long *ptes;
 879         long i;
 880
 881         if (!arena) return -EINVAL;
 882
 883         ptes = arena->ptes;
 884
 885         /* Make sure they're all reserved first... */
 886         for(i = pg_start; i < pg_start + pg_count; i++)
 887                 if (ptes[i] != IOMMU_RESERVED_PTE)
 888                         return -EBUSY;
 889
 890         iommu_arena_free(arena, pg_start, pg_count);
 891         return 0;
 892 }
 893
 894 int
 895 iommu_bind(struct pci_iommu_arena *arena, long pg_start, long pg_count,
 896            struct page **pages)
 897 {
 898         unsigned long flags;
 899         unsigned long *ptes;
 900         long i, j;
 901
 902         if (!arena) return -EINVAL;
 903
 904         spin_lock_irqsave(&arena->lock, flags);
 905
 906         ptes = arena->ptes;
 907
 908         for(j = pg_start; j < pg_start + pg_count; j++) {
 909                 if (ptes[j] != IOMMU_RESERVED_PTE) {
 910                         spin_unlock_irqrestore(&arena->lock, flags);
 911                         return -EBUSY;
 912                 }
 913         }
 914
 915         for(i = 0, j = pg_start; i < pg_count; i++, j++)
 916                 ptes[j] = mk_iommu_pte(page_to_phys(pages[i]));
 917
 918         spin_unlock_irqrestore(&arena->lock, flags);
 919
 920         return 0;
 921 }
 922
 923 int
 924 iommu_unbind(struct pci_iommu_arena *arena, long pg_start, long pg_count)
 925 {
 926         unsigned long *p;
 927         long i;
 928
 929         if (!arena) return -EINVAL;
 930
 931         p = arena->ptes + pg_start;
 932         for(i = 0; i < pg_count; i++)
 933                 p[i] = IOMMU_RESERVED_PTE;
 934
 935         return 0;
 936 }
 937
 938 static int alpha_pci_mapping_error(struct device *dev, dma_addr_t dma_addr)
 939 {
 940         return dma_addr == 0;
 941 }
 942
 943 static int alpha_pci_set_mask(struct device *dev, u64 mask)
 944 {
 945         if (!dev->dma_mask ||
 946             !pci_dma_supported(alpha_gendev_to_pci(dev), mask))
 947                 return -EIO;
 948
 949         *dev->dma_mask = mask;
 950         return 0;
 951 }
 952
 953 struct dma_map_ops alpha_pci_ops = {
 954         .alloc_coherent         = alpha_pci_alloc_coherent,
 955         .free_coherent          = alpha_pci_free_coherent,
 956         .map_page               = alpha_pci_map_page,
 957         .unmap_page             = alpha_pci_unmap_page,
 958         .map_sg                 = alpha_pci_map_sg,
 959         .unmap_sg               = alpha_pci_unmap_sg,
 960         .mapping_error          = alpha_pci_mapping_error,
 961         .dma_supported          = alpha_pci_supported,
 962         .set_dma_mask           = alpha_pci_set_mask,
 963 };
 964
 965 struct dma_map_ops *dma_ops = &alpha_pci_ops;
 966 EXPORT_SYMBOL(dma_ops);