include/lmb.h

   1 /* SPDX-License-Identifier: GPL-2.0+ */
   2 /*
   3  * Logical memory blocks.
   4  *
   5  * Copyright (C) 2001 Peter Bergner, IBM Corp.
   6  */
   7
   8 #ifndef _LINUX_LMB_H
   9 #define _LINUX_LMB_H
  10
  11 #ifdef __KERNEL__
  12
  13 #include <alist.h>
  14 #include <asm/types.h>
  15 #include <asm/u-boot.h>
  16 #include <linux/bitops.h>
  17
  18 #define LMB_ALLOC_ANYWHERE      0
  19 #define LMB_ALIST_INITIAL_SIZE  4
  20
  21 /**
  22  * enum lmb_flags - Definition of memory region attributes
  23  * @LMB_NONE: No special request
  24  * @LMB_NOMAP: Don't add to MMU configuration
  25  * @LMB_NOOVERWRITE: The memory region cannot be overwritten/re-reserved
  26  * @LMB_NONOTIFY: Do not notify other modules of changes to this memory region
  27  */
  28 enum lmb_flags {
  29         LMB_NONE                = 0,
  30         LMB_NOMAP               = BIT(1),
  31         LMB_NOOVERWRITE         = BIT(2),
  32         LMB_NONOTIFY            = BIT(3),
  33 };
  34
  35 /**
  36  * struct lmb_region - Description of one region
  37  * @base: Base address of the region
  38  * @size: Size of the region
  39  * @flags: Memory region attributes
  40  */
  41 struct lmb_region {
  42         phys_addr_t base;
  43         phys_size_t size;
  44         enum lmb_flags flags;
  45 };
  46
  47 /**
  48  * struct lmb - The LMB structure
  49  * @free_mem: List of free memory regions
  50  * @used_mem: List of used/reserved memory regions
  51  * @test: Is structure being used for LMB tests
  52  */
  53 struct lmb {
  54         struct alist free_mem;
  55         struct alist used_mem;
  56         bool test;
  57 };
  58
  59 /**
  60  * lmb_init() - Initialise the LMB module.
  61  *
  62  * Return: 0 on success, negative error code on failure.
  63  *
  64  * Initialise the LMB lists needed for keeping the memory map. There
  65  * are two lists, in form of allocated list data structure. One for the
  66  * available memory, and one for the used memory. Initialise the two
  67  * lists as part of board init. Add memory to the available memory
  68  * list and reserve common areas by adding them to the used memory
  69  * list.
  70  */
  71 int lmb_init(void);
  72
  73 /**
  74  * lmb_add_memory() - Add memory range for LMB allocations.
  75  *
  76  * Add the entire available memory range to the pool of memory that
  77  * can be used by the LMB module for allocations.
  78  */
  79 void lmb_add_memory(void);
  80
  81 long lmb_add(phys_addr_t base, phys_size_t size);
  82
  83 /**
  84  * lmb_reserve() - Reserve a memory region (with no special flags)
  85  * @base: Base address of the memory region
  86  * @size: Size of the memory region
  87  *
  88  * Return: 0 on success, negative error code on failure.
  89  */
  90 long lmb_reserve(phys_addr_t base, phys_size_t size);
  91
  92 /**
  93  * lmb_reserve_flags() - Reserve one region with a specific flags bitfield
  94  * @base: Base address of the memory region
  95  * @size: Size of the memory region
  96  * @flags: Flags for the memory region
  97  *
  98  * Return:
  99  * * %0         - Added successfully, or it's already added (only if LMB_NONE)
 100  * * %-EEXIST   - The region is already added, and flags != LMB_NONE
 101  * * %-1        - Failure
 102  */
 103 long lmb_reserve_flags(phys_addr_t base, phys_size_t size,
 104                        enum lmb_flags flags);
 105
 106 phys_addr_t lmb_alloc(phys_size_t size, ulong align);
 107 phys_addr_t lmb_alloc_base(phys_size_t size, ulong align, phys_addr_t max_addr);
 108 phys_addr_t lmb_alloc_addr(phys_addr_t base, phys_size_t size);
 109 phys_size_t lmb_get_free_size(phys_addr_t addr);
 110
 111 /**
 112  * lmb_alloc_base_flags() - Allocate specified memory region with specified
 113  *                          attributes
 114  * @size: Size of the region requested
 115  * @align: Alignment of the memory region requested
 116  * @max_addr: Maximum address of the requested region
 117  * @flags: Memory region attributes to be set
 118  *
 119  * Allocate a region of memory with the attributes specified through the
 120  * parameter. The max_addr parameter is used to specify the maximum address
 121  * below which the requested region should be allocated.
 122  *
 123  * Return: Base address on success, 0 on error.
 124  */
 125 phys_addr_t lmb_alloc_base_flags(phys_size_t size, ulong align,
 126                                  phys_addr_t max_addr, uint flags);
 127
 128 /**
 129  * lmb_alloc_addr_flags() - Allocate specified memory address with specified
 130  *                          attributes
 131  * @base: Base Address requested
 132  * @size: Size of the region requested
 133  * @flags: Memory region attributes to be set
 134  *
 135  * Allocate a region of memory with the attributes specified through the
 136  * parameter. The base parameter is used to specify the base address
 137  * of the requested region.
 138  *
 139  * Return: Base address on success, 0 on error.
 140  */
 141 phys_addr_t lmb_alloc_addr_flags(phys_addr_t base, phys_size_t size,
 142                                  uint flags);
 143
 144 /**
 145  * lmb_is_reserved_flags() - Test if address is in reserved region with flag
 146  *                           bits set
 147  * @addr: Address to be tested
 148  * @flags: Bitmap with bits to be tested
 149  *
 150  * The function checks if a reserved region comprising @addr exists which has
 151  * all flag bits set which are set in @flags.
 152  *
 153  * Return: 1 if matching reservation exists, 0 otherwise.
 154  */
 155 int lmb_is_reserved_flags(phys_addr_t addr, int flags);
 156
 157 /**
 158  * lmb_free_flags() - Free up a region of memory
 159  * @base: Base Address of region to be freed
 160  * @size: Size of the region to be freed
 161  * @flags: Memory region attributes
 162  *
 163  * Return: 0 on success, negative error code on failure.
 164  */
 165 long lmb_free_flags(phys_addr_t base, phys_size_t size, uint flags);
 166
 167 long lmb_free(phys_addr_t base, phys_size_t size);
 168
 169 void lmb_dump_all(void);
 170 void lmb_dump_all_force(void);
 171
 172 void lmb_arch_add_memory(void);
 173
 174 struct lmb *lmb_get(void);
 175 int lmb_push(struct lmb *store);
 176 void lmb_pop(struct lmb *store);
 177
 178 static inline int lmb_read_check(phys_addr_t addr, phys_size_t len)
 179 {
 180         return lmb_alloc_addr(addr, len) == addr ? 0 : -1;
 181 }
 182
 183 /**
 184  * io_lmb_setup() - Initialize LMB struct
 185  * @io_lmb: IO LMB to initialize
 186  *
 187  * Return: 0 on success, negative error code on failure.
 188  */
 189 int io_lmb_setup(struct lmb *io_lmb);
 190
 191 /**
 192  * io_lmb_teardown() - Tear LMB struct down
 193  * @io_lmb: IO LMB to teardown
 194  */
 195 void io_lmb_teardown(struct lmb *io_lmb);
 196
 197 /**
 198  * io_lmb_add() - Add an IOVA range for allocations
 199  * @io_lmb: LMB to add the space to
 200  * @base: Base Address of region to add
 201  * @size: Size of the region to add
 202  *
 203  * Add the IOVA space [base, base + size] to be managed by io_lmb.
 204  *
 205  * Return: 0 on success, negative error code on failure.
 206  */
 207 long io_lmb_add(struct lmb *io_lmb, phys_addr_t base, phys_size_t size);
 208
 209 /**
 210  * io_lmb_alloc() - Allocate specified IO memory address with specified
 211  *                  alignment
 212  * @io_lmb: LMB to alloc from
 213  * @size: Size of the region requested
 214  * @align: Required address and size alignment
 215  *
 216  * Allocate a region of IO memory. The base parameter is used to specify the
 217  * base address of the requested region.
 218  *
 219  * Return: Base IO address on success, 0 on error.
 220  */
 221 phys_addr_t io_lmb_alloc(struct lmb *io_lmb, phys_size_t size, ulong align);
 222
 223 /**
 224  * io_lmb_free() - Free up a region of IOVA space
 225  * @io_lmb: LMB to return the IO address space to
 226  * @base: Base Address of region to be freed
 227  * @size: Size of the region to be freed
 228  *
 229  * Return: 0 on success, negative error code on failure.
 230  */
 231 long io_lmb_free(struct lmb *io_lmb, phys_addr_t base, phys_size_t size);
 232
 233 #endif /* __KERNEL__ */
 234
 235 #endif /* _LINUX_LMB_H */