1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
|
/* 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 <alist.h>
#include <asm/types.h>
#include <asm/u-boot.h>
#include <linux/bitops.h>
#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 */
|
