Release 4.8 arch/mips/mm/dma-default.c

Directory: arch/mips/mm
/*
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2000  Ani Joshi <ajoshi@unixbox.com>
 * Copyright (C) 2000, 2001, 06  Ralf Baechle <ralf@linux-mips.org>
 * swiped from i386, and cloned for MIPS by Geert, polished by Ralf.
 */

#include <linux/types.h>
#include <linux/dma-mapping.h>
#include <linux/mm.h>
#include <linux/module.h>
#include <linux/scatterlist.h>
#include <linux/string.h>
#include <linux/gfp.h>
#include <linux/highmem.h>
#include <linux/dma-contiguous.h>

#include <asm/cache.h>
#include <asm/cpu-type.h>
#include <asm/io.h>

#include <dma-coherence.h>

#ifdef CONFIG_DMA_MAYBE_COHERENT

int coherentio = 0;	
/* User defined DMA coherency from command line. */

EXPORT_SYMBOL_GPL(coherentio);

int hw_coherentio = 0;	
/* Actual hardware supported DMA coherency setting. */



static int __init setcoherentio(char *str)
{
	coherentio = 1;
	pr_info("Hardware DMA cache coherency (command line)\n");
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
steven j. hill steven j. hill 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%

early_param("coherentio", setcoherentio);



static int __init setnocoherentio(char *str)
{
	coherentio = 0;
	pr_info("Software DMA cache coherency (command line)\n");
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
steven j. hill steven j. hill 23 100.00% 1 100.00%
Total 23 100.00% 1 100.00%

early_param("nocoherentio", setnocoherentio);
#endif



static inline struct page *dma_addr_to_page(struct device *dev,
	dma_addr_t dma_addr)
{
	return pfn_to_page(
		plat_dma_addr_to_phys(dev, dma_addr) >> PAGE_SHIFT);
}

Contributors
Person Tokens Prop Commits CommitProp
franck bui-huu franck bui-huu 14 46.67% 1 33.33%
dezhong diao dezhong diao 9 30.00% 1 33.33%
kevin cernekee kevin cernekee 7 23.33% 1 33.33%
Total 30 100.00% 3 100.00%

/*
 * The affected CPUs below in 'cpu_needs_post_dma_flush()' can
 * speculatively fill random cachelines with stale data at any time,
 * requiring an extra flush post-DMA.
 *
 * Warning on the terminology - Linux calls an uncached area coherent;
 * MIPS terminology calls memory areas with hardware maintained coherency
 * coherent.
 *
 * Note that the R14000 and R16000 should also be checked for in this
 * condition.  However this function is only called on non-I/O-coherent
 * systems and only the R10000 and R12000 are used in such systems, the
 * SGI IP28 IndigoÂ² rsp. SGI IP32 aka O2.
 */


static inline int cpu_needs_post_dma_flush(struct device *dev)
{
	return !plat_device_is_coherent(dev) &&
	       (boot_cpu_type() == CPU_R10000 ||
		boot_cpu_type() == CPU_R12000 ||
		boot_cpu_type() == CPU_BMIPS5000);
}

Contributors
Person Tokens Prop Commits CommitProp
ralf baechle ralf baechle 28 77.78% 3 50.00%
jim quinlan jim quinlan 5 13.89% 1 16.67%
jerin jacob jerin jacob 2 5.56% 1 16.67%
maxime bizon maxime bizon 1 2.78% 1 16.67%
Total 36 100.00% 6 100.00%



static gfp_t massage_gfp_flags(const struct device *dev, gfp_t gfp)
{
	gfp_t dma_flag;

	/* ignore region specifiers */
	gfp &= ~(__GFP_DMA | __GFP_DMA32 | __GFP_HIGHMEM);

#ifdef CONFIG_ISA
	if (dev == NULL)
		dma_flag = __GFP_DMA;
	else
#endif
#if defined(CONFIG_ZONE_DMA32) && defined(CONFIG_ZONE_DMA)
	     if (dev == NULL || dev->coherent_dma_mask < DMA_BIT_MASK(32))
			dma_flag = __GFP_DMA;
	else if (dev->coherent_dma_mask < DMA_BIT_MASK(64))
			dma_flag = __GFP_DMA32;
	else
#endif
#if defined(CONFIG_ZONE_DMA32) && !defined(CONFIG_ZONE_DMA)
	     if (dev == NULL || dev->coherent_dma_mask < DMA_BIT_MASK(64))
		dma_flag = __GFP_DMA32;
	else
#endif
#if defined(CONFIG_ZONE_DMA) && !defined(CONFIG_ZONE_DMA32)
	     if (dev == NULL ||
		 dev->coherent_dma_mask < DMA_BIT_MASK(sizeof(phys_addr_t) * 8))
		dma_flag = __GFP_DMA;
	else
#endif
		dma_flag = 0;

	/* Don't invoke OOM killer */
	gfp |= __GFP_NORETRY;

	return gfp | dma_flag;
}

Contributors
Person Tokens Prop Commits CommitProp
ralf baechle ralf baechle 134 73.63% 2 28.57%
andrew morton andrew morton 29 15.93% 2 28.57%
matt redfearn matt redfearn 12 6.59% 1 14.29%
james hogan james hogan 6 3.30% 1 14.29%
al viro al viro 1 0.55% 1 14.29%
Total 182 100.00% 7 100.00%



static void *mips_dma_alloc_noncoherent(struct device *dev, size_t size,
	dma_addr_t * dma_handle, gfp_t gfp)
{
	void *ret;

	gfp = massage_gfp_flags(dev, gfp);

	ret = (void *) __get_free_pages(gfp, get_order(size));

	if (ret != NULL) {
		memset(ret, 0, size);
		*dma_handle = plat_map_dma_mem(dev, ret, size);
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 45 54.22% 1 25.00%
ralf baechle ralf baechle 36 43.37% 2 50.00%
christoph hellwig christoph hellwig 2 2.41% 1 25.00%
Total 83 100.00% 4 100.00%



static void *mips_dma_alloc_coherent(struct device *dev, size_t size,
	dma_addr_t *dma_handle, gfp_t gfp, unsigned long attrs)
{
	void *ret;
	struct page *page = NULL;
	unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;

	/*
         * XXX: seems like the coherent and non-coherent implementations could
         * be consolidated.
         */
	if (attrs & DMA_ATTR_NON_CONSISTENT)
		return mips_dma_alloc_noncoherent(dev, size, dma_handle, gfp);

	gfp = massage_gfp_flags(dev, gfp);

	if (IS_ENABLED(CONFIG_DMA_CMA) && gfpflags_allow_blocking(gfp))
		page = dma_alloc_from_contiguous(dev,
					count, get_order(size));
	if (!page)
		page = alloc_pages(gfp, get_order(size));

	if (!page)
		return NULL;

	ret = page_address(page);
	memset(ret, 0, size);
	*dma_handle = plat_map_dma_mem(dev, ret, size);
	if (!plat_device_is_coherent(dev)) {
		dma_cache_wback_inv((unsigned long) ret, size);
		if (!hw_coherentio)
			ret = UNCAC_ADDR(ret);
	}

	return ret;
}


Contributors
Person Tokens Prop Commits CommitProp
zubair lutfullah zubair lutfullah 61 31.94% 1 9.09%
andrew morton andrew morton 57 29.84% 1 9.09%
ralf baechle ralf baechle 39 20.42% 2 18.18%
christoph hellwig christoph hellwig 17 8.90% 1 9.09%
steven j. hill steven j. hill 5 2.62% 1 9.09%
krzysztof kozlowski krzysztof kozlowski 4 2.09% 1 9.09%
qais yousef qais yousef 3 1.57% 1 9.09%
andrzej pietrasiewicz andrzej pietrasiewicz 2 1.05% 1 9.09%
david daney david daney 2 1.05% 1 9.09%
al viro al viro 1 0.52% 1 9.09%
Total 191 100.00% 11 100.00%



static void mips_dma_free_noncoherent(struct device *dev, size_t size,
		void *vaddr, dma_addr_t dma_handle)
{
	plat_unmap_dma_mem(dev, dma_handle, size, DMA_BIDIRECTIONAL);
	free_pages((unsigned long) vaddr, get_order(size));
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 33 71.74% 1 20.00%
david daney david daney 7 15.22% 2 40.00%
kevin cernekee kevin cernekee 4 8.70% 1 20.00%
christoph hellwig christoph hellwig 2 4.35% 1 20.00%
Total 46 100.00% 5 100.00%



static void mips_dma_free_coherent(struct device *dev, size_t size, void *vaddr,
	dma_addr_t dma_handle, unsigned long attrs)
{
	unsigned long addr = (unsigned long) vaddr;
	unsigned int count = PAGE_ALIGN(size) >> PAGE_SHIFT;
	struct page *page = NULL;

	if (attrs & DMA_ATTR_NON_CONSISTENT) {
		mips_dma_free_noncoherent(dev, size, vaddr, dma_handle);
		return;
	}

	plat_unmap_dma_mem(dev, dma_handle, size, DMA_BIDIRECTIONAL);

	if (!plat_device_is_coherent(dev) && !hw_coherentio)
		addr = CAC_ADDR(addr);

	page = virt_to_page((void *) addr);

	if (!dma_release_from_contiguous(dev, page, count))
		__free_pages(page, get_order(size));
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 45 33.33% 1 9.09%
zubair lutfullah zubair lutfullah 42 31.11% 1 9.09%
christoph hellwig christoph hellwig 18 13.33% 1 9.09%
david daney david daney 9 6.67% 3 27.27%
ralf baechle ralf baechle 8 5.93% 1 9.09%
kevin cernekee kevin cernekee 4 2.96% 1 9.09%
krzysztof kozlowski krzysztof kozlowski 4 2.96% 1 9.09%
steven j. hill steven j. hill 3 2.22% 1 9.09%
andrzej pietrasiewicz andrzej pietrasiewicz 2 1.48% 1 9.09%
Total 135 100.00% 11 100.00%



static int mips_dma_mmap(struct device *dev, struct vm_area_struct *vma,
	void *cpu_addr, dma_addr_t dma_addr, size_t size,
	unsigned long attrs)
{
	unsigned long user_count = (vma->vm_end - vma->vm_start) >> PAGE_SHIFT;
	unsigned long count = PAGE_ALIGN(size) >> PAGE_SHIFT;
	unsigned long addr = (unsigned long)cpu_addr;
	unsigned long off = vma->vm_pgoff;
	unsigned long pfn;
	int ret = -ENXIO;

	if (!plat_device_is_coherent(dev) && !hw_coherentio)
		addr = CAC_ADDR(addr);

	pfn = page_to_pfn(virt_to_page((void *)addr));

	if (attrs & DMA_ATTR_WRITE_COMBINE)
		vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot);
	else
		vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);

	if (dma_mmap_from_coherent(dev, vma, cpu_addr, size, &ret))
		return ret;

	if (off < count && user_count <= (count - off)) {
		ret = remap_pfn_range(vma, vma->vm_start,
				      pfn + off,
				      user_count << PAGE_SHIFT,
				      vma->vm_page_prot);
	}

	return ret;
}

Contributors
Person Tokens Prop Commits CommitProp
alex smith alex smith 203 98.07% 1 50.00%
krzysztof kozlowski krzysztof kozlowski 4 1.93% 1 50.00%
Total 207 100.00% 2 100.00%



static inline void __dma_sync_virtual(void *addr, size_t size,
	enum dma_data_direction direction)
{
	switch (direction) {
	case DMA_TO_DEVICE:
		dma_cache_wback((unsigned long)addr, size);
		break;

	case DMA_FROM_DEVICE:
		dma_cache_inv((unsigned long)addr, size);
		break;

	case DMA_BIDIRECTIONAL:
		dma_cache_wback_inv((unsigned long)addr, size);
		break;

	default:
		BUG();
	}
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 58 79.45% 1 50.00%
dezhong diao dezhong diao 15 20.55% 1 50.00%
Total 73 100.00% 2 100.00%

/*
 * A single sg entry may refer to multiple physically contiguous
 * pages. But we still need to process highmem pages individually.
 * If highmem is not configured then the bulk of this loop gets
 * optimized out.
 */


static inline void __dma_sync(struct page *page,
	unsigned long offset, size_t size, enum dma_data_direction direction)
{
	size_t left = size;

	do {
		size_t len = left;

		if (PageHighMem(page)) {
			void *addr;

			if (offset + len > PAGE_SIZE) {
				if (offset >= PAGE_SIZE) {
					page += offset >> PAGE_SHIFT;
					offset &= ~PAGE_MASK;
				}
				len = PAGE_SIZE - offset;
			}

			addr = kmap_atomic(page);
			__dma_sync_virtual(addr + offset, len, direction);
			kunmap_atomic(addr);
		} else
			__dma_sync_virtual(page_address(page) + offset,
					   size, direction);
		offset = 0;
		page++;
		left -= len;
	} while (left);
}

Contributors
Person Tokens Prop Commits CommitProp
dezhong diao dezhong diao 138 100.00% 1 100.00%
Total 138 100.00% 1 100.00%



static void mips_dma_unmap_page(struct device *dev, dma_addr_t dma_addr,
	size_t size, enum dma_data_direction direction, unsigned long attrs)
{
	if (cpu_needs_post_dma_flush(dev))
		__dma_sync(dma_addr_to_page(dev, dma_addr),
			   dma_addr & ~PAGE_MASK, size, direction);
	plat_post_dma_flush(dev);
	plat_unmap_dma_mem(dev, dma_addr, size, direction);
}

Contributors
Person Tokens Prop Commits CommitProp
ralf baechle ralf baechle 25 37.31% 2 20.00%
andrew morton andrew morton 21 31.34% 1 10.00%
david daney david daney 6 8.96% 2 20.00%
dezhong diao dezhong diao 6 8.96% 1 10.00%
kevin cernekee kevin cernekee 6 8.96% 2 20.00%
krzysztof kozlowski krzysztof kozlowski 2 2.99% 1 10.00%
jim quinlan jim quinlan 1 1.49% 1 10.00%
Total 67 100.00% 10 100.00%



static int mips_dma_map_sg(struct device *dev, struct scatterlist *sglist,
	int nents, enum dma_data_direction direction, unsigned long attrs)
{
	int i;
	struct scatterlist *sg;

	for_each_sg(sglist, sg, nents, i) {
		if (!plat_device_is_coherent(dev))
			__dma_sync(sg_page(sg), sg->offset, sg->length,
				   direction);
#ifdef CONFIG_NEED_SG_DMA_LENGTH
		sg->dma_length = sg->length;
#endif
		sg->dma_address = plat_map_dma_mem_page(dev, sg_page(sg)) +
				  sg->offset;
	}

	return nents;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 48 44.86% 1 12.50%
dezhong diao dezhong diao 16 14.95% 1 12.50%
akinobu mita akinobu mita 15 14.02% 1 12.50%
jayachandran c jayachandran c 13 12.15% 1 12.50%
ralf baechle ralf baechle 7 6.54% 1 12.50%
david daney david daney 4 3.74% 1 12.50%
thomas bogendoerfer thomas bogendoerfer 2 1.87% 1 12.50%
krzysztof kozlowski krzysztof kozlowski 2 1.87% 1 12.50%
Total 107 100.00% 8 100.00%



static dma_addr_t mips_dma_map_page(struct device *dev, struct page *page,
	unsigned long offset, size_t size, enum dma_data_direction direction,
	unsigned long attrs)
{
	if (!plat_device_is_coherent(dev))
		__dma_sync(page, offset, size, direction);

	return plat_map_dma_mem_page(dev, page) + offset;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 34 56.67% 1 16.67%
david daney david daney 12 20.00% 1 16.67%
dezhong diao dezhong diao 7 11.67% 1 16.67%
atsushi nemoto atsushi nemoto 3 5.00% 1 16.67%
krzysztof kozlowski krzysztof kozlowski 2 3.33% 1 16.67%
ralf baechle ralf baechle 2 3.33% 1 16.67%
Total 60 100.00% 6 100.00%



static void mips_dma_unmap_sg(struct device *dev, struct scatterlist *sglist,
	int nhwentries, enum dma_data_direction direction,
	unsigned long attrs)
{
	int i;
	struct scatterlist *sg;

	for_each_sg(sglist, sg, nhwentries, i) {
		if (!plat_device_is_coherent(dev) &&
		    direction != DMA_TO_DEVICE)
			__dma_sync(sg_page(sg), sg->offset, sg->length,
				   direction);
		plat_unmap_dma_mem(dev, sg->dma_address, sg->length, direction);
	}
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 34 36.96% 1 11.11%
ralf baechle ralf baechle 20 21.74% 1 11.11%
akinobu mita akinobu mita 15 16.30% 1 11.11%
dezhong diao dezhong diao 7 7.61% 1 11.11%
kevin cernekee kevin cernekee 6 6.52% 1 11.11%
david daney david daney 6 6.52% 2 22.22%
krzysztof kozlowski krzysztof kozlowski 2 2.17% 1 11.11%
thiemo seufer thiemo seufer 2 2.17% 1 11.11%
Total 92 100.00% 9 100.00%



static void mips_dma_sync_single_for_cpu(struct device *dev,
	dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
{
	if (cpu_needs_post_dma_flush(dev))
		__dma_sync(dma_addr_to_page(dev, dma_handle),
			   dma_handle & ~PAGE_MASK, size, direction);
	plat_post_dma_flush(dev);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 25 48.08% 2 25.00%
ralf baechle ralf baechle 14 26.92% 2 25.00%
dezhong diao dezhong diao 8 15.38% 1 12.50%
david daney david daney 2 3.85% 1 12.50%
kevin cernekee kevin cernekee 2 3.85% 1 12.50%
jim quinlan jim quinlan 1 1.92% 1 12.50%
Total 52 100.00% 8 100.00%



static void mips_dma_sync_single_for_device(struct device *dev,
	dma_addr_t dma_handle, size_t size, enum dma_data_direction direction)
{
	if (!plat_device_is_coherent(dev))
		__dma_sync(dma_addr_to_page(dev, dma_handle),
			   dma_handle & ~PAGE_MASK, size, direction);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 25 52.08% 1 16.67%
ralf baechle ralf baechle 9 18.75% 1 16.67%
dezhong diao dezhong diao 8 16.67% 1 16.67%
david daney david daney 2 4.17% 1 16.67%
thomas bogendoerfer thomas bogendoerfer 2 4.17% 1 16.67%
kevin cernekee kevin cernekee 2 4.17% 1 16.67%
Total 48 100.00% 6 100.00%



static void mips_dma_sync_sg_for_cpu(struct device *dev,
	struct scatterlist *sglist, int nelems,
	enum dma_data_direction direction)
{
	int i;
	struct scatterlist *sg;

	if (cpu_needs_post_dma_flush(dev)) {
		for_each_sg(sglist, sg, nelems, i) {
			__dma_sync(sg_page(sg), sg->offset, sg->length,
				   direction);
		}
	}
	plat_post_dma_flush(dev);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 33 44.00% 1 12.50%
akinobu mita akinobu mita 20 26.67% 1 12.50%
jayachandran c jayachandran c 7 9.33% 1 12.50%
ralf baechle ralf baechle 6 8.00% 2 25.00%
dezhong diao dezhong diao 4 5.33% 1 12.50%
jens axboe jens axboe 3 4.00% 1 12.50%
david daney david daney 2 2.67% 1 12.50%
Total 75 100.00% 8 100.00%



static void mips_dma_sync_sg_for_device(struct device *dev,
	struct scatterlist *sglist, int nelems,
	enum dma_data_direction direction)
{
	int i;
	struct scatterlist *sg;

	if (!plat_device_is_coherent(dev)) {
		for_each_sg(sglist, sg, nelems, i) {
			__dma_sync(sg_page(sg), sg->offset, sg->length,
				   direction);
		}
	}
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 33 46.48% 1 14.29%
akinobu mita akinobu mita 20 28.17% 1 14.29%
jayachandran c jayachandran c 8 11.27% 1 14.29%
dezhong diao dezhong diao 4 5.63% 1 14.29%
jens axboe jens axboe 3 4.23% 1 14.29%
david daney david daney 2 2.82% 1 14.29%
ralf baechle ralf baechle 1 1.41% 1 14.29%
Total 71 100.00% 7 100.00%



int mips_dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
{
	return 0;
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 9 56.25% 1 25.00%
fujita tomonori fujita tomonori 5 31.25% 1 25.00%
felix fietkau felix fietkau 1 6.25% 1 25.00%
david daney david daney 1 6.25% 1 25.00%
Total 16 100.00% 4 100.00%



int mips_dma_supported(struct device *dev, u64 mask)
{
	return plat_dma_supported(dev, mask);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 13 61.90% 1 25.00%
david daney david daney 6 28.57% 2 50.00%
ralf baechle ralf baechle 2 9.52% 1 25.00%
Total 21 100.00% 4 100.00%



void dma_cache_sync(struct device *dev, void *vaddr, size_t size,
			 enum dma_data_direction direction)
{
	BUG_ON(direction == DMA_NONE);

	if (!plat_device_is_coherent(dev))
		__dma_sync_virtual(vaddr, size, direction);
}

Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 25 55.56% 1 16.67%
ralf baechle ralf baechle 17 37.78% 3 50.00%
thomas bogendoerfer thomas bogendoerfer 2 4.44% 1 16.67%
dezhong diao dezhong diao 1 2.22% 1 16.67%
Total 45 100.00% 6 100.00%


EXPORT_SYMBOL(dma_cache_sync);


static struct dma_map_ops mips_default_dma_map_ops = {
	.alloc = mips_dma_alloc_coherent,
	.free = mips_dma_free_coherent,
	.mmap = mips_dma_mmap,
	.map_page = mips_dma_map_page,
	.unmap_page = mips_dma_unmap_page,
	.map_sg = mips_dma_map_sg,
	.unmap_sg = mips_dma_unmap_sg,
	.sync_single_for_cpu = mips_dma_sync_single_for_cpu,
	.sync_single_for_device = mips_dma_sync_single_for_device,
	.sync_sg_for_cpu = mips_dma_sync_sg_for_cpu,
	.sync_sg_for_device = mips_dma_sync_sg_for_device,
	.mapping_error = mips_dma_mapping_error,
	.dma_supported = mips_dma_supported
};


struct dma_map_ops *mips_dma_map_ops = &mips_default_dma_map_ops;

EXPORT_SYMBOL(mips_dma_map_ops);


#define PREALLOC_DMA_DEBUG_ENTRIES (1 << 16)



static int __init mips_dma_init(void)
{
	dma_debug_init(PREALLOC_DMA_DEBUG_ENTRIES);

	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
david daney david daney 17 100.00% 1 100.00%
Total 17 100.00% 1 100.00%


fs_initcall(mips_dma_init);
Overall Contributors
Person Tokens Prop Commits CommitProp
andrew morton andrew morton 588 29.18% 3 6.12%
ralf baechle ralf baechle 366 18.16% 12 24.49%
dezhong diao dezhong diao 227 11.27% 1 2.04%
alex smith alex smith 208 10.32% 1 2.04%
david daney david daney 161 7.99% 3 6.12%
zubair lutfullah zubair lutfullah 106 5.26% 1 2.04%
steven j. hill steven j. hill 85 4.22% 1 2.04%
akinobu mita akinobu mita 70 3.47% 1 2.04%
christoph hellwig christoph hellwig 39 1.94% 1 2.04%
kevin cernekee kevin cernekee 31 1.54% 2 4.08%
jayachandran c jayachandran c 28 1.39% 2 4.08%
krzysztof kozlowski krzysztof kozlowski 20 0.99% 1 2.04%
franck bui-huu franck bui-huu 14 0.69% 1 2.04%
matt redfearn matt redfearn 12 0.60% 1 2.04%
jens axboe jens axboe 8 0.40% 2 4.08%
jim quinlan jim quinlan 7 0.35% 1 2.04%
felix fietkau felix fietkau 6 0.30% 2 4.08%
james hogan james hogan 6 0.30% 1 2.04%
andrzej pietrasiewicz andrzej pietrasiewicz 6 0.30% 1 2.04%
thomas bogendoerfer thomas bogendoerfer 6 0.30% 3 6.12%
fujita tomonori fujita tomonori 5 0.25% 1 2.04%
atsushi nemoto atsushi nemoto 3 0.15% 1 2.04%
qais yousef qais yousef 3 0.15% 1 2.04%
tejun heo tejun heo 3 0.15% 1 2.04%
al viro al viro 2 0.10% 1 2.04%
thiemo seufer thiemo seufer 2 0.10% 1 2.04%
jerin jacob jerin jacob 2 0.10% 1 2.04%
maxime bizon maxime bizon 1 0.05% 1 2.04%
Total 2015 100.00% 49 100.00%
  Directory: arch/mips/mm

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.
	Person	Tokens	Prop	Commits	CommitProp
steven j. hill	steven j. hill	23	100.00%	1	100.00%
	Total	23	100.00%	1	100.00%
cregit-Linux how code gets into the kernel

Release 4.8 arch/mips/mm/dma-default.c

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Contributors

Overall Contributors
