/**
* function@_mali_ukk_mem_allocate - allocate mali memory
*/
_mali_osk_errcode_t _mali_ukk_mem_allocate(_mali_uk_alloc_mem_s *args)
{
struct mali_session_data *session = (struct mali_session_data *)(uintptr_t)args->ctx;
mali_mem_backend *mem_backend = NULL;
_mali_osk_errcode_t ret = _MALI_OSK_ERR_FAULT;
int retval = 0;
mali_mem_allocation *mali_allocation = NULL;
struct mali_vma_node *mali_vma_node = NULL;
MALI_DEBUG_PRINT(4, (" _mali_ukk_mem_allocate, vaddr=0x%x, size =0x%x! \n", args->gpu_vaddr, args->psize));
/* Check if the address is allocated
* Can we trust User mode?
*/
mali_vma_node = mali_vma_offset_search(&session->allocation_mgr, args->gpu_vaddr, 0);
if (unlikely(mali_vma_node)) {
/* Not support yet */
MALI_DEBUG_ASSERT(0);
return _MALI_OSK_ERR_FAULT;
}
/**
*create mali memory allocation
*/
mali_allocation = mali_mem_allocation_struct_create(session);
if (mali_allocation == NULL) {
MALI_DEBUG_PRINT(1, ("_mali_ukk_mem_allocate: Failed to create allocation struct! \n"));
return _MALI_OSK_ERR_NOMEM;
}
mali_allocation->psize = args->psize;
mali_allocation->vsize = args->vsize;
/* check if have dedicated memory */
if (MALI_TRUE == mali_memory_have_dedicated_memory()) {
mali_allocation->type = MALI_MEM_BLOCK;
} else {
mali_allocation->type = MALI_MEM_OS;
}
/**
*add allocation node to RB tree for index
*/
mali_allocation->mali_vma_node.vm_node.start = args->gpu_vaddr;
mali_allocation->mali_vma_node.vm_node.size = args->vsize;
mali_vma_offset_add(&session->allocation_mgr, &mali_allocation->mali_vma_node);
/* check if need to allocate backend */
if (mali_allocation->psize == 0)
return _MALI_OSK_ERR_OK;
/**
*allocate physical backend & pages
*/
if (likely(mali_allocation->psize > 0)) {
mali_allocation->backend_handle = mali_mem_backend_struct_create(&mem_backend, args->psize);
if (mali_allocation->backend_handle < 0) {
ret = _MALI_OSK_ERR_NOMEM;
MALI_DEBUG_PRINT(1, ("mali_allocation->backend_handle < 0! \n"));
goto failed_alloc_backend;
}
mem_backend->mali_allocation = mali_allocation;
mem_backend->type = mali_allocation->type;
if (mem_backend->type == MALI_MEM_OS) {
retval = mali_mem_os_alloc_pages(&mem_backend->os_mem, mem_backend->size);
} else if (mem_backend->type == MALI_MEM_BLOCK) {
/* try to allocated from BLOCK memory first, then try OS memory if failed.*/
if (mali_mem_block_alloc(&mem_backend->block_mem, mem_backend->size)) {
retval = mali_mem_os_alloc_pages(&mem_backend->os_mem, mem_backend->size);
mem_backend->type = MALI_MEM_OS;
mali_allocation->type = MALI_MEM_OS;
}
} else {
/* ONLY support mem_os type */
MALI_DEBUG_ASSERT(0);
}
if (retval) {
ret = _MALI_OSK_ERR_NOMEM;
MALI_DEBUG_PRINT(1, (" can't allocate enough pages! \n"));
goto failed_alloc_pages;
}
}
/**
*map to GPU side
*/
mali_allocation->mali_mapping.addr = args->gpu_vaddr;
/* set gpu mmu propery */
_mali_memory_gpu_map_property_set(&mali_allocation->mali_mapping.properties, args->flags);
if (!(args->flags & _MALI_MEMORY_ALLOCATE_NO_BIND_GPU) && mali_allocation->psize > 0) {
_mali_osk_mutex_wait(session->memory_lock);
/* Map on Mali */
ret = mali_mem_mali_map_prepare(mali_allocation);
if (0 != ret) {
MALI_DEBUG_PRINT(1, (" prepare map fail! \n"));
goto failed_gpu_map;
}
/* only support os memory type now */
if (mem_backend->type == MALI_MEM_OS) {
mali_mem_os_mali_map(mem_backend, args->gpu_vaddr,
mali_allocation->mali_mapping.properties);
} else if (mem_backend->type == MALI_MEM_BLOCK) {
mali_mem_block_mali_map(&mem_backend->block_mem, session, args->gpu_vaddr,
mali_allocation->mali_mapping.properties);
} else {
/* Not support yet */
MALI_DEBUG_ASSERT(0);
}
session->mali_mem_array[mem_backend->type] += mem_backend->size;
if (session->mali_mem_array[MALI_MEM_OS] + session->mali_mem_array[MALI_MEM_BLOCK] > session->max_mali_mem_allocated) {
session->max_mali_mem_allocated = session->mali_mem_array[MALI_MEM_OS] + session->mali_mem_array[MALI_MEM_BLOCK];
}
_mali_osk_mutex_signal(session->memory_lock);
}
return _MALI_OSK_ERR_OK;
failed_gpu_map:
_mali_osk_mutex_signal(session->memory_lock);
if (mem_backend->type == MALI_MEM_OS) {
mali_mem_os_free(&mem_backend->os_mem);
} else {
mali_mem_block_free(&mem_backend->block_mem);
}
failed_alloc_pages:
mali_mem_backend_struct_destory(&mem_backend, mali_allocation->backend_handle);
failed_alloc_backend:
mali_vma_offset_remove(&session->allocation_mgr, &mali_allocation->mali_vma_node);
mali_mem_allocation_struct_destory(mali_allocation);
return ret;
}
static _mali_osk_errcode_t mali_mem_resize(struct mali_session_data *session, mali_mem_backend *mem_backend, u32 physical_size)
{
_mali_osk_errcode_t ret = _MALI_OSK_ERR_FAULT;
int retval = 0;
mali_mem_allocation *mali_allocation = NULL;
mali_mem_os_mem tmp_os_mem;
s32 change_page_count;
MALI_DEBUG_ASSERT_POINTER(session);
MALI_DEBUG_ASSERT_POINTER(mem_backend);
MALI_DEBUG_PRINT(4, (" mali_mem_resize_memory called! \n"));
MALI_DEBUG_ASSERT(0 == physical_size % MALI_MMU_PAGE_SIZE);
mali_allocation = mem_backend->mali_allocation;
MALI_DEBUG_ASSERT_POINTER(mali_allocation);
MALI_DEBUG_ASSERT(MALI_MEM_FLAG_CAN_RESIZE & mali_allocation->flags);
MALI_DEBUG_ASSERT(MALI_MEM_OS == mali_allocation->type);
mutex_lock(&mem_backend->mutex);
/* Do resize*/
if (physical_size > mem_backend->size) {
u32 add_size = physical_size - mem_backend->size;
MALI_DEBUG_ASSERT(0 == add_size % MALI_MMU_PAGE_SIZE);
/* Allocate new pages from os mem */
retval = mali_mem_os_alloc_pages(&tmp_os_mem, add_size);
if (retval) {
if (-ENOMEM == retval) {
ret = _MALI_OSK_ERR_NOMEM;
} else {
ret = _MALI_OSK_ERR_FAULT;
}
MALI_DEBUG_PRINT(2, ("_mali_ukk_mem_resize: memory allocation failed !\n"));
goto failed_alloc_memory;
}
MALI_DEBUG_ASSERT(tmp_os_mem.count == add_size / MALI_MMU_PAGE_SIZE);
/* Resize the memory of the backend */
ret = mali_mem_os_resize_pages(&tmp_os_mem, &mem_backend->os_mem, 0, tmp_os_mem.count);
if (ret) {
MALI_DEBUG_PRINT(2, ("_mali_ukk_mem_resize: memory resizing failed !\n"));
goto failed_resize_pages;
}
/*Resize cpu mapping */
if (NULL != mali_allocation->cpu_mapping.vma) {
ret = mali_mem_os_resize_cpu_map_locked(mem_backend, mali_allocation->cpu_mapping.vma, mali_allocation->cpu_mapping.vma->vm_start + mem_backend->size, add_size);
if (unlikely(ret != _MALI_OSK_ERR_OK)) {
MALI_DEBUG_PRINT(2, ("_mali_ukk_mem_resize: cpu mapping failed !\n"));
goto failed_cpu_map;
}
}
/* Resize mali mapping */
_mali_osk_mutex_wait(session->memory_lock);
ret = mali_mem_mali_map_resize(mali_allocation, physical_size);
if (ret) {
MALI_DEBUG_PRINT(1, ("_mali_ukk_mem_resize: mali map resize fail !\n"));
goto failed_gpu_map;
}
ret = mali_mem_os_mali_map(&mem_backend->os_mem, session, mali_allocation->mali_vma_node.vm_node.start,
mali_allocation->psize / MALI_MMU_PAGE_SIZE, add_size / MALI_MMU_PAGE_SIZE, mali_allocation->mali_mapping.properties);
if (ret) {
MALI_DEBUG_PRINT(2, ("_mali_ukk_mem_resize: mali mapping failed !\n"));
goto failed_gpu_map;
}
_mali_osk_mutex_signal(session->memory_lock);
} else {
u32 dec_size, page_count;
u32 vaddr = 0;
INIT_LIST_HEAD(&tmp_os_mem.pages);
tmp_os_mem.count = 0;
dec_size = mem_backend->size - physical_size;
MALI_DEBUG_ASSERT(0 == dec_size % MALI_MMU_PAGE_SIZE);
page_count = dec_size / MALI_MMU_PAGE_SIZE;
vaddr = mali_allocation->mali_vma_node.vm_node.start + physical_size;
/* Resize the memory of the backend */
ret = mali_mem_os_resize_pages(&mem_backend->os_mem, &tmp_os_mem, physical_size / MALI_MMU_PAGE_SIZE, page_count);
if (ret) {
MALI_DEBUG_PRINT(4, ("_mali_ukk_mem_resize: mali map resize failed!\n"));
goto failed_resize_pages;
}
/* Resize mali map */
_mali_osk_mutex_wait(session->memory_lock);
mali_mem_mali_map_free(session, dec_size, vaddr, mali_allocation->flags);
_mali_osk_mutex_signal(session->memory_lock);
/* Zap cpu mapping */
if (0 != mali_allocation->cpu_mapping.addr) {
MALI_DEBUG_ASSERT(NULL != mali_allocation->cpu_mapping.vma);
zap_vma_ptes(mali_allocation->cpu_mapping.vma, mali_allocation->cpu_mapping.vma->vm_start + physical_size, dec_size);
}
/* Free those extra pages */
mali_mem_os_free(&tmp_os_mem.pages, tmp_os_mem.count, MALI_FALSE);
}
/* Resize memory allocation and memory backend */
change_page_count = (s32)(physical_size - mem_backend->size) / MALI_MMU_PAGE_SIZE;
mali_allocation->psize = physical_size;
mem_backend->size = physical_size;
mutex_unlock(&mem_backend->mutex);
if (change_page_count > 0) {
atomic_add(change_page_count, &session->mali_mem_allocated_pages);
if (atomic_read(&session->mali_mem_allocated_pages) * MALI_MMU_PAGE_SIZE > session->max_mali_mem_allocated_size) {
session->max_mali_mem_allocated_size = atomic_read(&session->mali_mem_allocated_pages) * MALI_MMU_PAGE_SIZE;
}
} else {
atomic_sub((s32)(-change_page_count), &session->mali_mem_allocated_pages);
}
return _MALI_OSK_ERR_OK;
failed_gpu_map:
_mali_osk_mutex_signal(session->memory_lock);
failed_cpu_map:
if (physical_size > mem_backend->size) {
mali_mem_os_resize_pages(&mem_backend->os_mem, &tmp_os_mem, mem_backend->size / MALI_MMU_PAGE_SIZE,
(physical_size - mem_backend->size) / MALI_MMU_PAGE_SIZE);
} else {
mali_mem_os_resize_pages(&tmp_os_mem, &mem_backend->os_mem, 0, tmp_os_mem.count);
}
failed_resize_pages:
if (0 != tmp_os_mem.count)
mali_mem_os_free(&tmp_os_mem.pages, tmp_os_mem.count, MALI_FALSE);
failed_alloc_memory:
mutex_unlock(&mem_backend->mutex);
return ret;
}
