/* SPDX-License-Identifier: GPL-2.0+ */ /* * Logical memory blocks. * * Copyright (C) 2001 Peter Bergner, IBM Corp. */ #ifndef _LINUX_LMB_H #define _LINUX_LMB_H #ifdef __KERNEL__ #include #include #include #include #define LMB_ALLOC_ANYWHERE 0 #define LMB_ALIST_INITIAL_SIZE 4 /** * DOC: Memory region attribute flags. * * %LMB_NONE: No special request * %LMB_NOMAP: Don't add to MMU configuration * %LMB_NOOVERWRITE: The memory region cannot be overwritten/re-reserved * %LMB_NONOTIFY: Do not notify other modules of changes to this memory region */ #define LMB_NONE 0 #define LMB_NOMAP BIT(1) #define LMB_NOOVERWRITE BIT(2) #define LMB_NONOTIFY BIT(3) /** * enum lmb_mem_type - type of memory allocation request * @LMB_MEM_ALLOC_ADDR: request for a particular region of memory * @LMB_MEM_ALLOC_ANY: allocate any available memory region * @LMB_MEM_ALLOC_MAX: allocate memory below a particular address */ enum lmb_mem_type { LMB_MEM_ALLOC_ADDR = 1, LMB_MEM_ALLOC_ANY, LMB_MEM_ALLOC_MAX, }; /** * enum lmb_map_op - memory map operation */ enum lmb_map_op { /** @LMB_MAP_OP_RESERVE: reserve memory */ LMB_MAP_OP_RESERVE = 1, /** @LMB_MAP_OP_FREE: free memory */ LMB_MAP_OP_FREE, /** @LMB_MAP_OP_ADD: add memory */ LMB_MAP_OP_ADD, }; /** * struct lmb_region - Description of one region * @base: Base address of the region * @size: Size of the region * @flags: Memory region attributes */ struct lmb_region { phys_addr_t base; phys_size_t size; u32 flags; }; /** * struct lmb - The LMB structure * @available_mem: List of memory available to LMB * @used_mem: List of used/reserved memory regions * @test: Is structure being used for LMB tests */ struct lmb { struct alist available_mem; struct alist used_mem; bool test; }; /** * lmb_alloc_mem() - Request LMB memory * @type: Type of memory allocation request * @align: Alignment of the memory region requested(0 for none) * @addr: Base address of the allocated memory region * @size: Size in bytes of the allocation request * @flags: Memory region attributes to be set * * Allocate a region of memory where the allocation is based on the parameters * that have been passed to the function.The first parameter specifies the * type of allocation that is being requested. The second parameter, @align * is used to specify if the allocation is to be made with a particular * alignment. Use 0 for no alignment requirements. * * The allocated address is returned through the @addr parameter when @type * is @LMB_MEM_ALLOC_ANY or @LMB_MEM_ALLOC_MAX. If @type is * @LMB_MEM_ALLOC_ADDR the @addr parameter would contain the address being * requested. * * The flags parameter is used to specify the memory attributes of the * requested region. * * Return: 0 on success, -ve value on failure * * When the allocation is of type @LMB_MEM_ALLOC_ADDR, the return value can * be -EINVAL if the requested memory region is not part of the LMB memory * map, and -EEXIST if the requested region is already allocated. */ int lmb_alloc_mem(enum lmb_mem_type type, u64 align, phys_addr_t *addr, phys_size_t size, u32 flags); /** * lmb_init() - Initialise the LMB module. * * Return: 0 on success, negative error code on failure. * * Initialise the LMB lists needed for keeping the memory map. There * are two lists, in form of allocated list data structure. One for the * available memory, and one for the used memory. Initialise the two * lists as part of board init. Add memory to the available memory * list and reserve common areas by adding them to the used memory * list. */ int lmb_init(void); long lmb_add(phys_addr_t base, phys_size_t size); phys_size_t lmb_get_free_size(phys_addr_t addr); /** * lmb_is_reserved_flags() - Test if address is in reserved region with flag * bits set * @addr: Address to be tested * @flags: Bitmap with bits to be tested * * The function checks if a reserved region comprising @addr exists which has * all flag bits set which are set in @flags. * * Return: 1 if matching reservation exists, 0 otherwise. */ int lmb_is_reserved_flags(phys_addr_t addr, int flags); /** * lmb_free() - Free up a region of memory * @base: Base Address of region to be freed * @size: Size of the region to be freed * @flags: Memory region attributes * * Return: 0 on success, negative error code on failure. */ long lmb_free(phys_addr_t base, phys_size_t size, u32 flags); void lmb_dump_all(void); void lmb_dump_all_force(void); void lmb_arch_add_memory(void); struct lmb *lmb_get(void); int lmb_push(struct lmb *store); void lmb_pop(struct lmb *store); static inline int lmb_read_check(phys_addr_t addr, phys_size_t len) { return lmb_alloc_mem(LMB_MEM_ALLOC_ADDR, 0, &addr, len, LMB_NONE); } /** * io_lmb_setup() - Initialize LMB struct * @io_lmb: IO LMB to initialize * * Return: 0 on success, negative error code on failure. */ int io_lmb_setup(struct lmb *io_lmb); /** * io_lmb_teardown() - Tear LMB struct down * @io_lmb: IO LMB to teardown */ void io_lmb_teardown(struct lmb *io_lmb); /** * io_lmb_add() - Add an IOVA range for allocations * @io_lmb: LMB to add the space to * @base: Base Address of region to add * @size: Size of the region to add * * Add the IOVA space [base, base + size] to be managed by io_lmb. * * Return: 0 on success, negative error code on failure. */ long io_lmb_add(struct lmb *io_lmb, phys_addr_t base, phys_size_t size); /** * io_lmb_alloc() - Allocate specified IO memory address with specified * alignment * @io_lmb: LMB to alloc from * @size: Size of the region requested * @align: Required address and size alignment * * Allocate a region of IO memory. The base parameter is used to specify the * base address of the requested region. * * Return: Base IO address on success, 0 on error. */ phys_addr_t io_lmb_alloc(struct lmb *io_lmb, phys_size_t size, ulong align); /** * io_lmb_free() - Free up a region of IOVA space * @io_lmb: LMB to return the IO address space to * @base: Base Address of region to be freed * @size: Size of the region to be freed * * Return: 0 on success, negative error code on failure. */ long io_lmb_free(struct lmb *io_lmb, phys_addr_t base, phys_size_t size); #endif /* __KERNEL__ */ #endif /* _LINUX_LMB_H */