* Coherent per-device memory handling.
* Borrowed from i386
*/
+
+#define pr_fmt(fmt) "%s:%d: " fmt, __func__, __LINE__
#include <linux/slab.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/dma-attrs.h>
#include <linux/dma-contiguous.h>
#include <linux/debugfs.h>
+#include <linux/highmem.h>
+#include <asm/cacheflush.h>
struct heap_info {
- const char *name;
+ char *name;
/* number of devices pointed by devs */
unsigned int num_devs;
- /* indices for start and end device for resize support */
- unsigned int dev_start;
- unsigned int dev_end;
/* devs to manage cma/coherent memory allocs, if resize allowed */
struct device *devs;
/* device to allocate memory from cma */
struct device *cma_dev;
- /* flag that indicates whether heap can resize :shrink/grow */
- bool can_resize;
/* lock to synchronise heap resizing */
struct mutex resize_lock;
/* CMA chunk size if resize supported */
heap->dma_debug_root, (u32 *)&heap->base);
debugfs_create_x32("size", S_IRUGO,
heap->dma_debug_root, (u32 *)&heap->len);
- if (heap->can_resize) {
- debugfs_create_x32("cma_base", S_IRUGO,
- heap->dma_debug_root, (u32 *)&heap->cma_base);
- debugfs_create_x32("cma_size", S_IRUGO,
- heap->dma_debug_root, (u32 *)&heap->cma_len);
- debugfs_create_x32("cma_chunk_size", S_IRUGO,
- heap->dma_debug_root, (u32 *)&heap->cma_chunk_size);
- debugfs_create_x32("num_cma_chunks", S_IRUGO,
- heap->dma_debug_root, (u32 *)&heap->num_devs);
- }
+ debugfs_create_x32("cma_base", S_IRUGO,
+ heap->dma_debug_root, (u32 *)&heap->cma_base);
+ debugfs_create_x32("cma_size", S_IRUGO,
+ heap->dma_debug_root, (u32 *)&heap->cma_len);
+ debugfs_create_x32("cma_chunk_size", S_IRUGO,
+ heap->dma_debug_root, (u32 *)&heap->cma_chunk_size);
+ debugfs_create_x32("num_cma_chunks", S_IRUGO,
+ heap->dma_debug_root, (u32 *)&heap->num_devs);
}
static struct device *dma_create_dma_devs(const char *name, int num_devs)
free1_out:
kfree(dev->dma_mem);
+ dev->dma_mem = NULL;
out:
if (mem_base)
iounmap(mem_base);
BUG_ON(dev->dma_mem);
dma_set_coherent_mask(dev, DMA_BIT_MASK(64));
err = dma_declare_coherent_memory(dev, 0,
- base, size,
- DMA_MEMORY_NOMAP);
+ base, size, DMA_MEMORY_NOMAP);
if (err & DMA_MEMORY_NOMAP) {
- dev_dbg(dev, "dma coherent mem base (%pa) size (%zu)\n",
+ dev_dbg(dev, "dma coherent mem base (0x%pa) size (0x%zx)\n",
&base, size);
return 0;
}
- dev_err(dev, "failed to declare dma coherent_mem (%pa)\n",
- &base);
+ dev_err(dev, "declare dma coherent_mem fail 0x%pa 0x%zx\n",
+ &base, size);
return -ENOMEM;
}
int dma_declare_coherent_resizable_cma_memory(struct device *dev,
struct dma_declare_info *dma_info)
{
+#ifdef CONFIG_CMA
int err = 0;
struct heap_info *heap_info = NULL;
+ struct dma_contiguous_stats stats;
struct dma_coherent_reserved *r =
&dma_coherent_reserved[dma_coherent_reserved_count];
return -ENOSPC;
}
- if (!dma_info || !dev)
+ if (!dev || !dma_info || !dma_info->name || !dma_info->cma_dev)
return -EINVAL;
heap_info = kzalloc(sizeof(*heap_info), GFP_KERNEL);
if (!heap_info)
return -ENOMEM;
- heap_info->name = dma_info->name;
- dev_set_name(dev, "dma-%s", heap_info->name);
-
- if (!dma_info->resize) {
- /* No Resize support */
- err = declare_coherent_heap(dev, dma_info->base,
- dma_info->size);
- if (err)
- goto fail;
-
- heap_info->base = dma_info->base;
- heap_info->len = dma_info->size;
- heap_info->can_resize = false;
- } else {
- /* Resize Heap memory */
-#ifdef CONFIG_CMA
- struct dma_contiguous_stats stats;
- if (!dma_info->cma_dev) {
- err = -EINVAL;
- goto fail;
- }
- heap_info->cma_dev = dma_info->cma_dev;
- dma_get_contiguous_stats(heap_info->cma_dev, &stats);
-
- heap_info->cma_chunk_size = dma_info->size;
- heap_info->cma_base = stats.base;
- heap_info->cma_len = stats.size;
- heap_info->can_resize = true;
- dev_set_name(heap_info->cma_dev, "cma-%s-heap", dma_info->name);
-
- if (heap_info->cma_len < heap_info->cma_chunk_size) {
- dev_err(dev, "error cma_len < cma_chunk_size");
- err = -EINVAL;
- goto fail;
- }
+ heap_info->name = kmalloc(strlen(dma_info->name) + 1, GFP_KERNEL);
+ if (!heap_info->name) {
+ kfree(heap_info);
+ return -ENOMEM;
+ }
- mutex_init(&heap_info->resize_lock);
- heap_info->num_devs = div_u64_rem(heap_info->cma_len,
- heap_info->cma_chunk_size, &heap_info->rem_chunk_size);
- if (heap_info->rem_chunk_size) {
- heap_info->num_devs++;
- dev_dbg(dev, "size is not multiple of cma_chunk_size\n"
- "heap_info->num_devs (%d) rem_chunk_size(%d)\n",
- heap_info->num_devs, heap_info->rem_chunk_size);
- }
- heap_info->devs = dma_create_dma_devs(dma_info->name,
- heap_info->num_devs);
- if (!heap_info->devs) {
- dev_err(dev, "failed to alloc devices\n");
- err = -ENOMEM;
- goto fail;
- }
- if (dma_info->notifier.ops)
- heap_info->update_resize_cfg =
- dma_info->notifier.ops->resize;
-#else
+ dma_get_contiguous_stats(dma_info->cma_dev, &stats);
+ pr_info("resizable heap=%s, base=0x%pa, size=0x%zx\n",
+ dma_info->name, &stats.base, stats.size);
+ strcpy(heap_info->name, dma_info->name);
+ dev_set_name(dev, "dma-%s", heap_info->name);
+ heap_info->cma_dev = dma_info->cma_dev;
+ heap_info->cma_chunk_size = dma_info->size;
+ heap_info->cma_base = stats.base;
+ heap_info->cma_len = stats.size;
+ dev_set_name(heap_info->cma_dev, "cma-%s-heap", heap_info->name);
+ mutex_init(&heap_info->resize_lock);
+
+ if (heap_info->cma_len < heap_info->cma_chunk_size) {
+ dev_err(dev, "error cma_len(0x%zx) < cma_chunk_size(0x%zx)\n",
+ heap_info->cma_len, heap_info->cma_chunk_size);
err = -EINVAL;
goto fail;
-#endif
}
+ heap_info->num_devs = div_u64_rem(heap_info->cma_len,
+ (u32)heap_info->cma_chunk_size, (u32 *)&heap_info->rem_chunk_size);
+ if (heap_info->rem_chunk_size) {
+ heap_info->num_devs++;
+ dev_info(dev, "heap size is not multiple of cma_chunk_size "
+ "heap_info->num_devs (%d) rem_chunk_size(0x%zx)\n",
+ heap_info->num_devs, heap_info->rem_chunk_size);
+ } else
+ heap_info->rem_chunk_size = heap_info->cma_chunk_size;
+ heap_info->devs = dma_create_dma_devs(heap_info->name,
+ heap_info->num_devs);
+ if (!heap_info->devs) {
+ dev_err(dev, "failed to alloc devices\n");
+ err = -ENOMEM;
+ goto fail;
+ }
+ if (dma_info->notifier.ops)
+ heap_info->update_resize_cfg =
+ dma_info->notifier.ops->resize;
+
r->dev = dev;
dma_coherent_reserved_count++;
dev_set_drvdata(dev, heap_info);
dma_debugfs_init(dev, heap_info);
+ pr_info("resizable cma heap=%s create successful", heap_info->name);
return 0;
fail:
kfree(heap_info);
return err;
+#else
+ return -EINVAL;
+#endif
}
EXPORT_SYMBOL(dma_declare_coherent_resizable_cma_memory);
struct page *page;
unsigned long order;
- /* check for if last chunk is residual chunk */
- if (h->len && (h->dev_end + 1 == (h->num_devs - 1))
- && h->rem_chunk_size) {
- len = h->rem_chunk_size;
- dev_dbg(h->cma_dev, "rem_chunk_size (%d)\n", len);
- }
-
+ dev_dbg(h->cma_dev, "req at base (0x%pa) size (0x%zx)\n",
+ &base, len);
order = get_order(len);
count = PAGE_ALIGN(len) >> PAGE_SHIFT;
- page = dma_alloc_from_contiguous(h->cma_dev, count, order);
+ page = dma_alloc_at_from_contiguous(h->cma_dev, count, order, base);
if (!page) {
- dev_err(h->cma_dev, "failed to alloc dma contiguous mem\n");
+ dev_err(h->cma_dev, "dma_alloc_at_from_contiguous failed\n");
goto dma_alloc_err;
}
+
base = page_to_phys(page);
- dev_dbg(h->cma_dev, "dma contiguous mem base (0x%pa) size (%zu)\n",
+ dev_dbg(h->cma_dev, "allocated at base (0x%pa) size (0x%zx)\n",
&base, len);
BUG_ON(base < h->cma_base ||
base - h->cma_base + len > h->cma_len);
dma_release_from_contiguous(h->cma_dev, page, count);
}
-static int heap_resize_locked(struct heap_info *h)
+static void get_first_and_last_idx(struct heap_info *h,
+ int *first_alloc_idx, int *last_alloc_idx)
{
int idx;
- phys_addr_t base;
- bool at_bottom = false;
- size_t cma_chunk_size = h->cma_chunk_size;
+ struct device *d;
+
+ *first_alloc_idx = -1;
+ *last_alloc_idx = h->num_devs;
+
+ for (idx = 0; idx < h->num_devs; idx++) {
+ d = &h->devs[idx];
+ if (d->dma_mem) {
+ if (*first_alloc_idx == -1)
+ *first_alloc_idx = idx;
+ *last_alloc_idx = idx;
+ }
+ }
+}
+
+static void update_heap_base_len(struct heap_info *h)
+{
+ int idx;
+ struct device *d;
+ phys_addr_t base = 0;
+ size_t len = 0;
+
+ for (idx = 0; idx < h->num_devs; idx++) {
+ d = &h->devs[idx];
+ if (d->dma_mem) {
+ if (!base)
+ base = idx * h->cma_chunk_size + h->cma_base;
+ len += (idx == h->num_devs - 1) ?
+ h->rem_chunk_size : h->cma_chunk_size;
+ }
+ }
+
+ h->base = base;
+ h->len = len;
+}
+
+static int heap_resize_locked(struct heap_info *h)
+{
+ int i;
int err = 0;
+ phys_addr_t base = -1;
+ size_t len = h->cma_chunk_size;
+ phys_addr_t prev_base = h->base;
+ size_t prev_len = h->len;
+ int alloc_at_idx = 0;
+ int first_alloc_idx;
+ int last_alloc_idx;
+ phys_addr_t start_addr = 0;
+
+ get_first_and_last_idx(h, &first_alloc_idx, &last_alloc_idx);
+ pr_debug("req resize, fi=%d,li=%d\n", first_alloc_idx, last_alloc_idx);
+
+ /* All chunks are in use. Can't grow it. */
+ if (first_alloc_idx == 0 && last_alloc_idx == h->num_devs - 1)
+ return -ENOMEM;
- base = alloc_from_contiguous_heap(h, 0, h->cma_chunk_size);
- if (dma_mapping_error(h->cma_dev, base)) {
- dev_err(&h->devs[idx],
- "Failed to allocate contiguous memory on resize\n");
- return 1;
+ /* All chunks are free. Can allocate anywhere in CMA with
+ * cma_chunk_size alignment.
+ */
+ if (first_alloc_idx == -1) {
+ base = alloc_from_contiguous_heap(h, start_addr, len);
+ if (!dma_mapping_error(h->cma_dev, base))
+ goto alloc_success;
+ }
+
+ /* Free chunk before previously allocated chunk. Attempt
+ * to allocate only immediate previous chunk.
+ */
+ if (first_alloc_idx > 0) {
+ alloc_at_idx = first_alloc_idx - 1;
+ start_addr = alloc_at_idx * h->cma_chunk_size + h->cma_base;
+ base = alloc_from_contiguous_heap(h, start_addr, len);
+ if (base == start_addr)
+ goto alloc_success;
+ BUG_ON(!dma_mapping_error(h->cma_dev, base));
}
- idx = div_u64(base - h->cma_base, h->cma_chunk_size);
- if (!h->len || base == h->base - h->cma_chunk_size) {
- /* new chunk can be added at bottom. */
- h->base = base;
- at_bottom = true;
- } else if (base != h->base + h->len) {
- /* new chunk can't be added at top */
- dev_err(&h->devs[idx],
- "Failed to get contiguous block(0x%pa) on resize\n",
- &base);
- goto fail_non_contig;
+
+ /* Free chunk after previously allocated chunk. */
+ if (last_alloc_idx < h->num_devs - 1) {
+ alloc_at_idx = last_alloc_idx + 1;
+ len = (alloc_at_idx == h->num_devs - 1) ?
+ h->rem_chunk_size : h->cma_chunk_size;
+ start_addr = alloc_at_idx * h->cma_chunk_size + h->cma_base;
+ base = alloc_from_contiguous_heap(h, start_addr, len);
+ if (base == start_addr)
+ goto alloc_success;
+ BUG_ON(!dma_mapping_error(h->cma_dev, base));
}
- BUG_ON(h->dev_start - 1 != idx && h->dev_end + 1 != idx && h->len);
- if (h->len && (h->dev_end + 1 == (h->num_devs - 1))
- && h->rem_chunk_size) {
- cma_chunk_size = h->rem_chunk_size;
- dev_dbg(h->cma_dev, "rem_chunk_size (%d)\n", cma_chunk_size);
+
+ if (dma_mapping_error(h->cma_dev, base))
+ dev_err(&h->devs[alloc_at_idx],
+ "Failed to allocate contiguous memory on heap grow req\n");
+
+ return -ENOMEM;
+
+alloc_success:
+ if (declare_coherent_heap(&h->devs[alloc_at_idx], base, len)) {
+ dev_err(&h->devs[alloc_at_idx],
+ "Failed to declare coherent memory\n");
+ goto fail_declare;
}
- if (declare_coherent_heap(&h->devs[idx], base, cma_chunk_size)) {
- dev_err(&h->devs[idx],
- "Failed to declare coherent memory on resize\n");
- goto fail_non_contig;
+ for (i = 0; i < len >> PAGE_SHIFT; i++) {
+ struct page *page = phys_to_page(i + base);
+
+ if (PageHighMem(page)) {
+ void *ptr = kmap_atomic(page);
+ dmac_flush_range(ptr, ptr + PAGE_SIZE);
+ kunmap_atomic(ptr);
+ } else {
+ void *ptr = page_address(page);
+ dmac_flush_range(ptr, ptr + PAGE_SIZE);
+ }
}
+ update_heap_base_len(h);
+
/* Handle VPR configuration updates*/
if (h->update_resize_cfg) {
- err = h->update_resize_cfg(h->base, h->len + cma_chunk_size);
+ err = h->update_resize_cfg(h->base, h->len);
if (err) {
- dev_err(&h->devs[idx], "Failed to update VPR resize\n");
+ dev_err(&h->devs[alloc_at_idx], "Failed to update heap resize\n");
goto fail_update;
}
}
- if (at_bottom) {
- h->dev_start = idx;
- if (!h->len)
- h->dev_end = h->dev_start;
- dev_dbg(&h->devs[idx],
- "Resize VPR base from=0x%pa to=0x%pa,"
- " len from=%zu to=%zu\n",
- &h->base, &base, h->len, h->len + cma_chunk_size);
- } else {
- h->dev_end = idx;
- dev_dbg(&h->devs[idx],
- "Resize VPR base 0x%pa len from=%zu to=%zu\n",
- &h->base, h->len, h->len + cma_chunk_size);
- }
- h->len += cma_chunk_size;
+ dev_dbg(&h->devs[alloc_at_idx],
+ "grow heap base from=0x%pa to=0x%pa,"
+ " len from=0x%zx to=0x%zx\n",
+ &prev_base, &h->base, prev_len, h->len);
return 0;
fail_update:
- dma_release_declared_memory(&h->devs[idx]);
-fail_non_contig:
- release_from_contiguous_heap(h, base, cma_chunk_size);
- return 1;
+ dma_release_declared_memory(&h->devs[alloc_at_idx]);
+fail_declare:
+ release_from_contiguous_heap(h, base, len);
+ h->base = prev_base;
+ h->len = prev_len;
+ return -ENOMEM;
}
+/* retval: !0 on success, 0 on failure */
static int dma_alloc_from_coherent_dev(struct device *dev, ssize_t size,
dma_addr_t *dma_handle, void **ret,
struct dma_attrs *attrs)
if (!mem)
return 0;
+ *dma_handle = DMA_ERROR_CODE;
*ret = NULL;
if (unlikely(size > (mem->size << PAGE_SHIFT)))
return mem->flags & DMA_MEMORY_EXCLUSIVE;
}
+/* retval: !0 on success, 0 on failure */
static int dma_alloc_from_coherent_heap_dev(struct device *dev, size_t len,
dma_addr_t *dma_handle, void **ret,
struct dma_attrs *attrs)
{
- int err = 0;
- int idx = 0;
- phys_addr_t pa;
+ int idx;
struct heap_info *h = NULL;
struct device *d;
+ *dma_handle = DMA_ERROR_CODE;
if (!dma_is_coherent_dev(dev))
return 0;
h = dev_get_drvdata(dev);
+ BUG_ON(!h);
if (!h)
- return 0;
-
- if (!h->can_resize)
- return 0;
-
+ return 1;
dma_set_attr(DMA_ATTR_ALLOC_EXACT_SIZE, attrs);
mutex_lock(&h->resize_lock);
retry_alloc:
/* Try allocation from already existing CMA chunks */
- for (idx = h->dev_start; idx <= h->dev_end && h->len; idx++) {
+ for (idx = 0; idx < h->num_devs; idx++) {
d = &h->devs[idx];
- if (d->dma_mem) {
- err = dma_alloc_from_coherent_dev(d, len, &pa,
- ret, attrs);
- if (err) {
- dev_dbg(d, "Allocated addr %pa len %zu\n",
- &pa, len);
- *dma_handle = pa;
- goto out;
- }
+ if (!d->dma_mem)
+ continue;
+ if (dma_alloc_from_coherent_dev(
+ d, len, dma_handle, ret, attrs)) {
+ dev_dbg(d, "allocated addr 0x%pa len 0x%zx\n",
+ dma_handle, len);
+ goto out;
}
}
- /* Check if a heap can be expanded */
- if (h->dev_end - h->dev_start + 1 < h->num_devs || !h->len) {
- if (!heap_resize_locked(h))
- goto retry_alloc;
- }
+ if (!heap_resize_locked(h))
+ goto retry_alloc;
out:
mutex_unlock(&h->resize_lock);
- return err;
+ return DMA_MEMORY_EXCLUSIVE;
}
+/* retval: !0 on success, 0 on failure */
static int dma_release_from_coherent_dev(struct device *dev, size_t size,
void *vaddr, struct dma_attrs *attrs)
{
return 0;
if (mem->flags & DMA_MEMORY_NOMAP)
- mem_addr = (void *)mem->device_base;
+ mem_addr = (void *)(uintptr_t)mem->device_base;
else
mem_addr = mem->virt_base;
-
if (mem && vaddr >= mem_addr &&
vaddr - mem_addr < mem->size << PAGE_SHIFT) {
int err = 0;
int resize_err = 0;
void *ret = NULL;
- dma_addr_t dev_base, update_base;
+ dma_addr_t dev_base;
struct heap_info *h = NULL;
- size_t cma_chunk_size = h->cma_chunk_size;
+ size_t chunk_size;
+ int first_alloc_idx;
+ int last_alloc_idx;
if (!dma_is_coherent_dev(dev))
return 0;
h = dev_get_drvdata(dev);
+ BUG_ON(!h);
if (!h)
- return 0;
+ return 1;
+ if ((uintptr_t)base < h->cma_base ||
+ len > h->cma_chunk_size ||
+ (uintptr_t)base - h->cma_base > h->cma_len - len) {
+ BUG();
+ return 1;
+ }
dma_set_attr(DMA_ATTR_ALLOC_EXACT_SIZE, attrs);
- if (!h->can_resize)
- return 0;
-
mutex_lock(&h->resize_lock);
idx = div_u64((uintptr_t)base - h->cma_base, h->cma_chunk_size);
- dev_dbg(&h->devs[idx], "dma free base (%pa) size (%zu) idx (%d)\n",
- (void *)(uintptr_t)&base, len, idx);
+ dev_dbg(&h->devs[idx], "req free addr (%p) size (0x%zx) idx (%d)\n",
+ base, len, idx);
err = dma_release_from_coherent_dev(&h->devs[idx], len, base, attrs);
if (!err)
goto out_unlock;
check_next_chunk:
+ get_first_and_last_idx(h, &first_alloc_idx, &last_alloc_idx);
+
/* Check if heap can be shrinked */
- if ((idx == h->dev_start || idx == h->dev_end) && h->len) {
- /* check if entire chunk is free
- * check if last chunk is residual chunk
- */
- if ((idx == h->num_devs - 1) && h->rem_chunk_size) {
- cma_chunk_size = h->rem_chunk_size;
- dev_dbg(&h->devs[idx], "rem chunk size (%d)\n",
- h->rem_chunk_size);
- } else
- cma_chunk_size = h->cma_chunk_size;
+ if (idx == first_alloc_idx || idx == last_alloc_idx) {
+ /* check if entire chunk is free */
+ if (idx == h->num_devs - 1)
+ chunk_size = h->rem_chunk_size;
+ else
+ chunk_size = h->cma_chunk_size;
resize_err = dma_alloc_from_coherent_dev(&h->devs[idx],
- cma_chunk_size,
+ chunk_size,
&dev_base, &ret, attrs);
if (!resize_err)
goto out_unlock;
else {
+ dev_dbg(&h->devs[idx],
+ "prep to remove chunk b=0x%pa, s=0x%zx\n",
+ &dev_base, chunk_size);
resize_err = dma_release_from_coherent_dev(
- &h->devs[idx], cma_chunk_size,
- (void *)dev_base, attrs);
- if (!resize_err)
+ &h->devs[idx], chunk_size,
+ (void *)(uintptr_t)dev_base, attrs);
+ if (!resize_err) {
+ dev_err(&h->devs[idx], "failed to rel mem\n");
goto out_unlock;
+ }
- dma_release_declared_memory(
- &h->devs[idx]);
+ dma_release_declared_memory(&h->devs[idx]);
BUG_ON(h->devs[idx].dma_mem != NULL);
- h->len -= cma_chunk_size;
- update_base = h->base;
-
- if ((idx == h->dev_start))
- update_base += cma_chunk_size;
+ update_heap_base_len(h);
/* Handle VPR configuration updates */
if (h->update_resize_cfg) {
resize_err =
- h->update_resize_cfg(update_base,
- h->len);
+ h->update_resize_cfg(h->base, h->len);
if (resize_err) {
+ dev_err(&h->devs[idx],
+ "update resize failed\n");
/* On update failure re-declare heap */
- err = declare_coherent_heap(
+ resize_err = declare_coherent_heap(
&h->devs[idx], dev_base,
- cma_chunk_size);
- if (!err)
- h->len += cma_chunk_size;
- else {
- /* on declare coherent failure release
- * heap chunk
- */
- release_from_contiguous_heap(
- h, dev_base,
- cma_chunk_size);
-
+ chunk_size);
+ if (resize_err) {
+ /* on declare coherent failure
+ * release heap chunk
+ */
+ release_from_contiguous_heap(h,
+ dev_base, chunk_size);
dev_err(&h->devs[idx],
- "Failed to update VPR "
- "resize\n");
- }
-
+ "declare failed\n");
+ } else
+ update_heap_base_len(h);
goto out_unlock;
}
}
- if (idx == h->dev_start) {
- h->dev_start++;
- h->base = update_base;
- dev_dbg(&h->devs[idx],
- "Release Chunk at bottom\n");
- dev_dbg(&h->devs[idx],
- "Resize VPR base from=0x%pa to=0x%pa,"
- " len from=%zu to=%zu\n",
- &h->base - cma_chunk_size, &h->base,
- h->len + cma_chunk_size, h->len);
- idx++;
- } else {
- h->dev_end--;
- dev_dbg(&h->devs[idx],
- "Release Chunk at top\n");
- dev_dbg(&h->devs[idx],
- "Resize VPR base %pa,"
- " len from=%zu to=%zu\n",
- &h->base,
- h->len + cma_chunk_size, h->len);
- idx--;
- }
-
- release_from_contiguous_heap(h, dev_base,
- cma_chunk_size);
+ idx == first_alloc_idx ? ++idx : --idx;
+ release_from_contiguous_heap(h, dev_base, chunk_size);
+ dev_dbg(&h->devs[idx], "removed chunk b=0x%pa, s=0x%zx"
+ "new heap b=0x%pa, s=0x%zx",
+ &dev_base, chunk_size, &h->base, h->len);
}
- goto check_next_chunk;
+ if (idx < h->num_devs)
+ goto check_next_chunk;
}
out_unlock:
mutex_unlock(&h->resize_lock);
return 0;
if (mem->flags & DMA_MEMORY_NOMAP)
- mem_addr = (void *)mem->device_base;
+ mem_addr = (void *)(uintptr_t)mem->device_base;
else
mem_addr = mem->virt_base;
projects / sojka / nv-tegra / linux-3.10.git / commitdiff