mm/dmapool.c

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