blob: 14206e3f0819a963d65fc5e6d3f26846b154f336 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +11002 * Copyright (C) 2006 Benjamin Herrenschmidt, IBM Corporation
Linus Torvalds1da177e2005-04-16 15:20:36 -07003 *
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +11004 * Provide default implementations of the DMA mapping callbacks for
5 * directly mapped busses and busses using the iommu infrastructure
Linus Torvalds1da177e2005-04-16 15:20:36 -07006 */
7
8#include <linux/device.h>
9#include <linux/dma-mapping.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070010#include <asm/bug.h>
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110011#include <asm/iommu.h>
12#include <asm/abs_addr.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070013
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110014/*
15 * Generic iommu implementation
16 */
17
18static inline unsigned long device_to_mask(struct device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -070019{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110020 if (dev->dma_mask && *dev->dma_mask)
21 return *dev->dma_mask;
22 /* Assume devices without mask can take 32 bit addresses */
23 return 0xfffffffful;
Linus Torvalds1da177e2005-04-16 15:20:36 -070024}
25
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110026
27/* Allocates a contiguous real buffer and creates mappings over it.
28 * Returns the virtual address of the buffer and sets dma_handle
29 * to the dma address (mapping) of the first page.
30 */
31static void *dma_iommu_alloc_coherent(struct device *dev, size_t size,
32 dma_addr_t *dma_handle, gfp_t flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -070033{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110034 return iommu_alloc_coherent(dev->archdata.dma_data, size, dma_handle,
35 device_to_mask(dev), flag,
36 dev->archdata.numa_node);
Linus Torvalds1da177e2005-04-16 15:20:36 -070037}
Linus Torvalds1da177e2005-04-16 15:20:36 -070038
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110039static void dma_iommu_free_coherent(struct device *dev, size_t size,
40 void *vaddr, dma_addr_t dma_handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -070041{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110042 iommu_free_coherent(dev->archdata.dma_data, size, vaddr, dma_handle);
Linus Torvalds1da177e2005-04-16 15:20:36 -070043}
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110045/* Creates TCEs for a user provided buffer. The user buffer must be
46 * contiguous real kernel storage (not vmalloc). The address of the buffer
47 * passed here is the kernel (virtual) address of the buffer. The buffer
48 * need not be page aligned, the dma_addr_t returned will point to the same
49 * byte within the page as vaddr.
50 */
51static dma_addr_t dma_iommu_map_single(struct device *dev, void *vaddr,
52 size_t size,
53 enum dma_data_direction direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -070054{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110055 return iommu_map_single(dev->archdata.dma_data, vaddr, size,
56 device_to_mask(dev), direction);
Linus Torvalds1da177e2005-04-16 15:20:36 -070057}
Linus Torvalds1da177e2005-04-16 15:20:36 -070058
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110059
60static void dma_iommu_unmap_single(struct device *dev, dma_addr_t dma_handle,
61 size_t size,
62 enum dma_data_direction direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -070063{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110064 iommu_unmap_single(dev->archdata.dma_data, dma_handle, size, direction);
Linus Torvalds1da177e2005-04-16 15:20:36 -070065}
Linus Torvalds1da177e2005-04-16 15:20:36 -070066
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110067
68static int dma_iommu_map_sg(struct device *dev, struct scatterlist *sglist,
69 int nelems, enum dma_data_direction direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -070070{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110071 return iommu_map_sg(dev->archdata.dma_data, sglist, nelems,
72 device_to_mask(dev), direction);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073}
Linus Torvalds1da177e2005-04-16 15:20:36 -070074
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110075static void dma_iommu_unmap_sg(struct device *dev, struct scatterlist *sglist,
76 int nelems, enum dma_data_direction direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -070077{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110078 iommu_unmap_sg(dev->archdata.dma_data, sglist, nelems, direction);
Linus Torvalds1da177e2005-04-16 15:20:36 -070079}
Linus Torvalds1da177e2005-04-16 15:20:36 -070080
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110081/* We support DMA to/from any memory page via the iommu */
82static int dma_iommu_dma_supported(struct device *dev, u64 mask)
Linus Torvalds1da177e2005-04-16 15:20:36 -070083{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110084 struct iommu_table *tbl = dev->archdata.dma_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -070085
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +110086 if (!tbl || tbl->it_offset > mask) {
87 printk(KERN_INFO
88 "Warning: IOMMU offset too big for device mask\n");
89 if (tbl)
90 printk(KERN_INFO
91 "mask: 0x%08lx, table offset: 0x%08lx\n",
92 mask, tbl->it_offset);
93 else
94 printk(KERN_INFO "mask: 0x%08lx, table unavailable\n",
95 mask);
96 return 0;
97 } else
98 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -070099}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700100
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100101struct dma_mapping_ops dma_iommu_ops = {
102 .alloc_coherent = dma_iommu_alloc_coherent,
103 .free_coherent = dma_iommu_free_coherent,
104 .map_single = dma_iommu_map_single,
105 .unmap_single = dma_iommu_unmap_single,
106 .map_sg = dma_iommu_map_sg,
107 .unmap_sg = dma_iommu_unmap_sg,
108 .dma_supported = dma_iommu_dma_supported,
109};
110EXPORT_SYMBOL(dma_iommu_ops);
111
112/*
113 * Generic direct DMA implementation
Benjamin Herrenschmidt92b20c42006-11-11 17:25:14 +1100114 *
115 * This implementation supports a global offset that can be applied if
116 * the address at which memory is visible to devices is not 0.
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100117 */
Benjamin Herrenschmidt92b20c42006-11-11 17:25:14 +1100118unsigned long dma_direct_offset;
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100119
120static void *dma_direct_alloc_coherent(struct device *dev, size_t size,
121 dma_addr_t *dma_handle, gfp_t flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122{
Benjamin Herrenschmidtc80d9132006-11-11 17:25:16 +1100123 struct page *page;
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100124 void *ret;
Benjamin Herrenschmidtc80d9132006-11-11 17:25:16 +1100125 int node = dev->archdata.numa_node;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100127 /* TODO: Maybe use the numa node here too ? */
Benjamin Herrenschmidtc80d9132006-11-11 17:25:16 +1100128 page = alloc_pages_node(node, flag, get_order(size));
129 if (page == NULL)
130 return NULL;
131 ret = page_address(page);
132 memset(ret, 0, size);
133 *dma_handle = virt_to_abs(ret) | dma_direct_offset;
134
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100135 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100138static void dma_direct_free_coherent(struct device *dev, size_t size,
139 void *vaddr, dma_addr_t dma_handle)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140{
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100141 free_pages((unsigned long)vaddr, get_order(size));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700142}
Linus Torvalds1da177e2005-04-16 15:20:36 -0700143
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100144static dma_addr_t dma_direct_map_single(struct device *dev, void *ptr,
145 size_t size,
146 enum dma_data_direction direction)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147{
Benjamin Herrenschmidt92b20c42006-11-11 17:25:14 +1100148 return virt_to_abs(ptr) | dma_direct_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149}
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100150
151static void dma_direct_unmap_single(struct device *dev, dma_addr_t dma_addr,
152 size_t size,
153 enum dma_data_direction direction)
154{
155}
156
Jens Axboe78bdc312007-10-12 13:44:12 +0200157static int dma_direct_map_sg(struct device *dev, struct scatterlist *sgl,
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100158 int nents, enum dma_data_direction direction)
159{
Jens Axboe78bdc312007-10-12 13:44:12 +0200160 struct scatterlist *sg;
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100161 int i;
162
Jens Axboe78bdc312007-10-12 13:44:12 +0200163 for_each_sg(sgl, sg, nents, i) {
Jens Axboe58b053e2007-10-22 20:02:46 +0200164 sg->dma_address = sg_phys(sg) | dma_direct_offset;
Benjamin Herrenschmidt12d04ee2006-11-11 17:25:02 +1100165 sg->dma_length = sg->length;
166 }
167
168 return nents;
169}
170
171static void dma_direct_unmap_sg(struct device *dev, struct scatterlist *sg,
172 int nents, enum dma_data_direction direction)
173{
174}
175
176static int dma_direct_dma_supported(struct device *dev, u64 mask)
177{
178 /* Could be improved to check for memory though it better be
179 * done via some global so platforms can set the limit in case
180 * they have limited DMA windows
181 */
182 return mask >= DMA_32BIT_MASK;
183}
184
185struct dma_mapping_ops dma_direct_ops = {
186 .alloc_coherent = dma_direct_alloc_coherent,
187 .free_coherent = dma_direct_free_coherent,
188 .map_single = dma_direct_map_single,
189 .unmap_single = dma_direct_unmap_single,
190 .map_sg = dma_direct_map_sg,
191 .unmap_sg = dma_direct_unmap_sg,
192 .dma_supported = dma_direct_dma_supported,
193};
194EXPORT_SYMBOL(dma_direct_ops);