blob: d5c004d017ef3501f34ba697b7dd845bacad7182 [file] [log] [blame]
Aaron Williams643d96d2020-08-20 07:22:02 +02001/* SPDX-License-Identifier: GPL-2.0 */
2/*
3 * Copyright (C) 2020 Marvell International Ltd.
4 */
5
6/**
7 * @file
8 * Simple allocate only memory allocator. Used to allocate memory at application
9 * start time.
10 */
11
12#ifndef __CVMX_BOOTMEM_H__
13#define __CVMX_BOOTMEM_H__
14
15/* Must be multiple of 8, changing breaks ABI */
16#define CVMX_BOOTMEM_NAME_LEN 128
17/* Can change without breaking ABI */
18#define CVMX_BOOTMEM_NUM_NAMED_BLOCKS 64
19/* minimum alignment of bootmem alloced blocks */
20#define CVMX_BOOTMEM_ALIGNMENT_SIZE (16ull)
21
22/* Flags for cvmx_bootmem_phy_mem* functions */
23/* Allocate from end of block instead of beginning */
24#define CVMX_BOOTMEM_FLAG_END_ALLOC (1 << 0)
25#define CVMX_BOOTMEM_FLAG_NO_LOCKING (1 << 1) /* Don't do any locking. */
26
27/* Real physical addresses of memory regions */
28#define OCTEON_DDR0_BASE (0x0ULL)
Stefan Roesecbe62432022-04-07 09:11:10 +020029/* Use 16MiB here, as 256 leads to overwriting U-Boot reloc space */
30#define OCTEON_DDR0_SIZE (0x001000000ULL)
Aaron Williams643d96d2020-08-20 07:22:02 +020031#define OCTEON_DDR1_BASE ((OCTEON_IS_OCTEON2() || OCTEON_IS_OCTEON3()) \
32 ? 0x20000000ULL : 0x410000000ULL)
33#define OCTEON_DDR1_SIZE (0x010000000ULL)
34#define OCTEON_DDR2_BASE ((OCTEON_IS_OCTEON2() || OCTEON_IS_OCTEON3()) \
35 ? 0x30000000ULL : 0x20000000ULL)
36#define OCTEON_DDR2_SIZE ((OCTEON_IS_OCTEON2() || OCTEON_IS_OCTEON3()) \
37 ? 0x7d0000000ULL : 0x3e0000000ULL)
38#define OCTEON_MAX_PHY_MEM_SIZE ((OCTEON_IS_MODEL(OCTEON_CN68XX)) \
39 ? 128 * 1024 * 1024 * 1024ULL \
40 : (OCTEON_IS_OCTEON2()) \
41 ? 32 * 1024 * 1024 * 1024ull \
42 : (OCTEON_IS_OCTEON3()) \
43 ? 512 * 1024 * 1024 * 1024ULL \
44 : 16 * 1024 * 1024 * 1024ULL)
45
46/*
47 * First bytes of each free physical block of memory contain this structure,
48 * which is used to maintain the free memory list. Since the bootloader is
49 * only 32 bits, there is a union providing 64 and 32 bit versions. The
50 * application init code converts addresses to 64 bit addresses before the
51 * application starts.
52 */
53struct cvmx_bootmem_block_header {
54 /* Note: these are referenced from assembly routines in the bootloader,
55 * so this structure should not be changed without changing those
56 * routines as well.
57 */
58 u64 next_block_addr;
59 u64 size;
60
61};
62
63/*
64 * Structure for named memory blocks
65 * Number of descriptors
66 * available can be changed without affecting compatibility,
67 * but name length changes require a bump in the bootmem
68 * descriptor version
69 * Note: This structure must be naturally 64 bit aligned, as a single
70 * memory image will be used by both 32 and 64 bit programs.
71 */
72struct cvmx_bootmem_named_block_desc {
73 u64 base_addr; /* Base address of named block */
74 /*
75 * Size actually allocated for named block (may differ from requested)
76 */
77 u64 size;
78 char name[CVMX_BOOTMEM_NAME_LEN]; /* name of named block */
79};
80
81/* Current descriptor versions */
82/* CVMX bootmem descriptor major version */
83#define CVMX_BOOTMEM_DESC_MAJ_VER 3
84/* CVMX bootmem descriptor minor version */
85#define CVMX_BOOTMEM_DESC_MIN_VER 0
86
87/*
88 * First three members of cvmx_bootmem_desc_t are left in original
89 * positions for backwards compatibility.
90 */
91struct cvmx_bootmem_desc {
92 /* Linux compatible proxy for __BIG_ENDIAN */
93 u32 lock; /* spinlock to control access to list */
94 u32 flags; /* flags for indicating various conditions */
95 u64 head_addr;
96
97 /* incremented changed when incompatible changes made */
98 u32 major_version;
99 /*
100 * incremented changed when compatible changes made, reset to
101 * zero when major incremented
102 */
103 u32 minor_version;
104 u64 app_data_addr;
105 u64 app_data_size;
106
107 /* number of elements in named blocks array */
108 u32 named_block_num_blocks;
109 /* length of name array in bootmem blocks */
110 u32 named_block_name_len;
111 /* address of named memory block descriptors */
112 u64 named_block_array_addr;
113};
114
115/**
116 * Initialize the boot alloc memory structures. This is
117 * normally called inside of cvmx_user_app_init()
118 *
119 * @param mem_desc_addr Address of the free memory list
120 * @return
121 */
122int cvmx_bootmem_init(u64 mem_desc_addr);
123
124/**
125 * Allocate a block of memory from the free list that was passed
126 * to the application by the bootloader.
127 * This is an allocate-only algorithm, so freeing memory is not possible.
128 *
129 * @param size Size in bytes of block to allocate
130 * @param alignment Alignment required - must be power of 2
131 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100132 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200133 */
134void *cvmx_bootmem_alloc(u64 size, u64 alignment);
135
136/**
137 * Allocate a block of memory from the free list that was passed
138 * to the application by the bootloader from a specific node.
139 * This is an allocate-only algorithm, so freeing memory is not possible.
140 *
141 * @param node The node to allocate memory from
142 * @param size Size in bytes of block to allocate
143 * @param alignment Alignment required - must be power of 2
144 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100145 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200146 */
147void *cvmx_bootmem_alloc_node(u64 node, u64 size, u64 alignment);
148
149/**
150 * Allocate a block of memory from the free list that was
151 * passed to the application by the bootloader at a specific
152 * address. This is an allocate-only algorithm, so
153 * freeing memory is not possible. Allocation will fail if
154 * memory cannot be allocated at the specified address.
155 *
156 * @param size Size in bytes of block to allocate
157 * @param address Physical address to allocate memory at. If this
158 * memory is not available, the allocation fails.
159 * @param alignment Alignment required - must be power of 2
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100160 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200161 */
162void *cvmx_bootmem_alloc_address(u64 size, u64 address,
163 u64 alignment);
164
165/**
166 * Allocate a block of memory from the free list that was
167 * passed to the application by the bootloader within a specified
168 * address range. This is an allocate-only algorithm, so
169 * freeing memory is not possible. Allocation will fail if
170 * memory cannot be allocated in the requested range.
171 *
172 * @param size Size in bytes of block to allocate
173 * @param min_addr defines the minimum address of the range
174 * @param max_addr defines the maximum address of the range
175 * @param alignment Alignment required - must be power of 2
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100176 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200177 */
178void *cvmx_bootmem_alloc_range(u64 size, u64 alignment,
179 u64 min_addr, u64 max_addr);
180
181/**
182 * Allocate a block of memory from the free list that was passed
183 * to the application by the bootloader, and assign it a name in the
184 * global named block table. (part of the cvmx_bootmem_descriptor_t structure)
185 * Named blocks can later be freed.
186 *
187 * @param size Size in bytes of block to allocate
188 * @param alignment Alignment required - must be power of 2
189 * @param name name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
190 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100191 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200192 */
193void *cvmx_bootmem_alloc_named(u64 size, u64 alignment,
194 const char *name);
195
196/**
197 * Allocate a block of memory from the free list that was passed
198 * to the application by the bootloader, and assign it a name in the
199 * global named block table. (part of the cvmx_bootmem_descriptor_t structure)
200 * Named blocks can later be freed.
201 *
202 * @param size Size in bytes of block to allocate
203 * @param alignment Alignment required - must be power of 2
204 * @param name name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
205 * @param flags Flags to control options for the allocation.
206 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100207 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200208 */
209void *cvmx_bootmem_alloc_named_flags(u64 size, u64 alignment,
210 const char *name, u32 flags);
211
212/**
213 * Allocate a block of memory from the free list that was passed
214 * to the application by the bootloader, and assign it a name in the
215 * global named block table. (part of the cvmx_bootmem_descriptor_t structure)
216 * Named blocks can later be freed.
217 *
218 * @param size Size in bytes of block to allocate
219 * @param address Physical address to allocate memory at. If this
220 * memory is not available, the allocation fails.
221 * @param name name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
222 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100223 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200224 */
225void *cvmx_bootmem_alloc_named_address(u64 size, u64 address,
226 const char *name);
227
228/**
229 * Allocate a block of memory from a specific range of the free list
230 * that was passed to the application by the bootloader, and assign it
231 * a name in the global named block table. (part of the
232 * cvmx_bootmem_descriptor_t structure) Named blocks can later be
233 * freed. If request cannot be satisfied within the address range
234 * specified, NULL is returned
235 *
236 * @param size Size in bytes of block to allocate
237 * @param min_addr minimum address of range
238 * @param max_addr maximum address of range
239 * @param align Alignment of memory to be allocated. (must be a power of 2)
240 * @param name name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
241 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100242 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200243 */
244void *cvmx_bootmem_alloc_named_range(u64 size, u64 min_addr,
245 u64 max_addr, u64 align,
246 const char *name);
247
248/**
249 * Allocate if needed a block of memory from a specific range of the
250 * free list that was passed to the application by the bootloader, and
251 * assign it a name in the global named block table. (part of the
252 * cvmx_bootmem_descriptor_t structure) Named blocks can later be
253 * freed. If the requested name block is already allocated, return
254 * the pointer to block of memory. If request cannot be satisfied
255 * within the address range specified, NULL is returned
256 *
257 * @param size Size in bytes of block to allocate
258 * @param min_addr minimum address of range
259 * @param max_addr maximum address of range
260 * @param align Alignment of memory to be allocated. (must be a power of 2)
261 * @param name name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
262 * @param init Initialization function
263 *
264 * The initialization function is optional, if omitted the named block
265 * is initialized to all zeros when it is created, i.e. once.
266 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100267 * Return: pointer to block of memory, NULL on error
Aaron Williams643d96d2020-08-20 07:22:02 +0200268 */
269void *cvmx_bootmem_alloc_named_range_once(u64 size,
270 u64 min_addr,
271 u64 max_addr,
272 u64 align,
273 const char *name,
274 void (*init)(void *));
275
276/**
277 * Allocate all free memory starting at the start address. This is used to
278 * prevent any free blocks from later being allocated within the reserved space.
279 * Note that any memory allocated with this function cannot be later freed.
280 *
281 * @param start_addr Starting address to reserve
282 * @param size Size in bytes to reserve starting at start_addr
283 * @param name Name to assign to reserved blocks
284 * @param flags Flags to use when reserving memory
285 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100286 * Return: 0 on failure,
Aaron Williams643d96d2020-08-20 07:22:02 +0200287 * !0 on success
288 */
289int cvmx_bootmem_reserve_memory(u64 start_addr, u64 size,
290 const char *name, u32 flags);
291
292/**
293 * Frees a previously allocated named bootmem block.
294 *
295 * @param name name of block to free
296 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100297 * Return: 0 on failure,
Aaron Williams643d96d2020-08-20 07:22:02 +0200298 * !0 on success
299 */
300int cvmx_bootmem_free_named(const char *name);
301
302/**
303 * Finds a named bootmem block by name.
304 *
305 * @param name name of block to free
306 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100307 * Return: pointer to named block descriptor on success
Aaron Williams643d96d2020-08-20 07:22:02 +0200308 * 0 on failure
309 */
310const struct cvmx_bootmem_named_block_desc *
311cvmx_bootmem_find_named_block(const char *name);
312
313/**
314 * Returns the size of available memory in bytes, only
315 * counting blocks that are at least as big as the minimum block
316 * size.
317 *
318 * @param min_block_size
319 * Minimum block size to count in total.
320 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100321 * Return: Number of bytes available for allocation that meet the
Aaron Williams643d96d2020-08-20 07:22:02 +0200322 * block size requirement
323 */
324u64 cvmx_bootmem_available_mem(u64 min_block_size);
325
326/**
327 * Prints out the list of named blocks that have been allocated
328 * along with their addresses and sizes.
329 * This is primarily used for debugging purposes
330 */
331void cvmx_bootmem_print_named(void);
332
333/**
334 * Allocates a block of physical memory from the free list, at
335 * (optional) requested address and alignment.
336 *
337 * @param req_size size of region to allocate. All requests are
338 * rounded up to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE bytes size
339 *
340 * @param address_min Minimum address that block can occupy.
341 *
342 * @param address_max Specifies the maximum address_min (inclusive)
343 * that the allocation can use.
344 *
345 * @param alignment Requested alignment of the block. If this
346 * alignment cannot be met, the allocation fails.
347 * This must be a power of 2. (Note: Alignment of
348 * CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and
349 * internally enforced. Requested alignments of less
350 * than CVMX_BOOTMEM_ALIGNMENT_SIZE are set to
351 * CVMX_BOOTMEM_ALIGNMENT_SIZE.)
352 * @param flags Flags to control options for the allocation.
353 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100354 * Return: physical address of block allocated, or -1 on failure
Aaron Williams643d96d2020-08-20 07:22:02 +0200355 */
356s64 cvmx_bootmem_phy_alloc(u64 req_size, u64 address_min, u64 address_max,
357 u64 alignment, u32 flags);
358
359/**
360 * Allocates a named block of physical memory from the free list, at
361 * (optional) requested address and alignment.
362 *
363 * @param size size of region to allocate. All requests are rounded
364 * up to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE bytes size
365 *
366 * @param min_addr Minimum address that block can occupy.
367 *
368 * @param max_addr Specifies the maximum address_min (inclusive) that
369 * the allocation can use.
370 *
371 * @param alignment Requested alignment of the block. If this
372 * alignment cannot be met, the allocation fails.
373 * This must be a power of 2. (Note: Alignment of
374 * CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and
375 * internally enforced. Requested alignments of less
376 * than CVMX_BOOTMEM_ALIGNMENT_SIZE are set to
377 * CVMX_BOOTMEM_ALIGNMENT_SIZE.)
378 *
379 * @param name name to assign to named block
380 *
381 * @param flags Flags to control options for the allocation.
382 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100383 * Return: physical address of block allocated, or -1 on failure
Aaron Williams643d96d2020-08-20 07:22:02 +0200384 */
385s64 cvmx_bootmem_phy_named_block_alloc(u64 size, u64 min_addr, u64 max_addr,
386 u64 alignment, const char *name,
387 u32 flags);
388
389/**
390 * Finds a named memory block by name.
391 * Also used for finding an unused entry in the named block table.
392 *
393 * @param name Name of memory block to find. If NULL pointer given,
394 * then finds unused descriptor, if available.
395 *
396 * @param flags Flags to control options for the allocation.
397 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100398 * Return: Physical address of the memory block descriptor, zero if not
Aaron Williams643d96d2020-08-20 07:22:02 +0200399 * found. If zero returned when name parameter is NULL, then no
400 * memory block descriptors are available.
401 */
402u64 cvmx_bootmem_phy_named_block_find(const char *name, u32 flags);
403
404/**
405 * Returns the size of available memory in bytes, only
406 * counting blocks that are at least as big as the minimum block
407 * size.
408 *
409 * @param min_block_size
410 * Minimum block size to count in total.
411 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100412 * Return: Number of bytes available for allocation that meet the
Aaron Williams643d96d2020-08-20 07:22:02 +0200413 * block size requirement
414 */
415u64 cvmx_bootmem_phy_available_mem(u64 min_block_size);
416
417/**
418 * Frees a named block.
419 *
420 * @param name name of block to free
421 * @param flags flags for passing options
422 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100423 * Return: 0 on failure
Aaron Williams643d96d2020-08-20 07:22:02 +0200424 * 1 on success
425 */
426int cvmx_bootmem_phy_named_block_free(const char *name, u32 flags);
427
428/**
429 * Frees a block to the bootmem allocator list. This must
430 * be used with care, as the size provided must match the size
431 * of the block that was allocated, or the list will become
432 * corrupted.
433 *
434 * IMPORTANT: This is only intended to be used as part of named block
435 * frees and initial population of the free memory list.
436 * *
437 *
438 * @param phy_addr physical address of block
439 * @param size size of block in bytes.
440 * @param flags flags for passing options
441 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100442 * Return: 1 on success,
Aaron Williams643d96d2020-08-20 07:22:02 +0200443 * 0 on failure
444 */
445int __cvmx_bootmem_phy_free(u64 phy_addr, u64 size, u32 flags);
446
447/**
448 * Prints the list of currently allocated named blocks
449 *
450 */
451void cvmx_bootmem_phy_named_block_print(void);
452
453/**
454 * Prints the list of available memory.
455 *
456 */
457void cvmx_bootmem_phy_list_print(void);
458
459/**
460 * This function initializes the free memory list used by cvmx_bootmem.
461 * This must be called before any allocations can be done.
462 *
463 * @param mem_size Total memory available, in bytes
464 *
465 * @param low_reserved_bytes Number of bytes to reserve (leave out of
466 * free list) at address 0x0.
467 *
468 * @param desc_buffer Buffer for the bootmem descriptor. This must be
469 * a 32 bit addressable address.
470 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100471 * Return: 1 on success
Aaron Williams643d96d2020-08-20 07:22:02 +0200472 * 0 on failure
473 */
474s64 cvmx_bootmem_phy_mem_list_init(u64 mem_size, u32 low_reserved_bytes,
475 struct cvmx_bootmem_desc *desc_buffer);
476
477/**
478 * This function initializes the free memory list used by cvmx_bootmem.
479 * This must be called before any allocations can be done.
480 *
481 * @param nodemask Nodemask - one bit per node (bit0->node0, bit1->node1,...)
482 *
483 * @param mem_size[] Array of memory sizes in MBytes per node ([0]->node0,...)
484 *
485 * @param low_reserved_bytes Number of bytes to reserve (leave out of
486 * free list) at address 0x0.
487 *
488 * @param desc_buffer Buffer for the bootmem descriptor. This must be
489 * a 32 bit addressable address.
490 *
Heinrich Schuchardt47b4c022022-01-19 18:05:50 +0100491 * Return: 1 on success
Aaron Williams643d96d2020-08-20 07:22:02 +0200492 * 0 on failure
493 */
494s64 cvmx_bootmem_phy_mem_list_init_multi(u8 nodemask, u32 mem_size[],
495 u32 low_reserved_bytes,
496 struct cvmx_bootmem_desc *desc_buffer);
497/**
498 * Locks the bootmem allocator. This is useful in certain situations
499 * where multiple allocations must be made without being interrupted.
500 * This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag.
501 *
502 */
503void cvmx_bootmem_lock(void);
504
505/**
506 * Unlocks the bootmem allocator. This is useful in certain situations
507 * where multiple allocations must be made without being interrupted.
508 * This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag.
509 *
510 */
511void cvmx_bootmem_unlock(void);
512
513/**
514 * Internal use function to get the current descriptor pointer
515 */
516void *__cvmx_bootmem_internal_get_desc_ptr(void);
517
518/**
519 * Internal use. This is userd to get a pointer to a physical
520 * address. For linux n32 the physical address in mmaped to a virtual
521 * address and the virtual address is returned. For n64 the address
522 * is converted to an xkphys address and the xkhpys address is
523 * returned.
524 */
525void *__cvmx_phys_addr_to_ptr(u64 phys, int size);
526const struct cvmx_bootmem_named_block_desc *
527__cvmx_bootmem_find_named_block_flags(const char *name, u32 flags);
528void *cvmx_bootmem_alloc_named_range_flags(u64 size, u64 min_addr,
529 u64 max_addr, u64 align,
530 const char *name, u32 flags);
531u64 cvmx_bootmem_phy_alloc_range(u64 size, u64 alignment,
532 u64 min_addr, u64 max_addr);
533
534#endif /* __CVMX_BOOTMEM_H__ */