PageRenderTime 32ms CodeModel.GetById 14ms app.highlight 12ms RepoModel.GetById 1ms app.codeStats 1ms

/arch/mips/include/asm/octeon/cvmx-bootmem.h

http://github.com/mirrors/linux
C Header | 341 lines | 71 code | 35 blank | 235 comment | 1 complexity | ff204cb4c2d05dfca5f92678571df999 MD5 | raw file
  1/***********************license start***************
  2 * Author: Cavium Networks
  3 *
  4 * Contact: support@caviumnetworks.com
  5 * This file is part of the OCTEON SDK
  6 *
  7 * Copyright (c) 2003-2008 Cavium Networks
  8 *
  9 * This file is free software; you can redistribute it and/or modify
 10 * it under the terms of the GNU General Public License, Version 2, as
 11 * published by the Free Software Foundation.
 12 *
 13 * This file is distributed in the hope that it will be useful, but
 14 * AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
 15 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
 16 * NONINFRINGEMENT.  See the GNU General Public License for more
 17 * details.
 18 *
 19 * You should have received a copy of the GNU General Public License
 20 * along with this file; if not, write to the Free Software
 21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 22 * or visit http://www.gnu.org/licenses/.
 23 *
 24 * This file may also be available under a different license from Cavium.
 25 * Contact Cavium Networks for more information
 26 ***********************license end**************************************/
 27
 28/*
 29 * Simple allocate only memory allocator.  Used to allocate memory at
 30 * application start time.
 31 */
 32
 33#ifndef __CVMX_BOOTMEM_H__
 34#define __CVMX_BOOTMEM_H__
 35/* Must be multiple of 8, changing breaks ABI */
 36#define CVMX_BOOTMEM_NAME_LEN 128
 37
 38/* Can change without breaking ABI */
 39#define CVMX_BOOTMEM_NUM_NAMED_BLOCKS 64
 40
 41/* minimum alignment of bootmem alloced blocks */
 42#define CVMX_BOOTMEM_ALIGNMENT_SIZE	(16ull)
 43
 44/* Flags for cvmx_bootmem_phy_mem* functions */
 45/* Allocate from end of block instead of beginning */
 46#define CVMX_BOOTMEM_FLAG_END_ALLOC    (1 << 0)
 47
 48/* Don't do any locking. */
 49#define CVMX_BOOTMEM_FLAG_NO_LOCKING   (1 << 1)
 50
 51/* First bytes of each free physical block of memory contain this structure,
 52 * which is used to maintain the free memory list.  Since the bootloader is
 53 * only 32 bits, there is a union providing 64 and 32 bit versions.  The
 54 * application init code converts addresses to 64 bit addresses before the
 55 * application starts.
 56 */
 57struct cvmx_bootmem_block_header {
 58	/*
 59	 * Note: these are referenced from assembly routines in the
 60	 * bootloader, so this structure should not be changed
 61	 * without changing those routines as well.
 62	 */
 63	uint64_t next_block_addr;
 64	uint64_t size;
 65
 66};
 67
 68/*
 69 * Structure for named memory blocks.  Number of descriptors available
 70 * can be changed without affecting compatibility, but name length
 71 * changes require a bump in the bootmem descriptor version Note: This
 72 * structure must be naturally 64 bit aligned, as a single memory
 73 * image will be used by both 32 and 64 bit programs.
 74 */
 75struct cvmx_bootmem_named_block_desc {
 76	/* Base address of named block */
 77	uint64_t base_addr;
 78	/*
 79	 * Size actually allocated for named block (may differ from
 80	 * requested).
 81	 */
 82	uint64_t size;
 83	/* name of named block */
 84	char name[CVMX_BOOTMEM_NAME_LEN];
 85};
 86
 87/* Current descriptor versions */
 88/* CVMX bootmem descriptor major version */
 89#define CVMX_BOOTMEM_DESC_MAJ_VER   3
 90
 91/* CVMX bootmem descriptor minor version */
 92#define CVMX_BOOTMEM_DESC_MIN_VER   0
 93
 94/* First three members of cvmx_bootmem_desc_t are left in original
 95 * positions for backwards compatibility.
 96 */
 97struct cvmx_bootmem_desc {
 98#if defined(__BIG_ENDIAN_BITFIELD) || defined(CVMX_BUILD_FOR_LINUX_HOST)
 99	/* spinlock to control access to list */
100	uint32_t lock;
101	/* flags for indicating various conditions */
102	uint32_t flags;
103	uint64_t head_addr;
104
105	/* Incremented when incompatible changes made */
106	uint32_t major_version;
107
108	/*
109	 * Incremented changed when compatible changes made, reset to
110	 * zero when major incremented.
111	 */
112	uint32_t minor_version;
113
114	uint64_t app_data_addr;
115	uint64_t app_data_size;
116
117	/* number of elements in named blocks array */
118	uint32_t named_block_num_blocks;
119
120	/* length of name array in bootmem blocks */
121	uint32_t named_block_name_len;
122	/* address of named memory block descriptors */
123	uint64_t named_block_array_addr;
124#else                           /* __LITTLE_ENDIAN */
125	uint32_t flags;
126	uint32_t lock;
127	uint64_t head_addr;
128
129	uint32_t minor_version;
130	uint32_t major_version;
131	uint64_t app_data_addr;
132	uint64_t app_data_size;
133
134	uint32_t named_block_name_len;
135	uint32_t named_block_num_blocks;
136	uint64_t named_block_array_addr;
137#endif
138};
139
140/**
141 * Initialize the boot alloc memory structures. This is
142 * normally called inside of cvmx_user_app_init()
143 *
144 * @mem_desc_ptr:	Address of the free memory list
145 */
146extern int cvmx_bootmem_init(void *mem_desc_ptr);
147
148/**
149 * Allocate a block of memory from the free list that was
150 * passed to the application by the bootloader at a specific
151 * address. This is an allocate-only algorithm, so
152 * freeing memory is not possible. Allocation will fail if
153 * memory cannot be allocated at the specified address.
154 *
155 * @size:      Size in bytes of block to allocate
156 * @address:   Physical address to allocate memory at.	If this memory is not
157 *		    available, the allocation fails.
158 * @alignment: Alignment required - must be power of 2
159 * Returns pointer to block of memory, NULL on error
160 */
161extern void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address,
162					uint64_t alignment);
163
164/**
165 * Frees a previously allocated named bootmem block.
166 *
167 * @name:   name of block to free
168 *
169 * Returns 0 on failure,
170 *	   !0 on success
171 */
172
173
174/**
175 * Allocate a block of memory from the free list that was passed
176 * to the application by the bootloader, and assign it a name in the
177 * global named block table.  (part of the cvmx_bootmem_descriptor_t structure)
178 * Named blocks can later be freed.
179 *
180 * @size:      Size in bytes of block to allocate
181 * @alignment: Alignment required - must be power of 2
182 * @name:      name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
183 *
184 * Returns a pointer to block of memory, NULL on error
185 */
186extern void *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment,
187				      char *name);
188
189/**
190 * Allocate a block of memory from a specific range of the free list
191 * that was passed to the application by the bootloader, and assign it
192 * a name in the global named block table.  (part of the
193 * cvmx_bootmem_descriptor_t structure) Named blocks can later be
194 * freed.  If request cannot be satisfied within the address range
195 * specified, NULL is returned
196 *
197 * @size:      Size in bytes of block to allocate
198 * @min_addr:  minimum address of range
199 * @max_addr:  maximum address of range
200 * @align:     Alignment of memory to be allocated. (must be a power of 2)
201 * @name:      name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
202 *
203 * Returns a pointer to block of memory, NULL on error
204 */
205extern void *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr,
206					    uint64_t max_addr, uint64_t align,
207					    char *name);
208
209/**
210 * Allocate if needed a block of memory from a specific range of the
211 * free list that was passed to the application by the bootloader, and
212 * assign it a name in the global named block table.  (part of the
213 * cvmx_bootmem_descriptor_t structure) Named blocks can later be
214 * freed.  If the requested name block is already allocated, return
215 * the pointer to block of memory.  If request cannot be satisfied
216 * within the address range specified, NULL is returned
217 *
218 * @param size   Size in bytes of block to allocate
219 * @param min_addr  minimum address of range
220 * @param max_addr  maximum address of range
221 * @param align  Alignment of memory to be allocated. (must be a power of 2)
222 * @param name   name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
223 * @param init   Initialization function
224 *
225 * The initialization function is optional, if omitted the named block
226 * is initialized to all zeros when it is created, i.e. once.
227 *
228 * @return pointer to block of memory, NULL on error
229 */
230void *cvmx_bootmem_alloc_named_range_once(uint64_t size,
231					  uint64_t min_addr,
232					  uint64_t max_addr,
233					  uint64_t align,
234					  char *name,
235					  void (*init) (void *));
236
237extern int cvmx_bootmem_free_named(char *name);
238
239/**
240 * Finds a named bootmem block by name.
241 *
242 * @name:   name of block to free
243 *
244 * Returns pointer to named block descriptor on success
245 *	   0 on failure
246 */
247struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name);
248
249/**
250 * Allocates a block of physical memory from the free list, at
251 * (optional) requested address and alignment.
252 *
253 * @req_size: size of region to allocate.  All requests are rounded up
254 *	      to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE bytes size
255 *
256 * @address_min: Minimum address that block can occupy.
257 *
258 * @address_max: Specifies the maximum address_min (inclusive) that
259 *		 the allocation can use.
260 *
261 * @alignment: Requested alignment of the block.  If this alignment
262 *	       cannot be met, the allocation fails.  This must be a
263 *	       power of 2.  (Note: Alignment of
264 *	       CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and
265 *	       internally enforced.  Requested alignments of less than
266 *	       CVMX_BOOTMEM_ALIGNMENT_SIZE are set to
267 *	       CVMX_BOOTMEM_ALIGNMENT_SIZE.)
268 *
269 * @flags:     Flags to control options for the allocation.
270 *
271 * Returns physical address of block allocated, or -1 on failure
272 */
273int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min,
274			       uint64_t address_max, uint64_t alignment,
275			       uint32_t flags);
276
277/**
278 * Allocates a named block of physical memory from the free list, at
279 * (optional) requested address and alignment.
280 *
281 * @param size	    size of region to allocate.	 All requests are rounded
282 *		    up to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE
283 *		    bytes size
284 * @param min_addr Minimum address that block can occupy.
285 * @param max_addr  Specifies the maximum address_min (inclusive) that
286 *		    the allocation can use.
287 * @param alignment Requested alignment of the block.  If this
288 *		    alignment cannot be met, the allocation fails.
289 *		    This must be a power of 2.	(Note: Alignment of
290 *		    CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and
291 *		    internally enforced.  Requested alignments of less
292 *		    than CVMX_BOOTMEM_ALIGNMENT_SIZE are set to
293 *		    CVMX_BOOTMEM_ALIGNMENT_SIZE.)
294 * @param name	    name to assign to named block
295 * @param flags	    Flags to control options for the allocation.
296 *
297 * @return physical address of block allocated, or -1 on failure
298 */
299int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr,
300					   uint64_t max_addr,
301					   uint64_t alignment,
302					   char *name, uint32_t flags);
303
304/**
305 * Frees a block to the bootmem allocator list.	 This must
306 * be used with care, as the size provided must match the size
307 * of the block that was allocated, or the list will become
308 * corrupted.
309 *
310 * IMPORTANT:  This is only intended to be used as part of named block
311 * frees and initial population of the free memory list.
312 *							*
313 *
314 * @phy_addr: physical address of block
315 * @size:     size of block in bytes.
316 * @flags:    flags for passing options
317 *
318 * Returns 1 on success,
319 *	   0 on failure
320 */
321int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags);
322
323/**
324 * Locks the bootmem allocator.	 This is useful in certain situations
325 * where multiple allocations must be made without being interrupted.
326 * This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag.
327 *
328 */
329void cvmx_bootmem_lock(void);
330
331/**
332 * Unlocks the bootmem allocator.  This is useful in certain situations
333 * where multiple allocations must be made without being interrupted.
334 * This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag.
335 *
336 */
337void cvmx_bootmem_unlock(void);
338
339extern struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void);
340
341#endif /*   __CVMX_BOOTMEM_H__ */