1#ifndef __LINUX_CMA_H 2#define __LINUX_CMA_H 3 4/* 5 * Contiguous Memory Allocator for DMA mapping framework 6 * Copyright (c) 2010-2011 by Samsung Electronics. 7 * Written by: 8 * Marek Szyprowski <m.szyprowski@samsung.com> 9 * Michal Nazarewicz <mina86@mina86.com> 10 * 11 * This program is free software; you can redistribute it and/or 12 * modify it under the terms of the GNU General Public License as 13 * published by the Free Software Foundation; either version 2 of the 14 * License or (at your optional) any later version of the license. 15 */ 16 17/* 18 * Contiguous Memory Allocator 19 * 20 * The Contiguous Memory Allocator (CMA) makes it possible to 21 * allocate big contiguous chunks of memory after the system has 22 * booted. 23 * 24 * Why is it needed? 25 * 26 * Various devices on embedded systems have no scatter-getter and/or 27 * IO map support and require contiguous blocks of memory to 28 * operate. They include devices such as cameras, hardware video 29 * coders, etc. 30 * 31 * Such devices often require big memory buffers (a full HD frame 32 * is, for instance, more then 2 mega pixels large, i.e. more than 6 33 * MB of memory), which makes mechanisms such as kmalloc() or 34 * alloc_page() ineffective. 35 * 36 * At the same time, a solution where a big memory region is 37 * reserved for a device is suboptimal since often more memory is 38 * reserved then strictly required and, moreover, the memory is 39 * inaccessible to page system even if device drivers don't use it. 40 * 41 * CMA tries to solve this issue by operating on memory regions 42 * where only movable pages can be allocated from. This way, kernel 43 * can use the memory for pagecache and when device driver requests 44 * it, allocated pages can be migrated. 45 * 46 * Driver usage 47 * 48 * CMA should not be used by the device drivers directly. It is 49 * only a helper framework for dma-mapping subsystem. 50 * 51 * For more information, see kernel-docs in drivers/base/dma-contiguous.c 52 */ 53 54#ifdef __KERNEL__ 55 56#include <linux/device.h> 57 58struct cma; 59struct page; 60 61#ifdef CONFIG_DMA_CMA 62 63extern struct cma *dma_contiguous_default_area; 64 65static inline struct cma *dev_get_cma_area(struct device *dev) 66{ 67 if (dev && dev->cma_area) 68 return dev->cma_area; 69 return dma_contiguous_default_area; 70} 71 72static inline void dev_set_cma_area(struct device *dev, struct cma *cma) 73{ 74 if (dev) 75 dev->cma_area = cma; 76} 77 78static inline void dma_contiguous_set_default(struct cma *cma) 79{ 80 dma_contiguous_default_area = cma; 81} 82 83void dma_contiguous_reserve(phys_addr_t addr_limit); 84 85int __init dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base, 86 phys_addr_t limit, struct cma **res_cma, 87 bool fixed); 88 89/** 90 * dma_declare_contiguous() - reserve area for contiguous memory handling 91 * for particular device 92 * @dev: Pointer to device structure. 93 * @size: Size of the reserved memory. 94 * @base: Start address of the reserved memory (optional, 0 for any). 95 * @limit: End address of the reserved memory (optional, 0 for any). 96 * 97 * This function reserves memory for specified device. It should be 98 * called by board specific code when early allocator (memblock or bootmem) 99 * is still activate. 100 */ 101 102static inline int dma_declare_contiguous(struct device *dev, phys_addr_t size, 103 phys_addr_t base, phys_addr_t limit) 104{ 105 struct cma *cma; 106 int ret; 107 ret = dma_contiguous_reserve_area(size, base, limit, &cma, true); 108 if (ret == 0) 109 dev_set_cma_area(dev, cma); 110 111 return ret; 112} 113 114struct page *dma_alloc_from_contiguous(struct device *dev, size_t count, 115 unsigned int order); 116bool dma_release_from_contiguous(struct device *dev, struct page *pages, 117 int count); 118 119#else 120 121static inline struct cma *dev_get_cma_area(struct device *dev) 122{ 123 return NULL; 124} 125 126static inline void dev_set_cma_area(struct device *dev, struct cma *cma) { } 127 128static inline void dma_contiguous_set_default(struct cma *cma) { } 129 130static inline void dma_contiguous_reserve(phys_addr_t limit) { } 131 132static inline int dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base, 133 phys_addr_t limit, struct cma **res_cma, 134 bool fixed) 135{ 136 return -ENOSYS; 137} 138 139static inline 140int dma_declare_contiguous(struct device *dev, phys_addr_t size, 141 phys_addr_t base, phys_addr_t limit) 142{ 143 return -ENOSYS; 144} 145 146static inline 147struct page *dma_alloc_from_contiguous(struct device *dev, size_t count, 148 unsigned int order) 149{ 150 return NULL; 151} 152 153static inline 154bool dma_release_from_contiguous(struct device *dev, struct page *pages, 155 int count) 156{ 157 return false; 158} 159 160#endif 161 162#endif 163 164#endif 165