Release 4.7 arch/microblaze/kernel/dma.c
/*
* Copyright (C) 2009-2010 PetaLogix
* Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corporation
*
* Provide default implementations of the DMA mapping callbacks for
* directly mapped busses.
*/
#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/gfp.h>
#include <linux/dma-debug.h>
#include <linux/export.h>
#include <linux/bug.h>
#define NOT_COHERENT_CACHE
static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
dma_addr_t *dma_handle, gfp_t flag,
struct dma_attrs *attrs)
{
#ifdef NOT_COHERENT_CACHE
return consistent_alloc(flag, size, dma_handle);
#else
void *ret;
struct page *page;
int node = dev_to_node(dev);
/* ignore region specifiers */
flag &= ~(__GFP_HIGHMEM);
page = alloc_pages_node(node, flag, get_order(size));
if (page == NULL)
return NULL;
ret = page_address(page);
memset(ret, 0, size);
*dma_handle = virt_to_phys(ret);
return ret;
#endif
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 114 | 95.80% | 2 | 66.67% |
| andrzej pietrasiewicz | andrzej pietrasiewicz | 5 | 4.20% | 1 | 33.33% |
| Total | 119 | 100.00% | 3 | 100.00% |
static void dma_direct_free_coherent(struct device *dev, size_t size,
void *vaddr, dma_addr_t dma_handle,
struct dma_attrs *attrs)
{
#ifdef NOT_COHERENT_CACHE
consistent_free(size, vaddr);
#else
free_pages((unsigned long)vaddr, get_order(size));
#endif
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 49 | 90.74% | 3 | 75.00% |
| andrzej pietrasiewicz | andrzej pietrasiewicz | 5 | 9.26% | 1 | 25.00% |
| Total | 54 | 100.00% | 4 | 100.00% |
static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
int nents, enum dma_data_direction direction,
struct dma_attrs *attrs)
{
struct scatterlist *sg;
int i;
/* FIXME this part of code is untested */
for_each_sg(sgl, sg, nents, i) {
sg->dma_address = sg_phys(sg);
__dma_sync(page_to_phys(sg_page(sg)) + sg->offset,
sg->length, direction);
}
return nents;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 73 | 89.02% | 2 | 50.00% |
| dan williams | dan williams | 8 | 9.76% | 1 | 25.00% |
| eli billauer | eli billauer | 1 | 1.22% | 1 | 25.00% |
| Total | 82 | 100.00% | 4 | 100.00% |
static int dma_direct_dma_supported(struct device *dev, u64 mask)
{
return 1;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 17 | 100.00% | 1 | 100.00% |
| Total | 17 | 100.00% | 1 | 100.00% |
static inline dma_addr_t dma_direct_map_page(struct device *dev,
struct page *page,
unsigned long offset,
size_t size,
enum dma_data_direction direction,
struct dma_attrs *attrs)
{
__dma_sync(page_to_phys(page) + offset, size, direction);
return page_to_phys(page) + offset;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 53 | 96.36% | 3 | 75.00% |
| eli billauer | eli billauer | 2 | 3.64% | 1 | 25.00% |
| Total | 55 | 100.00% | 4 | 100.00% |
static inline void dma_direct_unmap_page(struct device *dev,
dma_addr_t dma_address,
size_t size,
enum dma_data_direction direction,
struct dma_attrs *attrs)
{
/* There is not necessary to do cache cleanup
*
* phys_to_virt is here because in __dma_sync_page is __virt_to_phys and
* dma_address is physical address
*/
__dma_sync(dma_address, size, direction);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 36 | 97.30% | 3 | 75.00% |
| eli billauer | eli billauer | 1 | 2.70% | 1 | 25.00% |
| Total | 37 | 100.00% | 4 | 100.00% |
static inline void
dma_direct_sync_single_for_cpu(struct device *dev,
dma_addr_t dma_handle, size_t size,
enum dma_data_direction direction)
{
/*
* It's pointless to flush the cache as the memory segment
* is given to the CPU
*/
if (direction == DMA_FROM_DEVICE)
__dma_sync(dma_handle, size, direction);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| eli billauer | eli billauer | 38 | 100.00% | 1 | 100.00% |
| Total | 38 | 100.00% | 1 | 100.00% |
static inline void
dma_direct_sync_single_for_device(struct device *dev,
dma_addr_t dma_handle, size_t size,
enum dma_data_direction direction)
{
/*
* It's pointless to invalidate the cache if the device isn't
* supposed to write to the relevant region
*/
if (direction == DMA_TO_DEVICE)
__dma_sync(dma_handle, size, direction);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| eli billauer | eli billauer | 38 | 100.00% | 1 | 100.00% |
| Total | 38 | 100.00% | 1 | 100.00% |
static inline void
dma_direct_sync_sg_for_cpu(struct device *dev,
struct scatterlist *sgl, int nents,
enum dma_data_direction direction)
{
struct scatterlist *sg;
int i;
/* FIXME this part of code is untested */
if (direction == DMA_FROM_DEVICE)
for_each_sg(sgl, sg, nents, i)
__dma_sync(sg->dma_address, sg->length, direction);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| eli billauer | eli billauer | 62 | 100.00% | 1 | 100.00% |
| Total | 62 | 100.00% | 1 | 100.00% |
static inline void
dma_direct_sync_sg_for_device(struct device *dev,
struct scatterlist *sgl, int nents,
enum dma_data_direction direction)
{
struct scatterlist *sg;
int i;
/* FIXME this part of code is untested */
if (direction == DMA_TO_DEVICE)
for_each_sg(sgl, sg, nents, i)
__dma_sync(sg->dma_address, sg->length, direction);
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| eli billauer | eli billauer | 62 | 100.00% | 1 | 100.00% |
| Total | 62 | 100.00% | 1 | 100.00% |
static
int dma_direct_mmap_coherent(struct device *dev, struct vm_area_struct *vma,
void *cpu_addr, dma_addr_t handle, size_t size,
struct dma_attrs *attrs)
{
#ifdef CONFIG_MMU
unsigned long user_count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
unsigned long off = vma->vm_pgoff;
unsigned long pfn;
if (off >= count || user_count > (count - off))
return -ENXIO;
#ifdef NOT_COHERENT_CACHE
vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
pfn = consistent_virt_to_pfn(cpu_addr);
#else
pfn = virt_to_pfn(cpu_addr);
#endif
return remap_pfn_range(vma, vma->vm_start, pfn + off,
vma->vm_end - vma->vm_start, vma->vm_page_prot);
#else
return -ENXIO;
#endif
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| lars-peter clausen | lars-peter clausen | 156 | 99.36% | 1 | 50.00% |
| michal simek | michal simek | 1 | 0.64% | 1 | 50.00% |
| Total | 157 | 100.00% | 2 | 100.00% |
struct dma_map_ops dma_direct_ops = {
.alloc = dma_direct_alloc_coherent,
.free = dma_direct_free_coherent,
.mmap = dma_direct_mmap_coherent,
.map_sg = dma_direct_map_sg,
.dma_supported = dma_direct_dma_supported,
.map_page = dma_direct_map_page,
.unmap_page = dma_direct_unmap_page,
.sync_single_for_cpu = dma_direct_sync_single_for_cpu,
.sync_single_for_device = dma_direct_sync_single_for_device,
.sync_sg_for_cpu = dma_direct_sync_sg_for_cpu,
.sync_sg_for_device = dma_direct_sync_sg_for_device,
};
EXPORT_SYMBOL(dma_direct_ops);
/* Number of entries preallocated for DMA-API debugging */
#define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)
static int __init dma_init(void)
{
dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);
return 0;
}
Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 17 | 100.00% | 1 | 100.00% |
| Total | 17 | 100.00% | 1 | 100.00% |
fs_initcall(dma_init);
Overall Contributors
| Person | Tokens | Prop | Commits | CommitProp |
| michal simek | michal simek | 425 | 50.84% | 7 | 50.00% |
| eli billauer | eli billauer | 224 | 26.79% | 2 | 14.29% |
| lars-peter clausen | lars-peter clausen | 161 | 19.26% | 1 | 7.14% |
| andrzej pietrasiewicz | andrzej pietrasiewicz | 12 | 1.44% | 1 | 7.14% |
| dan williams | dan williams | 8 | 0.96% | 1 | 7.14% |
| paul gortmaker | paul gortmaker | 3 | 0.36% | 1 | 7.14% |
| tejun heo | tejun heo | 3 | 0.36% | 1 | 7.14% |
| Total | 836 | 100.00% | 14 | 100.00% |
Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.