Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 78bdc310 authored by Jens Axboe's avatar Jens Axboe
Browse files

PPC: sg chaining support 



This updates the ppc iommu/pci dma mappers to sg chaining. Includes
further fixes from FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>.

Signed-off-by: default avatarJens Axboe <jens.axboe@oracle.com>
parent d1ed455e

arch/powerpc/kernel/dma_64.c

+3 −2
Original line number Diff line number Diff line
@@ -154,12 +154,13 @@ static void dma_direct_unmap_single(struct device *dev, dma_addr_t dma_addr, 
{

}



static int dma_direct_map_sg(struct device *dev, struct scatterlist *sg,

static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,

			     int nents, enum dma_data_direction direction)

{

	struct scatterlist *sg;

	int i;



	for (i = 0; i < nents; i++, sg++) {

	for_each_sg(sgl, sg, nents, i) {

		sg->dma_address = (page_to_phys(sg->page) + sg->offset) |

			dma_direct_offset;

		sg->dma_length = sg->length;

arch/powerpc/kernel/ibmebus.c

+6 −5
Original line number Diff line number Diff line
@@ -87,15 +87,16 @@ static void ibmebus_unmap_single(struct device *dev, 
}



static int ibmebus_map_sg(struct device *dev,

			  struct scatterlist *sg,

			  struct scatterlist *sgl,

			  int nents, enum dma_data_direction direction)

{

	struct scatterlist *sg;

	int i;



	for (i = 0; i < nents; i++) {

		sg[i].dma_address = (dma_addr_t)page_address(sg[i].page)

			+ sg[i].offset;

		sg[i].dma_length = sg[i].length;

	for_each_sg(sgl, sg, nents, i) {

		sg->dma_address = (dma_addr_t)page_address(sg->page)

			+ sg->offset;

		sg->dma_length = sg->length;

	}



	return nents;

arch/powerpc/kernel/iommu.c

+14 −9
Original line number Diff line number Diff line
@@ -277,7 +277,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 
	dma_addr_t dma_next = 0, dma_addr;

	unsigned long flags;

	struct scatterlist *s, *outs, *segstart;

	int outcount, incount;

	int outcount, incount, i;

	unsigned long handle;



	BUG_ON(direction == DMA_NONE);
@@ -297,7 +297,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 


	spin_lock_irqsave(&(tbl->it_lock), flags);



	for (s = outs; nelems; nelems--, s++) {

	for_each_sg(sglist, s, nelems, i) {

		unsigned long vaddr, npages, entry, slen;



		slen = s->length;
@@ -341,7 +341,8 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 
			if (novmerge || (dma_addr != dma_next)) {

				/* Can't merge: create a new segment */

				segstart = s;

				outcount++; outs++;

				outcount++;

				outs = sg_next(outs);

				DBG("    can't merge, new segment.\n");

			} else {

				outs->dma_length += s->length;
@@ -374,7 +375,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 
	 * next entry of the sglist if we didn't fill the list completely

	 */

	if (outcount < incount) {

		outs++;

		outs = sg_next(outs);

		outs->dma_address = DMA_ERROR_CODE;

		outs->dma_length = 0;

	}
@@ -385,7 +386,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 
	return outcount;



 failure:

	for (s = &sglist[0]; s <= outs; s++) {

	for_each_sg(sglist, s, nelems, i) {

		if (s->dma_length != 0) {

			unsigned long vaddr, npages;
@@ -395,6 +396,8 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 
			s->dma_address = DMA_ERROR_CODE;

			s->dma_length = 0;

		}

		if (s == outs)

			break;

	}

	spin_unlock_irqrestore(&(tbl->it_lock), flags);

	return 0;
@@ -404,6 +407,7 @@ int iommu_map_sg(struct iommu_table *tbl, struct scatterlist *sglist, 
void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,

		int nelems, enum dma_data_direction direction)

{

	struct scatterlist *sg;

	unsigned long flags;



	BUG_ON(direction == DMA_NONE);
@@ -413,15 +417,16 @@ void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist, 


	spin_lock_irqsave(&(tbl->it_lock), flags);



	sg = sglist;

	while (nelems--) {

		unsigned int npages;

		dma_addr_t dma_handle = sglist->dma_address;

		dma_addr_t dma_handle = sg->dma_address;



		if (sglist->dma_length == 0)

		if (sg->dma_length == 0)

			break;

		npages = iommu_num_pages(dma_handle,sglist->dma_length);

		npages = iommu_num_pages(dma_handle, sg->dma_length);

		__iommu_free(tbl, dma_handle, npages);

		sglist++;

		sg = sg_next(sg);

	}



	/* Flush/invalidate TLBs if necessary. As for iommu_free(), we

include/asm-powerpc/dma-mapping.h

+9 −149
Original line number Diff line number Diff line
@@ -6,149 +6,6 @@ 
 */

#ifndef _ASM_DMA_MAPPING_H

#define _ASM_DMA_MAPPING_H

#ifdef __KERNEL__



#include <linux/types.h>

#include <linux/cache.h>

/* need struct page definitions */

#include <linux/mm.h>

#include <linux/scatterlist.h>

#include <asm/io.h>



#define DMA_ERROR_CODE		(~(dma_addr_t)0x0)



#ifdef CONFIG_NOT_COHERENT_CACHE

/*

 * DMA-consistent mapping functions for PowerPCs that don't support

 * cache snooping.  These allocate/free a region of uncached mapped

 * memory space for use with DMA devices.  Alternatively, you could

 * allocate the space "normally" and use the cache management functions

 * to ensure it is consistent.

 */

extern void *__dma_alloc_coherent(size_t size, dma_addr_t *handle, gfp_t gfp);

extern void __dma_free_coherent(size_t size, void *vaddr);

extern void __dma_sync(void *vaddr, size_t size, int direction);

extern void __dma_sync_page(struct page *page, unsigned long offset,

				 size_t size, int direction);



#else /* ! CONFIG_NOT_COHERENT_CACHE */

/*

 * Cache coherent cores.

 */



#define __dma_alloc_coherent(gfp, size, handle)	NULL

#define __dma_free_coherent(size, addr)		((void)0)

#define __dma_sync(addr, size, rw)		((void)0)

#define __dma_sync_page(pg, off, sz, rw)	((void)0)



#endif /* ! CONFIG_NOT_COHERENT_CACHE */



#ifdef CONFIG_PPC64

/*

 * DMA operations are abstracted for G5 vs. i/pSeries, PCI vs. VIO

 */

struct dma_mapping_ops {

	void *		(*alloc_coherent)(struct device *dev, size_t size,

				dma_addr_t *dma_handle, gfp_t flag);

	void		(*free_coherent)(struct device *dev, size_t size,

				void *vaddr, dma_addr_t dma_handle);

	dma_addr_t	(*map_single)(struct device *dev, void *ptr,

				size_t size, enum dma_data_direction direction);

	void		(*unmap_single)(struct device *dev, dma_addr_t dma_addr,

				size_t size, enum dma_data_direction direction);

	int		(*map_sg)(struct device *dev, struct scatterlist *sg,

				int nents, enum dma_data_direction direction);

	void		(*unmap_sg)(struct device *dev, struct scatterlist *sg,

				int nents, enum dma_data_direction direction);

	int		(*dma_supported)(struct device *dev, u64 mask);

	int		(*set_dma_mask)(struct device *dev, u64 dma_mask);

};



static inline struct dma_mapping_ops *get_dma_ops(struct device *dev)

{

	/* We don't handle the NULL dev case for ISA for now. We could

	 * do it via an out of line call but it is not needed for now. The

	 * only ISA DMA device we support is the floppy and we have a hack

	 * in the floppy driver directly to get a device for us.

	 */

	if (unlikely(dev == NULL || dev->archdata.dma_ops == NULL))

		return NULL;

	return dev->archdata.dma_ops;

}



static inline int dma_supported(struct device *dev, u64 mask)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	if (unlikely(dma_ops == NULL))

		return 0;

	if (dma_ops->dma_supported == NULL)

		return 1;

	return dma_ops->dma_supported(dev, mask);

}



static inline int dma_set_mask(struct device *dev, u64 dma_mask)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	if (unlikely(dma_ops == NULL))

		return -EIO;

	if (dma_ops->set_dma_mask != NULL)

		return dma_ops->set_dma_mask(dev, dma_mask);

	if (!dev->dma_mask || !dma_supported(dev, dma_mask))

		return -EIO;

	*dev->dma_mask = dma_mask;

	return 0;

}



static inline void *dma_alloc_coherent(struct device *dev, size_t size,

				       dma_addr_t *dma_handle, gfp_t flag)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	BUG_ON(!dma_ops);

	return dma_ops->alloc_coherent(dev, size, dma_handle, flag);

}



static inline void dma_free_coherent(struct device *dev, size_t size,

				     void *cpu_addr, dma_addr_t dma_handle)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	BUG_ON(!dma_ops);

	dma_ops->free_coherent(dev, size, cpu_addr, dma_handle);

}



static inline dma_addr_t dma_map_single(struct device *dev, void *cpu_addr,

					size_t size,

					enum dma_data_direction direction)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	BUG_ON(!dma_ops);

	return dma_ops->map_single(dev, cpu_addr, size, direction);

}



static inline void dma_unmap_single(struct device *dev, dma_addr_t dma_addr,

				    size_t size,

				    enum dma_data_direction direction)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	BUG_ON(!dma_ops);

	dma_ops->unmap_single(dev, dma_addr, size, direction);

}



static inline dma_addr_t dma_map_page(struct device *dev, struct page *page,

				      unsigned long offset, size_t size,

				      enum dma_data_direction direction)

{

	struct dma_mapping_ops *dma_ops = get_dma_ops(dev);



	BUG_ON(!dma_ops);

	return dma_ops->map_single(dev, page_address(page) + offset, size,

			direction);

}



static inline void dma_unmap_page(struct device *dev, dma_addr_t dma_address,

				  size_t size,
@@ -276,14 +133,15 @@ static inline void dma_unmap_page(struct device *dev, dma_addr_t dma_address, 
}



static inline int

dma_map_sg(struct device *dev, struct scatterlist *sg, int nents,

dma_map_sg(struct device *dev, struct scatterlist *sgl, int nents,

	   enum dma_data_direction direction)

{

	struct scatterlist *sg;

	int i;



	BUG_ON(direction == DMA_NONE);



	for (i = 0; i < nents; i++, sg++) {

	for_each_sg(sgl, sg, nents, i) {

		BUG_ON(!sg->page);

		__dma_sync_page(sg->page, sg->offset, sg->length, direction);

		sg->dma_address = page_to_bus(sg->page) + sg->offset;
@@ -318,26 +176,28 @@ static inline void dma_sync_single_for_device(struct device *dev, 
}



static inline void dma_sync_sg_for_cpu(struct device *dev,

		struct scatterlist *sg, int nents,

		struct scatterlist *sgl, int nents,

		enum dma_data_direction direction)

{

	struct scatterlist *sg;

	int i;



	BUG_ON(direction == DMA_NONE);



	for (i = 0; i < nents; i++, sg++)

	for_each_sg(sgl, sg, nents, i)

		__dma_sync_page(sg->page, sg->offset, sg->length, direction);

}



static inline void dma_sync_sg_for_device(struct device *dev,

		struct scatterlist *sg, int nents,

		struct scatterlist *sgl, int nents,

		enum dma_data_direction direction)

{

	struct scatterlist *sg;

	int i;



	BUG_ON(direction == DMA_NONE);



	for (i = 0; i < nents; i++, sg++)

	for_each_sg(sgl, sg, nents, i)

		__dma_sync_page(sg->page, sg->offset, sg->length, direction);

}

include/asm-powerpc/scatterlist.h

+2 −0
Original line number Diff line number Diff line
@@ -41,5 +41,7 @@ struct scatterlist { 
#define ISA_DMA_THRESHOLD	(~0UL)

#endif



#define ARCH_HAS_SG_CHAIN



#endif /* __KERNEL__ */

#endif /* _ASM_POWERPC_SCATTERLIST_H */