Release 4.11 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/export.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>

#if defined(CONFIG_DMA_MAYBE_COHERENT) && !defined(CONFIG_DMA_PERDEV_COHERENT)
/* User defined DMA coherency from command line. */

enum coherent_io_user_state coherentio = IO_COHERENCE_DEFAULT;

EXPORT_SYMBOL_GPL(coherentio);

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



static int __init setcoherentio(char *str)
{
	coherentio = IO_COHERENCE_ENABLED;
	pr_info("Hardware DMA cache coherency (command line)\n");
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Steven J. Hill 22 95.65% 1 50.00%
Paul Burton 1 4.35% 1 50.00%
Total 23 100.00% 2 100.00%

early_param("coherentio", setcoherentio);



static int __init setnocoherentio(char *str)
{
	coherentio = IO_COHERENCE_DISABLED;
	pr_info("Software DMA cache coherency (command line)\n");
	return 0;
}
Contributors
Person Tokens Prop Commits CommitProp
Steven J. Hill 22 95.65% 1 50.00%
Paul Burton 1 4.35% 1 50.00%
Total 23 100.00% 2 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 14 46.67% 1 33.33%
Dezhong Diao 9 30.00% 1 33.33%
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 Bächle 28 77.78% 3 50.00%
Jim Quinlan 5 13.89% 1 16.67%
Jerin Jacob 2 5.56% 1 16.67%
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 Bächle 134 73.63% 2 28.57%
Andrew Morton 29 15.93% 2 28.57%
Matt Redfearn 12 6.59% 1 14.29%
James Hogan 6 3.30% 1 14.29%
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 45 54.22% 1 25.00%
Ralf Bächle 36 43.37% 2 50.00%
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),
						 gfp);
	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);
		ret = UNCAC_ADDR(ret);
	}

	return ret;
}


Contributors
Person Tokens Prop Commits CommitProp
Zubair Lutfullah Kakakhel 61 32.45% 1 9.09%
Andrew Morton 57 30.32% 1 9.09%
Ralf Bächle 39 20.74% 2 18.18%
Christoph Hellwig 17 9.04% 1 9.09%
Krzysztof Kozlowski 4 2.13% 1 9.09%
Qais Yousef 3 1.60% 1 9.09%
Andrzej Pietrasiewicz 2 1.06% 1 9.09%
Lucas Stach 2 1.06% 1 9.09%
David Daney 2 1.06% 1 9.09%
Al Viro 1 0.53% 1 9.09%
Total 188 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 33 71.74% 1 20.00%
David Daney 7 15.22% 2 40.00%
Kevin Cernekee 4 8.70% 1 20.00%
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))
		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 45 34.09% 1 10.00%
Zubair Lutfullah Kakakhel 42 31.82% 1 10.00%
Christoph Hellwig 18 13.64% 1 10.00%
David Daney 9 6.82% 3 30.00%
Ralf Bächle 8 6.06% 1 10.00%
Krzysztof Kozlowski 4 3.03% 1 10.00%
Kevin Cernekee 4 3.03% 1 10.00%
Andrzej Pietrasiewicz 2 1.52% 1 10.00%
Total 132 100.00% 10 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))
		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 200 98.04% 1 50.00%
Krzysztof Kozlowski 4 1.96% 1 50.00%
Total 204 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 58 79.45% 1 50.00%
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 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) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
		__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 Bächle 25 33.78% 2 18.18%
Andrew Morton 21 28.38% 1 9.09%
Alexander Duyck 7 9.46% 1 9.09%
Kevin Cernekee 6 8.11% 2 18.18%
David Daney 6 8.11% 2 18.18%
Dezhong Diao 6 8.11% 1 9.09%
Krzysztof Kozlowski 2 2.70% 1 9.09%
Jim Quinlan 1 1.35% 1 9.09%
Total 74 100.00% 11 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) &&
		    !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
			__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 48 42.11% 1 11.11%
Dezhong Diao 16 14.04% 1 11.11%
Akinobu Mita 15 13.16% 1 11.11%
Jayachandran C 13 11.40% 1 11.11%
Alexander Duyck 7 6.14% 1 11.11%
Ralf Bächle 7 6.14% 1 11.11%
David Daney 4 3.51% 1 11.11%
Krzysztof Kozlowski 2 1.75% 1 11.11%
Thomas Bogendoerfer 2 1.75% 1 11.11%
Total 114 100.00% 9 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) && !(attrs & DMA_ATTR_SKIP_CPU_SYNC))
		__dma_sync(page, offset, size, direction);

	return plat_map_dma_mem_page(dev, page) + offset;
}

Contributors
Person Tokens Prop Commits CommitProp
Andrew Morton 34 50.75% 1 14.29%
David Daney 12 17.91% 1 14.29%
Dezhong Diao 7 10.45% 1 14.29%
Alexander Duyck 7 10.45% 1 14.29%
Atsushi Nemoto 3 4.48% 1 14.29%
Krzysztof Kozlowski 2 2.99% 1 14.29%
Ralf Bächle 2 2.99% 1 14.29%
Total 67 100.00% 7 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) &&
		    !(attrs & DMA_ATTR_SKIP_CPU_SYNC) &&
		    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 34 34.34% 1 10.00%
