mirror of
https://github.com/team-infusion-developers/android_kernel_samsung_msm8976.git
synced 2024-10-31 18:09:19 +00:00
fc9499e55a
* Package version: T713XXU2BQCO Change-Id: I293d9e7f2df458c512d59b7a06f8ca6add610c99
167 lines
4.5 KiB
C
167 lines
4.5 KiB
C
#ifndef __LINUX_CMA_H
|
|
#define __LINUX_CMA_H
|
|
|
|
/*
|
|
* Contiguous Memory Allocator for DMA mapping framework
|
|
* Copyright (c) 2010-2011 by Samsung Electronics.
|
|
* Written by:
|
|
* Marek Szyprowski <m.szyprowski@samsung.com>
|
|
* Michal Nazarewicz <mina86@mina86.com>
|
|
*
|
|
* This program is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU General Public License as
|
|
* published by the Free Software Foundation; either version 2 of the
|
|
* License or (at your optional) any later version of the license.
|
|
*/
|
|
|
|
/*
|
|
* Contiguous Memory Allocator
|
|
*
|
|
* The Contiguous Memory Allocator (CMA) makes it possible to
|
|
* allocate big contiguous chunks of memory after the system has
|
|
* booted.
|
|
*
|
|
* Why is it needed?
|
|
*
|
|
* Various devices on embedded systems have no scatter-getter and/or
|
|
* IO map support and require contiguous blocks of memory to
|
|
* operate. They include devices such as cameras, hardware video
|
|
* coders, etc.
|
|
*
|
|
* Such devices often require big memory buffers (a full HD frame
|
|
* is, for instance, more then 2 mega pixels large, i.e. more than 6
|
|
* MB of memory), which makes mechanisms such as kmalloc() or
|
|
* alloc_page() ineffective.
|
|
*
|
|
* At the same time, a solution where a big memory region is
|
|
* reserved for a device is suboptimal since often more memory is
|
|
* reserved then strictly required and, moreover, the memory is
|
|
* inaccessible to page system even if device drivers don't use it.
|
|
*
|
|
* CMA tries to solve this issue by operating on memory regions
|
|
* where only movable pages can be allocated from. This way, kernel
|
|
* can use the memory for pagecache and when device driver requests
|
|
* it, allocated pages can be migrated.
|
|
*
|
|
* Driver usage
|
|
*
|
|
* CMA should not be used by the device drivers directly. It is
|
|
* only a helper framework for dma-mapping subsystem.
|
|
*
|
|
* For more information, see kernel-docs in drivers/base/dma-contiguous.c
|
|
*/
|
|
|
|
#ifdef __KERNEL__
|
|
|
|
struct cma;
|
|
struct page;
|
|
struct device;
|
|
|
|
#ifdef CONFIG_CMA
|
|
|
|
/*
|
|
* There is always at least global CMA area and a few optional device
|
|
* private areas configured in kernel .config.
|
|
*/
|
|
#define MAX_CMA_AREAS (1 + CONFIG_CMA_AREAS)
|
|
|
|
|
|
phys_addr_t cma_get_base(struct device *dev);
|
|
unsigned long cma_get_size(struct device *dev);
|
|
|
|
extern struct cma *dma_contiguous_def_area;
|
|
|
|
void dma_contiguous_reserve(phys_addr_t addr_limit);
|
|
|
|
int dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t *res_base,
|
|
phys_addr_t limit, const char *name,
|
|
bool in_system,
|
|
bool remove, bool fixup);
|
|
|
|
int dma_contiguous_add_device(struct device *dev, phys_addr_t base);
|
|
|
|
/**
|
|
* dma_declare_contiguous() - reserve area for contiguous memory handling
|
|
* for particular device
|
|
* @dev: Pointer to device structure.
|
|
* @size: Size of the reserved memory.
|
|
* @base: Start address of the reserved memory (optional, 0 for any).
|
|
* @limit: End address of the reserved memory (optional, 0 for any).
|
|
*
|
|
* This function reserves memory for specified device. It should be
|
|
* called by board specific code when early allocator (memblock or bootmem)
|
|
* is still activate.
|
|
*/
|
|
|
|
static inline int dma_declare_contiguous(struct device *dev, phys_addr_t size,
|
|
phys_addr_t base, phys_addr_t limit)
|
|
{
|
|
int ret;
|
|
ret = dma_contiguous_reserve_area(size, &base, limit, NULL, true,
|
|
false, false);
|
|
if (ret == 0)
|
|
ret = dma_contiguous_add_device(dev, base);
|
|
return ret;
|
|
}
|
|
|
|
static inline int dma_declare_contiguous_reserved(struct device *dev,
|
|
phys_addr_t size,
|
|
phys_addr_t base,
|
|
phys_addr_t limit)
|
|
{
|
|
int ret;
|
|
ret = dma_contiguous_reserve_area(size, &base, limit, NULL, false,
|
|
false, false);
|
|
if (ret == 0)
|
|
ret = dma_contiguous_add_device(dev, base);
|
|
return ret;
|
|
}
|
|
|
|
unsigned long dma_alloc_from_contiguous(struct device *dev, int count,
|
|
unsigned int order);
|
|
bool dma_release_from_contiguous(struct device *dev, unsigned long pfn,
|
|
int count);
|
|
|
|
#else
|
|
|
|
#define MAX_CMA_AREAS (0)
|
|
|
|
static inline void dma_contiguous_reserve(phys_addr_t limit) { }
|
|
|
|
static inline
|
|
int dma_declare_contiguous(struct device *dev, phys_addr_t size,
|
|
phys_addr_t base, phys_addr_t limit)
|
|
{
|
|
return -ENOSYS;
|
|
}
|
|
|
|
static inline
|
|
unsigned long dma_alloc_from_contiguous(struct device *dev, int count,
|
|
unsigned int order)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline
|
|
bool dma_release_from_contiguous(struct device *dev, unsigned long pfn,
|
|
int count)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
|
|
static inline phys_addr_t cma_get_base(struct device *dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
static inline unsigned long cma_get_size(struct device *dev)
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
#endif
|
|
|
|
#endif
|
|
|
|
#endif
|