WebSVN – Kolibri OS – Diff – /drivers/ddk/linux/dmapool.c

  * 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.
  */
+#include
+#include
+#include
+#include
 #include
 #include
+#include
 #include
-#include
 #include
 #include
 #include
 #include
+struct dma_pool {       /* the pool */
-struct dma_pool {       /* the pool */
+    struct list_head page_list;
-    struct list_head page_list;
+	spinlock_t lock;
+   size_t size;
-    struct mutex lock;
+	struct device *dev;
-    size_t size;
+    size_t allocation;
-    size_t allocation;
+    size_t boundary;
-    size_t boundary;
+	char name[32];
     dma_addr_t dma;
     unsigned int in_use;
     unsigned int offset;
 };
+static DEFINE_MUTEX(pools_lock);
+static DEFINE_MUTEX(pools_reg_lock);
 static DEFINE_MUTEX(pools_lock);
 struct dma_pool *dma_pool_create(const char *name, struct device *dev,
-                 size_t size, size_t align, size_t boundary)
+				 size_t size, size_t align, size_t boundary)
+{
-    struct dma_pool *retval;
+	struct dma_pool *retval;
-    size_t allocation;
+	size_t allocation;
+	bool empty = false;
-    if (align == 0) {
+	if (align == 0)
-        align = 1;
+		align = 1;
-    } else if (align & (align - 1)) {
+	else if (align & (align - 1))
-        return NULL;
-    }
+		return NULL;
-    if (size == 0) {
+	if (size == 0)
-        return NULL;
+		return NULL;
-    } else if (size < 4) {
-        size = 4;
+	else if (size < 4)
 		size = 4;
-    if ((size % align) != 0)
+	if ((size % align) != 0)
-        size = ALIGN(size, align);
+		size = ALIGN(size, align);
-    allocation = max_t(size_t, size, PAGE_SIZE);
+	allocation = max_t(size_t, size, PAGE_SIZE);
-    allocation = (allocation+0x7FFF) & ~0x7FFF;
     allocation = (allocation+0x7FFF) & ~0x7FFF;
     if (!boundary) {
-        boundary = allocation;
+	if (!boundary)
-    } else if ((boundary < size) || (boundary & (boundary - 1))) {
+		boundary = allocation;
-        return NULL;
+	else if ((boundary < size) || (boundary & (boundary - 1)))
+		return NULL;
     retval = kmalloc(sizeof(*retval), GFP_KERNEL);
-    retval = kmalloc(sizeof(*retval), GFP_KERNEL);
+    if (!retval)
         return retval;
         *(int *)(page->vaddr + offset) = next;
         offset = next;
     } while (offset < pool->allocation);
+}
-static struct dma_page *pool_alloc_page(struct dma_pool *pool)
+static struct dma_page *pool_alloc_page(struct dma_pool *pool, gfp_t mem_flags)
+{
     struct dma_page *page;
-    page = __builtin_malloc(sizeof(*page));
+	page = kmalloc(sizeof(*page), mem_flags);
-    if (!page)
+	if (!page)
-        return NULL;
+		return NULL;
     page->vaddr = (void*)KernelAlloc(pool->allocation);
+    dbgprintf("%s 0x%0x ",__FUNCTION__, page->vaddr);
+	if (page->vaddr) {
-    dbgprintf("%s 0x%0x ",__FUNCTION__, page->vaddr);
+#ifdef	DMAPOOL_DEBUG
 		memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
-    if (page->vaddr)
+#endif
-    {
         page->dma = GetPgAddr(page->vaddr);
         page->dma = GetPgAddr(page->vaddr);
         dbgprintf("dma 0x%0x\n", page->dma);
+        dbgprintf("dma 0x%0x\n", page->dma);
         pool_initialise_page(pool, page);
-        list_add(&page->page_list, &pool->page_list);
+        pool_initialise_page(pool, page);
         page->in_use = 0;
         page->offset = 0;
     } else {
-        free(page);
+		kfree(page);
         page = NULL;
+    }
-    return page;
     return page;
+}
 static inline int is_page_busy(struct dma_page *page)
+static inline bool is_page_busy(struct dma_page *page)
+{
+	return page->in_use != 0;
+}
-    return page->in_use != 0;
+static void pool_free_page(struct dma_pool *pool, struct dma_page *page)
-}
+{
 	dma_addr_t dma = page->dma;
 static void pool_free_page(struct dma_pool *pool, struct dma_page *page)
 #ifdef	DMAPOOL_DEBUG
-    dma_addr_t dma = page->dma;
+	memset(page->vaddr, POOL_POISON_FREED, pool->allocation);
 #endif
     KernelFree(page->vaddr);
-    list_del(&page->page_list);
+    KernelFree(page->vaddr);
-    free(page);
+	list_del(&page->page_list);
 	kfree(page);
+}
+/**
+ * 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.
- * dma_pool_destroy - destroys a pool of dma memory blocks.
+ */
- * @pool: dma pool that will be destroyed
+void dma_pool_destroy(struct dma_pool *pool)
+{
+	bool empty = false;
  * Context: !in_interrupt()
 	if (unlikely(!pool))
- * Caller guarantees that no more memory from the pool is in use,
+		return;
  * and that nothing will try to use the pool after this call.
- */
+	mutex_lock(&pools_reg_lock);
-void dma_pool_destroy(struct dma_pool *pool)
     mutex_lock(&pools_lock);
-    mutex_lock(&pools_lock);
+    list_del(&pool->pools);
-    list_del(&pool->pools);
+    mutex_unlock(&pools_lock);
     mutex_unlock(&pools_lock);
 	mutex_unlock(&pools_reg_lock);
             pool_free_page(pool, page);
+    }
     kfree(pool);
-}
+}
 EXPORT_SYMBOL(dma_pool_destroy);
 /**
  * dma_pool_alloc - get a block of consistent memory
  * If such a memory block can't be allocated, %NULL is returned.
  */
 void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
              dma_addr_t *handle)
