1/* 2 * drivers/base/dma-mapping.c - arch-independent dma-mapping routines 3 * 4 * Copyright (c) 2006 SUSE Linux Products GmbH 5 * Copyright (c) 2006 Tejun Heo <teheo@suse.de> 6 * 7 * This file is released under the GPLv2. 8 */ 9 10#include <linux/dma-mapping.h> 11#include <linux/gfp.h> 12 13/* 14 * Managed DMA API 15 */ 16struct dma_devres { 17 size_t size; 18 void *vaddr; 19 dma_addr_t dma_handle; 20}; 21 22static void dmam_coherent_release(struct device *dev, void *res) 23{ 24 struct dma_devres *this = res; 25 26 dma_free_coherent(dev, this->size, this->vaddr, this->dma_handle); 27} 28 29static void dmam_noncoherent_release(struct device *dev, void *res) 30{ 31 struct dma_devres *this = res; 32 33 dma_free_noncoherent(dev, this->size, this->vaddr, this->dma_handle); 34} 35 36static int dmam_match(struct device *dev, void *res, void *match_data) 37{ 38 struct dma_devres *this = res, *match = match_data; 39 40 if (this->vaddr == match->vaddr) { 41 WARN_ON(this->size != match->size || 42 this->dma_handle != match->dma_handle); 43 return 1; 44 } 45 return 0; 46} 47 48/** 49 * dmam_alloc_coherent - Managed dma_alloc_coherent() 50 * @dev: Device to allocate coherent memory for 51 * @size: Size of allocation 52 * @dma_handle: Out argument for allocated DMA handle 53 * @gfp: Allocation flags 54 * 55 * Managed dma_alloc_coherent(). Memory allocated using this function 56 * will be automatically released on driver detach. 57 * 58 * RETURNS: 59 * Pointer to allocated memory on success, NULL on failure. 60 */ 61void * dmam_alloc_coherent(struct device *dev, size_t size, 62 dma_addr_t *dma_handle, gfp_t gfp) 63{ 64 struct dma_devres *dr; 65 void *vaddr; 66 67 dr = devres_alloc(dmam_coherent_release, sizeof(*dr), gfp); 68 if (!dr) 69 return NULL; 70 71 vaddr = dma_alloc_coherent(dev, size, dma_handle, gfp); 72 if (!vaddr) { 73 devres_free(dr); 74 return NULL; 75 } 76 77 dr->vaddr = vaddr; 78 dr->dma_handle = *dma_handle; 79 dr->size = size; 80 81 devres_add(dev, dr); 82 83 return vaddr; 84} 85EXPORT_SYMBOL(dmam_alloc_coherent); 86 87/** 88 * dmam_free_coherent - Managed dma_free_coherent() 89 * @dev: Device to free coherent memory for 90 * @size: Size of allocation 91 * @vaddr: Virtual address of the memory to free 92 * @dma_handle: DMA handle of the memory to free 93 * 94 * Managed dma_free_coherent(). 95 */ 96void dmam_free_coherent(struct device *dev, size_t size, void *vaddr, 97 dma_addr_t dma_handle) 98{ 99 struct dma_devres match_data = { size, vaddr, dma_handle }; 100 101 dma_free_coherent(dev, size, vaddr, dma_handle); 102 WARN_ON(devres_destroy(dev, dmam_coherent_release, dmam_match, 103 &match_data)); 104} 105EXPORT_SYMBOL(dmam_free_coherent); 106 107/** 108 * dmam_alloc_non_coherent - Managed dma_alloc_non_coherent() 109 * @dev: Device to allocate non_coherent memory for 110 * @size: Size of allocation 111 * @dma_handle: Out argument for allocated DMA handle 112 * @gfp: Allocation flags 113 * 114 * Managed dma_alloc_non_coherent(). Memory allocated using this 115 * function will be automatically released on driver detach. 116 * 117 * RETURNS: 118 * Pointer to allocated memory on success, NULL on failure. 119 */ 120void *dmam_alloc_noncoherent(struct device *dev, size_t size, 121 dma_addr_t *dma_handle, gfp_t gfp) 122{ 123 struct dma_devres *dr; 124 void *vaddr; 125 126 dr = devres_alloc(dmam_noncoherent_release, sizeof(*dr), gfp); 127 if (!dr) 128 return NULL; 129 130 vaddr = dma_alloc_noncoherent(dev, size, dma_handle, gfp); 131 if (!vaddr) { 132 devres_free(dr); 133 return NULL; 134 } 135 136 dr->vaddr = vaddr; 137 dr->dma_handle = *dma_handle; 138 dr->size = size; 139 140 devres_add(dev, dr); 141 142 return vaddr; 143} 144EXPORT_SYMBOL(dmam_alloc_noncoherent); 145 146/** 147 * dmam_free_coherent - Managed dma_free_noncoherent() 148 * @dev: Device to free noncoherent memory for 149 * @size: Size of allocation 150 * @vaddr: Virtual address of the memory to free 151 * @dma_handle: DMA handle of the memory to free 152 * 153 * Managed dma_free_noncoherent(). 154 */ 155void dmam_free_noncoherent(struct device *dev, size_t size, void *vaddr, 156 dma_addr_t dma_handle) 157{ 158 struct dma_devres match_data = { size, vaddr, dma_handle }; 159 160 dma_free_noncoherent(dev, size, vaddr, dma_handle); 161 WARN_ON(!devres_destroy(dev, dmam_noncoherent_release, dmam_match, 162 &match_data)); 163} 164EXPORT_SYMBOL(dmam_free_noncoherent); 165 166#ifdef ARCH_HAS_DMA_DECLARE_COHERENT_MEMORY 167 168static void dmam_coherent_decl_release(struct device *dev, void *res) 169{ 170 dma_release_declared_memory(dev); 171} 172 173/** 174 * dmam_declare_coherent_memory - Managed dma_declare_coherent_memory() 175 * @dev: Device to declare coherent memory for 176 * @bus_addr: Bus address of coherent memory to be declared 177 * @device_addr: Device address of coherent memory to be declared 178 * @size: Size of coherent memory to be declared 179 * @flags: Flags 180 * 181 * Managed dma_declare_coherent_memory(). 182 * 183 * RETURNS: 184 * 0 on success, -errno on failure. 185 */ 186int dmam_declare_coherent_memory(struct device *dev, dma_addr_t bus_addr, 187 dma_addr_t device_addr, size_t size, int flags) 188{ 189 void *res; 190 int rc; 191 192 res = devres_alloc(dmam_coherent_decl_release, 0, GFP_KERNEL); 193 if (!res) 194 return -ENOMEM; 195 196 rc = dma_declare_coherent_memory(dev, bus_addr, device_addr, size, 197 flags); 198 if (rc == 0) 199 devres_add(dev, res); 200 else 201 devres_free(res); 202 203 return rc; 204} 205EXPORT_SYMBOL(dmam_declare_coherent_memory); 206 207/** 208 * dmam_release_declared_memory - Managed dma_release_declared_memory(). 209 * @dev: Device to release declared coherent memory for 210 * 211 * Managed dmam_release_declared_memory(). 212 */ 213void dmam_release_declared_memory(struct device *dev) 214{ 215 WARN_ON(devres_destroy(dev, dmam_coherent_decl_release, NULL, NULL)); 216} 217EXPORT_SYMBOL(dmam_release_declared_memory); 218 219#endif 220