]>
Commit | Line | Data |
---|---|---|
f14f75b8 | 1 | /* |
7f184275 HY |
2 | * Basic general purpose allocator for managing special purpose |
3 | * memory, for example, memory that is not managed by the regular | |
4 | * kmalloc/kfree interface. Uses for this includes on-device special | |
5 | * memory, uncached memory etc. | |
6 | * | |
7 | * It is safe to use the allocator in NMI handlers and other special | |
8 | * unblockable contexts that could otherwise deadlock on locks. This | |
9 | * is implemented by using atomic operations and retries on any | |
10 | * conflicts. The disadvantage is that there may be livelocks in | |
11 | * extreme cases. For better scalability, one allocator can be used | |
12 | * for each CPU. | |
13 | * | |
14 | * The lockless operation only works if there is enough memory | |
15 | * available. If new memory is added to the pool a lock has to be | |
16 | * still taken. So any user relying on locklessness has to ensure | |
17 | * that sufficient memory is preallocated. | |
18 | * | |
19 | * The basic atomic operation of this allocator is cmpxchg on long. | |
20 | * On architectures that don't have NMI-safe cmpxchg implementation, | |
21 | * the allocator can NOT be used in NMI handler. So code uses the | |
22 | * allocator in NMI handler should depend on | |
23 | * CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG. | |
f14f75b8 | 24 | * |
f14f75b8 JS |
25 | * Copyright 2005 (C) Jes Sorensen <jes@trained-monkey.org> |
26 | * | |
27 | * This source code is licensed under the GNU General Public License, | |
28 | * Version 2. See the file COPYING for more details. | |
29 | */ | |
30 | ||
5a0e3ad6 | 31 | #include <linux/slab.h> |
8bc3bcc9 | 32 | #include <linux/export.h> |
243797f5 | 33 | #include <linux/bitmap.h> |
7f184275 HY |
34 | #include <linux/rculist.h> |
35 | #include <linux/interrupt.h> | |
f14f75b8 | 36 | #include <linux/genalloc.h> |
9375db07 | 37 | #include <linux/of_device.h> |
f14f75b8 | 38 | |
674470d9 JS |
39 | static inline size_t chunk_size(const struct gen_pool_chunk *chunk) |
40 | { | |
41 | return chunk->end_addr - chunk->start_addr + 1; | |
42 | } | |
43 | ||
7f184275 HY |
44 | static int set_bits_ll(unsigned long *addr, unsigned long mask_to_set) |
45 | { | |
46 | unsigned long val, nval; | |
47 | ||
48 | nval = *addr; | |
49 | do { | |
50 | val = nval; | |
51 | if (val & mask_to_set) | |
52 | return -EBUSY; | |
53 | cpu_relax(); | |
54 | } while ((nval = cmpxchg(addr, val, val | mask_to_set)) != val); | |
55 | ||
56 | return 0; | |
57 | } | |
58 | ||
59 | static int clear_bits_ll(unsigned long *addr, unsigned long mask_to_clear) | |
60 | { | |
61 | unsigned long val, nval; | |
62 | ||
63 | nval = *addr; | |
64 | do { | |
65 | val = nval; | |
66 | if ((val & mask_to_clear) != mask_to_clear) | |
67 | return -EBUSY; | |
68 | cpu_relax(); | |
69 | } while ((nval = cmpxchg(addr, val, val & ~mask_to_clear)) != val); | |
70 | ||
71 | return 0; | |
72 | } | |
73 | ||
74 | /* | |
75 | * bitmap_set_ll - set the specified number of bits at the specified position | |
76 | * @map: pointer to a bitmap | |
77 | * @start: a bit position in @map | |
78 | * @nr: number of bits to set | |
79 | * | |
80 | * Set @nr bits start from @start in @map lock-lessly. Several users | |
81 | * can set/clear the same bitmap simultaneously without lock. If two | |
82 | * users set the same bit, one user will return remain bits, otherwise | |
83 | * return 0. | |
84 | */ | |
85 | static int bitmap_set_ll(unsigned long *map, int start, int nr) | |
86 | { | |
87 | unsigned long *p = map + BIT_WORD(start); | |
88 | const int size = start + nr; | |
89 | int bits_to_set = BITS_PER_LONG - (start % BITS_PER_LONG); | |
90 | unsigned long mask_to_set = BITMAP_FIRST_WORD_MASK(start); | |
91 | ||
92 | while (nr - bits_to_set >= 0) { | |
93 | if (set_bits_ll(p, mask_to_set)) | |
94 | return nr; | |
95 | nr -= bits_to_set; | |
96 | bits_to_set = BITS_PER_LONG; | |
97 | mask_to_set = ~0UL; | |
98 | p++; | |
99 | } | |
100 | if (nr) { | |
101 | mask_to_set &= BITMAP_LAST_WORD_MASK(size); | |
102 | if (set_bits_ll(p, mask_to_set)) | |
103 | return nr; | |
104 | } | |
105 | ||
106 | return 0; | |
107 | } | |
108 | ||
109 | /* | |
110 | * bitmap_clear_ll - clear the specified number of bits at the specified position | |
111 | * @map: pointer to a bitmap | |
112 | * @start: a bit position in @map | |
113 | * @nr: number of bits to set | |
114 | * | |
115 | * Clear @nr bits start from @start in @map lock-lessly. Several users | |
116 | * can set/clear the same bitmap simultaneously without lock. If two | |
117 | * users clear the same bit, one user will return remain bits, | |
118 | * otherwise return 0. | |
119 | */ | |
120 | static int bitmap_clear_ll(unsigned long *map, int start, int nr) | |
121 | { | |
122 | unsigned long *p = map + BIT_WORD(start); | |
123 | const int size = start + nr; | |
124 | int bits_to_clear = BITS_PER_LONG - (start % BITS_PER_LONG); | |
125 | unsigned long mask_to_clear = BITMAP_FIRST_WORD_MASK(start); | |
126 | ||
127 | while (nr - bits_to_clear >= 0) { | |
128 | if (clear_bits_ll(p, mask_to_clear)) | |
129 | return nr; | |
130 | nr -= bits_to_clear; | |
131 | bits_to_clear = BITS_PER_LONG; | |
132 | mask_to_clear = ~0UL; | |
133 | p++; | |
134 | } | |
135 | if (nr) { | |
136 | mask_to_clear &= BITMAP_LAST_WORD_MASK(size); | |
137 | if (clear_bits_ll(p, mask_to_clear)) | |
138 | return nr; | |
139 | } | |
140 | ||
141 | return 0; | |
142 | } | |
f14f75b8 | 143 | |
a58cbd7c DN |
144 | /** |
145 | * gen_pool_create - create a new special memory pool | |
929f9727 DN |
146 | * @min_alloc_order: log base 2 of number of bytes each bitmap bit represents |
147 | * @nid: node id of the node the pool structure should be allocated on, or -1 | |
a58cbd7c DN |
148 | * |
149 | * Create a new special memory pool that can be used to manage special purpose | |
150 | * memory not managed by the regular kmalloc/kfree interface. | |
929f9727 DN |
151 | */ |
152 | struct gen_pool *gen_pool_create(int min_alloc_order, int nid) | |
f14f75b8 | 153 | { |
929f9727 | 154 | struct gen_pool *pool; |
f14f75b8 | 155 | |
929f9727 DN |
156 | pool = kmalloc_node(sizeof(struct gen_pool), GFP_KERNEL, nid); |
157 | if (pool != NULL) { | |
7f184275 | 158 | spin_lock_init(&pool->lock); |
929f9727 DN |
159 | INIT_LIST_HEAD(&pool->chunks); |
160 | pool->min_alloc_order = min_alloc_order; | |
ca279cf1 BG |
161 | pool->algo = gen_pool_first_fit; |
162 | pool->data = NULL; | |
c98c3635 | 163 | pool->name = NULL; |
929f9727 DN |
164 | } |
165 | return pool; | |
f14f75b8 JS |
166 | } |
167 | EXPORT_SYMBOL(gen_pool_create); | |
168 | ||
a58cbd7c | 169 | /** |
3c8f370d | 170 | * gen_pool_add_virt - add a new chunk of special memory to the pool |
929f9727 | 171 | * @pool: pool to add new memory chunk to |
3c8f370d JCPV |
172 | * @virt: virtual starting address of memory chunk to add to pool |
173 | * @phys: physical starting address of memory chunk to add to pool | |
929f9727 DN |
174 | * @size: size in bytes of the memory chunk to add to pool |
175 | * @nid: node id of the node the chunk structure and bitmap should be | |
176 | * allocated on, or -1 | |
a58cbd7c DN |
177 | * |
178 | * Add a new chunk of special memory to the specified pool. | |
3c8f370d JCPV |
179 | * |
180 | * Returns 0 on success or a -ve errno on failure. | |
f14f75b8 | 181 | */ |
3c8f370d JCPV |
182 | int gen_pool_add_virt(struct gen_pool *pool, unsigned long virt, phys_addr_t phys, |
183 | size_t size, int nid) | |
f14f75b8 | 184 | { |
929f9727 DN |
185 | struct gen_pool_chunk *chunk; |
186 | int nbits = size >> pool->min_alloc_order; | |
187 | int nbytes = sizeof(struct gen_pool_chunk) + | |
eedce141 | 188 | BITS_TO_LONGS(nbits) * sizeof(long); |
f14f75b8 | 189 | |
ade34a35 | 190 | chunk = kzalloc_node(nbytes, GFP_KERNEL, nid); |
929f9727 | 191 | if (unlikely(chunk == NULL)) |
3c8f370d | 192 | return -ENOMEM; |
f14f75b8 | 193 | |
3c8f370d JCPV |
194 | chunk->phys_addr = phys; |
195 | chunk->start_addr = virt; | |
674470d9 | 196 | chunk->end_addr = virt + size - 1; |
6b2a7d63 | 197 | atomic_long_set(&chunk->avail, size); |
f14f75b8 | 198 | |
7f184275 HY |
199 | spin_lock(&pool->lock); |
200 | list_add_rcu(&chunk->next_chunk, &pool->chunks); | |
201 | spin_unlock(&pool->lock); | |
929f9727 DN |
202 | |
203 | return 0; | |
f14f75b8 | 204 | } |
3c8f370d JCPV |
205 | EXPORT_SYMBOL(gen_pool_add_virt); |
206 | ||
207 | /** | |
208 | * gen_pool_virt_to_phys - return the physical address of memory | |
209 | * @pool: pool to allocate from | |
210 | * @addr: starting address of memory | |
211 | * | |
212 | * Returns the physical address on success, or -1 on error. | |
213 | */ | |
214 | phys_addr_t gen_pool_virt_to_phys(struct gen_pool *pool, unsigned long addr) | |
215 | { | |
3c8f370d | 216 | struct gen_pool_chunk *chunk; |
7f184275 | 217 | phys_addr_t paddr = -1; |
3c8f370d | 218 | |
7f184275 HY |
219 | rcu_read_lock(); |
220 | list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { | |
674470d9 | 221 | if (addr >= chunk->start_addr && addr <= chunk->end_addr) { |
7f184275 HY |
222 | paddr = chunk->phys_addr + (addr - chunk->start_addr); |
223 | break; | |
224 | } | |
3c8f370d | 225 | } |
7f184275 | 226 | rcu_read_unlock(); |
3c8f370d | 227 | |
7f184275 | 228 | return paddr; |
3c8f370d JCPV |
229 | } |
230 | EXPORT_SYMBOL(gen_pool_virt_to_phys); | |
f14f75b8 | 231 | |
a58cbd7c DN |
232 | /** |
233 | * gen_pool_destroy - destroy a special memory pool | |
322acc96 | 234 | * @pool: pool to destroy |
a58cbd7c DN |
235 | * |
236 | * Destroy the specified special memory pool. Verifies that there are no | |
237 | * outstanding allocations. | |
322acc96 SW |
238 | */ |
239 | void gen_pool_destroy(struct gen_pool *pool) | |
240 | { | |
241 | struct list_head *_chunk, *_next_chunk; | |
242 | struct gen_pool_chunk *chunk; | |
243 | int order = pool->min_alloc_order; | |
244 | int bit, end_bit; | |
245 | ||
322acc96 SW |
246 | list_for_each_safe(_chunk, _next_chunk, &pool->chunks) { |
247 | chunk = list_entry(_chunk, struct gen_pool_chunk, next_chunk); | |
248 | list_del(&chunk->next_chunk); | |
249 | ||
674470d9 | 250 | end_bit = chunk_size(chunk) >> order; |
322acc96 SW |
251 | bit = find_next_bit(chunk->bits, end_bit, 0); |
252 | BUG_ON(bit < end_bit); | |
253 | ||
254 | kfree(chunk); | |
255 | } | |
c98c3635 | 256 | kfree_const(pool->name); |
322acc96 | 257 | kfree(pool); |
322acc96 SW |
258 | } |
259 | EXPORT_SYMBOL(gen_pool_destroy); | |
260 | ||
a58cbd7c DN |
261 | /** |
262 | * gen_pool_alloc - allocate special memory from the pool | |
929f9727 DN |
263 | * @pool: pool to allocate from |
264 | * @size: number of bytes to allocate from the pool | |
a58cbd7c DN |
265 | * |
266 | * Allocate the requested number of bytes from the specified pool. | |
ca279cf1 BG |
267 | * Uses the pool allocation function (with first-fit algorithm by default). |
268 | * Can not be used in NMI handler on architectures without | |
269 | * NMI-safe cmpxchg implementation. | |
f14f75b8 | 270 | */ |
929f9727 | 271 | unsigned long gen_pool_alloc(struct gen_pool *pool, size_t size) |
f14f75b8 | 272 | { |
929f9727 | 273 | struct gen_pool_chunk *chunk; |
7f184275 | 274 | unsigned long addr = 0; |
929f9727 | 275 | int order = pool->min_alloc_order; |
6405a428 | 276 | int nbits, start_bit, end_bit, remain; |
7f184275 HY |
277 | |
278 | #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG | |
279 | BUG_ON(in_nmi()); | |
280 | #endif | |
f14f75b8 | 281 | |
929f9727 DN |
282 | if (size == 0) |
283 | return 0; | |
f14f75b8 | 284 | |
929f9727 | 285 | nbits = (size + (1UL << order) - 1) >> order; |
7f184275 HY |
286 | rcu_read_lock(); |
287 | list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { | |
6b2a7d63 | 288 | if (size > atomic_long_read(&chunk->avail)) |
7f184275 | 289 | continue; |
929f9727 | 290 | |
6405a428 | 291 | start_bit = 0; |
674470d9 | 292 | end_bit = chunk_size(chunk) >> order; |
7f184275 | 293 | retry: |
ca279cf1 BG |
294 | start_bit = pool->algo(chunk->bits, end_bit, start_bit, nbits, |
295 | pool->data); | |
7f184275 | 296 | if (start_bit >= end_bit) |
243797f5 | 297 | continue; |
7f184275 HY |
298 | remain = bitmap_set_ll(chunk->bits, start_bit, nbits); |
299 | if (remain) { | |
300 | remain = bitmap_clear_ll(chunk->bits, start_bit, | |
301 | nbits - remain); | |
302 | BUG_ON(remain); | |
303 | goto retry; | |
f14f75b8 | 304 | } |
243797f5 AM |
305 | |
306 | addr = chunk->start_addr + ((unsigned long)start_bit << order); | |
7f184275 | 307 | size = nbits << order; |
6b2a7d63 | 308 | atomic_long_sub(size, &chunk->avail); |
7f184275 | 309 | break; |
929f9727 | 310 | } |
7f184275 HY |
311 | rcu_read_unlock(); |
312 | return addr; | |
929f9727 DN |
313 | } |
314 | EXPORT_SYMBOL(gen_pool_alloc); | |
f14f75b8 | 315 | |
684f0d3d NC |
316 | /** |
317 | * gen_pool_dma_alloc - allocate special memory from the pool for DMA usage | |
318 | * @pool: pool to allocate from | |
319 | * @size: number of bytes to allocate from the pool | |
0368dfd0 | 320 | * @dma: dma-view physical address return value. Use NULL if unneeded. |
684f0d3d NC |
321 | * |
322 | * Allocate the requested number of bytes from the specified pool. | |
323 | * Uses the pool allocation function (with first-fit algorithm by default). | |
324 | * Can not be used in NMI handler on architectures without | |
325 | * NMI-safe cmpxchg implementation. | |
326 | */ | |
327 | void *gen_pool_dma_alloc(struct gen_pool *pool, size_t size, dma_addr_t *dma) | |
328 | { | |
329 | unsigned long vaddr; | |
330 | ||
331 | if (!pool) | |
332 | return NULL; | |
333 | ||
334 | vaddr = gen_pool_alloc(pool, size); | |
335 | if (!vaddr) | |
336 | return NULL; | |
337 | ||
0368dfd0 LP |
338 | if (dma) |
339 | *dma = gen_pool_virt_to_phys(pool, vaddr); | |
684f0d3d NC |
340 | |
341 | return (void *)vaddr; | |
342 | } | |
343 | EXPORT_SYMBOL(gen_pool_dma_alloc); | |
344 | ||
a58cbd7c DN |
345 | /** |
346 | * gen_pool_free - free allocated special memory back to the pool | |
929f9727 DN |
347 | * @pool: pool to free to |
348 | * @addr: starting address of memory to free back to pool | |
349 | * @size: size in bytes of memory to free | |
a58cbd7c | 350 | * |
7f184275 HY |
351 | * Free previously allocated special memory back to the specified |
352 | * pool. Can not be used in NMI handler on architectures without | |
353 | * NMI-safe cmpxchg implementation. | |
929f9727 DN |
354 | */ |
355 | void gen_pool_free(struct gen_pool *pool, unsigned long addr, size_t size) | |
356 | { | |
929f9727 | 357 | struct gen_pool_chunk *chunk; |
929f9727 | 358 | int order = pool->min_alloc_order; |
7f184275 | 359 | int start_bit, nbits, remain; |
929f9727 | 360 | |
7f184275 HY |
361 | #ifndef CONFIG_ARCH_HAVE_NMI_SAFE_CMPXCHG |
362 | BUG_ON(in_nmi()); | |
363 | #endif | |
929f9727 | 364 | |
7f184275 HY |
365 | nbits = (size + (1UL << order) - 1) >> order; |
366 | rcu_read_lock(); | |
367 | list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) { | |
674470d9 JS |
368 | if (addr >= chunk->start_addr && addr <= chunk->end_addr) { |
369 | BUG_ON(addr + size - 1 > chunk->end_addr); | |
7f184275 HY |
370 | start_bit = (addr - chunk->start_addr) >> order; |
371 | remain = bitmap_clear_ll(chunk->bits, start_bit, nbits); | |
372 | BUG_ON(remain); | |
373 | size = nbits << order; | |
6b2a7d63 | 374 | atomic_long_add(size, &chunk->avail); |
7f184275 HY |
375 | rcu_read_unlock(); |
376 | return; | |
f14f75b8 | 377 | } |
f14f75b8 | 378 | } |
7f184275 HY |
379 | rcu_read_unlock(); |
380 | BUG(); | |
f14f75b8 JS |
381 | } |
382 | EXPORT_SYMBOL(gen_pool_free); | |
7f184275 HY |
383 | |
384 | /** | |
385 | * gen_pool_for_each_chunk - call func for every chunk of generic memory pool | |
386 | * @pool: the generic memory pool | |
387 | * @func: func to call | |
388 | * @data: additional data used by @func | |
389 | * | |
390 | * Call @func for every chunk of generic memory pool. The @func is | |
391 | * called with rcu_read_lock held. | |
392 | */ | |
393 | void gen_pool_for_each_chunk(struct gen_pool *pool, | |
394 | void (*func)(struct gen_pool *pool, struct gen_pool_chunk *chunk, void *data), | |
395 | void *data) | |
396 | { | |
397 | struct gen_pool_chunk *chunk; | |
398 | ||
399 | rcu_read_lock(); | |
400 | list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) | |
401 | func(pool, chunk, data); | |
402 | rcu_read_unlock(); | |
403 | } | |
404 | EXPORT_SYMBOL(gen_pool_for_each_chunk); | |
405 | ||
9efb3a42 LA |
406 | /** |
407 | * addr_in_gen_pool - checks if an address falls within the range of a pool | |
408 | * @pool: the generic memory pool | |
409 | * @start: start address | |
410 | * @size: size of the region | |
411 | * | |
412 | * Check if the range of addresses falls within the specified pool. Returns | |
413 | * true if the entire range is contained in the pool and false otherwise. | |
414 | */ | |
415 | bool addr_in_gen_pool(struct gen_pool *pool, unsigned long start, | |
416 | size_t size) | |
417 | { | |
418 | bool found = false; | |
ad3d5d2f | 419 | unsigned long end = start + size - 1; |
9efb3a42 LA |
420 | struct gen_pool_chunk *chunk; |
421 | ||
422 | rcu_read_lock(); | |
423 | list_for_each_entry_rcu(chunk, &(pool)->chunks, next_chunk) { | |
424 | if (start >= chunk->start_addr && start <= chunk->end_addr) { | |
425 | if (end <= chunk->end_addr) { | |
426 | found = true; | |
427 | break; | |
428 | } | |
429 | } | |
430 | } | |
431 | rcu_read_unlock(); | |
432 | return found; | |
433 | } | |
434 | ||
7f184275 HY |
435 | /** |
436 | * gen_pool_avail - get available free space of the pool | |
437 | * @pool: pool to get available free space | |
438 | * | |
439 | * Return available free space of the specified pool. | |
440 | */ | |
441 | size_t gen_pool_avail(struct gen_pool *pool) | |
442 | { | |
443 | struct gen_pool_chunk *chunk; | |
444 | size_t avail = 0; | |
445 | ||
446 | rcu_read_lock(); | |
447 | list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) | |
6b2a7d63 | 448 | avail += atomic_long_read(&chunk->avail); |
7f184275 HY |
449 | rcu_read_unlock(); |
450 | return avail; | |
451 | } | |
452 | EXPORT_SYMBOL_GPL(gen_pool_avail); | |
453 | ||
454 | /** | |
455 | * gen_pool_size - get size in bytes of memory managed by the pool | |
456 | * @pool: pool to get size | |
457 | * | |
458 | * Return size in bytes of memory managed by the pool. | |
459 | */ | |
460 | size_t gen_pool_size(struct gen_pool *pool) | |
461 | { | |
462 | struct gen_pool_chunk *chunk; | |
463 | size_t size = 0; | |
464 | ||
465 | rcu_read_lock(); | |
466 | list_for_each_entry_rcu(chunk, &pool->chunks, next_chunk) | |
674470d9 | 467 | size += chunk_size(chunk); |
7f184275 HY |
468 | rcu_read_unlock(); |
469 | return size; | |
470 | } | |
471 | EXPORT_SYMBOL_GPL(gen_pool_size); | |
ca279cf1 BG |
472 | |
473 | /** | |
474 | * gen_pool_set_algo - set the allocation algorithm | |
475 | * @pool: pool to change allocation algorithm | |
476 | * @algo: custom algorithm function | |
477 | * @data: additional data used by @algo | |
478 | * | |
479 | * Call @algo for each memory allocation in the pool. | |
480 | * If @algo is NULL use gen_pool_first_fit as default | |
481 | * memory allocation function. | |
482 | */ | |
483 | void gen_pool_set_algo(struct gen_pool *pool, genpool_algo_t algo, void *data) | |
484 | { | |
485 | rcu_read_lock(); | |
486 | ||
487 | pool->algo = algo; | |
488 | if (!pool->algo) | |
489 | pool->algo = gen_pool_first_fit; | |
490 | ||
491 | pool->data = data; | |
492 | ||
493 | rcu_read_unlock(); | |
494 | } | |
495 | EXPORT_SYMBOL(gen_pool_set_algo); | |
496 | ||
497 | /** | |
498 | * gen_pool_first_fit - find the first available region | |
499 | * of memory matching the size requirement (no alignment constraint) | |
500 | * @map: The address to base the search on | |
501 | * @size: The bitmap size in bits | |
502 | * @start: The bitnumber to start searching at | |
503 | * @nr: The number of zeroed bits we're looking for | |
504 | * @data: additional data - unused | |
505 | */ | |
506 | unsigned long gen_pool_first_fit(unsigned long *map, unsigned long size, | |
507 | unsigned long start, unsigned int nr, void *data) | |
508 | { | |
509 | return bitmap_find_next_zero_area(map, size, start, nr, 0); | |
510 | } | |
511 | EXPORT_SYMBOL(gen_pool_first_fit); | |
512 | ||
505e3be6 LA |
513 | /** |
514 | * gen_pool_first_fit_order_align - find the first available region | |
515 | * of memory matching the size requirement. The region will be aligned | |
516 | * to the order of the size specified. | |
517 | * @map: The address to base the search on | |
518 | * @size: The bitmap size in bits | |
519 | * @start: The bitnumber to start searching at | |
520 | * @nr: The number of zeroed bits we're looking for | |
521 | * @data: additional data - unused | |
522 | */ | |
523 | unsigned long gen_pool_first_fit_order_align(unsigned long *map, | |
524 | unsigned long size, unsigned long start, | |
525 | unsigned int nr, void *data) | |
526 | { | |
527 | unsigned long align_mask = roundup_pow_of_two(nr) - 1; | |
528 | ||
529 | return bitmap_find_next_zero_area(map, size, start, nr, align_mask); | |
530 | } | |
531 | EXPORT_SYMBOL(gen_pool_first_fit_order_align); | |
532 | ||
ca279cf1 BG |
533 | /** |
534 | * gen_pool_best_fit - find the best fitting region of memory | |
535 | * macthing the size requirement (no alignment constraint) | |
536 | * @map: The address to base the search on | |
537 | * @size: The bitmap size in bits | |
538 | * @start: The bitnumber to start searching at | |
539 | * @nr: The number of zeroed bits we're looking for | |
540 | * @data: additional data - unused | |
541 | * | |
542 | * Iterate over the bitmap to find the smallest free region | |
543 | * which we can allocate the memory. | |
544 | */ | |
545 | unsigned long gen_pool_best_fit(unsigned long *map, unsigned long size, | |
546 | unsigned long start, unsigned int nr, void *data) | |
547 | { | |
548 | unsigned long start_bit = size; | |
549 | unsigned long len = size + 1; | |
550 | unsigned long index; | |
551 | ||
552 | index = bitmap_find_next_zero_area(map, size, start, nr, 0); | |
553 | ||
554 | while (index < size) { | |
555 | int next_bit = find_next_bit(map, size, index + nr); | |
556 | if ((next_bit - index) < len) { | |
557 | len = next_bit - index; | |
558 | start_bit = index; | |
559 | if (len == nr) | |
560 | return start_bit; | |
561 | } | |
562 | index = bitmap_find_next_zero_area(map, size, | |
563 | next_bit + 1, nr, 0); | |
564 | } | |
565 | ||
566 | return start_bit; | |
567 | } | |
568 | EXPORT_SYMBOL(gen_pool_best_fit); | |
9375db07 PZ |
569 | |
570 | static void devm_gen_pool_release(struct device *dev, void *res) | |
571 | { | |
572 | gen_pool_destroy(*(struct gen_pool **)res); | |
573 | } | |
574 | ||
c98c3635 VZ |
575 | static int devm_gen_pool_match(struct device *dev, void *res, void *data) |
576 | { | |
577 | struct gen_pool **p = res; | |
578 | ||
579 | /* NULL data matches only a pool without an assigned name */ | |
580 | if (!data && !(*p)->name) | |
581 | return 1; | |
582 | ||
583 | if (!data || !(*p)->name) | |
584 | return 0; | |
585 | ||
586 | return !strcmp((*p)->name, data); | |
587 | } | |
588 | ||
73858173 VZ |
589 | /** |
590 | * gen_pool_get - Obtain the gen_pool (if any) for a device | |
591 | * @dev: device to retrieve the gen_pool from | |
592 | * @name: name of a gen_pool or NULL, identifies a particular gen_pool on device | |
593 | * | |
594 | * Returns the gen_pool for the device if one is present, or NULL. | |
595 | */ | |
596 | struct gen_pool *gen_pool_get(struct device *dev, const char *name) | |
597 | { | |
598 | struct gen_pool **p; | |
599 | ||
c98c3635 VZ |
600 | p = devres_find(dev, devm_gen_pool_release, devm_gen_pool_match, |
601 | (void *)name); | |
73858173 VZ |
602 | if (!p) |
603 | return NULL; | |
604 | return *p; | |
605 | } | |
606 | EXPORT_SYMBOL_GPL(gen_pool_get); | |
607 | ||
9375db07 PZ |
608 | /** |
609 | * devm_gen_pool_create - managed gen_pool_create | |
610 | * @dev: device that provides the gen_pool | |
611 | * @min_alloc_order: log base 2 of number of bytes each bitmap bit represents | |
73858173 VZ |
612 | * @nid: node selector for allocated gen_pool, %NUMA_NO_NODE for all nodes |
613 | * @name: name of a gen_pool or NULL, identifies a particular gen_pool on device | |
9375db07 PZ |
614 | * |
615 | * Create a new special memory pool that can be used to manage special purpose | |
616 | * memory not managed by the regular kmalloc/kfree interface. The pool will be | |
617 | * automatically destroyed by the device management code. | |
618 | */ | |
619 | struct gen_pool *devm_gen_pool_create(struct device *dev, int min_alloc_order, | |
73858173 | 620 | int nid, const char *name) |
9375db07 PZ |
621 | { |
622 | struct gen_pool **ptr, *pool; | |
c98c3635 | 623 | const char *pool_name = NULL; |
9375db07 | 624 | |
73858173 VZ |
625 | /* Check that genpool to be created is uniquely addressed on device */ |
626 | if (gen_pool_get(dev, name)) | |
627 | return ERR_PTR(-EINVAL); | |
628 | ||
c98c3635 VZ |
629 | if (name) { |
630 | pool_name = kstrdup_const(name, GFP_KERNEL); | |
631 | if (!pool_name) | |
632 | return ERR_PTR(-ENOMEM); | |
633 | } | |
634 | ||
9375db07 | 635 | ptr = devres_alloc(devm_gen_pool_release, sizeof(*ptr), GFP_KERNEL); |
310ee9e8 | 636 | if (!ptr) |
c98c3635 | 637 | goto free_pool_name; |
9375db07 PZ |
638 | |
639 | pool = gen_pool_create(min_alloc_order, nid); | |
c98c3635 VZ |
640 | if (!pool) |
641 | goto free_devres; | |
642 | ||
643 | *ptr = pool; | |
644 | pool->name = pool_name; | |
645 | devres_add(dev, ptr); | |
9375db07 PZ |
646 | |
647 | return pool; | |
c98c3635 VZ |
648 | |
649 | free_devres: | |
650 | devres_free(ptr); | |
651 | free_pool_name: | |
652 | kfree_const(pool_name); | |
653 | ||
654 | return ERR_PTR(-ENOMEM); | |
9375db07 | 655 | } |
b724aa21 | 656 | EXPORT_SYMBOL(devm_gen_pool_create); |
9375db07 | 657 | |
9375db07 PZ |
658 | #ifdef CONFIG_OF |
659 | /** | |
abdd4a70 | 660 | * of_gen_pool_get - find a pool by phandle property |
9375db07 PZ |
661 | * @np: device node |
662 | * @propname: property name containing phandle(s) | |
663 | * @index: index into the phandle array | |
664 | * | |
665 | * Returns the pool that contains the chunk starting at the physical | |
666 | * address of the device tree node pointed at by the phandle property, | |
667 | * or NULL if not found. | |
668 | */ | |
abdd4a70 | 669 | struct gen_pool *of_gen_pool_get(struct device_node *np, |
9375db07 PZ |
670 | const char *propname, int index) |
671 | { | |
672 | struct platform_device *pdev; | |
c98c3635 VZ |
673 | struct device_node *np_pool, *parent; |
674 | const char *name = NULL; | |
675 | struct gen_pool *pool = NULL; | |
9375db07 PZ |
676 | |
677 | np_pool = of_parse_phandle(np, propname, index); | |
678 | if (!np_pool) | |
679 | return NULL; | |
c98c3635 | 680 | |
9375db07 | 681 | pdev = of_find_device_by_node(np_pool); |
c98c3635 VZ |
682 | if (!pdev) { |
683 | /* Check if named gen_pool is created by parent node device */ | |
684 | parent = of_get_parent(np_pool); | |
685 | pdev = of_find_device_by_node(parent); | |
686 | of_node_put(parent); | |
687 | ||
688 | of_property_read_string(np_pool, "label", &name); | |
689 | if (!name) | |
690 | name = np_pool->name; | |
691 | } | |
692 | if (pdev) | |
693 | pool = gen_pool_get(&pdev->dev, name); | |
6f3aabd1 | 694 | of_node_put(np_pool); |
c98c3635 VZ |
695 | |
696 | return pool; | |
9375db07 | 697 | } |
abdd4a70 | 698 | EXPORT_SYMBOL_GPL(of_gen_pool_get); |
9375db07 | 699 | #endif /* CONFIG_OF */ |