diff options
Diffstat (limited to 'drivers/gpu/mali/mali400ko/driver/src/devicedrv/mali/common/mali_kernel_mem_buddy.c')
| -rw-r--r-- | drivers/gpu/mali/mali400ko/driver/src/devicedrv/mali/common/mali_kernel_mem_buddy.c | 1425 |
1 files changed, 1425 insertions, 0 deletions
diff --git a/drivers/gpu/mali/mali400ko/driver/src/devicedrv/mali/common/mali_kernel_mem_buddy.c b/drivers/gpu/mali/mali400ko/driver/src/devicedrv/mali/common/mali_kernel_mem_buddy.c new file mode 100644 index 00000000000..8277fd1e1c6 --- /dev/null +++ b/drivers/gpu/mali/mali400ko/driver/src/devicedrv/mali/common/mali_kernel_mem_buddy.c @@ -0,0 +1,1425 @@ +/* + * 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; +} |