Logo Search packages:      
Sourcecode: linux version File versions  Download package

dma-coherent.c

/*
 *  Copyright (C) 2004-2006 Atmel Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */

#include <linux/dma-mapping.h>

#include <asm/addrspace.h>
#include <asm/cacheflush.h>

void dma_cache_sync(struct device *dev, void *vaddr, size_t size, int direction)
{
      /*
       * No need to sync an uncached area
       */
      if (PXSEG(vaddr) == P2SEG)
            return;

      switch (direction) {
      case DMA_FROM_DEVICE:         /* invalidate only */
            invalidate_dcache_region(vaddr, size);
            break;
      case DMA_TO_DEVICE:           /* writeback only */
            clean_dcache_region(vaddr, size);
            break;
      case DMA_BIDIRECTIONAL:       /* writeback and invalidate */
            flush_dcache_region(vaddr, size);
            break;
      default:
            BUG();
      }
}
EXPORT_SYMBOL(dma_cache_sync);

static struct page *__dma_alloc(struct device *dev, size_t size,
                        dma_addr_t *handle, gfp_t gfp)
{
      struct page *page, *free, *end;
      int order;

      /* Following is a work-around (a.k.a. hack) to prevent pages
       * with __GFP_COMP being passed to split_page() which cannot
       * handle them.  The real problem is that this flag probably
       * should be 0 on AVR32 as it is not supported on this
       * platform--see CONFIG_HUGETLB_PAGE. */
      gfp &= ~(__GFP_COMP);

      size = PAGE_ALIGN(size);
      order = get_order(size);

      page = alloc_pages(gfp, order);
      if (!page)
            return NULL;
      split_page(page, order);

      /*
       * When accessing physical memory with valid cache data, we
       * get a cache hit even if the virtual memory region is marked
       * as uncached.
       *
       * Since the memory is newly allocated, there is no point in
       * doing a writeback. If the previous owner cares, he should
       * have flushed the cache before releasing the memory.
       */
      invalidate_dcache_region(phys_to_virt(page_to_phys(page)), size);

      *handle = page_to_bus(page);
      free = page + (size >> PAGE_SHIFT);
      end = page + (1 << order);

      /*
       * Free any unused pages
       */
      while (free < end) {
            __free_page(free);
            free++;
      }

      return page;
}

static void __dma_free(struct device *dev, size_t size,
                   struct page *page, dma_addr_t handle)
{
      struct page *end = page + (PAGE_ALIGN(size) >> PAGE_SHIFT);

      while (page < end)
            __free_page(page++);
}

void *dma_alloc_coherent(struct device *dev, size_t size,
                   dma_addr_t *handle, gfp_t gfp)
{
      struct page *page;
      void *ret = NULL;

      page = __dma_alloc(dev, size, handle, gfp);
      if (page)
            ret = phys_to_uncached(page_to_phys(page));

      return ret;
}
EXPORT_SYMBOL(dma_alloc_coherent);

void dma_free_coherent(struct device *dev, size_t size,
                   void *cpu_addr, dma_addr_t handle)
{
      void *addr = phys_to_cached(uncached_to_phys(cpu_addr));
      struct page *page;

      pr_debug("dma_free_coherent addr %p (phys %08lx) size %u\n",
             cpu_addr, (unsigned long)handle, (unsigned)size);
      BUG_ON(!virt_addr_valid(addr));
      page = virt_to_page(addr);
      __dma_free(dev, size, page, handle);
}
EXPORT_SYMBOL(dma_free_coherent);

void *dma_alloc_writecombine(struct device *dev, size_t size,
                       dma_addr_t *handle, gfp_t gfp)
{
      struct page *page;
      dma_addr_t phys;

      page = __dma_alloc(dev, size, handle, gfp);
      if (!page)
            return NULL;

      phys = page_to_phys(page);
      *handle = phys;

      /* Now, map the page into P3 with write-combining turned on */
      return __ioremap(phys, size, _PAGE_BUFFER);
}
EXPORT_SYMBOL(dma_alloc_writecombine);

void dma_free_writecombine(struct device *dev, size_t size,
                     void *cpu_addr, dma_addr_t handle)
{
      struct page *page;

      iounmap(cpu_addr);

      page = phys_to_page(handle);
      __dma_free(dev, size, page, handle);
}
EXPORT_SYMBOL(dma_free_writecombine);

Generated by  Doxygen 1.6.0   Back to index