dmapool.c 13.9 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
/*
 * DMA Pool allocator
 *
 * Copyright 2001 David Brownell
 * Copyright 2007 Intel Corporation
 *   Author: Matthew Wilcox <willy@linux.intel.com>
 *
 * This software may be redistributed and/or modified under the terms of
 * the GNU General Public License ("GPL") version 2 as published by the
 * Free Software Foundation.
 *
 * This allocator returns small blocks of a given size which are DMA-able by
 * the given device.  It uses the dma_alloc_coherent page allocator to get
 * new pages, then splits them up into blocks of the required size.
 * Many older drivers still have their own code to do this.
 *
 * The current design of this allocator is fairly simple.  The pool is
 * represented by the 'struct dma_pool' which keeps a doubly-linked list of
 * allocated pages.  Each page in the page_list is split into blocks of at
20 21 22
 * least 'size' bytes.  Free blocks are tracked in an unsorted singly-linked
 * list of free blocks within the page.  Used blocks aren't tracked, but we
 * keep a count of how many are currently allocated from each page.
23
 */
Linus Torvalds's avatar
Linus Torvalds committed
24 25 26 27

#include <linux/device.h>
#include <linux/dma-mapping.h>
#include <linux/dmapool.h>
28 29
#include <linux/kernel.h>
#include <linux/list.h>
30
#include <linux/export.h>
31
#include <linux/mutex.h>
32
#include <linux/poison.h>
Alexey Dobriyan's avatar
Alexey Dobriyan committed
33
#include <linux/sched.h>
34
#include <linux/slab.h>
35
#include <linux/stat.h>
36 37 38 39
#include <linux/spinlock.h>
#include <linux/string.h>
#include <linux/types.h>
#include <linux/wait.h>
Linus Torvalds's avatar
Linus Torvalds committed
40

41 42 43 44
#if defined(CONFIG_DEBUG_SLAB) || defined(CONFIG_SLUB_DEBUG_ON)
#define DMAPOOL_DEBUG 1
#endif

Matthew Wilcox's avatar
Matthew Wilcox committed
45 46 47 48 49 50
struct dma_pool {		/* the pool */
	struct list_head page_list;
	spinlock_t lock;
	size_t size;
	struct device *dev;
	size_t allocation;
51
	size_t boundary;
Matthew Wilcox's avatar
Matthew Wilcox committed
52 53
	char name[32];
	struct list_head pools;
Linus Torvalds's avatar
Linus Torvalds committed
54 55
};

Matthew Wilcox's avatar
Matthew Wilcox committed
56 57 58 59
struct dma_page {		/* cacheable header for 'allocation' bytes */
	struct list_head page_list;
	void *vaddr;
	dma_addr_t dma;
60 61
	unsigned int in_use;
	unsigned int offset;
Linus Torvalds's avatar
Linus Torvalds committed
62 63
};

