Skip to content

L
linux
Commit e1df56ff authored by Andrew Morton's avatar Andrew Morton Committed by Linus Torvalds
Browse files
Options

[PATCH] ppc64: Consolidate some of the iommu DMA mapping routines. 

From: Stephen Rothwell <sfr@canb.auug.org.au>

This patch consolidates some of the iommu DMA mapping routines.
parent 9b678c1e
Hide whitespace changes
Inline Side-by-side
Showing with 149 additions and 244 deletions
arch/ppc64/kernel/iommu.c
View file @ e1df56ff
...@@ -140,7 +140,7 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl, unsigned long np ...@@ -140,7 +140,7 @@ static unsigned long iommu_range_alloc(struct iommu_table *tbl, unsigned long np
return n; return n;
} }
dma_addr_t iommu_alloc(struct iommu_table *tbl, void *page, static dma_addr_t iommu_alloc(struct iommu_table *tbl, void *page,
unsigned int npages, enum dma_data_direction direction) unsigned int npages, enum dma_data_direction direction)
{ {
unsigned long entry, flags; unsigned long entry, flags;
...@@ -206,7 +206,7 @@ static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr, ...@@ -206,7 +206,7 @@ static void __iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
__clear_bit(free_entry+i, tbl->it_map); __clear_bit(free_entry+i, tbl->it_map);
} }
void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr, static void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
unsigned int npages) unsigned int npages)
{ {
unsigned long flags; unsigned long flags;
...@@ -225,9 +225,9 @@ void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr, ...@@ -225,9 +225,9 @@ void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr,
spin_unlock_irqrestore(&(tbl->it_lock), flags); spin_unlock_irqrestore(&(tbl->it_lock), flags);
} }
int iommu_alloc_sg(struct iommu_table *tbl, struct device *dev, int iommu_map_sg(struct device *dev, struct iommu_table *tbl,
struct scatterlist *sglist, int nelems, struct scatterlist *sglist, int nelems,
enum dma_data_direction direction) enum dma_data_direction direction)
{ {
dma_addr_t dma_next, dma_addr; dma_addr_t dma_next, dma_addr;
unsigned long flags; unsigned long flags;
...@@ -235,6 +235,11 @@ int iommu_alloc_sg(struct iommu_table *tbl, struct device *dev, ...@@ -235,6 +235,11 @@ int iommu_alloc_sg(struct iommu_table *tbl, struct device *dev,
int outcount; int outcount;
unsigned long handle; unsigned long handle;
BUG_ON(direction == DMA_NONE);
if ((nelems == 0) || !tbl)
return 0;
outs = s = segstart = &sglist[0]; outs = s = segstart = &sglist[0];
outcount = 1; outcount = 1;
handle = 0; handle = 0;
...@@ -349,11 +354,16 @@ int iommu_alloc_sg(struct iommu_table *tbl, struct device *dev, ...@@ -349,11 +354,16 @@ int iommu_alloc_sg(struct iommu_table *tbl, struct device *dev,
} }
void iommu_free_sg(struct iommu_table *tbl, struct scatterlist *sglist, void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,
int nelems) int nelems, enum dma_data_direction direction)
{ {
unsigned long flags; unsigned long flags;
BUG_ON(direction == DMA_NONE);
if (!tbl)
return;
spin_lock_irqsave(&(tbl->it_lock), flags); spin_lock_irqsave(&(tbl->it_lock), flags);
while (nelems--) { while (nelems--) {
...@@ -414,3 +424,104 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl) ...@@ -414,3 +424,104 @@ struct iommu_table *iommu_init_table(struct iommu_table *tbl)
return tbl; return tbl;
} }
/* Creates TCEs for a user provided buffer. The user buffer must be
* contiguous real kernel storage (not vmalloc). The address of the buffer
* passed here is the kernel (virtual) address of the buffer. The buffer
* need not be page aligned, the dma_addr_t returned will point to the same
* byte within the page as vaddr.
*/
dma_addr_t iommu_map_single(struct iommu_table *tbl, void *vaddr,
size_t size, enum dma_data_direction direction)
{
dma_addr_t dma_handle = DMA_ERROR_CODE;
unsigned long uaddr;
unsigned int npages;
BUG_ON(direction == DMA_NONE);
uaddr = (unsigned long)vaddr;
npages = PAGE_ALIGN(uaddr + size) - (uaddr & PAGE_MASK);
npages >>= PAGE_SHIFT;
if (tbl) {
dma_handle = iommu_alloc(tbl, vaddr, npages, direction);
if (dma_handle == DMA_ERROR_CODE) {
if (printk_ratelimit()) {
printk(KERN_INFO "iommu_alloc failed, "
"tbl %p vaddr %p npages %d\n",
tbl, vaddr, npages);
}
} else
dma_handle |= (uaddr & ~PAGE_MASK);
}
return dma_handle;
}
void iommu_unmap_single(struct iommu_table *tbl, dma_addr_t dma_handle,
size_t size, enum dma_data_direction direction)
{
BUG_ON(direction == DMA_NONE);
if (tbl)
iommu_free(tbl, dma_handle, (PAGE_ALIGN(dma_handle + size) -
(dma_handle & PAGE_MASK)) >> PAGE_SHIFT);
}
/* Allocates a contiguous real buffer and creates mappings over it.
* Returns the virtual address of the buffer and sets dma_handle
* to the dma address (mapping) of the first page.
*/
void *iommu_alloc_consistent(struct iommu_table *tbl, size_t size,
dma_addr_t *dma_handle)
{
void *ret = NULL;
dma_addr_t mapping;
unsigned int npages, order;
size = PAGE_ALIGN(size);
npages = size >> PAGE_SHIFT;
order = get_order(size);
/*
* Client asked for way too much space. This is checked later
* anyway. It is easier to debug here for the drivers than in
* the tce tables.
*/
if (order >= IOMAP_MAX_ORDER) {
printk("iommu_alloc_consistent size too large: 0x%lx\n", size);
return (void *)DMA_ERROR_CODE;
}
if (!tbl)
return NULL;
/* Alloc enough pages (and possibly more) */
ret = (void *)__get_free_pages(GFP_ATOMIC, order);
if (!ret)
return NULL;
memset(ret, 0, size);
/* Set up tces to cover the allocated range */
mapping = iommu_alloc(tbl, ret, npages, DMA_BIDIRECTIONAL);
if (mapping == DMA_ERROR_CODE) {
free_pages((unsigned long)ret, order);
ret = NULL;
} else
*dma_handle = mapping;
return ret;
}
void iommu_free_consistent(struct iommu_table *tbl, size_t size,
void *vaddr, dma_addr_t dma_handle)
{
unsigned int npages;
if (tbl) {
size = PAGE_ALIGN(size);
npages = size >> PAGE_SHIFT;
iommu_free(tbl, dma_handle, npages);
free_pages((unsigned long)vaddr, get_order(size));
}
}
arch/ppc64/kernel/pci_iommu.c
View file @ e1df56ff
...@@ -43,8 +43,6 @@ ...@@ -43,8 +43,6 @@
#include <asm/iSeries/iSeries_pci.h> #include <asm/iSeries/iSeries_pci.h>
#endif /* CONFIG_PPC_ISERIES */ #endif /* CONFIG_PPC_ISERIES */
#define DBG(...)
static inline struct iommu_table *devnode_table(struct pci_dev *dev) static inline struct iommu_table *devnode_table(struct pci_dev *dev)
{ {
if (!dev) if (!dev)
...@@ -69,67 +67,15 @@ static inline struct iommu_table *devnode_table(struct pci_dev *dev) ...@@ -69,67 +67,15 @@ static inline struct iommu_table *devnode_table(struct pci_dev *dev)
static void *pci_iommu_alloc_consistent(struct pci_dev *hwdev, size_t size, static void *pci_iommu_alloc_consistent(struct pci_dev *hwdev, size_t size,
dma_addr_t *dma_handle) dma_addr_t *dma_handle)
{ {
struct iommu_table *tbl; return iommu_alloc_consistent(devnode_table(hwdev), size, dma_handle);
void *ret = NULL;
dma_addr_t mapping;
unsigned int npages, order;
size = PAGE_ALIGN(size);
npages = size >> PAGE_SHIFT;
order = get_order(size);
/* Client asked for way too much space. This is checked later anyway */
/* It is easier to debug here for the drivers than in the tce tables.*/
if (order >= IOMAP_MAX_ORDER) {
printk("PCI_DMA: pci_alloc_consistent size too large: 0x%lx\n",
size);
return NULL;
}
tbl = devnode_table(hwdev);
if (!tbl)
return NULL;
/* Alloc enough pages (and possibly more) */
ret = (void *)__get_free_pages(GFP_ATOMIC, order);
if (!ret)
return NULL;
memset(ret, 0, size);
/* Set up tces to cover the allocated range */
mapping = iommu_alloc(tbl, ret, npages, DMA_BIDIRECTIONAL);
if (mapping == DMA_ERROR_CODE) {
free_pages((unsigned long)ret, order);
ret = NULL;
} else
*dma_handle = mapping;
return ret;
} }
static void pci_iommu_free_consistent(struct pci_dev *hwdev, size_t size, static void pci_iommu_free_consistent(struct pci_dev *hwdev, size_t size,
void *vaddr, dma_addr_t dma_handle) void *vaddr, dma_addr_t dma_handle)
{ {
struct iommu_table *tbl; iommu_free_consistent(devnode_table(hwdev), size, vaddr, dma_handle);
unsigned int npages;
size = PAGE_ALIGN(size);
npages = size >> PAGE_SHIFT;
tbl = devnode_table(hwdev);
if (tbl) {
iommu_free(tbl, dma_handle, npages);
free_pages((unsigned long)vaddr, get_order(size));
}
} }
/* Creates TCEs for a user provided buffer. The user buffer must be /* Creates TCEs for a user provided buffer. The user buffer must be
* contiguous real kernel storage (not vmalloc). The address of the buffer * contiguous real kernel storage (not vmalloc). The address of the buffer
* passed here is the kernel (virtual) address of the buffer. The buffer * passed here is the kernel (virtual) address of the buffer. The buffer
...@@ -139,81 +85,28 @@ static void pci_iommu_free_consistent(struct pci_dev *hwdev, size_t size, ...@@ -139,81 +85,28 @@ static void pci_iommu_free_consistent(struct pci_dev *hwdev, size_t size,
static dma_addr_t pci_iommu_map_single(struct pci_dev *hwdev, void *vaddr, static dma_addr_t pci_iommu_map_single(struct pci_dev *hwdev, void *vaddr,
size_t size, enum dma_data_direction direction) size_t size, enum dma_data_direction direction)
{ {
struct iommu_table * tbl; return iommu_map_single(devnode_table(hwdev), vaddr, size, direction);
dma_addr_t dma_handle = DMA_ERROR_CODE;
unsigned long uaddr;
unsigned int npages;
BUG_ON(direction == DMA_NONE);
uaddr = (unsigned long)vaddr;
npages = PAGE_ALIGN(uaddr + size) - (uaddr & PAGE_MASK);
npages >>= PAGE_SHIFT;
tbl = devnode_table(hwdev);
if (tbl) {
dma_handle = iommu_alloc(tbl, vaddr, npages, direction);
if (dma_handle == DMA_ERROR_CODE) {
if (printk_ratelimit()) {
printk(KERN_INFO "iommu_alloc failed, tbl %p vaddr %p npages %d\n",
tbl, vaddr, npages);
}
} else
dma_handle |= (uaddr & ~PAGE_MASK);
}
return dma_handle;
} }
static void pci_iommu_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_handle, static void pci_iommu_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_handle,
size_t size, enum dma_data_direction direction) size_t size, enum dma_data_direction direction)
{ {
struct iommu_table *tbl; iommu_unmap_single(devnode_table(hwdev), dma_handle, size, direction);
unsigned int npages;
BUG_ON(direction == DMA_NONE);
npages = (PAGE_ALIGN(dma_handle + size) - (dma_handle & PAGE_MASK))
>> PAGE_SHIFT;
tbl = devnode_table(hwdev);
if (tbl)
iommu_free(tbl, dma_handle, npages);
} }
static int pci_iommu_map_sg(struct pci_dev *pdev, struct scatterlist *sglist, static int pci_iommu_map_sg(struct pci_dev *pdev, struct scatterlist *sglist,
int nelems, enum dma_data_direction direction) int nelems, enum dma_data_direction direction)
{ {
struct iommu_table * tbl; return iommu_map_sg(&pdev->dev, devnode_table(pdev), sglist,
nelems, direction);
BUG_ON(direction == DMA_NONE);
if (nelems == 0)
return 0;
tbl = devnode_table(pdev);
if (!tbl)
return 0;
return iommu_alloc_sg(tbl, &pdev->dev, sglist, nelems, direction);
} }
static void pci_iommu_unmap_sg(struct pci_dev *pdev, struct scatterlist *sglist, static void pci_iommu_unmap_sg(struct pci_dev *pdev, struct scatterlist *sglist,
int nelems, enum dma_data_direction direction) int nelems, enum dma_data_direction direction)
{ {
struct iommu_table *tbl; iommu_unmap_sg(devnode_table(pdev), sglist, nelems, direction);
BUG_ON(direction == DMA_NONE);
tbl = devnode_table(pdev);
if (!tbl)
return;
iommu_free_sg(tbl, sglist, nelems);
} }
/* We support DMA to/from any memory page via the iommu */ /* We support DMA to/from any memory page via the iommu */
......
arch/ppc64/kernel/vio.c
View file @ e1df56ff
...@@ -413,145 +413,46 @@ int vio_disable_interrupts(struct vio_dev *dev) ...@@ -413,145 +413,46 @@ int vio_disable_interrupts(struct vio_dev *dev)
} }
EXPORT_SYMBOL(vio_disable_interrupts); EXPORT_SYMBOL(vio_disable_interrupts);
dma_addr_t vio_map_single(struct vio_dev *dev, void *vaddr, dma_addr_t vio_map_single(struct vio_dev *dev, void *vaddr,
size_t size, enum dma_data_direction direction) size_t size, enum dma_data_direction direction)
{ {
struct iommu_table *tbl; return iommu_map_single(dev->iommu_table, vaddr, size, direction);
dma_addr_t dma_handle = DMA_ERROR_CODE;
unsigned long uaddr;
unsigned int npages;
BUG_ON(direction == DMA_NONE);
uaddr = (unsigned long)vaddr;
npages = PAGE_ALIGN( uaddr + size ) - ( uaddr & PAGE_MASK );
npages >>= PAGE_SHIFT;
tbl = dev->iommu_table;
if (tbl) {
dma_handle = iommu_alloc(tbl, vaddr, npages, direction);
dma_handle |= (uaddr & ~PAGE_MASK);
}
return dma_handle;
} }
EXPORT_SYMBOL(vio_map_single); EXPORT_SYMBOL(vio_map_single);
void vio_unmap_single(struct vio_dev *dev, dma_addr_t dma_handle, void vio_unmap_single(struct vio_dev *dev, dma_addr_t dma_handle,
size_t size, enum dma_data_direction direction) size_t size, enum dma_data_direction direction)
{ {
struct iommu_table * tbl; iommu_unmap_single(dev->iommu_table, dma_handle, size, direction);
unsigned int npages;
BUG_ON(direction == DMA_NONE);
npages = PAGE_ALIGN( dma_handle + size ) - ( dma_handle & PAGE_MASK );
npages >>= PAGE_SHIFT;
tbl = dev->iommu_table;
if(tbl)
iommu_free(tbl, dma_handle, npages);
} }
EXPORT_SYMBOL(vio_unmap_single); EXPORT_SYMBOL(vio_unmap_single);
int vio_map_sg(struct vio_dev *vdev, struct scatterlist *sglist, int nelems, int vio_map_sg(struct vio_dev *vdev, struct scatterlist *sglist, int nelems,
enum dma_data_direction direction) enum dma_data_direction direction)
{ {
struct iommu_table *tbl; return iommu_map_sg(&vdev->dev, vdev->iommu_table, sglist,
nelems, direction);
BUG_ON(direction == DMA_NONE);
if (nelems == 0)
return 0;
tbl = vdev->iommu_table;
if (!tbl)
return 0;
return iommu_alloc_sg(tbl, &vdev->dev, sglist, nelems, direction);
} }
EXPORT_SYMBOL(vio_map_sg); EXPORT_SYMBOL(vio_map_sg);
void vio_unmap_sg(struct vio_dev *vdev, struct scatterlist *sglist, int nelems, void vio_unmap_sg(struct vio_dev *vdev, struct scatterlist *sglist, int nelems,
enum dma_data_direction direction) enum dma_data_direction direction)
{ {
struct iommu_table *tbl; iommu_unmap_sg(vdev->iommu_table, sglist, nelems, direction);
BUG_ON(direction == DMA_NONE);
tbl = vdev->iommu_table;
if (tbl)
iommu_free_sg(tbl, sglist, nelems);
} }
EXPORT_SYMBOL(vio_unmap_sg); EXPORT_SYMBOL(vio_unmap_sg);
void *vio_alloc_consistent(struct vio_dev *dev, size_t size, void *vio_alloc_consistent(struct vio_dev *dev, size_t size,
dma_addr_t *dma_handle) dma_addr_t *dma_handle)
{ {
struct iommu_table * tbl; return iommu_alloc_consistent(dev->iommu_table, size, dma_handle);
void *ret = NULL;
unsigned int npages, order;
dma_addr_t tce;
size = PAGE_ALIGN(size);
npages = size >> PAGE_SHIFT;
order = get_order(size);
/* Client asked for way to much space. This is checked later anyway */
/* It is easier to debug here for the drivers than in the tce tables.*/
if(order >= IOMAP_MAX_ORDER) {
printk("VIO_DMA: vio_alloc_consistent size too large: 0x%lx \n", size);
return NULL;
}
tbl = dev->iommu_table;
if (tbl) {
/* Alloc enough pages (and possibly more) */
ret = (void *)__get_free_pages(GFP_ATOMIC, order);
if (ret) {
/* Page allocation succeeded */
memset(ret, 0, npages << PAGE_SHIFT);
/* Set up tces to cover the allocated range */
tce = iommu_alloc(tbl, ret, npages, DMA_BIDIRECTIONAL);
if (tce == DMA_ERROR_CODE) {
PPCDBG(PPCDBG_TCE, "vio_alloc_consistent: iommu_alloc failed\n" );
free_pages((unsigned long)ret, order);
ret = NULL;
} else {
*dma_handle = tce;
}
}
else PPCDBG(PPCDBG_TCE, "vio_alloc_consistent: __get_free_pages failed for size = %d\n", size);
}
else PPCDBG(PPCDBG_TCE, "vio_alloc_consistent: get_iommu_table failed for 0x%016lx\n", dev);
PPCDBG(PPCDBG_TCE, "\tvio_alloc_consistent: dma_handle = 0x%16.16lx\n", *dma_handle);
PPCDBG(PPCDBG_TCE, "\tvio_alloc_consistent: return = 0x%16.16lx\n", ret);
return ret;
} }
EXPORT_SYMBOL(vio_alloc_consistent); EXPORT_SYMBOL(vio_alloc_consistent);
void vio_free_consistent(struct vio_dev *dev, size_t size, void vio_free_consistent(struct vio_dev *dev, size_t size,
void *vaddr, dma_addr_t dma_handle) void *vaddr, dma_addr_t dma_handle)
{ {
struct iommu_table *tbl; iommu_free_consistent(dev->iommu_table, size, vaddr, dma_handle);
unsigned int npages;
PPCDBG(PPCDBG_TCE, "vio_free_consistent:\n");
PPCDBG(PPCDBG_TCE, "\tdev = 0x%16.16lx, size = 0x%16.16lx, dma_handle = 0x%16.16lx, vaddr = 0x%16.16lx\n", dev, size, dma_handle, vaddr);
size = PAGE_ALIGN(size);
npages = size >> PAGE_SHIFT;
tbl = dev->iommu_table;
if ( tbl ) {
iommu_free(tbl, dma_handle, npages);
free_pages((unsigned long)vaddr, get_order(size));
}
} }
EXPORT_SYMBOL(vio_free_consistent); EXPORT_SYMBOL(vio_free_consistent);
......
include/asm-ppc64/iommu.h
View file @ e1df56ff
...@@ -19,8 +19,8 @@ ...@@ -19,8 +19,8 @@
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/ */
#ifndef _PCI_DMA_H #ifndef _ASM_IOMMU_H
#define _PCI_DMA_H #define _ASM_IOMMU_H
#include <asm/types.h> #include <asm/types.h>
#include <linux/spinlock.h> #include <linux/spinlock.h>
...@@ -131,20 +131,20 @@ extern void iommu_devnode_init(struct iSeries_Device_Node *dn); ...@@ -131,20 +131,20 @@ extern void iommu_devnode_init(struct iSeries_Device_Node *dn);
*/ */
extern struct iommu_table *iommu_init_table(struct iommu_table * tbl); extern struct iommu_table *iommu_init_table(struct iommu_table * tbl);
/* allocates a range of tces and sets them to the pages */ extern int iommu_map_sg(struct device *dev, struct iommu_table *tbl,
extern dma_addr_t iommu_alloc(struct iommu_table *, void *page, struct scatterlist *sglist, int nelems,
unsigned int numPages, enum dma_data_direction direction);
enum dma_data_direction direction); extern void iommu_unmap_sg(struct iommu_table *tbl, struct scatterlist *sglist,
extern void iommu_free(struct iommu_table *tbl, dma_addr_t dma_addr, int nelems, enum dma_data_direction direction);
unsigned int npages);
extern void *iommu_alloc_consistent(struct iommu_table *tbl, size_t size,
/* same with sg lists */ dma_addr_t *dma_handle);
extern int iommu_alloc_sg(struct iommu_table *table, struct device *dev, extern void iommu_free_consistent(struct iommu_table *tbl, size_t size,
struct scatterlist *sglist, int nelems, void *vaddr, dma_addr_t dma_handle);
enum dma_data_direction direction); extern dma_addr_t iommu_map_single(struct iommu_table *tbl, void *vaddr,
extern void iommu_free_sg(struct iommu_table *tbl, struct scatterlist *sglist, size_t size, enum dma_data_direction direction);
int nelems); extern void iommu_unmap_single(struct iommu_table *tbl, dma_addr_t dma_handle,
size_t size, enum dma_data_direction direction);
extern void tce_init_pSeries(void); extern void tce_init_pSeries(void);
extern void tce_init_iSeries(void); extern void tce_init_iSeries(void);
...@@ -154,4 +154,4 @@ extern void pci_dma_init_direct(void); ...@@ -154,4 +154,4 @@ extern void pci_dma_init_direct(void);
extern int ppc64_iommu_off; extern int ppc64_iommu_off;
#endif #endif /* _ASM_IOMMU_H */
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7