Lines Matching refs:pool
14 * The current design of this allocator is fairly simple. The pool is
48 struct dma_pool { /* the pool */
74 struct dma_pool *pool;
80 list_for_each_entry(pool, &dev->dma_pools, pools) {
81 /* per-pool info, no real statistics yet */
83 pool->name, pool->nr_active,
84 pool->nr_blocks, pool->size,
85 pool->nr_pages);
95 static void pool_check_block(struct dma_pool *pool, struct dma_block *block,
101 for (i = sizeof(struct dma_block); i < pool->size; i++) {
104 dev_err(pool->dev, "%s %s, %p (corrupted)\n", __func__,
105 pool->name, block);
112 data, pool->size, 1);
117 memset(block, POOL_POISON_ALLOCATED, pool->size);
120 static struct dma_page *pool_find_page(struct dma_pool *pool, dma_addr_t dma)
124 list_for_each_entry(page, &pool->page_list, page_list) {
127 if ((dma - page->dma) < pool->allocation)
133 static bool pool_block_err(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
135 struct dma_block *block = pool->next_block;
138 page = pool_find_page(pool, dma);
140 dev_err(pool->dev, "%s %s, %p/%pad (bad dma)\n",
141 __func__, pool->name, vaddr, &dma);
150 dev_err(pool->dev, "%s %s, dma %pad already free\n",
151 __func__, pool->name, &dma);
155 memset(vaddr, POOL_POISON_FREED, pool->size);
159 static void pool_init_page(struct dma_pool *pool, struct dma_page *page)
161 memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
164 static void pool_check_block(struct dma_pool *pool, struct dma_block *block,
169 static bool pool_block_err(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
172 memset(vaddr, 0, pool->size);
176 static void pool_init_page(struct dma_pool *pool, struct dma_page *page)
181 static struct dma_block *pool_block_pop(struct dma_pool *pool)
183 struct dma_block *block = pool->next_block;
186 pool->next_block = block->next_block;
187 pool->nr_active++;
192 static void pool_block_push(struct dma_pool *pool, struct dma_block *block,
196 block->next_block = pool->next_block;
197 pool->next_block = block;
202 * dma_pool_create - Creates a pool of consistent memory blocks, for dma.
203 * @name: name of pool, for diagnostics
205 * @size: size of the blocks in this pool.
221 * Return: a dma allocation pool with the requested characteristics, or
300 static void pool_initialise_page(struct dma_pool *pool, struct dma_page *page)
302 unsigned int next_boundary = pool->boundary, offset = 0;
305 pool_init_page(pool, page);
306 while (offset + pool->size <= pool->allocation) {
307 if (offset + pool->size > next_boundary) {
309 next_boundary += pool->boundary;
323 offset += pool->size;
324 pool->nr_blocks++;
327 last->next_block = pool->next_block;
328 pool->next_block = first;
330 list_add(&page->page_list, &pool->page_list);
331 pool->nr_pages++;
334 static struct dma_page *pool_alloc_page(struct dma_pool *pool, gfp_t mem_flags)
342 page->vaddr = dma_alloc_coherent(pool->dev, pool->allocation,
353 * dma_pool_destroy - destroys a pool of dma memory blocks.
354 * @pool: dma pool that will be destroyed
357 * Caller guarantees that no more memory from the pool is in use,
358 * and that nothing will try to use the pool after this call.
360 void dma_pool_destroy(struct dma_pool *pool)
365 if (unlikely(!pool))
370 list_del(&pool->pools);
371 empty = list_empty(&pool->dev->dma_pools);
374 device_remove_file(pool->dev, &dev_attr_pools);
377 if (pool->nr_active) {
378 dev_err(pool->dev, "%s %s busy\n", __func__, pool->name);
382 list_for_each_entry_safe(page, tmp, &pool->page_list, page_list) {
384 dma_free_coherent(pool->dev, pool->allocation,
390 kfree(pool);
396 * @pool: dma pool that will produce the block
404 void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
413 spin_lock_irqsave(&pool->lock, flags);
414 block = pool_block_pop(pool);
418 * &pool->lock
420 spin_unlock_irqrestore(&pool->lock, flags);
422 page = pool_alloc_page(pool, mem_flags & (~__GFP_ZERO));
426 spin_lock_irqsave(&pool->lock, flags);
427 pool_initialise_page(pool, page);
428 block = pool_block_pop(pool);
430 spin_unlock_irqrestore(&pool->lock, flags);
433 pool_check_block(pool, block, mem_flags);
435 memset(block, 0, pool->size);
442 * dma_pool_free - put block back into dma pool
443 * @pool: the dma pool holding the block
450 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
455 spin_lock_irqsave(&pool->lock, flags);
456 if (!pool_block_err(pool, vaddr, dma)) {
457 pool_block_push(pool, block, dma);
458 pool->nr_active--;
460 spin_unlock_irqrestore(&pool->lock, flags);
465 * Managed DMA pool
469 struct dma_pool *pool = *(struct dma_pool **)res;
471 dma_pool_destroy(pool);
481 * @name: name of pool, for diagnostics
483 * @size: size of the blocks in this pool.
487 * Managed dma_pool_create(). DMA pool created with this function is
490 * Return: a managed dma allocation pool with the requested
496 struct dma_pool **ptr, *pool;
502 pool = *ptr = dma_pool_create(name, dev, size, align, allocation);
503 if (pool)
508 return pool;
514 * @pool: dma pool that will be destroyed
518 void dmam_pool_destroy(struct dma_pool *pool)
520 struct device *dev = pool->dev;
522 WARN_ON(devres_release(dev, dmam_pool_release, dmam_pool_match, pool));