Matthew Wilcox's avatar
Matthew Wilcox committed
64
static DEFINE_MUTEX(pools_lock);
65
static DEFINE_MUTEX(pools_reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
66 67

static ssize_t
Matthew Wilcox's avatar
Matthew Wilcox committed
68
show_pools(struct device *dev, struct device_attribute *attr, char *buf)
Linus Torvalds's avatar
Linus Torvalds committed
69 70 71 72 73 74 75 76 77 78 79 80 81 82
{
	unsigned temp;
	unsigned size;
	char *next;
	struct dma_page *page;
	struct dma_pool *pool;

	next = buf;
	size = PAGE_SIZE;

	temp = scnprintf(next, size, "poolinfo - 0.1\n");
	size -= temp;
	next += temp;

83
	mutex_lock(&pools_lock);
Linus Torvalds's avatar
Linus Torvalds committed
84 85 86 87
	list_for_each_entry(pool, &dev->dma_pools, pools) {
		unsigned pages = 0;
		unsigned blocks = 0;

88
		spin_lock_irq(&pool->lock);
Linus Torvalds's avatar
Linus Torvalds committed
89 90 91 92
		list_for_each_entry(page, &pool->page_list, page_list) {
			pages++;
			blocks += page->in_use;
		}
93
		spin_unlock_irq(&pool->lock);
Linus Torvalds's avatar
Linus Torvalds committed
94 95 96

		/* per-pool info, no real statistics yet */
		temp = scnprintf(next, size, "%-16s %4u %4Zu %4Zu %2u\n",
97 98
				 pool->name, blocks,
				 pages * (pool->allocation / pool->size),
Matthew Wilcox's avatar
Matthew Wilcox committed
99
				 pool->size, pages);
Linus Torvalds's avatar
Linus Torvalds committed
100 101 102
		size -= temp;
		next += temp;
	}
103
	mutex_unlock(&pools_lock);
Linus Torvalds's avatar
Linus Torvalds committed
104 105 106

	return PAGE_SIZE - size;
}
Matthew Wilcox's avatar
Matthew Wilcox committed
107 108

static DEVICE_ATTR(pools, S_IRUGO, show_pools, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
109 110 111 112 113 114 115

/**
 * dma_pool_create - Creates a pool of consistent memory blocks, for dma.
 * @name: name of pool, for diagnostics
 * @dev: device that will be doing the DMA
 * @size: size of the blocks in this pool.
 * @align: alignment requirement for blocks; must be a power of two
116
 * @boundary: returned blocks won't cross this power of two boundary
Linus Torvalds's avatar
Linus Torvalds committed
117 118 119 120 121 122 123 124 125
 * Context: !in_interrupt()
 *
 * Returns a dma allocation pool with the requested characteristics, or
 * null if one can't be created.  Given one of these pools, dma_pool_alloc()
 * may be used to allocate memory.  Such memory will all have "consistent"
 * DMA mappings, accessible by the device and its driver without using
 * cache flushing primitives.  The actual size of blocks allocated may be
 * larger than requested because of alignment.
 *
126
 * If @boundary is nonzero, objects returned from dma_pool_alloc() won't
Linus Torvalds's avatar
Linus Torvalds committed
127 128 129 130
 * cross that size boundary.  This is useful for devices which have
 * addressing restrictions on individual DMA transfers, such as not crossing
 * boundaries of 4KBytes.
 */
Matthew Wilcox's avatar
Matthew Wilcox committed
131
struct dma_pool *dma_pool_create(const char *name, struct device *dev,
132
				 size_t size, size_t align, size_t boundary)
Linus Torvalds's avatar
Linus Torvalds committed
133
{
Matthew Wilcox's avatar
Matthew Wilcox committed
134
	struct dma_pool *retval;
135
	size_t allocation;
136
	bool empty = false;
Linus Torvalds's avatar
Linus Torvalds committed
137

138
	if (align == 0)
Linus Torvalds's avatar
Linus Torvalds committed
139
		align = 1;
140
	else if (align & (align - 1))
Linus Torvalds's avatar
Linus Torvalds committed
141 142
		return NULL;

143
	if (size == 0)
144
		return NULL;
145
	else if (size < 4)
146
		size = 4;
147 148 149 150

	if ((size % align) != 0)
		size = ALIGN(size, align);

151 152
	allocation = max_t(size_t, size, PAGE_SIZE);

153
	if (!boundary)
154
		boundary = allocation;
155
	else if ((boundary < size) || (boundary & (boundary - 1)))
Linus Torvalds's avatar
Linus Torvalds committed
156 157
		return NULL;

158 159
	retval = kmalloc_node(sizeof(*retval), GFP_KERNEL, dev_to_node(dev));
	if (!retval)
Linus Torvalds's avatar
Linus Torvalds committed
160 161
		return retval;

162
	strlcpy(retval->name, name, sizeof(retval->name));
Linus Torvalds's avatar
Linus Torvalds committed
163 164 165

	retval->dev = dev;

Matthew Wilcox's avatar
Matthew Wilcox committed
166 167
	INIT_LIST_HEAD(&retval->page_list);
	spin_lock_init(&retval->lock);
Linus Torvalds's avatar
Linus Torvalds committed
168
	retval->size = size;
169
	retval->boundary = boundary;
Linus Torvalds's avatar
Linus Torvalds committed
170 171
	retval->allocation = allocation;

172 173
	INIT_LIST_HEAD(&retval->pools);

174 175 176 177 178 179 180 181 182
	/*
	 * pools_lock ensures that the ->dma_pools list does not get corrupted.
	 * pools_reg_lock ensures that there is not a race between
	 * dma_pool_create() and dma_pool_destroy() or within dma_pool_create()
	 * when the first invocation of dma_pool_create() failed on
	 * device_create_file() and the second assumes that it has been done (I
	 * know it is a short window).
	 */
	mutex_lock(&pools_reg_lock);
183
	mutex_lock(&pools_lock);
184 185 186
	if (list_empty(&dev->dma_pools))
		empty = true;
	list_add(&retval->pools, &dev->dma_pools);
187
	mutex_unlock(&pools_lock);
188 189 190 191 192 193 194 195 196 197 198 199 200 201
	if (empty) {
		int err;

		err = device_create_file(dev, &dev_attr_pools);
		if (err) {
			mutex_lock(&pools_lock);
			list_del(&retval->pools);
			mutex_unlock(&pools_lock);
			mutex_unlock(&pools_reg_lock);
			kfree(retval);
			return NULL;
		}
	}
	mutex_unlock(&pools_reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
202 203
	return retval;
}
Matthew Wilcox's avatar
Matthew Wilcox committed
204
EXPORT_SYMBOL(dma_pool_create);
Linus Torvalds's avatar
Linus Torvalds committed
205

206 207 208
static void pool_initialise_page(struct dma_pool *pool, struct dma_page *page)
{
	unsigned int offset = 0;
209
	unsigned int next_boundary = pool->boundary;
210 211 212

	do {
		unsigned int next = offset + pool->size;
213 214 215 216
		if (unlikely((next + pool->size) >= next_boundary)) {
			next = next_boundary;
			next_boundary += pool->boundary;
		}
217 218 219 220 221
		*(int *)(page->vaddr + offset) = next;
		offset = next;
	} while (offset < pool->allocation);
}

Matthew Wilcox's avatar
Matthew Wilcox committed
222
static struct dma_page *pool_alloc_page(struct dma_pool *pool, gfp_t mem_flags)
Linus Torvalds's avatar
Linus Torvalds committed
223
{
Matthew Wilcox's avatar
Matthew Wilcox committed
224
	struct dma_page *page;
Linus Torvalds's avatar
Linus Torvalds committed
225

226
	page = kmalloc(sizeof(*page), mem_flags);
Linus Torvalds's avatar
Linus Torvalds committed
227 228
	if (!page)
		return NULL;
229
	page->vaddr = dma_alloc_coherent(pool->dev, pool->allocation,
Matthew Wilcox's avatar
Matthew Wilcox committed
230
					 &page->dma, mem_flags);
Linus Torvalds's avatar
Linus Torvalds committed
231
	if (page->vaddr) {
232
#ifdef	DMAPOOL_DEBUG
Matthew Wilcox's avatar
Matthew Wilcox committed
233
		memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
Linus Torvalds's avatar
Linus Torvalds committed
234
#endif
235
		pool_initialise_page(pool, page);
Linus Torvalds's avatar
Linus Torvalds committed
236
		page->in_use = 0;
237
		page->offset = 0;
Linus Torvalds's avatar
Linus Torvalds committed
238
	} else {
Matthew Wilcox's avatar
Matthew Wilcox committed
239
		kfree(page);
Linus Torvalds's avatar
Linus Torvalds committed
240 241 242 243 244
		page = NULL;
	}
	return page;
}

245
static inline bool is_page_busy(struct dma_page *page)
Linus Torvalds's avatar
Linus Torvalds committed
246
{
247
	return page->in_use != 0;
Linus Torvalds's avatar
Linus Torvalds committed
248 249
}

Matthew Wilcox's avatar
Matthew Wilcox committed
250
static void pool_free_page(struct dma_pool *pool, struct dma_page *page)
Linus Torvalds's avatar
Linus Torvalds committed
251
{
Matthew Wilcox's avatar
Matthew Wilcox committed
252
	dma_addr_t dma = page->dma;
Linus Torvalds's avatar
Linus Torvalds committed
253

254
#ifdef	DMAPOOL_DEBUG
Matthew Wilcox's avatar
Matthew Wilcox committed
255
	memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
Linus Torvalds's avatar
Linus Torvalds committed
256
#endif
Matthew Wilcox's avatar
Matthew Wilcox committed
257 258 259
	dma_free_coherent(pool->dev, pool->allocation, page->vaddr, dma);
	list_del(&page->page_list);
	kfree(page);
Linus Torvalds's avatar
Linus Torvalds committed
260 261 262 263 264 265 266 267 268 269
}

/**
 * dma_pool_destroy - destroys a pool of dma memory blocks.
 * @pool: dma pool that will be destroyed
 * Context: !in_interrupt()
 *
 * Caller guarantees that no more memory from the pool is in use,
 * and that nothing will try to use the pool after this call.
 */
Matthew Wilcox's avatar
Matthew Wilcox committed
270
void dma_pool_destroy(struct dma_pool *pool)
Linus Torvalds's avatar
Linus Torvalds committed
271
{
272 273
	bool empty = false;

274 275 276
	if (unlikely(!pool))
		return;

277
	mutex_lock(&pools_reg_lock);
278
	mutex_lock(&pools_lock);
Matthew Wilcox's avatar
Matthew Wilcox committed
279 280
	list_del(&pool->pools);
	if (pool->dev && list_empty(&pool->dev->dma_pools))
281
		empty = true;
282
	mutex_unlock(&pools_lock);
283 284 285
	if (empty)
		device_remove_file(pool->dev, &dev_attr_pools);
	mutex_unlock(&pools_reg_lock);
Linus Torvalds's avatar
Linus Torvalds committed
286

Matthew Wilcox's avatar
Matthew Wilcox committed
287 288 289 290
	while (!list_empty(&pool->page_list)) {
		struct dma_page *page;
		page = list_entry(pool->page_list.next,
				  struct dma_page, page_list);
291
		if (is_page_busy(page)) {
Linus Torvalds's avatar
Linus Torvalds committed
292
			if (pool->dev)
Matthew Wilcox's avatar
Matthew Wilcox committed
293 294
				dev_err(pool->dev,
					"dma_pool_destroy %s, %p busy\n",
Linus Torvalds's avatar
Linus Torvalds committed
295 296
					pool->name, page->vaddr);
			else
Matthew Wilcox's avatar
Matthew Wilcox committed
297 298 299
				printk(KERN_ERR
				       "dma_pool_destroy %s, %p busy\n",
				       pool->name, page->vaddr);
Linus Torvalds's avatar
Linus Torvalds committed
300
			/* leak the still-in-use consistent memory */
Matthew Wilcox's avatar
Matthew Wilcox committed
301 302
			list_del(&page->page_list);
			kfree(page);
Linus Torvalds's avatar
Linus Torvalds committed
303
		} else
Matthew Wilcox's avatar
Matthew Wilcox committed
304
			pool_free_page(pool, page);
Linus Torvalds's avatar
Linus Torvalds committed
305 306
	}

Matthew Wilcox's avatar
Matthew Wilcox committed
307
	kfree(pool);
Linus Torvalds's avatar
Linus Torvalds committed
308
}
Matthew Wilcox's avatar
Matthew Wilcox committed
309
EXPORT_SYMBOL(dma_pool_destroy);
Linus Torvalds's avatar
Linus Torvalds committed
310 311 312 313 314 315 316 317 318

/**
 * dma_pool_alloc - get a block of consistent memory
 * @pool: dma pool that will produce the block
 * @mem_flags: GFP_* bitmask
 * @handle: pointer to dma address of block
 *
 * This returns the kernel virtual address of a currently unused block,
 * and reports its dma address through the handle.
319
 * If such a memory block can't be allocated, %NULL is returned.
Linus Torvalds's avatar
Linus Torvalds committed
320
 */
Matthew Wilcox's avatar
Matthew Wilcox committed
321 322
void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
		     dma_addr_t *handle)
Linus Torvalds's avatar
Linus Torvalds committed
323
{
Matthew Wilcox's avatar
Matthew Wilcox committed
324 325 326 327 328
	unsigned long flags;
	struct dma_page *page;
	size_t offset;
	void *retval;

329 330
	might_sleep_if(mem_flags & __GFP_WAIT);

Matthew Wilcox's avatar
Matthew Wilcox committed
331
	spin_lock_irqsave(&pool->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
332
	list_for_each_entry(page, &pool->page_list, page_list) {
333 334
		if (page->offset < pool->allocation)
			goto ready;
Linus Torvalds's avatar
Linus Torvalds committed
335 336
	}

337 338
	/* pool_alloc_page() might sleep, so temporarily drop &pool->lock */
	spin_unlock_irqrestore(&pool->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
339

340
	page = pool_alloc_page(pool, mem_flags & (~__GFP_ZERO));
341 342
	if (!page)
		return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
343

344
	spin_lock_irqsave(&pool->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
345

346
	list_add(&page->page_list, &pool->page_list);
Matthew Wilcox's avatar
Matthew Wilcox committed
347
 ready:
Linus Torvalds's avatar
Linus Torvalds committed
348
	page->in_use++;
349 350
	offset = page->offset;
	page->offset = *(int *)(page->vaddr + offset);
Linus Torvalds's avatar
Linus Torvalds committed
351 352
	retval = offset + page->vaddr;
	*handle = offset + page->dma;
353
#ifdef	DMAPOOL_DEBUG
354 355 356 357 358 359 360 361 362
	{
		int i;
		u8 *data = retval;
		/* page->offset is stored in first 4 bytes */
		for (i = sizeof(page->offset); i < pool->size; i++) {
			if (data[i] == POOL_POISON_FREED)
				continue;
			if (pool->dev)
				dev_err(pool->dev,
363
					"dma_pool_alloc %s, %p (corrupted)\n",
364 365
					pool->name, retval);
			else
366
				pr_err("dma_pool_alloc %s, %p (corrupted)\n",
367 368 369 370 371 372 373 374 375 376 377
					pool->name, retval);

			/*
			 * Dump the first 4 bytes even if they are not
			 * POOL_POISON_FREED
			 */
			print_hex_dump(KERN_ERR, "", DUMP_PREFIX_OFFSET, 16, 1,
					data, pool->size, 1);
			break;
		}
	}
378 379
	if (!(mem_flags & __GFP_ZERO))
		memset(retval, POOL_POISON_ALLOCATED, pool->size);
Linus Torvalds's avatar
Linus Torvalds committed
380
#endif
Matthew Wilcox's avatar
Matthew Wilcox committed
381
	spin_unlock_irqrestore(&pool->lock, flags);
382 383 384 385

	if (mem_flags & __GFP_ZERO)
		memset(retval, 0, pool->size);

Linus Torvalds's avatar
Linus Torvalds committed
386 387
	return retval;
}
Matthew Wilcox's avatar
Matthew Wilcox committed
388
EXPORT_SYMBOL(dma_pool_alloc);
Linus Torvalds's avatar
Linus Torvalds committed
389

Matthew Wilcox's avatar
Matthew Wilcox committed
390
static struct dma_page *pool_find_page(struct dma_pool *pool, dma_addr_t dma)
Linus Torvalds's avatar
Linus Torvalds committed
391
{
Matthew Wilcox's avatar
Matthew Wilcox committed
392
	struct dma_page *page;
Linus Torvalds's avatar
Linus Torvalds committed
393 394 395 396

	list_for_each_entry(page, &pool->page_list, page_list) {
		if (dma < page->dma)
			continue;
397
		if ((dma - page->dma) < pool->allocation)
398
			return page;
Linus Torvalds's avatar
Linus Torvalds committed
399
	}
400
	return NULL;
Linus Torvalds's avatar
Linus Torvalds committed
401 402 403 404 405 406 407 408 409 410 411
}

/**
 * dma_pool_free - put block back into dma pool
 * @pool: the dma pool holding the block
 * @vaddr: virtual address of block
 * @dma: dma address of block
 *
 * Caller promises neither device nor driver will again touch this block
 * unless it is first re-allocated.
 */
Matthew Wilcox's avatar
Matthew Wilcox committed
412
void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
Linus Torvalds's avatar
Linus Torvalds committed
413
{
Matthew Wilcox's avatar
Matthew Wilcox committed
414 415
	struct dma_page *page;
	unsigned long flags;
416
	unsigned int offset;
Linus Torvalds's avatar
Linus Torvalds committed
417

418
	spin_lock_irqsave(&pool->lock, flags);
Matthew Wilcox's avatar
Matthew Wilcox committed
419 420
	page = pool_find_page(pool, dma);
	if (!page) {
421
		spin_unlock_irqrestore(&pool->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
422
		if (pool->dev)
Matthew Wilcox's avatar
Matthew Wilcox committed
423 424 425
			dev_err(pool->dev,
				"dma_pool_free %s, %p/%lx (bad dma)\n",
				pool->name, vaddr, (unsigned long)dma);
Linus Torvalds's avatar
Linus Torvalds committed
426
		else
Matthew Wilcox's avatar
Matthew Wilcox committed
427 428
			printk(KERN_ERR "dma_pool_free %s, %p/%lx (bad dma)\n",
			       pool->name, vaddr, (unsigned long)dma);
Linus Torvalds's avatar
Linus Torvalds committed
429 430 431
		return;
	}

432
	offset = vaddr - page->vaddr;
433
#ifdef	DMAPOOL_DEBUG
434
	if ((dma - page->dma) != offset) {
435
		spin_unlock_irqrestore(&pool->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
436
		if (pool->dev)
Matthew Wilcox's avatar
Matthew Wilcox committed
437 438 439
			dev_err(pool->dev,
				"dma_pool_free %s, %p (bad vaddr)/%Lx\n",
				pool->name, vaddr, (unsigned long long)dma);
Linus Torvalds's avatar
Linus Torvalds committed
440
		else
Matthew Wilcox's avatar
Matthew Wilcox committed
441 442 443
			printk(KERN_ERR
			       "dma_pool_free %s, %p (bad vaddr)/%Lx\n",
			       pool->name, vaddr, (unsigned long long)dma);
Linus Torvalds's avatar
Linus Torvalds committed
444 445
		return;
	}
446 447 448 449 450 451 452
	{
		unsigned int chain = page->offset;
		while (chain < pool->allocation) {
			if (chain != offset) {
				chain = *(int *)(page->vaddr + chain);
				continue;
			}
453
			spin_unlock_irqrestore(&pool->lock, flags);
454 455 456 457 458 459 460 461 462 463
			if (pool->dev)
				dev_err(pool->dev, "dma_pool_free %s, dma %Lx "
					"already free\n", pool->name,
					(unsigned long long)dma);
			else
				printk(KERN_ERR "dma_pool_free %s, dma %Lx "
					"already free\n", pool->name,
					(unsigned long long)dma);
			return;
		}
Linus Torvalds's avatar
Linus Torvalds committed
464
	}
Matthew Wilcox's avatar
Matthew Wilcox committed
465
	memset(vaddr, POOL_POISON_FREED, pool->size);
Linus Torvalds's avatar
Linus Torvalds committed
466 467 468
#endif

	page->in_use--;
469 470
	*(int *)vaddr = page->offset;
	page->offset = offset;
Linus Torvalds's avatar
Linus Torvalds committed
471 472
	/*
	 * Resist a temptation to do
473
	 *    if (!is_page_busy(page)) pool_free_page(pool, page);
Linus Torvalds's avatar
Linus Torvalds committed
474 475
	 * Better have a few empty pages hang around.
	 */
Matthew Wilcox's avatar
Matthew Wilcox committed
476
	spin_unlock_irqrestore(&pool->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
477
}
Matthew Wilcox's avatar
Matthew Wilcox committed
478
EXPORT_SYMBOL(dma_pool_free);
Linus Torvalds's avatar
Linus Torvalds committed
479

480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522
/*
 * Managed DMA pool
 */
static void dmam_pool_release(struct device *dev, void *res)
{
	struct dma_pool *pool = *(struct dma_pool **)res;

	dma_pool_destroy(pool);
}

static int dmam_pool_match(struct device *dev, void *res, void *match_data)
{
	return *(struct dma_pool **)res == match_data;
}

/**
 * dmam_pool_create - Managed dma_pool_create()
 * @name: name of pool, for diagnostics
 * @dev: device that will be doing the DMA
 * @size: size of the blocks in this pool.
 * @align: alignment requirement for blocks; must be a power of two
 * @allocation: returned blocks won't cross this boundary (or zero)
 *
 * Managed dma_pool_create().  DMA pool created with this function is
 * automatically destroyed on driver detach.
 */
struct dma_pool *dmam_pool_create(const char *name, struct device *dev,
				  size_t size, size_t align, size_t allocation)
{
	struct dma_pool **ptr, *pool;

	ptr = devres_alloc(dmam_pool_release, sizeof(*ptr), GFP_KERNEL);
	if (!ptr)
		return NULL;

	pool = *ptr = dma_pool_create(name, dev, size, align, allocation);
	if (pool)
		devres_add(dev, ptr);
	else
		devres_free(ptr);

	return pool;
}
Matthew Wilcox's avatar
Matthew Wilcox committed
523
EXPORT_SYMBOL(dmam_pool_create);
524 525 526 527 528 529 530 531 532 533 534

/**
 * dmam_pool_destroy - Managed dma_pool_destroy()
 * @pool: dma pool that will be destroyed
 *
 * Managed dma_pool_destroy().
 */
void dmam_pool_destroy(struct dma_pool *pool)
{
	struct device *dev = pool->dev;

535
	WARN_ON(devres_release(dev, dmam_pool_release, dmam_pool_match, pool));
536
}
Matthew Wilcox's avatar
Matthew Wilcox committed
537
EXPORT_SYMBOL(dmam_pool_destroy);