mirror of
https://github.com/AetherDroid/android_kernel_samsung_on5xelte.git
synced 2025-10-30 23:58:51 +01:00
Fixed MTP to work with TWRP
This commit is contained in:
awab228
commit
f6dfaef42e
50820 changed files with 20846062 additions and 0 deletions
375
arch/mips/include/asm/octeon/cvmx-bootmem.h
Normal file
375
arch/mips/include/asm/octeon/cvmx-bootmem.h
Normal file
|
|
@ -0,0 +1,375 @@
|
|||
/***********************license start***************
|
||||
* Author: Cavium Networks
|
||||
*
|
||||
* Contact: support@caviumnetworks.com
|
||||
* This file is part of the OCTEON SDK
|
||||
*
|
||||
* Copyright (c) 2003-2008 Cavium Networks
|
||||
*
|
||||
* This file is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License, Version 2, as
|
||||
* published by the Free Software Foundation.
|
||||
*
|
||||
* This file is distributed in the hope that it will be useful, but
|
||||
* AS-IS and WITHOUT ANY WARRANTY; without even the implied warranty
|
||||
* of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, TITLE, or
|
||||
* NONINFRINGEMENT. See the GNU General Public License for more
|
||||
* details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this file; if not, write to the Free Software
|
||||
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
|
||||
* or visit http://www.gnu.org/licenses/.
|
||||
*
|
||||
* This file may also be available under a different license from Cavium.
|
||||
* Contact Cavium Networks for more information
|
||||
***********************license end**************************************/
|
||||
|
||||
/*
|
||||
* Simple allocate only memory allocator. Used to allocate memory at
|
||||
* application start time.
|
||||
*/
|
||||
|
||||
#ifndef __CVMX_BOOTMEM_H__
|
||||
#define __CVMX_BOOTMEM_H__
|
||||
/* Must be multiple of 8, changing breaks ABI */
|
||||
#define CVMX_BOOTMEM_NAME_LEN 128
|
||||
|
||||
/* Can change without breaking ABI */
|
||||
#define CVMX_BOOTMEM_NUM_NAMED_BLOCKS 64
|
||||
|
||||
/* minimum alignment of bootmem alloced blocks */
|
||||
#define CVMX_BOOTMEM_ALIGNMENT_SIZE (16ull)
|
||||
|
||||
/* Flags for cvmx_bootmem_phy_mem* functions */
|
||||
/* Allocate from end of block instead of beginning */
|
||||
#define CVMX_BOOTMEM_FLAG_END_ALLOC (1 << 0)
|
||||
|
||||
/* Don't do any locking. */
|
||||
#define CVMX_BOOTMEM_FLAG_NO_LOCKING (1 << 1)
|
||||
|
||||
/* First bytes of each free physical block of memory contain this structure,
|
||||
* which is used to maintain the free memory list. Since the bootloader is
|
||||
* only 32 bits, there is a union providing 64 and 32 bit versions. The
|
||||
* application init code converts addresses to 64 bit addresses before the
|
||||
* application starts.
|
||||
*/
|
||||
struct cvmx_bootmem_block_header {
|
||||
/*
|
||||
* Note: these are referenced from assembly routines in the
|
||||
* bootloader, so this structure should not be changed
|
||||
* without changing those routines as well.
|
||||
*/
|
||||
uint64_t next_block_addr;
|
||||
uint64_t size;
|
||||
|
||||
};
|
||||
|
||||
/*
|
||||
* Structure for named memory blocks. Number of descriptors available
|
||||
* can be changed without affecting compatibility, but name length
|
||||
* changes require a bump in the bootmem descriptor version Note: This
|
||||
* structure must be naturally 64 bit aligned, as a single memory
|
||||
* image will be used by both 32 and 64 bit programs.
|
||||
*/
|
||||
struct cvmx_bootmem_named_block_desc {
|
||||
/* Base address of named block */
|
||||
uint64_t base_addr;
|
||||
/*
|
||||
* Size actually allocated for named block (may differ from
|
||||
* requested).
|
||||
*/
|
||||
uint64_t size;
|
||||
/* name of named block */
|
||||
char name[CVMX_BOOTMEM_NAME_LEN];
|
||||
};
|
||||
|
||||
/* Current descriptor versions */
|
||||
/* CVMX bootmem descriptor major version */
|
||||
#define CVMX_BOOTMEM_DESC_MAJ_VER 3
|
||||
|
||||
/* CVMX bootmem descriptor minor version */
|
||||
#define CVMX_BOOTMEM_DESC_MIN_VER 0
|
||||
|
||||
/* First three members of cvmx_bootmem_desc_t are left in original
|
||||
* positions for backwards compatibility.
|
||||
*/
|
||||
struct cvmx_bootmem_desc {
|
||||
/* spinlock to control access to list */
|
||||
uint32_t lock;
|
||||
/* flags for indicating various conditions */
|
||||
uint32_t flags;
|
||||
uint64_t head_addr;
|
||||
|
||||
/* Incremented when incompatible changes made */
|
||||
uint32_t major_version;
|
||||
|
||||
/*
|
||||
* Incremented changed when compatible changes made, reset to
|
||||
* zero when major incremented.
|
||||
*/
|
||||
uint32_t minor_version;
|
||||
|
||||
uint64_t app_data_addr;
|
||||
uint64_t app_data_size;
|
||||
|
||||
/* number of elements in named blocks array */
|
||||
uint32_t named_block_num_blocks;
|
||||
|
||||
/* length of name array in bootmem blocks */
|
||||
uint32_t named_block_name_len;
|
||||
/* address of named memory block descriptors */
|
||||
uint64_t named_block_array_addr;
|
||||
|
||||
};
|
||||
|
||||
/**
|
||||
* Initialize the boot alloc memory structures. This is
|
||||
* normally called inside of cvmx_user_app_init()
|
||||
*
|
||||
* @mem_desc_ptr: Address of the free memory list
|
||||
*/
|
||||
extern int cvmx_bootmem_init(void *mem_desc_ptr);
|
||||
|
||||
/**
|
||||
* Allocate a block of memory from the free list that was passed
|
||||
* to the application by the bootloader.
|
||||
* This is an allocate-only algorithm, so freeing memory is not possible.
|
||||
*
|
||||
* @size: Size in bytes of block to allocate
|
||||
* @alignment: Alignment required - must be power of 2
|
||||
*
|
||||
* Returns pointer to block of memory, NULL on error
|
||||
*/
|
||||
extern void *cvmx_bootmem_alloc(uint64_t size, uint64_t alignment);
|
||||
|
||||
/**
|
||||
* Allocate a block of memory from the free list that was
|
||||
* passed to the application by the bootloader at a specific
|
||||
* address. This is an allocate-only algorithm, so
|
||||
* freeing memory is not possible. Allocation will fail if
|
||||
* memory cannot be allocated at the specified address.
|
||||
*
|
||||
* @size: Size in bytes of block to allocate
|
||||
* @address: Physical address to allocate memory at. If this memory is not
|
||||
* available, the allocation fails.
|
||||
* @alignment: Alignment required - must be power of 2
|
||||
* Returns pointer to block of memory, NULL on error
|
||||
*/
|
||||
extern void *cvmx_bootmem_alloc_address(uint64_t size, uint64_t address,
|
||||
uint64_t alignment);
|
||||
|
||||
/**
|
||||
* Allocate a block of memory from the free list that was
|
||||
* passed to the application by the bootloader within a specified
|
||||
* address range. This is an allocate-only algorithm, so
|
||||
* freeing memory is not possible. Allocation will fail if
|
||||
* memory cannot be allocated in the requested range.
|
||||
*
|
||||
* @size: Size in bytes of block to allocate
|
||||
* @min_addr: defines the minimum address of the range
|
||||
* @max_addr: defines the maximum address of the range
|
||||
* @alignment: Alignment required - must be power of 2
|
||||
* Returns pointer to block of memory, NULL on error
|
||||
*/
|
||||
extern void *cvmx_bootmem_alloc_range(uint64_t size, uint64_t alignment,
|
||||
uint64_t min_addr, uint64_t max_addr);
|
||||
|
||||
/**
|
||||
* Frees a previously allocated named bootmem block.
|
||||
*
|
||||
* @name: name of block to free
|
||||
*
|
||||
* Returns 0 on failure,
|
||||
* !0 on success
|
||||
*/
|
||||
|
||||
|
||||
/**
|
||||
* Allocate a block of memory from the free list that was passed
|
||||
* to the application by the bootloader, and assign it a name in the
|
||||
* global named block table. (part of the cvmx_bootmem_descriptor_t structure)
|
||||
* Named blocks can later be freed.
|
||||
*
|
||||
* @size: Size in bytes of block to allocate
|
||||
* @alignment: Alignment required - must be power of 2
|
||||
* @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
|
||||
*
|
||||
* Returns a pointer to block of memory, NULL on error
|
||||
*/
|
||||
extern void *cvmx_bootmem_alloc_named(uint64_t size, uint64_t alignment,
|
||||
char *name);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Allocate a block of memory from the free list that was passed
|
||||
* to the application by the bootloader, and assign it a name in the
|
||||
* global named block table. (part of the cvmx_bootmem_descriptor_t structure)
|
||||
* Named blocks can later be freed.
|
||||
*
|
||||
* @size: Size in bytes of block to allocate
|
||||
* @address: Physical address to allocate memory at. If this
|
||||
* memory is not available, the allocation fails.
|
||||
* @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN
|
||||
* bytes
|
||||
*
|
||||
* Returns a pointer to block of memory, NULL on error
|
||||
*/
|
||||
extern void *cvmx_bootmem_alloc_named_address(uint64_t size, uint64_t address,
|
||||
char *name);
|
||||
|
||||
|
||||
|
||||
/**
|
||||
* Allocate a block of memory from a specific range of the free list
|
||||
* that was passed to the application by the bootloader, and assign it
|
||||
* a name in the global named block table. (part of the
|
||||
* cvmx_bootmem_descriptor_t structure) Named blocks can later be
|
||||
* freed. If request cannot be satisfied within the address range
|
||||
* specified, NULL is returned
|
||||
*
|
||||
* @size: Size in bytes of block to allocate
|
||||
* @min_addr: minimum address of range
|
||||
* @max_addr: maximum address of range
|
||||
* @align: Alignment of memory to be allocated. (must be a power of 2)
|
||||
* @name: name of block - must be less than CVMX_BOOTMEM_NAME_LEN bytes
|
||||
*
|
||||
* Returns a pointer to block of memory, NULL on error
|
||||
*/
|
||||
extern void *cvmx_bootmem_alloc_named_range(uint64_t size, uint64_t min_addr,
|
||||
uint64_t max_addr, uint64_t align,
|
||||
char *name);
|
||||
|
||||
extern int cvmx_bootmem_free_named(char *name);
|
||||
|
||||
/**
|
||||
* Finds a named bootmem block by name.
|
||||
*
|
||||
* @name: name of block to free
|
||||
*
|
||||
* Returns pointer to named block descriptor on success
|
||||
* 0 on failure
|
||||
*/
|
||||
struct cvmx_bootmem_named_block_desc *cvmx_bootmem_find_named_block(char *name);
|
||||
|
||||
/**
|
||||
* Allocates a block of physical memory from the free list, at
|
||||
* (optional) requested address and alignment.
|
||||
*
|
||||
* @req_size: size of region to allocate. All requests are rounded up
|
||||
* to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE bytes size
|
||||
*
|
||||
* @address_min: Minimum address that block can occupy.
|
||||
*
|
||||
* @address_max: Specifies the maximum address_min (inclusive) that
|
||||
* the allocation can use.
|
||||
*
|
||||
* @alignment: Requested alignment of the block. If this alignment
|
||||
* cannot be met, the allocation fails. This must be a
|
||||
* power of 2. (Note: Alignment of
|
||||
* CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and
|
||||
* internally enforced. Requested alignments of less than
|
||||
* CVMX_BOOTMEM_ALIGNMENT_SIZE are set to
|
||||
* CVMX_BOOTMEM_ALIGNMENT_SIZE.)
|
||||
*
|
||||
* @flags: Flags to control options for the allocation.
|
||||
*
|
||||
* Returns physical address of block allocated, or -1 on failure
|
||||
*/
|
||||
int64_t cvmx_bootmem_phy_alloc(uint64_t req_size, uint64_t address_min,
|
||||
uint64_t address_max, uint64_t alignment,
|
||||
uint32_t flags);
|
||||
|
||||
/**
|
||||
* Allocates a named block of physical memory from the free list, at
|
||||
* (optional) requested address and alignment.
|
||||
*
|
||||
* @param size size of region to allocate. All requests are rounded
|
||||
* up to be a multiple CVMX_BOOTMEM_ALIGNMENT_SIZE
|
||||
* bytes size
|
||||
* @param min_addr Minimum address that block can occupy.
|
||||
* @param max_addr Specifies the maximum address_min (inclusive) that
|
||||
* the allocation can use.
|
||||
* @param alignment Requested alignment of the block. If this
|
||||
* alignment cannot be met, the allocation fails.
|
||||
* This must be a power of 2. (Note: Alignment of
|
||||
* CVMX_BOOTMEM_ALIGNMENT_SIZE bytes is required, and
|
||||
* internally enforced. Requested alignments of less
|
||||
* than CVMX_BOOTMEM_ALIGNMENT_SIZE are set to
|
||||
* CVMX_BOOTMEM_ALIGNMENT_SIZE.)
|
||||
* @param name name to assign to named block
|
||||
* @param flags Flags to control options for the allocation.
|
||||
*
|
||||
* @return physical address of block allocated, or -1 on failure
|
||||
*/
|
||||
int64_t cvmx_bootmem_phy_named_block_alloc(uint64_t size, uint64_t min_addr,
|
||||
uint64_t max_addr,
|
||||
uint64_t alignment,
|
||||
char *name, uint32_t flags);
|
||||
|
||||
/**
|
||||
* Finds a named memory block by name.
|
||||
* Also used for finding an unused entry in the named block table.
|
||||
*
|
||||
* @name: Name of memory block to find. If NULL pointer given, then
|
||||
* finds unused descriptor, if available.
|
||||
*
|
||||
* @flags: Flags to control options for the allocation.
|
||||
*
|
||||
* Returns Pointer to memory block descriptor, NULL if not found.
|
||||
* If NULL returned when name parameter is NULL, then no memory
|
||||
* block descriptors are available.
|
||||
*/
|
||||
struct cvmx_bootmem_named_block_desc *
|
||||
cvmx_bootmem_phy_named_block_find(char *name, uint32_t flags);
|
||||
|
||||
/**
|
||||
* Frees a named block.
|
||||
*
|
||||
* @name: name of block to free
|
||||
* @flags: flags for passing options
|
||||
*
|
||||
* Returns 0 on failure
|
||||
* 1 on success
|
||||
*/
|
||||
int cvmx_bootmem_phy_named_block_free(char *name, uint32_t flags);
|
||||
|
||||
/**
|
||||
* Frees a block to the bootmem allocator list. This must
|
||||
* be used with care, as the size provided must match the size
|
||||
* of the block that was allocated, or the list will become
|
||||
* corrupted.
|
||||
*
|
||||
* IMPORTANT: This is only intended to be used as part of named block
|
||||
* frees and initial population of the free memory list.
|
||||
* *
|
||||
*
|
||||
* @phy_addr: physical address of block
|
||||
* @size: size of block in bytes.
|
||||
* @flags: flags for passing options
|
||||
*
|
||||
* Returns 1 on success,
|
||||
* 0 on failure
|
||||
*/
|
||||
int __cvmx_bootmem_phy_free(uint64_t phy_addr, uint64_t size, uint32_t flags);
|
||||
|
||||
/**
|
||||
* Locks the bootmem allocator. This is useful in certain situations
|
||||
* where multiple allocations must be made without being interrupted.
|
||||
* This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag.
|
||||
*
|
||||
*/
|
||||
void cvmx_bootmem_lock(void);
|
||||
|
||||
/**
|
||||
* Unlocks the bootmem allocator. This is useful in certain situations
|
||||
* where multiple allocations must be made without being interrupted.
|
||||
* This should be used with the CVMX_BOOTMEM_FLAG_NO_LOCKING flag.
|
||||
*
|
||||
*/
|
||||
void cvmx_bootmem_unlock(void);
|
||||
|
||||
extern struct cvmx_bootmem_desc *cvmx_bootmem_get_desc(void);
|
||||
|
||||
#endif /* __CVMX_BOOTMEM_H__ */
|
||||
Loading…
Add table
Add a link
Reference in a new issue