frodovdr/satip-axe
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
ce99684df9
satip-axe/kernel/drivers/stm/mali/common/mali_kernel_mem_buddy.c
Jaroslav Kysela e9070cdc77 add idl4k kernel firmware version 1.13.0.105
2015-03-26 17:24:57 +01:00

1426 lines
48 KiB
C
Raw Blame History

/*
* Copyright (C) 2010-2011 ARM Limited. All rights reserved.
*
* This program is free software and is provided to you under the terms of the GNU General Public License version 2
* as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence.
*
* A copy of the licence is included with the program, and can also be obtained from Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include "mali_kernel_core.h"
#include "mali_kernel_subsystem.h"
#include "mali_kernel_mem.h"
#include "mali_kernel_descriptor_mapping.h"
#include "mali_kernel_session_manager.h"
/* kernel side OS functions and user-kernel interface */
#include "mali_osk.h"
#include "mali_osk_mali.h"
#include "mali_osk_list.h"
#include "mali_ukk.h"
#ifdef _MALI_OSK_SPECIFIC_INDIRECT_MMAP
#include "mali_osk_indir_mmap.h"
#endif
/**
* Minimum memory allocation size
*/
#define MIN_BLOCK_SIZE (1024*1024UL)
/**
* Per-session memory descriptor mapping table sizes
*/
#define MALI_MEM_DESCRIPTORS_INIT 64
#define MALI_MEM_DESCRIPTORS_MAX 4096
/**
* Enum uses to store multiple fields in one u32 to keep the memory block struct small
*/
enum MISC_SHIFT { MISC_SHIFT_FREE = 0, MISC_SHIFT_ORDER = 1, MISC_SHIFT_TOPLEVEL = 6 };
enum MISC_MASK { MISC_MASK_FREE = 0x01, MISC_MASK_ORDER = 0x1F, MISC_MASK_TOPLEVEL = 0x1F };
/* forward declaration of the block struct */
struct mali_memory_block;
/**
* Definition of memory bank type.
* Represents a memory bank (separate address space)
* Each bank keeps track of its block usage.
* A buddy system used to track the usage
*/
typedef struct mali_memory_bank
{
_mali_osk_list_t list; /* links multiple banks together */
_mali_osk_lock_t *lock;
u32 base_addr; /* Mali seen address of bank */
u32 cpu_usage_adjust; /* Adjustmen factor for what the CPU sees */
u32 size; /* the effective size */
u32 real_size; /* the real size of the bank, as given by to the subsystem */
int min_order;
int max_order;
struct mali_memory_block * blocklist;
_mali_osk_list_t *freelist;
_mali_osk_atomic_t num_active_allocations;
u32 used_for_flags;
u32 alloc_order; /**< Order in which the bank will be used for allocations */
const char *name; /**< Descriptive name of the bank */
} mali_memory_bank;
/**
* Definition of the memory block type
* Represents a memory block, which is the smallest memory unit operated on.
* A block keeps info about its mapping, if in use by a user process
*/
typedef struct mali_memory_block
{
_mali_osk_list_t link; /* used for freelist and process usage list*/
mali_memory_bank * bank; /* the bank it belongs to */
void __user * mapping; /* possible user space mapping of this block */
u32 misc; /* used while a block is free to track the number blocks it represents */
int descriptor;
u32 mmap_cookie; /**< necessary for interaction with _mali_ukk_mem_mmap/munmap */
} mali_memory_block;
/**
* Defintion of the type used to represent memory used by a session.
* Containts the head of the list of memory currently in use by a session.
*/
typedef struct memory_session
{
_mali_osk_lock_t *lock;
_mali_osk_list_t memory_head; /* List of the memory blocks used by this session. */
mali_descriptor_mapping * descriptor_mapping; /**< Mapping between userspace descriptors and our pointers */
} memory_session;
/*
Subsystem interface implementation
*/
/**
* Buddy block memory subsystem startup function
* Called by the driver core when the driver is loaded.
* Registers the memory systems ioctl handler, resource handlers and memory map function with the core.
*
* @param id Identifier assigned by the core to the memory subsystem
* @return 0 on success, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_initialize(mali_kernel_subsystem_identifier id);
/**
* Buddy block memory subsystem shutdown function
* Called by the driver core when the driver is unloaded.
* Cleans up
* @param id Identifier assigned by the core to the memory subsystem
*/
static void mali_memory_core_terminate(mali_kernel_subsystem_identifier id);
/**
* Buddy block memory load complete notification function.
* Called by the driver core when all drivers have loaded and all resources has been registered
* Reports on the memory resources registered
* @param id Identifier assigned by the core to the memory subsystem
* @return 0 on success, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_load_complete(mali_kernel_subsystem_identifier id);
/**
* Buddy block memory subsystem session begin notification
* Called by the core when a new session to the driver is started.
* Creates a memory session object and sets it as the subsystem slot data for this session
* @param slot Pointer to the slot to use for storing per-session data
* @param queue The user space event sink
* @return 0 on success, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_session_begin(struct mali_session_data * mali_session_data, mali_kernel_subsystem_session_slot * slot, _mali_osk_notification_queue_t * queue);
/**
* Buddy block memory subsystem session end notification
* Called by the core when a session to the driver has ended.
* Cleans up per session data, which includes checking and fixing memory leaks
*
* @param slot Pointer to the slot to use for storing per-session data
*/
static void mali_memory_core_session_end(struct mali_session_data * mali_session_data, mali_kernel_subsystem_session_slot * slot);
/**
* Buddy block memory subsystem system info filler
* Called by the core when a system info update is needed
* We fill in info about all the memory types we have
* @param info Pointer to system info struct to update
* @return 0 on success, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_system_info_fill(_mali_system_info* info);
/* our registered resource handlers */
/**
* Buddy block memory subsystem's notification handler for MEMORY resource instances.
* Registered with the core during startup.
* Called by the core for each memory bank described in the active architecture's config.h file.
* Requests memory region ownership and calls backend.
* @param resource The resource to handle (type MEMORY)
* @return 0 if the memory was claimed and accepted, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_resource_memory(_mali_osk_resource_t * resource);
/**
* Buddy block memory subsystem's notification handler for MMU resource instances.
* Registered with the core during startup.
* Called by the core for each mmu described in the active architecture's config.h file.
* @param resource The resource to handle (type MMU)
* @return 0 if the MMU was found and initialized, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_resource_mmu(_mali_osk_resource_t * resource);
/**
* Buddy block memory subsystem's notification handler for FPGA_FRAMEWORK resource instances.
* Registered with the core during startup.
* Called by the core for each fpga framework described in the active architecture's config.h file.
* @param resource The resource to handle (type FPGA_FRAMEWORK)
* @return 0 if the FPGA framework was found and initialized, negative on error
*/
static _mali_osk_errcode_t mali_memory_core_resource_fpga(_mali_osk_resource_t * resource);
/* ioctl command implementations */
/**
* Buddy block memory subsystem's handler for MALI_IOC_MEM_GET_BIG_BLOCK ioctl
* Called by the generic ioctl handler when the MALI_IOC_MEM_GET_BIG_BLOCK command is received.
* Finds an available memory block and maps into the current process' address space.
* @param ukk_private private word for use by the User/Kernel interface
* @param session_data Pointer to the per-session object which will track the memory usage
* @param argument The argument from the user. A pointer to an struct mali_dd_get_big_block in user space
* @return Zero if successful, a standard Linux error value value on error (a negative value)
*/
_mali_osk_errcode_t _mali_ukk_get_big_block( _mali_uk_get_big_block_s *args );
/**
* Buddy block memory subsystem's handler for MALI_IOC_MEM_FREE_BIG_BLOCK ioctl
* Called by the generic ioctl handler when the MALI_IOC_MEM_FREE_BIG_BLOCK command is received.
* Unmaps the memory from the process' address space and marks the block as free.
* @param session_data Pointer to the per-session object which tracks the memory usage
* @param argument The argument from the user. A pointer to an struct mali_dd_get_big_block in user space
* @return Zero if successful, a standard Linux error value value on error (a negative value)
*/
/* this static version allows us to make use of it while holding the memory_session lock.
* This is required for the session_end code */
static _mali_osk_errcode_t _mali_ukk_free_big_block_internal( struct mali_session_data * mali_session_data, memory_session * session_data, _mali_uk_free_big_block_s *args);
_mali_osk_errcode_t _mali_ukk_free_big_block( _mali_uk_free_big_block_s *args );
/**
* Buddy block memory subsystem's memory bank registration routine
* Called when a MEMORY resource has been found.
* The memory region has already been reserved for use by this driver.
* Create a bank object to represent this region and initialize its slots.
* @note Can only be called in an module atomic scope, i.e. during module init since no locking is performed
* @param phys_base Physical base address of this bank
* @param cpu_usage_adjust Adjustment factor for CPU seen address
* @param size Size of the bank in bytes
* @param flags Memory type bits
* @param alloc_order Order in which the bank will be used for allocations
* @param name descriptive name of the bank
* @return Zero on success, negative on error
*/
static int mali_memory_bank_register(u32 phys_base, u32 cpu_usage_adjust, u32 size, u32 flags, u32 alloc_order, const char *name);
/**
* Get a block of mali memory of at least the given size and of the given type
* This is the backend for get_big_block.
* @param type_id The type id of memory requested.
* @param minimum_size The size requested
* @return Pointer to a block on success, NULL on failure
*/
static mali_memory_block * mali_memory_block_get(u32 type_id, u32 minimum_size);
/**
* Get the mali seen address of the memory described by the block
* @param block The memory block to return the address of
* @return The mali seen address of the memory block
*/
MALI_STATIC_INLINE u32 block_mali_addr_get(mali_memory_block * block);
/**
* Get the cpu seen address of the memory described by the block
* The cpu_usage_adjust will be used to change the mali seen phys address
* @param block The memory block to return the address of
* @return The mali seen address of the memory block
*/
MALI_STATIC_INLINE u32 block_cpu_addr_get(mali_memory_block * block);
/**
* Get the size of the memory described by the given block
* @param block The memory block to return the size of
* @return The size of the memory block described by the object
*/
MALI_STATIC_INLINE u32 block_size_get(mali_memory_block * block);
/**
* Get the user space accessible mapping the memory described by the given memory block
* Returns a pointer in user space to the memory, if one has been created.
* @param block The memory block to return the mapping of
* @return User space pointer to cpu accessible memory or NULL if not mapped
*/
MALI_STATIC_INLINE void __user * block_mapping_get(mali_memory_block * block);
/**
* Set the user space accessible mapping the memory described by the given memory block.
* Sets the stored pointer to user space for the memory described by this block.
* @param block The memory block to set mapping info for
* @param ptr User space pointer to cpu accessible memory or NULL if not mapped
*/
MALI_STATIC_INLINE void block_mapping_set(mali_memory_block * block, void __user * ptr);
/**
* Get the cookie for use with _mali_ukk_mem_munmap().
* @param block The memory block to get the cookie from
* @return the cookie. A return of 0 is still a valid cookie.
*/
MALI_STATIC_INLINE u32 block_mmap_cookie_get(mali_memory_block * block);
/**
* Set the cookie returned via _mali_ukk_mem_mmap().
* @param block The memory block to set the cookie for
* @param cookie the cookie
*/
MALI_STATIC_INLINE void block_mmap_cookie_set(mali_memory_block * block, u32 cookie);
/**
* Get a memory block's free status
* @param block The block to get the state of
*/
MALI_STATIC_INLINE u32 get_block_free(mali_memory_block * block);
/**
* Set a memory block's free status
* @param block The block to set the state for
* @param state The state to set
*/
MALI_STATIC_INLINE void set_block_free(mali_memory_block * block, int state);
/**
* Set a memory block's order
* @param block The block to set the order for
* @param order The order to set
*/
MALI_STATIC_INLINE void set_block_order(mali_memory_block * block, u32 order);
/**
* Get a memory block's order
* @param block The block to get the order for
* @return The order this block exists on
*/
MALI_STATIC_INLINE u32 get_block_order(mali_memory_block * block);
/**
* Tag a block as being a toplevel block.
* A toplevel block has no buddy and no parent
* @param block The block to tag as being toplevel
*/
MALI_STATIC_INLINE void set_block_toplevel(mali_memory_block * block, u32 level);
/**
* Check if a block is a toplevel block
* @param block The block to check
* @return 1 if toplevel, 0 else
*/
MALI_STATIC_INLINE u32 get_block_toplevel(mali_memory_block * block);
/**
* Checks if the given block is a buddy at the given order and that it's free
* @param block The block to check
* @param order The order to check against
* @return 0 if not valid, else 1
*/
MALI_STATIC_INLINE int block_is_valid_buddy(mali_memory_block * block, int order);
/*
The buddy system uses the following rules to quickly find a blocks buddy
and parent (block representing this block at a higher order level):
- Given a block with index i the blocks buddy is at index i ^ ( 1 << order)
- Given a block with index i the blocks parent is at i & ~(1 << order)
*/
/**
* Get a blocks buddy
* @param block The block to find the buddy for
* @param order The order to operate on
* @return Pointer to the buddy block
*/
MALI_STATIC_INLINE mali_memory_block * block_get_buddy(mali_memory_block * block, u32 order);
/**
* Get a blocks parent
* @param block The block to find the parent for
* @param order The order to operate on
* @return Pointer to the parent block
*/
MALI_STATIC_INLINE mali_memory_block * block_get_parent(mali_memory_block * block, u32 order);
/**
* Release mali memory
* Backend for free_big_block.
* Will release the mali memory described by the given block struct.
* @param block Memory block to free
*/
static void block_release(mali_memory_block * block);
/* end interface implementation */
/**
* List of all the memory banks registerd with the subsystem.
* Access to this list is NOT synchronized since it's only
* written to during module init and termination.
*/
static _MALI_OSK_LIST_HEAD(memory_banks_list);
/*
The buddy memory system's mali subsystem interface implementation.
We currently handle module and session life-time management.
*/
struct mali_kernel_subsystem mali_subsystem_memory =
{
mali_memory_core_initialize, /* startup */
mali_memory_core_terminate, /* shutdown */
mali_memory_core_load_complete, /* load_complete */
mali_memory_core_system_info_fill, /* system_info_fill */
mali_memory_core_session_begin, /* session_begin */
mali_memory_core_session_end, /* session_end */
NULL, /* broadcast_notification */
#if MALI_STATE_TRACKING
NULL, /* dump_state */
#endif
};
/* Initialized when this subsystem is initialized. This is determined by the
* position in subsystems[], and so the value used to initialize this is
* determined at compile time */
static mali_kernel_subsystem_identifier mali_subsystem_memory_id = -1;
/* called during module init */
static _mali_osk_errcode_t mali_memory_core_initialize(mali_kernel_subsystem_identifier id)
{
_MALI_OSK_INIT_LIST_HEAD(&memory_banks_list);
mali_subsystem_memory_id = id;
/* register our handlers */
MALI_CHECK_NO_ERROR(_mali_kernel_core_register_resource_handler(MEMORY, mali_memory_core_resource_memory));
MALI_CHECK_NO_ERROR(_mali_kernel_core_register_resource_handler(MMU, mali_memory_core_resource_mmu));
MALI_CHECK_NO_ERROR(_mali_kernel_core_register_resource_handler(FPGA_FRAMEWORK, mali_memory_core_resource_fpga));
MALI_SUCCESS;
}
/* called if/when our module is unloaded */
static void mali_memory_core_terminate(mali_kernel_subsystem_identifier id)
{
mali_memory_bank * bank, *temp;
/* loop over all memory banks to free them */
/* we use the safe version since we delete the current bank in the body */
_MALI_OSK_LIST_FOREACHENTRY(bank, temp, &memory_banks_list, mali_memory_bank, list)
{
MALI_DEBUG_CODE(int usage_count = _mali_osk_atomic_read(&bank->num_active_allocations));
/*
Report leaked memory
If this happens we have a bug in our session cleanup code.
*/
MALI_DEBUG_PRINT_IF(1, 0 != usage_count, ("%d allocation(s) from memory bank at 0x%X still in use\n", usage_count, bank->base_addr));
_mali_osk_atomic_term(&bank->num_active_allocations);
_mali_osk_lock_term(bank->lock);
/* unlink from bank list */
_mali_osk_list_del(&bank->list);
/* release kernel resources used by the bank */
_mali_osk_mem_unreqregion(bank->base_addr, bank->real_size);
/* remove all resources used to represent this bank*/
_mali_osk_free(bank->freelist);
_mali_osk_free(bank->blocklist);
/* destroy the bank object itself */
_mali_osk_free(bank);
}
/* No need to de-initialize mali_subsystem_memory_id - it could only be
* re-initialized to the same value */
}
/* load_complete handler */
static _mali_osk_errcode_t mali_memory_core_load_complete(mali_kernel_subsystem_identifier id)
{
mali_memory_bank * bank, *temp;
MALI_DEBUG_PRINT( 1, ("Mali memory allocators will be used in this order of preference (lowest number first) :\n"));
_MALI_OSK_LIST_FOREACHENTRY(bank, temp, &memory_banks_list, mali_memory_bank, list)
{
if ( NULL != bank->name )
{
MALI_DEBUG_PRINT( 1, ("\t%d: %s\n", bank->alloc_order, bank->name) );
}
else
{
MALI_DEBUG_PRINT( 1, ("\t%d: (UNNAMED ALLOCATOR)\n", bank->alloc_order ) );
}
}
MALI_SUCCESS;
}
MALI_STATIC_INLINE u32 order_needed_for_size(u32 size, struct mali_memory_bank * bank)
{
u32 order = 0;
if (0 < size)
{
for ( order = sizeof(u32)*8 - 1; ((1UL<<order) & size) == 0; --order)
/* nothing */;
/* check if size is pow2, if not we need increment order by one */
if (0 != (size & ((1UL<<order)-1))) ++order;
}
if ((NULL != bank) && (order < bank->min_order)) order = bank->min_order;
/* Not capped to max order, that doesn't make sense */
return order;
}
MALI_STATIC_INLINE u32 maximum_order_which_fits(u32 size)
{
u32 order = 0;
u32 powsize = 1;
while (powsize < size)
{
powsize <<= 1;
if (powsize > size) break;
order++;
}
return order;
}
/* called for new MEMORY resources */
static _mali_osk_errcode_t mali_memory_bank_register(u32 phys_base, u32 cpu_usage_adjust, u32 size, u32 flags, u32 alloc_order, const char *name)
{
/* no locking performed due to function contract */
int i;
u32 left, offset;
mali_memory_bank * bank;
mali_memory_bank * bank_enum, *temp;
_mali_osk_errcode_t err;
/* Only a multiple of MIN_BLOCK_SIZE is usable */
u32 usable_size = size & ~(MIN_BLOCK_SIZE - 1);
/* handle zero sized banks and bank smaller than the fixed block size */
if (0 == usable_size)
{
MALI_PRINT(("Usable size == 0\n"));
MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS);
}
/* warn for banks not a muliple of the block size */
MALI_DEBUG_PRINT_IF(1, usable_size != size, ("Memory bank @ 0x%X not a multiple of minimum block size. %d bytes wasted\n", phys_base, size - usable_size));
/* check against previous registrations */
MALI_DEBUG_CODE(
{
_MALI_OSK_LIST_FOREACHENTRY(bank, temp, &memory_banks_list, mali_memory_bank, list)
{
/* duplicate ? */
if (bank->base_addr == phys_base)
{
MALI_PRINT(("Duplicate registration of a memory bank at 0x%X detected\n", phys_base));
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
/* overlapping ? */
else if (
( (phys_base > bank->base_addr) && (phys_base < (bank->base_addr + bank->real_size)) ) ||
( (phys_base + size) > bank->base_addr && ((phys_base + size) < (bank->base_addr + bank->real_size)) )
)
{
MALI_PRINT(("Overlapping memory blocks found. Memory at 0x%X overlaps with memory at 0x%X size 0x%X\n", bank->base_addr, phys_base, size));
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
}
}
);
/* create an object to represent this memory bank */
MALI_CHECK_NON_NULL(bank = (mali_memory_bank*)_mali_osk_malloc(sizeof(mali_memory_bank)), _MALI_OSK_ERR_NOMEM);
/* init the fields */
_MALI_OSK_INIT_LIST_HEAD(&bank->list);
bank->base_addr = phys_base;
bank->cpu_usage_adjust = cpu_usage_adjust;
bank->size = usable_size;
bank->real_size = size;
bank->alloc_order = alloc_order;
bank->name = name;
err = _mali_osk_atomic_init(&bank->num_active_allocations, 0);
if (err != _MALI_OSK_ERR_OK)
{
_mali_osk_free(bank);
MALI_ERROR(err);
}
bank->used_for_flags = flags;
bank->min_order = order_needed_for_size(MIN_BLOCK_SIZE, NULL);
bank->max_order = maximum_order_which_fits(usable_size);
bank->lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_SPINLOCK | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE), 0, 0);
if (NULL == bank->lock)
{
_mali_osk_atomic_term(&bank->num_active_allocations);
_mali_osk_free(bank);
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
bank->blocklist = _mali_osk_calloc(1, sizeof(struct mali_memory_block) * (usable_size / MIN_BLOCK_SIZE));
if (NULL == bank->blocklist)
{
_mali_osk_lock_term(bank->lock);
_mali_osk_atomic_term(&bank->num_active_allocations);
_mali_osk_free(bank);
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
for (i = 0; i < (usable_size / MIN_BLOCK_SIZE); i++)
{
bank->blocklist[i].bank = bank;
}
bank->freelist = _mali_osk_calloc(1, sizeof(_mali_osk_list_t) * (bank->max_order - bank->min_order + 1));
if (NULL == bank->freelist)
{
_mali_osk_lock_term(bank->lock);
_mali_osk_free(bank->blocklist);
_mali_osk_atomic_term(&bank->num_active_allocations);
_mali_osk_free(bank);
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
for (i = 0; i < (bank->max_order - bank->min_order + 1); i++) _MALI_OSK_INIT_LIST_HEAD(&bank->freelist[i]);
/* init slot info */
for (offset = 0, left = usable_size; offset < (usable_size / MIN_BLOCK_SIZE); /* updated inside the body */)
{
u32 block_order;
mali_memory_block * block;
/* the maximum order which fits in the remaining area */
block_order = maximum_order_which_fits(left);
/* find the block pointer */
block = &bank->blocklist[offset];
/* tag the block as being toplevel */
set_block_toplevel(block, block_order);
/* tag it as being free */
set_block_free(block, 1);
/* set the order */
set_block_order(block, block_order);
_mali_osk_list_addtail(&block->link, bank->freelist + (block_order - bank->min_order));
left -= (1 << block_order);
offset += ((1 << block_order) / MIN_BLOCK_SIZE);
}
/* add bank to list of banks on the system */
_MALI_OSK_LIST_FOREACHENTRY( bank_enum, temp, &memory_banks_list, mali_memory_bank, list )
{
if ( bank_enum->alloc_order >= alloc_order )
{
/* Found insertion point - our item must go before this one */
break;
}
}
_mali_osk_list_addtail(&bank->list, &bank_enum->list);
MALI_SUCCESS;
}
_mali_osk_errcode_t mali_memory_mmu_register(u32 type, u32 phys_base)
{
/* not supported */
return _MALI_OSK_ERR_INVALID_FUNC;
}
void mali_memory_mmu_unregister(u32 phys_base)
{
/* not supported */
return;
}
static mali_memory_block * mali_memory_block_get(u32 type_id, u32 minimum_size)
{
mali_memory_bank * bank;
mali_memory_block * block = NULL;
u32 requested_order, current_order;
/* input validation */
if (0 == minimum_size)
{
/* bad size */
MALI_DEBUG_PRINT(2, ("Zero size block requested by mali_memory_block_get\n"));
return NULL;
}
bank = (mali_memory_bank*)type_id;
requested_order = order_needed_for_size(minimum_size, bank);
MALI_DEBUG_PRINT(4, ("For size %d we need order %d (%d)\n", minimum_size, requested_order, 1 << requested_order));
_mali_osk_lock_wait(bank->lock, _MALI_OSK_LOCKMODE_RW);
/* ! critical section begin */
MALI_DEBUG_PRINT(7, ("Bank 0x%x locked\n", bank));
for (current_order = requested_order; current_order <= bank->max_order; ++current_order)
{
_mali_osk_list_t * list = bank->freelist + (current_order - bank->min_order);
MALI_DEBUG_PRINT(7, ("Checking freelist 0x%x for order %d\n", list, current_order));
if (0 != _mali_osk_list_empty(list)) continue; /* empty list */
MALI_DEBUG_PRINT(7, ("Found an entry on the freelist for order %d\n", current_order));
block = _MALI_OSK_LIST_ENTRY(list->next, mali_memory_block, link);
_mali_osk_list_delinit(&block->link);
while (current_order > requested_order)
{
mali_memory_block * buddy_block;
MALI_DEBUG_PRINT(7, ("Splitting block 0x%x\n", block));
current_order--;
list--;
buddy_block = block_get_buddy(block, current_order - bank->min_order);
set_block_order(buddy_block, current_order);
set_block_free(buddy_block, 1);
_mali_osk_list_add(&buddy_block->link, list);
}
set_block_order(block, current_order);
set_block_free(block, 0);
/* update usage count */
_mali_osk_atomic_inc(&bank->num_active_allocations);
break;
}
/* ! critical section end */
_mali_osk_lock_signal(bank->lock, _MALI_OSK_LOCKMODE_RW);
MALI_DEBUG_PRINT(7, ("Lock released for bank 0x%x\n", bank));
MALI_DEBUG_PRINT_IF(7, NULL != block, ("Block 0x%x allocated\n", block));
return block;
}
static void block_release(mali_memory_block * block)
{
mali_memory_bank * bank;
u32 current_order;
if (NULL == block) return;
bank = block->bank;
/* we're manipulating the free list, so we need to lock it */
_mali_osk_lock_wait(bank->lock, _MALI_OSK_LOCKMODE_RW);
/* ! critical section begin */
set_block_free(block, 1);
current_order = get_block_order(block);
while (current_order <= bank->max_order)
{
mali_memory_block * buddy_block;
buddy_block = block_get_buddy(block, current_order - bank->min_order);
if (!block_is_valid_buddy(buddy_block, current_order)) break;
_mali_osk_list_delinit(&buddy_block->link); /* remove from free list */
/* clear tracked data in both blocks */
set_block_order(block, 0);
set_block_free(block, 0);
set_block_order(buddy_block, 0);
set_block_free(buddy_block, 0);
/* make the parent control the new state */
block = block_get_parent(block, current_order - bank->min_order);
set_block_order(block, current_order + 1); /* merged has a higher order */
set_block_free(block, 1); /* mark it as free */
current_order++;
if (get_block_toplevel(block) == current_order) break; /* stop the merge if we've arrived at a toplevel block */
}
_mali_osk_list_add(&block->link, &bank->freelist[current_order - bank->min_order]);
/* update bank usage statistics */
_mali_osk_atomic_dec(&block->bank->num_active_allocations);
/* !critical section end */
_mali_osk_lock_signal(bank->lock, _MALI_OSK_LOCKMODE_RW);
return;
}
MALI_STATIC_INLINE u32 block_get_offset(mali_memory_block * block)
{
return block - block->bank->blocklist;
}
MALI_STATIC_INLINE u32 block_mali_addr_get(mali_memory_block * block)
{
if (NULL != block) return block->bank->base_addr + MIN_BLOCK_SIZE * block_get_offset(block);
else return 0;
}
MALI_STATIC_INLINE u32 block_cpu_addr_get(mali_memory_block * block)
{
if (NULL != block) return (block->bank->base_addr + MIN_BLOCK_SIZE * block_get_offset(block)) + block->bank->cpu_usage_adjust;
else return 0;
}
MALI_STATIC_INLINE u32 block_size_get(mali_memory_block * block)
{
if (NULL != block) return 1 << get_block_order(block);
else return 0;
}
MALI_STATIC_INLINE void __user * block_mapping_get(mali_memory_block * block)
{
if (NULL != block) return block->mapping;
else return NULL;
}
MALI_STATIC_INLINE void block_mapping_set(mali_memory_block * block, void __user * ptr)
{
if (NULL != block) block->mapping = ptr;
}
MALI_STATIC_INLINE u32 block_mmap_cookie_get(mali_memory_block * block)
{
if (NULL != block) return block->mmap_cookie;
else return 0;
}
/**
* Set the cookie returned via _mali_ukk_mem_mmap().
* @param block The memory block to set the cookie for
* @param cookie the cookie
*/
MALI_STATIC_INLINE void block_mmap_cookie_set(mali_memory_block * block, u32 cookie)
{
if (NULL != block) block->mmap_cookie = cookie;
}
static _mali_osk_errcode_t mali_memory_core_session_begin(struct mali_session_data * mali_session_data, mali_kernel_subsystem_session_slot * slot, _mali_osk_notification_queue_t * queue)
{
memory_session * session_data;
/* validate input */
if (NULL == slot)
{
MALI_DEBUG_PRINT(1, ("NULL slot given to memory session begin\n"));
MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS);
}
if (NULL != *slot)
{
MALI_DEBUG_PRINT(1, ("The slot given to memory session begin already contains data"));
MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS);
}
/* create the session data object */
MALI_CHECK_NON_NULL(session_data = _mali_osk_malloc(sizeof(memory_session)), _MALI_OSK_ERR_NOMEM);
/* create descriptor mapping table */
session_data->descriptor_mapping = mali_descriptor_mapping_create(MALI_MEM_DESCRIPTORS_INIT, MALI_MEM_DESCRIPTORS_MAX);
if (NULL == session_data->descriptor_mapping)
{
_mali_osk_free(session_data);
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
_MALI_OSK_INIT_LIST_HEAD(&session_data->memory_head); /* no memory in use */
session_data->lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_ONELOCK | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE), 0, 0);
if (NULL == session_data->lock)
{
_mali_osk_free(session_data);
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
*slot = session_data; /* slot will point to our data object */
MALI_SUCCESS;
}
static void mali_memory_core_session_end(struct mali_session_data * mali_session_data, mali_kernel_subsystem_session_slot * slot)
{
memory_session * session_data;
/* validate input */
if (NULL == slot)
{
MALI_DEBUG_PRINT(1, ("NULL slot given to memory session begin\n"));
return;
}
if (NULL == *slot)
{
MALI_DEBUG_PRINT(1, ("NULL memory_session found in current session object"));
return;
}
_mali_osk_lock_wait(((memory_session*)*slot)->lock, _MALI_OSK_LOCKMODE_RW);
session_data = (memory_session *)*slot;
/* clear our slot */
*slot = NULL;
/*
First free all memory still being used.
This can happen if the caller has leaked memory or
the application has crashed forcing an auto-session end.
*/
if (0 == _mali_osk_list_empty(&session_data->memory_head))
{
mali_memory_block * block, * temp;
MALI_DEBUG_PRINT(1, ("Memory found on session usage list during session termination\n"));
/* use the _safe version since fre_big_block removes the active block from the list we're iterating */
_MALI_OSK_LIST_FOREACHENTRY(block, temp, &session_data->memory_head, mali_memory_block, link)
{
_mali_osk_errcode_t err;
_mali_uk_free_big_block_s uk_args;
MALI_DEBUG_PRINT(4, ("Freeing block 0x%x with mali address 0x%x size %d mapped in user space at 0x%x\n",
block,
(void*)block_mali_addr_get(block),
block_size_get(block),
block_mapping_get(block))
);
/* free the block */
/** @note manual type safety check-point */
uk_args.ctx = mali_session_data;
uk_args.cookie = (u32)block->descriptor;
err = _mali_ukk_free_big_block_internal( mali_session_data, session_data, &uk_args );
if ( _MALI_OSK_ERR_OK != err )
{
MALI_DEBUG_PRINT_ERROR(("_mali_ukk_free_big_block_internal() failed during session termination on block with cookie==0x%X\n",
uk_args.cookie)
);
}
}
}
if (NULL != session_data->descriptor_mapping)
{
mali_descriptor_mapping_destroy(session_data->descriptor_mapping);
session_data->descriptor_mapping = NULL;
}
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
_mali_osk_lock_term(session_data->lock);
/* free the session data object */
_mali_osk_free(session_data);
return;
}
static _mali_osk_errcode_t mali_memory_core_system_info_fill(_mali_system_info* info)
{
mali_memory_bank * bank, *temp;
_mali_mem_info **mem_info_tail;
/* check input */
MALI_CHECK_NON_NULL(info, _MALI_OSK_ERR_INVALID_ARGS);
/* make sure we won't leak any memory. It could also be that it's an uninitialized variable, but that would be a bug in the caller */
MALI_DEBUG_ASSERT(NULL == info->mem_info);
mem_info_tail = &info->mem_info;
_MALI_OSK_LIST_FOREACHENTRY(bank, temp, &memory_banks_list, mali_memory_bank, list)
{
_mali_mem_info * mem_info;
mem_info = (_mali_mem_info *)_mali_osk_calloc(1, sizeof(_mali_mem_info));
if (NULL == mem_info) return _MALI_OSK_ERR_NOMEM; /* memory already allocated will be freed by the caller */
/* set info */
mem_info->size = bank->size;
mem_info->flags = (_mali_bus_usage)bank->used_for_flags;
mem_info->maximum_order_supported = bank->max_order;
mem_info->identifier = (u32)bank;
/* add to system info linked list */
(*mem_info_tail) = mem_info;
mem_info_tail = &mem_info->next;
}
/* all OK */
MALI_SUCCESS;
}
static _mali_osk_errcode_t mali_memory_core_resource_memory(_mali_osk_resource_t * resource)
{
_mali_osk_errcode_t err;
/* Request ownership of the memory */
if (_MALI_OSK_ERR_OK != _mali_osk_mem_reqregion(resource->base, resource->size, resource->description))
{
MALI_DEBUG_PRINT(1, ("Failed to request memory region %s (0x%08X - 0x%08X)\n", resource->description, resource->base, resource->base + resource->size - 1));
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
/* call backend */
err = mali_memory_bank_register(resource->base, resource->cpu_usage_adjust, resource->size, resource->flags, resource->alloc_order, resource->description);
if (_MALI_OSK_ERR_OK != err)
{
/* if backend refused the memory we have to release the region again */
MALI_DEBUG_PRINT(1, ("Memory bank registration failed\n"));
_mali_osk_mem_unreqregion(resource->base, resource->size);
MALI_ERROR(err);
}
MALI_SUCCESS;
}
static _mali_osk_errcode_t mali_memory_core_resource_mmu(_mali_osk_resource_t * resource)
{
/* Not supported by the fixed block memory system */
MALI_DEBUG_PRINT(1, ("MMU resource not supported by non-MMU driver!\n"));
MALI_ERROR(_MALI_OSK_ERR_INVALID_FUNC);
}
static _mali_osk_errcode_t mali_memory_core_resource_fpga(_mali_osk_resource_t * resource)
{
mali_io_address mapping;
MALI_DEBUG_PRINT(5, ("FPGA framework '%s' @ (0x%08X - 0x%08X)\n",
resource->description, resource->base, resource->base + sizeof(u32) * 2 - 1
));
mapping = _mali_osk_mem_mapioregion(resource->base + 0x1000, sizeof(u32) * 2, "fpga framework");
if (mapping)
{
u32 data;
data = _mali_osk_mem_ioread32(mapping, 0);
MALI_DEBUG_PRINT(2, ("FPGA framwork '%s' @ 0x%08X:\n", resource->description, resource->base));
MALI_DEBUG_PRINT(2, ("\tBitfile date: %d%02d%02d_%02d%02d\n",
(data >> 20),
(data >> 16) & 0xF,
(data >> 11) & 0x1F,
(data >> 6) & 0x1F,
(data >> 0) & 0x3F));
data = _mali_osk_mem_ioread32(mapping, sizeof(u32));
MALI_DEBUG_PRINT(2, ("\tBitfile SCCS rev: %d\n", data));
_mali_osk_mem_unmapioregion(resource->base + 0x1000, sizeof(u32) *2, mapping);
}
else MALI_DEBUG_PRINT(1, ("Failed to access FPGA framwork '%s' @ 0x%08X\n", resource->description, resource->base));
MALI_SUCCESS;
}
/* static _mali_osk_errcode_t get_big_block(void * ukk_private, struct mali_session_data * mali_session_data, void __user * argument) */
_mali_osk_errcode_t _mali_ukk_get_big_block( _mali_uk_get_big_block_s *args )
{
_mali_uk_mem_mmap_s args_mmap = {0, };
int md;
mali_memory_block * block;
_mali_osk_errcode_t err;
memory_session * session_data;
MALI_DEBUG_ASSERT_POINTER( args );
MALI_DEBUG_ASSERT_POINTER( args->ctx );
/** @note manual type safety check-point */
session_data = (memory_session *)mali_kernel_session_manager_slot_get(args->ctx, mali_subsystem_memory_id);
MALI_CHECK_NON_NULL(session_data, _MALI_OSK_ERR_INVALID_ARGS);
_mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
if (!args->type_id)
{
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
MALI_ERROR(_MALI_OSK_ERR_FAULT);
}
/* at least min block size */
if (MIN_BLOCK_SIZE > args->minimum_size_requested) args->minimum_size_requested = MIN_BLOCK_SIZE;
/* perform the actual allocation */
block = mali_memory_block_get(args->type_id, args->minimum_size_requested);
if ( NULL == block )
{
/* no memory available with requested type_id */
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
if (_MALI_OSK_ERR_OK != mali_descriptor_mapping_allocate_mapping(session_data->descriptor_mapping, block, &md))
{
block_release(block);
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
MALI_ERROR(_MALI_OSK_ERR_NOMEM);
}
block->descriptor = md;
/* fill in response */
args->mali_address = block_mali_addr_get(block);
args->block_size = block_size_get(block);
args->cookie = (u32)md;
args->flags = block->bank->used_for_flags;
/* map the block into the process' address space */
/** @note manual type safety check-point */
args_mmap.ukk_private = (void *)args->ukk_private;
args_mmap.ctx = args->ctx;
args_mmap.size = args->block_size;
args_mmap.phys_addr = block_cpu_addr_get(block);
#ifndef _MALI_OSK_SPECIFIC_INDIRECT_MMAP
err = _mali_ukk_mem_mmap( &args_mmap );
#else
err = _mali_osk_specific_indirect_mmap( &args_mmap );
#endif
/* check if the mapping failed */
if ( _MALI_OSK_ERR_OK != err )
{
MALI_DEBUG_PRINT(1, ("Memory mapping failed 0x%x\n", args->cpuptr));
/* mapping failed */
/* remove descriptor entry */
mali_descriptor_mapping_free(session_data->descriptor_mapping, md);
/* free the mali memory */
block_release(block);
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
return err;
}
args->cpuptr = args_mmap.mapping;
block_mmap_cookie_set(block, args_mmap.cookie);
block_mapping_set(block, args->cpuptr);
MALI_DEBUG_PRINT(2, ("Mali memory 0x%x (size %d) mapped in process memory space at 0x%x\n", (void*)args->mali_address, args->block_size, args->cpuptr));
/* track memory in use for the session */
_mali_osk_list_addtail(&block->link, &session_data->memory_head);
/* memory assigned to the session, memory mapped into the process' view */
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
MALI_SUCCESS;
}
/* Internal code that assumes the memory session lock is held */
static _mali_osk_errcode_t _mali_ukk_free_big_block_internal( struct mali_session_data * mali_session_data, memory_session * session_data, _mali_uk_free_big_block_s *args)
{
mali_memory_block * block = NULL;
_mali_osk_errcode_t err;
_mali_uk_mem_munmap_s args_munmap = {0,};
MALI_DEBUG_ASSERT_POINTER( mali_session_data );
MALI_DEBUG_ASSERT_POINTER( session_data );
MALI_DEBUG_ASSERT_POINTER( args );
err = mali_descriptor_mapping_get(session_data->descriptor_mapping, (int)args->cookie, (void**)&block);
if (_MALI_OSK_ERR_OK != err)
{
MALI_DEBUG_PRINT(1, ("Invalid memory descriptor %d used to release memory pages\n", (int)args->cookie));
MALI_ERROR(err);
}
MALI_DEBUG_ASSERT_POINTER(block);
MALI_DEBUG_PRINT(4, ("Asked to free block 0x%x with mali address 0x%x size %d mapped in user space at 0x%x\n",
block,
(void*)block_mali_addr_get(block),
block_size_get(block),
block_mapping_get(block))
);
/** @note manual type safety check-point */
args_munmap.ctx = (void*)mali_session_data;
args_munmap.mapping = block_mapping_get( block );
args_munmap.size = block_size_get( block );
args_munmap.cookie = block_mmap_cookie_get( block );
#ifndef _MALI_OSK_SPECIFIC_INDIRECT_MMAP
_mali_ukk_mem_munmap( &args_munmap );
#else
_mali_osk_specific_indirect_munmap( &args_munmap );
#endif
MALI_DEBUG_PRINT(6, ("Session data 0x%x, lock 0x%x\n", session_data, &session_data->lock));
/* unlink from session usage list */
MALI_DEBUG_PRINT(5, ("unlink from session usage list\n"));
_mali_osk_list_delinit(&block->link);
/* remove descriptor entry */
mali_descriptor_mapping_free(session_data->descriptor_mapping, (int)args->cookie);
/* free the mali memory */
block_release(block);
MALI_DEBUG_PRINT(5, ("Block freed\n"));
MALI_SUCCESS;
}
/* static _mali_osk_errcode_t free_big_block( struct mali_session_data * mali_session_data, void __user * argument) */
_mali_osk_errcode_t _mali_ukk_free_big_block( _mali_uk_free_big_block_s *args )
{
_mali_osk_errcode_t err;
struct mali_session_data * mali_session_data;
memory_session * session_data;
MALI_DEBUG_ASSERT_POINTER( args );
MALI_DEBUG_ASSERT_POINTER( args->ctx );
/** @note manual type safety check-point */
mali_session_data = (struct mali_session_data *)args->ctx;
/* Must always verify this, since these are provided by the user */
MALI_CHECK_NON_NULL(mali_session_data, _MALI_OSK_ERR_INVALID_ARGS);
session_data = mali_kernel_session_manager_slot_get(mali_session_data, mali_subsystem_memory_id);
MALI_CHECK_NON_NULL(session_data, _MALI_OSK_ERR_INVALID_ARGS);
_mali_osk_lock_wait(session_data->lock, _MALI_OSK_LOCKMODE_RW);
/** @note this has been separated out so that the session_end handler can call this while it has the memory_session lock held */
err = _mali_ukk_free_big_block_internal( mali_session_data, session_data, args );
_mali_osk_lock_signal(session_data->lock, _MALI_OSK_LOCKMODE_RW);
return err;
}
MALI_STATIC_INLINE u32 get_block_free(mali_memory_block * block)
{
return (block->misc >> MISC_SHIFT_FREE) & MISC_MASK_FREE;
}
MALI_STATIC_INLINE void set_block_free(mali_memory_block * block, int state)
{
if (state) block->misc |= (MISC_MASK_FREE << MISC_SHIFT_FREE);
else block->misc &= ~(MISC_MASK_FREE << MISC_SHIFT_FREE);
}
MALI_STATIC_INLINE void set_block_order(mali_memory_block * block, u32 order)
{
block->misc &= ~(MISC_MASK_ORDER << MISC_SHIFT_ORDER);
block->misc |= ((order & MISC_MASK_ORDER) << MISC_SHIFT_ORDER);
}
MALI_STATIC_INLINE u32 get_block_order(mali_memory_block * block)
{
return (block->misc >> MISC_SHIFT_ORDER) & MISC_MASK_ORDER;
}
MALI_STATIC_INLINE void set_block_toplevel(mali_memory_block * block, u32 level)
{
block->misc |= ((level & MISC_MASK_TOPLEVEL) << MISC_SHIFT_TOPLEVEL);
}
MALI_STATIC_INLINE u32 get_block_toplevel(mali_memory_block * block)
{
return (block->misc >> MISC_SHIFT_TOPLEVEL) & MISC_MASK_TOPLEVEL;
}
MALI_STATIC_INLINE int block_is_valid_buddy(mali_memory_block * block, int order)
{
if (get_block_free(block) && (get_block_order(block) == order)) return 1;
else return 0;
}
MALI_STATIC_INLINE mali_memory_block * block_get_buddy(mali_memory_block * block, u32 order)
{
return block + ( (block_get_offset(block) ^ (1 << order)) - block_get_offset(block));
}
MALI_STATIC_INLINE mali_memory_block * block_get_parent(mali_memory_block * block, u32 order)
{
return block + ((block_get_offset(block) & ~(1 << order)) - block_get_offset(block));
}
/* This handler registered to mali_mmap for non-MMU builds */
_mali_osk_errcode_t _mali_ukk_mem_mmap( _mali_uk_mem_mmap_s *args )
{
_mali_osk_errcode_t ret;
struct mali_session_data * mali_session_data;
mali_memory_allocation * descriptor;
memory_session * session_data;
/* validate input */
if (NULL == args) { MALI_DEBUG_PRINT(3,("mali_ukk_mem_mmap: args was NULL\n")); MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS); }
/* Unpack arguments */
mali_session_data = (struct mali_session_data *)args->ctx;
if (NULL == mali_session_data) { MALI_DEBUG_PRINT(3,("mali_ukk_mem_mmap: mali_session data was NULL\n")); MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS); }
MALI_DEBUG_ASSERT( mali_subsystem_memory_id >= 0 );
session_data = mali_kernel_session_manager_slot_get(mali_session_data, mali_subsystem_memory_id);
/* validate input */
if (NULL == session_data) { MALI_DEBUG_PRINT(3,("mali_ukk_mem_mmap: session data was NULL\n")); MALI_ERROR(_MALI_OSK_ERR_FAULT); }
descriptor = (mali_memory_allocation*) _mali_osk_calloc( 1, sizeof(mali_memory_allocation) );
if (NULL == descriptor) { MALI_DEBUG_PRINT(3,("mali_ukk_mem_mmap: descriptor was NULL\n")); MALI_ERROR(_MALI_OSK_ERR_NOMEM); }
descriptor->size = args->size;
descriptor->mali_address = args->phys_addr;
descriptor->mali_addr_mapping_info = (void*)session_data;
descriptor->process_addr_mapping_info = args->ukk_private; /* save to be used during physical manager callback */
descriptor->flags = MALI_MEMORY_ALLOCATION_FLAG_MAP_INTO_USERSPACE;
ret = _mali_osk_mem_mapregion_init( descriptor );
if ( _MALI_OSK_ERR_OK != ret )
{
MALI_DEBUG_PRINT(3, ("_mali_osk_mem_mapregion_init() failed\n"));
_mali_osk_free(descriptor);
MALI_ERROR(ret);
}
ret = _mali_osk_mem_mapregion_map( descriptor, 0, &descriptor->mali_address, descriptor->size );
if ( _MALI_OSK_ERR_OK != ret )
{
MALI_DEBUG_PRINT(3, ("_mali_osk_mem_mapregion_map() failed\n"));
_mali_osk_mem_mapregion_term( descriptor );
_mali_osk_free(descriptor);
MALI_ERROR(ret);
}
args->mapping = descriptor->mapping;
/**
* @note we do not require use of mali_descriptor_mapping here:
* the cookie gets stored in the mali_memory_block struct, which itself is
* protected by mali_descriptor_mapping, and so this cookie never leaves
* kernel space (on any OS).
*
* In the MMU case, we must use a mali_descriptor_mapping, since on _some_
* OSs, the cookie leaves kernel space.
*/
args->cookie = (u32)descriptor;
MALI_SUCCESS;
}
/* This handler registered to mali_munmap for non-MMU builds */
_mali_osk_errcode_t _mali_ukk_mem_munmap( _mali_uk_mem_munmap_s *args )
{
mali_memory_allocation * descriptor;
/** see note in _mali_ukk_mem_mmap() - no need to use descriptor mapping */
descriptor = (mali_memory_allocation *)args->cookie;
MALI_DEBUG_ASSERT_POINTER(descriptor);
/* args->mapping and args->size are also discarded. They are only necessary for certain do_munmap implementations. However, they could be used to check the descriptor at this point. */
_mali_osk_mem_mapregion_unmap( descriptor, 0, descriptor->size, (_mali_osk_mem_mapregion_flags_t)0 );
_mali_osk_mem_mapregion_term( descriptor );
_mali_osk_free(descriptor);
return _MALI_OSK_ERR_OK;
}
/**
* Stub function to satisfy UDD interface exclusion requirement.
* This is because the Base code compiles in \b both MMU and non-MMU calls,
* so both sets must be declared (but the 'unused' set may be stub)
*/
_mali_osk_errcode_t _mali_ukk_init_mem( _mali_uk_init_mem_s *args )
{
MALI_IGNORE( args );
return _MALI_OSK_ERR_FAULT;
}
/**
* Stub function to satisfy UDD interface exclusion requirement.
* This is because the Base code compiles in \b both MMU and non-MMU calls,
* so both sets must be declared (but the 'unused' set may be stub)
*/
_mali_osk_errcode_t _mali_ukk_term_mem( _mali_uk_term_mem_s *args )
{
MALI_IGNORE( args );
return _MALI_OSK_ERR_FAULT;
}
/**
* Stub function to satisfy UDD interface exclusion requirement.
* This is because the Base code compiles in \b both MMU and non-MMU calls,
* so both sets must be declared (but the 'unused' set may be stub)
*/
_mali_osk_errcode_t _mali_ukk_map_external_mem( _mali_uk_map_external_mem_s *args )
{
MALI_IGNORE( args );
return _MALI_OSK_ERR_FAULT;
}
/**
* Stub function to satisfy UDD interface exclusion requirement.
* This is because the Base code compiles in \b both MMU and non-MMU calls,
* so both sets must be declared (but the 'unused' set may be stub)
*/
_mali_osk_errcode_t _mali_ukk_unmap_external_mem( _mali_uk_unmap_external_mem_s *args )
{
MALI_IGNORE( args );
return _MALI_OSK_ERR_FAULT;
}
/**
* Stub function to satisfy UDD interface exclusion requirement.
* This is because the Base code compiles in \b both MMU and non-MMU calls,
* so both sets must be declared (but the 'unused' set may be stub)
*/
_mali_osk_errcode_t _mali_ukk_query_mmu_page_table_dump_size( _mali_uk_query_mmu_page_table_dump_size_s *args )
{
MALI_IGNORE( args );
return _MALI_OSK_ERR_FAULT;
}
/**
* Stub function to satisfy UDD interface exclusion requirement.
* This is because the Base code compiles in \b both MMU and non-MMU calls,
* so both sets must be declared (but the 'unused' set may be stub)
*/
_mali_osk_errcode_t _mali_ukk_dump_mmu_page_table( _mali_uk_dump_mmu_page_table_s * args )
{
MALI_IGNORE( args );
return _MALI_OSK_ERR_FAULT;
}
Reference in New Issue View Git Blame Copy Permalink