Ralf Bächle 20 20.20% 1 10.00%
Akinobu Mita 15 15.15% 1 10.00%
Dezhong Diao 7 7.07% 1 10.00%
Alexander Duyck 7 7.07% 1 10.00%
David Daney 6 6.06% 2 20.00%
Kevin Cernekee 6 6.06% 1 10.00%
Krzysztof Kozlowski 2 2.02% 1 10.00%
Thiemo Seufer 2 2.02% 1 10.00%
Total 99 100.00% 10 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 25 48.08% 2 25.00%
Ralf Bächle 14 26.92% 2 25.00%
Dezhong Diao 8 15.38% 1 12.50%
Kevin Cernekee 2 3.85% 1 12.50%
David Daney 2 3.85% 1 12.50%
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 25 52.08% 1 16.67%
Ralf Bächle 9 18.75% 1 16.67%
Dezhong Diao 8 16.67% 1 16.67%
Kevin Cernekee 2 4.17% 1 16.67%
David Daney 2 4.17% 1 16.67%
Thomas Bogendoerfer 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 33 44.00% 1 12.50%
Akinobu Mita 20 26.67% 1 12.50%
Jayachandran C 7 9.33% 1 12.50%
Ralf Bächle 6 8.00% 2 25.00%
Dezhong Diao 4 5.33% 1 12.50%
Jens Axboe 3 4.00% 1 12.50%
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 33 46.48% 1 14.29%
Akinobu Mita 20 28.17% 1 14.29%
Jayachandran C 8 11.27% 1 14.29%
Dezhong Diao 4 5.63% 1 14.29%
Jens Axboe 3 4.23% 1 14.29%
David Daney 2 2.82% 1 14.29%
Ralf Bächle 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 9 56.25% 1 25.00%
FUJITA Tomonori 5 31.25% 1 25.00%
David Daney 1 6.25% 1 25.00%
Felix Fietkau 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 13 61.90% 1 25.00%
David Daney 6 28.57% 2 50.00%
Ralf Bächle 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 25 55.56% 1 16.67%
Ralf Bächle 17 37.78% 3 50.00%
Thomas Bogendoerfer 2 4.44% 1 16.67%
Dezhong Diao 1 2.22% 1 16.67%
Total 45 100.00% 6 100.00%


EXPORT_SYMBOL(dma_cache_sync);


static const 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
};


const 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 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 587 28.69% 3 5.45%
Ralf Bächle 366 17.89% 12 21.82%
Dezhong Diao 227 11.09% 1 1.82%
Alex Smith 205 10.02% 1 1.82%
David Daney 161 7.87% 3 5.45%
Zubair Lutfullah Kakakhel 106 5.18% 1 1.82%
Steven J. Hill 72 3.52% 1 1.82%
Akinobu Mita 70 3.42% 1 1.82%
Christoph Hellwig 39 1.91% 1 1.82%
Kevin Cernekee 31 1.52% 2 3.64%
Alexander Duyck 28 1.37% 1 1.82%
Jayachandran C 28 1.37% 2 3.64%
Krzysztof Kozlowski 20 0.98% 1 1.82%
Paul Burton 17 0.83% 2 3.64%
Franck Bui-Huu 14 0.68% 1 1.82%
Matt Redfearn 12 0.59% 1 1.82%
Jens Axboe 8 0.39% 2 3.64%
Jim Quinlan 7 0.34% 1 1.82%
Andrzej Pietrasiewicz 6 0.29% 1 1.82%
Thomas Bogendoerfer 6 0.29% 3 5.45%
James Hogan 6 0.29% 1 1.82%
FUJITA Tomonori 5 0.24% 1 1.82%
Felix Fietkau 4 0.20% 2 3.64%
Atsushi Nemoto 3 0.15% 1 1.82%
Tejun Heo 3 0.15% 1 1.82%
Qais Yousef 3 0.15% 1 1.82%
Al Viro 2 0.10% 1 1.82%
Bart Van Assche 2 0.10% 1 1.82%
Jerin Jacob 2 0.10% 1 1.82%
Thiemo Seufer 2 0.10% 1 1.82%
Lucas Stach 2 0.10% 1 1.82%
Maxime Bizon 1 0.05% 1 1.82%
Paul Gortmaker 1 0.05% 1 1.82%
Total 2046 100.00% 55 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.
Created with cregit.
Person	Tokens	Prop	Commits	CommitProp
Steven J. Hill	22	95.65%	1	50.00%
Paul Burton	1	4.35%	1	50.00%
Total	23	100.00%	2	100.00%
cregit-Linux how code gets into the kernel

Release 4.11 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