+{
-    u32   efl;
+	unsigned long flags;
     struct  dma_page *page;
     size_t  offset;
     void   *retval;
-    efl = safe_cli();
- restart:
+	spin_lock_irqsave(&pool->lock, flags);
     list_for_each_entry(page, &pool->page_list, page_list) {
         if (page->offset < pool->allocation)
             goto ready;
+    }
+	/* pool_alloc_page() might sleep, so temporarily drop &pool->lock */
+	spin_unlock_irqrestore(&pool->lock, flags);
-    }
-    page = pool_alloc_page(pool);
+	page = pool_alloc_page(pool, mem_flags & (~__GFP_ZERO));
-    if (!page)
-    {
+    if (!page)
-        retval = NULL;
-        goto done;
+		return NULL;
+	spin_lock_irqsave(&pool->lock, flags);
 	list_add(&page->page_list, &pool->page_list);
  ready:
-    page->in_use++;
+	page->in_use++;
     offset = page->offset;
     page->offset = *(int *)(page->vaddr + offset);
+    retval = offset + page->vaddr;
+	*handle = offset + page->dma;
-    retval = offset + page->vaddr;
+#ifdef	DMAPOOL_DEBUG
-    *handle = offset + page->dma;
+	{
+		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,
+					"dma_pool_alloc %s, %p (corrupted)\n",
+					pool->name, retval);
- done:
+			else
+				pr_err("dma_pool_alloc %s, %p (corrupted)\n",
+					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);
-    safe_sti(efl);
+			break;
+		}
+	}
+	if (!(mem_flags & __GFP_ZERO))
+		memset(retval, POOL_POISON_ALLOCATED, pool->size);
+#endif
+	spin_unlock_irqrestore(&pool->lock, flags);
+	if (mem_flags & __GFP_ZERO)
+		memset(retval, 0, pool->size);
     return retval;
     return retval;
+}
-static struct dma_page *pool_find_page(struct dma_pool *pool, dma_addr_t dma)
 EXPORT_SYMBOL(dma_pool_alloc);
     struct dma_page *page;
-    u32  efl;
+static struct dma_page *pool_find_page(struct dma_pool *pool, dma_addr_t dma)
+{
-    efl = safe_cli();
-    list_for_each_entry(page, &pool->page_list, page_list) {
-        if (dma < page->dma)
-            continue;
-        if (dma < (page->dma + pool->allocation))
-            goto done;
+    struct dma_page *page;
+    list_for_each_entry(page, &pool->page_list, page_list) {
+        if (dma < page->dma)
-    page = NULL;
+            continue;
- done:
+		if ((dma - page->dma) < pool->allocation)
-    safe_sti(efl);
+			return page;
+    }
+{
     struct dma_page *page;
     unsigned long flags;
     unsigned int offset;
-    u32 efl;
 	spin_lock_irqsave(&pool->lock, flags);
     page = pool_find_page(pool, dma);
+    if (!page) {
-    if (!page) {
+		spin_unlock_irqrestore(&pool->lock, flags);
-        printk(KERN_ERR "dma_pool_free %p/%lx (bad dma)\n",
+		printk(KERN_ERR "dma_pool_free %s, %p/%lx (bad dma)\n",
-               vaddr, (unsigned long)dma);
+		       pool->name, vaddr, (unsigned long)dma);
         return;
+    }
+    offset = vaddr - page->vaddr;
+#ifdef	DMAPOOL_DEBUG
+	if ((dma - page->dma) != offset) {
+		spin_unlock_irqrestore(&pool->lock, flags);
+		if (pool->dev)
+			dev_err(pool->dev,
+				"dma_pool_free %s, %p (bad vaddr)/%Lx\n",
-    offset = vaddr - page->vaddr;
+				pool->name, vaddr, (unsigned long long)dma);
+		else
+			printk(KERN_ERR
+			       "dma_pool_free %s, %p (bad vaddr)/%Lx\n",
+			       pool->name, vaddr, (unsigned long long)dma);
 		return;
+	}
+	{
+		unsigned int chain = page->offset;
+		while (chain < pool->allocation) {
+			if (chain != offset) {
+				chain = *(int *)(page->vaddr + chain);
+				continue;
+			}
+			spin_unlock_irqrestore(&pool->lock, flags);
+			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;
+		}
+	}
+	memset(vaddr, POOL_POISON_FREED, pool->size);
-    efl = safe_cli();
+#endif
-        page->in_use--;
+	page->in_use--;
-        *(int *)vaddr = page->offset;
+	*(int *)vaddr = page->offset;
-        page->offset = offset;
+	page->offset = offset;
     /*
      * Resist a temptation to do
      *    if (!is_page_busy(page)) pool_free_page(pool, page);
+     * Better have a few empty pages hang around.
+     */
+	spin_unlock_irqrestore(&pool->lock, flags);
+}
+EXPORT_SYMBOL(dma_pool_free);
-     * Better have a few empty pages hang around.
+/*
+ * 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)
      */

Subversion Repositories Kolibri OS

(root)/drivers/ddk/linux/dmapool.c – Rev 5270 → 6295