pool: Improve memory usage for devices which can't cross boundaries
[linux-2.6.git] / mm / dmapool.c
1 /*
2  * DMA Pool allocator
3  *
4  * Copyright 2001 David Brownell
5  * Copyright 2007 Intel Corporation
6  *   Author: Matthew Wilcox <willy@linux.intel.com>
7  *
8  * This software may be redistributed and/or modified under the terms of
9  * the GNU General Public License ("GPL") version 2 as published by the
10  * Free Software Foundation.
11  *
12  * This allocator returns small blocks of a given size which are DMA-able by
13  * the given device.  It uses the dma_alloc_coherent page allocator to get
14  * new pages, then splits them up into blocks of the required size.
15  * Many older drivers still have their own code to do this.
16  *
17  * The current design of this allocator is fairly simple.  The pool is
18  * represented by the 'struct dma_pool' which keeps a doubly-linked list of
19  * allocated pages.  Each page in the page_list is split into blocks of at
20  * least 'size' bytes.  Free blocks are tracked in an unsorted singly-linked
21  * list of free blocks within the page.  Used blocks aren't tracked, but we
22  * keep a count of how many are currently allocated from each page.
23  */
24
25 #include <linux/device.h>
26 #include <linux/dma-mapping.h>
27 #include <linux/dmapool.h>
28 #include <linux/kernel.h>
29 #include <linux/list.h>
30 #include <linux/module.h>
31 #include <linux/mutex.h>
32 #include <linux/poison.h>
33 #include <linux/sched.h>
34 #include <linux/slab.h>
35 #include <linux/spinlock.h>
36 #include <linux/string.h>
37 #include <linux/types.h>
38 #include <linux/wait.h>
39
40 struct dma_pool {               /* the pool */
41         struct list_head page_list;
42         spinlock_t lock;
43         size_t size;
44         struct device *dev;
45         size_t allocation;
46         size_t boundary;
47         char name[32];
48         wait_queue_head_t waitq;
49         struct list_head pools;
50 };
51
52 struct dma_page {               /* cacheable header for 'allocation' bytes */
53         struct list_head page_list;
54         void *vaddr;
55         dma_addr_t dma;
56         unsigned int in_use;
57         unsigned int offset;
58 };
59
60 #define POOL_TIMEOUT_JIFFIES    ((100 /* msec */ * HZ) / 1000)
61
62 static DEFINE_MUTEX(pools_lock);
63
64 static ssize_t
65 show_pools(struct device *dev, struct device_attribute *attr, char *buf)
66 {
67         unsigned temp;
68         unsigned size;
69         char *next;
70         struct dma_page *page;
71         struct dma_pool *pool;
72
73         next = buf;
74         size = PAGE_SIZE;
75
76         temp = scnprintf(next, size, "poolinfo - 0.1\n");
77         size -= temp;
78         next += temp;
79
80         mutex_lock(&pools_lock);
81         list_for_each_entry(pool, &dev->dma_pools, pools) {
82                 unsigned pages = 0;
83                 unsigned blocks = 0;
84
85                 list_for_each_entry(page, &pool->page_list, page_list) {
86                         pages++;
87                         blocks += page->in_use;
88                 }
89
90                 /* per-pool info, no real statistics yet */
91                 temp = scnprintf(next, size, "%-16s %4u %4Zu %4Zu %2u\n",
92                                  pool->name, blocks,
93                                  pages * (pool->allocation / pool->size),
94                                  pool->size, pages);
95                 size -= temp;
96                 next += temp;
97         }
98         mutex_unlock(&pools_lock);
99
100         return PAGE_SIZE - size;
101 }
102
103 static DEVICE_ATTR(pools, S_IRUGO, show_pools, NULL);
104
105 /**
106  * dma_pool_create - Creates a pool of consistent memory blocks, for dma.
107  * @name: name of pool, for diagnostics
108  * @dev: device that will be doing the DMA
109  * @size: size of the blocks in this pool.
110  * @align: alignment requirement for blocks; must be a power of two
111  * @boundary: returned blocks won't cross this power of two boundary
112  * Context: !in_interrupt()
113  *
114  * Returns a dma allocation pool with the requested characteristics, or
115  * null if one can't be created.  Given one of these pools, dma_pool_alloc()
116  * may be used to allocate memory.  Such memory will all have "consistent"
117  * DMA mappings, accessible by the device and its driver without using
118  * cache flushing primitives.  The actual size of blocks allocated may be
119  * larger than requested because of alignment.
120  *
121  * If @boundary is nonzero, objects returned from dma_pool_alloc() won't
122  * cross that size boundary.  This is useful for devices which have
123  * addressing restrictions on individual DMA transfers, such as not crossing
124  * boundaries of 4KBytes.
125  */
126 struct dma_pool *dma_pool_create(const char *name, struct device *dev,
127                                  size_t size, size_t align, size_t boundary)
128 {
129         struct dma_pool *retval;
130         size_t allocation;
131
132         if (align == 0) {
133                 align = 1;
134         } else if (align & (align - 1)) {
135                 return NULL;
136         }
137
138         if (size == 0) {
139                 return NULL;
140         } else if (size < 4) {
141                 size = 4;
142         }
143
144         if ((size % align) != 0)
145                 size = ALIGN(size, align);
146
147         allocation = max_t(size_t, size, PAGE_SIZE);
148
149         if (!boundary) {
150                 boundary = allocation;
151         } else if ((boundary < size) || (boundary & (boundary - 1))) {
152                 return NULL;
153         }
154
155         retval = kmalloc_node(sizeof(*retval), GFP_KERNEL, dev_to_node(dev));
156         if (!retval)
157                 return retval;
158
159         strlcpy(retval->name, name, sizeof(retval->name));
160
161         retval->dev = dev;
162
163         INIT_LIST_HEAD(&retval->page_list);
164         spin_lock_init(&retval->lock);
165         retval->size = size;
166         retval->boundary = boundary;
167         retval->allocation = allocation;
168         init_waitqueue_head(&retval->waitq);
169
170         if (dev) {
171                 int ret;
172
173                 mutex_lock(&pools_lock);
174                 if (list_empty(&dev->dma_pools))
175                         ret = device_create_file(dev, &dev_attr_pools);
176                 else
177                         ret = 0;
178                 /* note:  not currently insisting "name" be unique */
179                 if (!ret)
180                         list_add(&retval->pools, &dev->dma_pools);
181                 else {
182                         kfree(retval);
183                         retval = NULL;
184                 }
185                 mutex_unlock(&pools_lock);
186         } else
187                 INIT_LIST_HEAD(&retval->pools);
188
189         return retval;
190 }
191 EXPORT_SYMBOL(dma_pool_create);
192
193 static void pool_initialise_page(struct dma_pool *pool, struct dma_page *page)
194 {
195         unsigned int offset = 0;
196         unsigned int next_boundary = pool->boundary;
197
198         do {
199                 unsigned int next = offset + pool->size;
200                 if (unlikely((next + pool->size) >= next_boundary)) {
201                         next = next_boundary;
202                         next_boundary += pool->boundary;
203                 }
204                 *(int *)(page->vaddr + offset) = next;
205                 offset = next;
206         } while (offset < pool->allocation);
207 }
208
209 static struct dma_page *pool_alloc_page(struct dma_pool *pool, gfp_t mem_flags)
210 {
211         struct dma_page *page;
212
213         page = kmalloc(sizeof(*page), mem_flags);
214         if (!page)
215                 return NULL;
216         page->vaddr = dma_alloc_coherent(pool->dev, pool->allocation,
217                                          &page->dma, mem_flags);
218         if (page->vaddr) {
219 #ifdef  CONFIG_DEBUG_SLAB
220                 memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
221 #endif
222                 pool_initialise_page(pool, page);
223                 list_add(&page->page_list, &pool->page_list);
224                 page->in_use = 0;
225                 page->offset = 0;
226         } else {
227                 kfree(page);
228                 page = NULL;
229         }
230         return page;
231 }
232
233 static inline int is_page_busy(struct dma_page *page)
234 {
235         return page->in_use != 0;
236 }
237
238 static void pool_free_page(struct dma_pool *pool, struct dma_page *page)
239 {
240         dma_addr_t dma = page->dma;
241
242 #ifdef  CONFIG_DEBUG_SLAB
243         memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
244 #endif
245         dma_free_coherent(pool->dev, pool->allocation, page->vaddr, dma);
246         list_del(&page->page_list);
247         kfree(page);
248 }
249
250 /**
251  * dma_pool_destroy - destroys a pool of dma memory blocks.
252  * @pool: dma pool that will be destroyed
253  * Context: !in_interrupt()
254  *
255  * Caller guarantees that no more memory from the pool is in use,
256  * and that nothing will try to use the pool after this call.
257  */
258 void dma_pool_destroy(struct dma_pool *pool)
259 {
260         mutex_lock(&pools_lock);
261         list_del(&pool->pools);
262         if (pool->dev && list_empty(&pool->dev->dma_pools))
263                 device_remove_file(pool->dev, &dev_attr_pools);
264         mutex_unlock(&pools_lock);
265
266         while (!list_empty(&pool->page_list)) {
267                 struct dma_page *page;
268                 page = list_entry(pool->page_list.next,
269                                   struct dma_page, page_list);
270                 if (is_page_busy(page)) {
271                         if (pool->dev)
272                                 dev_err(pool->dev,
273                                         "dma_pool_destroy %s, %p busy\n",
274                                         pool->name, page->vaddr);
275                         else
276                                 printk(KERN_ERR
277                                        "dma_pool_destroy %s, %p busy\n",
278                                        pool->name, page->vaddr);
279                         /* leak the still-in-use consistent memory */
280                         list_del(&page->page_list);
281                         kfree(page);
282                 } else
283                         pool_free_page(pool, page);
284         }
285
286         kfree(pool);
287 }
288 EXPORT_SYMBOL(dma_pool_destroy);
289
290 /**
291  * dma_pool_alloc - get a block of consistent memory
292  * @pool: dma pool that will produce the block
293  * @mem_flags: GFP_* bitmask
294  * @handle: pointer to dma address of block
295  *
296  * This returns the kernel virtual address of a currently unused block,
297  * and reports its dma address through the handle.
298  * If such a memory block can't be allocated, %NULL is returned.
299  */
300 void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
301                      dma_addr_t *handle)
302 {
303         unsigned long flags;
304         struct dma_page *page;
305         size_t offset;
306         void *retval;
307
308         spin_lock_irqsave(&pool->lock, flags);
309  restart:
310         list_for_each_entry(page, &pool->page_list, page_list) {
311                 if (page->offset < pool->allocation)
312                         goto ready;
313         }
314         page = pool_alloc_page(pool, GFP_ATOMIC);
315         if (!page) {
316                 if (mem_flags & __GFP_WAIT) {
317                         DECLARE_WAITQUEUE(wait, current);
318
319                         __set_current_state(TASK_INTERRUPTIBLE);
320                         __add_wait_queue(&pool->waitq, &wait);
321                         spin_unlock_irqrestore(&pool->lock, flags);
322
323                         schedule_timeout(POOL_TIMEOUT_JIFFIES);
324
325                         spin_lock_irqsave(&pool->lock, flags);
326                         __remove_wait_queue(&pool->waitq, &wait);
327                         goto restart;
328                 }
329                 retval = NULL;
330                 goto done;
331         }
332
333  ready:
334         page->in_use++;
335         offset = page->offset;
336         page->offset = *(int *)(page->vaddr + offset);
337         retval = offset + page->vaddr;
338         *handle = offset + page->dma;
339 #ifdef  CONFIG_DEBUG_SLAB
340         memset(retval, POOL_POISON_ALLOCATED, pool->size);
341 #endif
342  done:
343         spin_unlock_irqrestore(&pool->lock, flags);
344         return retval;
345 }
346 EXPORT_SYMBOL(dma_pool_alloc);
347
348 static struct dma_page *pool_find_page(struct dma_pool *pool, dma_addr_t dma)
349 {
350         unsigned long flags;
351         struct dma_page *page;
352
353         spin_lock_irqsave(&pool->lock, flags);
354         list_for_each_entry(page, &pool->page_list, page_list) {
355                 if (dma < page->dma)
356                         continue;
357                 if (dma < (page->dma + pool->allocation))
358                         goto done;
359         }
360         page = NULL;
361  done:
362         spin_unlock_irqrestore(&pool->lock, flags);
363         return page;
364 }
365
366 /**
367  * dma_pool_free - put block back into dma pool
368  * @pool: the dma pool holding the block
369  * @vaddr: virtual address of block
370  * @dma: dma address of block
371  *
372  * Caller promises neither device nor driver will again touch this block
373  * unless it is first re-allocated.
374  */
375 void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t dma)
376 {
377         struct dma_page *page;
378         unsigned long flags;
379         unsigned int offset;
380
381         page = pool_find_page(pool, dma);
382         if (!page) {
383                 if (pool->dev)
384                         dev_err(pool->dev,
385                                 "dma_pool_free %s, %p/%lx (bad dma)\n",
386                                 pool->name, vaddr, (unsigned long)dma);
387                 else
388                         printk(KERN_ERR "dma_pool_free %s, %p/%lx (bad dma)\n",
389                                pool->name, vaddr, (unsigned long)dma);
390                 return;
391         }
392
393         offset = vaddr - page->vaddr;
394 #ifdef  CONFIG_DEBUG_SLAB
395         if ((dma - page->dma) != offset) {
396                 if (pool->dev)
397                         dev_err(pool->dev,
398                                 "dma_pool_free %s, %p (bad vaddr)/%Lx\n",
399                                 pool->name, vaddr, (unsigned long long)dma);
400                 else
401                         printk(KERN_ERR
402                                "dma_pool_free %s, %p (bad vaddr)/%Lx\n",
403                                pool->name, vaddr, (unsigned long long)dma);
404                 return;
405         }
406         {
407                 unsigned int chain = page->offset;
408                 while (chain < pool->allocation) {
409                         if (chain != offset) {
410                                 chain = *(int *)(page->vaddr + chain);
411                                 continue;
412                         }
413                         if (pool->dev)
414                                 dev_err(pool->dev, "dma_pool_free %s, dma %Lx "
415                                         "already free\n", pool->name,
416                                         (unsigned long long)dma);
417                         else
418                                 printk(KERN_ERR "dma_pool_free %s, dma %Lx "
419                                         "already free\n", pool->name,
420                                         (unsigned long long)dma);
421                         return;
422                 }
423         }
424         memset(vaddr, POOL_POISON_FREED, pool->size);
425 #endif
426
427         spin_lock_irqsave(&pool->lock, flags);
428         page->in_use--;
429         *(int *)vaddr = page->offset;
430         page->offset = offset;
431         if (waitqueue_active(&pool->waitq))
432                 wake_up_locked(&pool->waitq);
433         /*
434          * Resist a temptation to do
435          *    if (!is_page_busy(page)) pool_free_page(pool, page);
436          * Better have a few empty pages hang around.
437          */
438         spin_unlock_irqrestore(&pool->lock, flags);
439 }
440 EXPORT_SYMBOL(dma_pool_free);
441
442 /*
443  * Managed DMA pool
444  */
445 static void dmam_pool_release(struct device *dev, void *res)
446 {
447         struct dma_pool *pool = *(struct dma_pool **)res;
448
449         dma_pool_destroy(pool);
450 }
451
452 static int dmam_pool_match(struct device *dev, void *res, void *match_data)
453 {
454         return *(struct dma_pool **)res == match_data;
455 }
456
457 /**
458  * dmam_pool_create - Managed dma_pool_create()
459  * @name: name of pool, for diagnostics
460  * @dev: device that will be doing the DMA
461  * @size: size of the blocks in this pool.
462  * @align: alignment requirement for blocks; must be a power of two
463  * @allocation: returned blocks won't cross this boundary (or zero)
464  *
465  * Managed dma_pool_create().  DMA pool created with this function is
466  * automatically destroyed on driver detach.
467  */
468 struct dma_pool *dmam_pool_create(const char *name, struct device *dev,
469                                   size_t size, size_t align, size_t allocation)
470 {
471         struct dma_pool **ptr, *pool;
472
473         ptr = devres_alloc(dmam_pool_release, sizeof(*ptr), GFP_KERNEL);
474         if (!ptr)
475                 return NULL;
476
477         pool = *ptr = dma_pool_create(name, dev, size, align, allocation);
478         if (pool)
479                 devres_add(dev, ptr);
480         else
481                 devres_free(ptr);
482
483         return pool;
484 }
485 EXPORT_SYMBOL(dmam_pool_create);
486
487 /**
488  * dmam_pool_destroy - Managed dma_pool_destroy()
489  * @pool: dma pool that will be destroyed
490  *
491  * Managed dma_pool_destroy().
492  */
493 void dmam_pool_destroy(struct dma_pool *pool)
494 {
495         struct device *dev = pool->dev;
496
497         dma_pool_destroy(pool);
498         WARN_ON(devres_destroy(dev, dmam_pool_release, dmam_pool_match, pool));
499 }
500 EXPORT_SYMBOL(dmam_pool_destroy);