使用dma_alloc_writecombine申请内存空间大小的限制

最近在调TFT分辨率,当使用1024x768 16bpp时正常,而当调整为1024x768 24bpp时报"Failed to allocate video memory"的错误.

出错的地方是在分配显示缓冲区.代码如下:

static __inline int allocate_video_memory_map(struct fb_info *fbinfo)

{

...

fbinfo->screen_base = dma_alloc_writecombine(fbi->dev, map_size, (dma_addr_t *)&fbinfo->fix.smem_start, GFP_KERNEL);

if (!fbinfo->screen_base) {

return -ENOMEM;

}

return 0;

}

...

{

ret = allocate_video_memory_map(fbinfo);

if (ret) {

dev_err(fbi->dev, "Failed to allocate video memory ma (%d)\n", ret);

return -ENOMEM;

}

}

dma_alloc_writecombine函数

/*

* Allocate DMA-coherent memory space and return both the kernel remapped

* virtual and bus address for that space.

*/

void *

dma_alloc_coherent(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp)

{

void *memory;

if (dma_alloc_from_coherent(dev, size, handle, &memory))

return memory;

if (arch_is_coherent()) {

void *virt;

virt = kmalloc(size, gfp);

if (!virt)

return NULL;

*handle = virt_to_dma(dev, virt);

return virt;

}

return __dma_alloc(dev, size, handle, gfp,

pgprot_noncached(pgprot_kernel));

}

EXPORT_SYMBOL(dma_alloc_coherent);

/*

* Allocate a writecombining region, in much the same way as

* dma_alloc_coherent above.

*/

void *

dma_alloc_writecombine(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp)

{

return __dma_alloc(dev, size, handle, gfp,

pgprot_writecombine(pgprot_kernel));

}

EXPORT_SYMBOL(dma_alloc_writecombine);

由上方代码可以看出，两个函数都调用了__dma_alloc函数，差别只在于最后一个参数。

dma_alloc_coherent 在 arm 平台上会禁止页表项中的 C （Cacheable） 域以及 B （Bufferable）域。而 dma_alloc_writecombine 只禁止 C （Cacheable） 域.

C 代表是否应用高速缓冲存储器， 而 B 代表是否应用写缓冲区。

如许，dma_alloc_writecombine 分派出来的内存不应用缓存，然则会应用写缓冲区。而 dma_alloc_coherent 则二者都不应用。

C B 位的具体含义

0 0 无cache，无写缓冲；任何对memory的读写都反应到总线上。对 memory 的操纵过程中CPU须要守候。

0 1 无cache，有写缓冲；读操纵直接反应到总线上；写操纵，CPU将数据写入到写缓冲后持续运行，由写缓冲进行写回操纵。

1 0 有cache，写通模式；读操纵起首推敲cache hit；写操纵时直接将数据写入写缓冲，若是同时呈现cache hit，那么也更新cache。

1 1 有cache，写回模式；读操纵起首推敲cache hit；写操纵也起首推敲cache hit。

如许，两者的差别就很清楚了。

static void *

__dma_alloc(struct device *dev, size_t size, dma_addr_t *handle, gfp_t gfp,

pgprot_t prot)

{

struct page *page;

struct arm_vm_region *c;

unsigned long order;

u64 mask = ISA_DMA_THRESHOLD, limit;

if (!consistent_pte[0]) {

printk(KERN_ERR "%s: not initialised\n", __func__);

dump_stack();

return NULL;

}

if (dev) {

mask = dev->coherent_dma_mask;

/*

* Sanity check the DMA mask - it must be non-zero, and

* must be able to be satisfied by a DMA allocation.

*/

if (mask == 0) {

dev_warn(dev, "coherent DMA mask is unset\n");

goto no_page;

}

if ((~mask) & ISA_DMA_THRESHOLD) {

dev_warn(dev, "coherent DMA mask %#llx is smaller "

"than system GFP_DMA mask %#llx\n",

mask, (unsigned long long)ISA_DMA_THRESHOLD);

goto no_page;

}

}

/*

* Sanity check the allocation size.

*/

size = PAGE_ALIGN(size);

limit = (mask + 1) & ~mask;

if ((limit && size >= limit) ||

size >= (CONSISTENT_END - CONSISTENT_BASE)) {

printk(KERN_WARNING "coherent allocation too big "

"(requested %#x mask %#llx)\n", size, mask);

goto no_page;

}

order = get_order(size);

if (mask != 0xffffffff)

gfp |= GFP_DMA;

page = alloc_pages(gfp, order);

if (!page)

goto no_page;

/*

* Invalidate any data that might be lurking in the

* kernel direct-mapped region for device DMA.

*/

{

void *ptr = page_address(page);

memset(ptr, 0, size);

dmac_flush_range(ptr, ptr + size);

outer_flush_range(__pa(ptr), __pa(ptr) + size);

}

/*

* Allocate a virtual address in the consistent mapping region.

*/

c = arm_vm_region_alloc(&consistent_head, size,

gfp & ~(__GFP_DMA | __GFP_HIGHMEM));

if (c) {

pte_t *pte;

struct page *end = page + (1 << order);

int idx = CONSISTENT_PTE_INDEX(c->vm_start);

u32 off = CONSISTENT_OFFSET(c->vm_start) & (PTRS_PER_PTE-1);

pte = consistent_pte[idx] + off;

c->vm_pages = page;

split_page(page, order);

/*

* Set the "dma handle"

*/

*handle = page_to_dma(dev, page);

do {

BUG_ON(!pte_none(*pte));

/*

* x86 does not mark the pages reserved...

*/

SetPageReserved(page);

set_pte_ext(pte, mk_pte(page, prot), 0);

page++;

pte++;

off++;

if (off >= PTRS_PER_PTE) {

off = 0;

pte = consistent_pte[++idx];

}

} while (size -= PAGE_SIZE);

/*

* Free the otherwise unused pages.

*/

while (page < end) {

__free_page(page);

page++;

}

return (void *)c->vm_start;

}

if (page)

__free_pages(page, order);

no_page:

*handle = ~0;

return NULL;

}

在文件arch/arm/include/asm/memory.h中找到有关CONSISTENT_DMA_SIZE的定义:

/*
* Size of DMA-consistent memory region.  Must be multiple of 2M,
* between 2MB and 14MB inclusive.
*/
#ifndef CONSISTENT_DMA_SIZE
#define CONSISTENT_DMA_SIZE SZ_2M
#endif

而文件arch/arm/include/asm/memory.h定义的是Linux下整个ARM体系的公共参数,如果直接修改会引起别的平台的一些不可预料的结果.

幸运的是在memory.h文件开头有一个include文件

#include <mach/memory.h>

找到<mach/memory.h>文件arch/arm/mach-xxx/include/mach/memory.h,在其中添加CONSISTENT_DMA_SIZE的定义即可,如:

#define CONSISTENT_DMA_SIZE SZ_4M