_mali_osk_errcode_t _mali_ukk_release_ump_mem(_mali_uk_release_ump_mem_s *args) { mali_mem_allocation * descriptor; struct mali_session_data *session; MALI_DEBUG_ASSERT_POINTER(args); MALI_CHECK_NON_NULL(args->ctx, _MALI_OSK_ERR_INVALID_ARGS); session = (struct mali_session_data *)args->ctx; MALI_CHECK_NON_NULL(session, _MALI_OSK_ERR_INVALID_ARGS); if (_MALI_OSK_ERR_OK != mali_descriptor_mapping_get(session->descriptor_mapping, args->cookie, (void**)&descriptor)) { MALI_DEBUG_PRINT(1, ("Invalid memory descriptor %d used to release ump memory\n", args->cookie)); MALI_ERROR(_MALI_OSK_ERR_FAULT); } descriptor = mali_descriptor_mapping_free(session->descriptor_mapping, args->cookie); if (NULL != descriptor) { _mali_osk_mutex_wait(session->memory_lock); mali_mem_ump_release(descriptor); _mali_osk_mutex_signal(session->memory_lock); mali_mem_descriptor_destroy(descriptor); } MALI_SUCCESS; }
static void mali_mem_vma_close(struct vm_area_struct *vma) { mali_mem_allocation *descriptor; struct mali_session_data *session; mali_mem_virt_cpu_mapping *mapping; MALI_DEBUG_PRINT(3, ("Close called on vma %p\n", vma)); descriptor = (mali_mem_allocation *)vma->vm_private_data; BUG_ON(!descriptor); MALI_DEBUG_ASSERT(MALI_MEM_ALLOCATION_VALID_MAGIC == descriptor->magic); mapping = &descriptor->cpu_mapping; BUG_ON(0 == mapping->ref); mapping->ref--; if (0 != mapping->ref) { MALI_DEBUG_PRINT(3, ("Ignoring this close, %d references still exists\n", mapping->ref)); return; } session = descriptor->session; mali_descriptor_mapping_free(session->descriptor_mapping, descriptor->id); _mali_osk_mutex_wait(session->memory_lock); mali_mem_release(descriptor); _mali_osk_mutex_signal(session->memory_lock); mali_mem_descriptor_destroy(descriptor); }
/** @brief Callback function that releases memory * * session->memory_lock must be held when calling this function. */ static void descriptor_table_cleanup_callback(int descriptor_id, void *map_target) { mali_mem_allocation *descriptor; descriptor = (mali_mem_allocation *)map_target; MALI_DEBUG_ASSERT_LOCK_HELD(descriptor->session->memory_lock); MALI_DEBUG_PRINT(3, ("Cleanup of descriptor %d mapping to 0x%x in descriptor table\n", descriptor_id, map_target)); MALI_DEBUG_ASSERT(descriptor); mali_mem_release(descriptor); mali_mem_descriptor_destroy(descriptor); }
_mali_osk_errcode_t _mali_ukk_attach_ump_mem(_mali_uk_attach_ump_mem_s *args) { ump_dd_handle ump_mem; struct mali_session_data *session; mali_mem_allocation *descriptor; int md, ret; MALI_DEBUG_ASSERT_POINTER(args); MALI_CHECK_NON_NULL(args->ctx, _MALI_OSK_ERR_INVALID_ARGS); session = (struct mali_session_data *)args->ctx; MALI_CHECK_NON_NULL(session, _MALI_OSK_ERR_INVALID_ARGS); /* check arguments */ /* NULL might be a valid Mali address */ if (!args->size) MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS); /* size must be a multiple of the system page size */ if (args->size % _MALI_OSK_MALI_PAGE_SIZE) MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS); MALI_DEBUG_PRINT(3, ("Requested to map ump memory with secure id %d into virtual memory 0x%08X, size 0x%08X\n", args->secure_id, args->mali_address, args->size)); ump_mem = ump_dd_handle_create_from_secure_id((int)args->secure_id); if (UMP_DD_HANDLE_INVALID == ump_mem) MALI_ERROR(_MALI_OSK_ERR_FAULT); descriptor = mali_mem_descriptor_create(session, MALI_MEM_UMP); if (NULL == descriptor) { ump_dd_reference_release(ump_mem); MALI_ERROR(_MALI_OSK_ERR_NOMEM); } descriptor->ump_mem.handle = ump_mem; descriptor->mali_mapping.addr = args->mali_address; descriptor->size = args->size; descriptor->mali_mapping.properties = MALI_MMU_FLAGS_DEFAULT; descriptor->flags |= MALI_MEM_FLAG_DONT_CPU_MAP; if (args->flags & _MALI_MAP_EXTERNAL_MAP_GUARD_PAGE) { descriptor->flags = MALI_MEM_FLAG_MALI_GUARD_PAGE; } _mali_osk_mutex_wait(session->memory_lock); ret = mali_ump_map(session, descriptor); if (0 != ret) { _mali_osk_mutex_signal(session->memory_lock); ump_dd_reference_release(ump_mem); mali_mem_descriptor_destroy(descriptor); MALI_ERROR(_MALI_OSK_ERR_NOMEM); } _mali_osk_mutex_signal(session->memory_lock); if (_MALI_OSK_ERR_OK != mali_descriptor_mapping_allocate_mapping(session->descriptor_mapping, descriptor, &md)) { ump_dd_reference_release(ump_mem); mali_mem_descriptor_destroy(descriptor); MALI_ERROR(_MALI_OSK_ERR_FAULT); } args->cookie = md; MALI_DEBUG_PRINT(5,("Returning from UMP attach\n")); MALI_SUCCESS; }
mali_mem_allocation *mali_mem_block_alloc(u32 mali_addr, u32 size, struct vm_area_struct *vma, struct mali_session_data *session) { _mali_osk_errcode_t err; mali_mem_allocation *descriptor; block_allocator *info; u32 left; block_info *last_allocated = NULL; block_allocator_allocation *ret_allocation; u32 offset = 0; size = ALIGN(size, MALI_BLOCK_SIZE); info = mali_mem_block_gobal_allocator; if (NULL == info) return NULL; left = size; MALI_DEBUG_ASSERT(0 != left); descriptor = mali_mem_descriptor_create(session, MALI_MEM_BLOCK); if (NULL == descriptor) { return NULL; } descriptor->mali_mapping.addr = mali_addr; descriptor->size = size; descriptor->cpu_mapping.addr = (void __user *)vma->vm_start; descriptor->cpu_mapping.ref = 1; if (VM_SHARED == (VM_SHARED & vma->vm_flags)) { descriptor->mali_mapping.properties = MALI_MMU_FLAGS_DEFAULT; } else { /* Cached Mali memory mapping */ descriptor->mali_mapping.properties = MALI_MMU_FLAGS_FORCE_GP_READ_ALLOCATE; vma->vm_flags |= VM_SHARED; } ret_allocation = &descriptor->block_mem.mem; ret_allocation->mapping_length = 0; _mali_osk_mutex_wait(session->memory_lock); mutex_lock(&info->mutex); if (left > (info->free_blocks * MALI_BLOCK_SIZE)) { MALI_DEBUG_PRINT(2, ("Mali block allocator: not enough free blocks to service allocation (%u)\n", left)); mutex_unlock(&info->mutex); _mali_osk_mutex_signal(session->memory_lock); mali_mem_descriptor_destroy(descriptor); return NULL; } err = mali_mem_mali_map_prepare(descriptor); if (_MALI_OSK_ERR_OK != err) { mutex_unlock(&info->mutex); _mali_osk_mutex_signal(session->memory_lock); mali_mem_descriptor_destroy(descriptor); return NULL; } while ((left > 0) && (info->first_free)) { block_info *block; u32 phys_addr; u32 current_mapping_size; block = info->first_free; info->first_free = info->first_free->next; block->next = last_allocated; last_allocated = block; phys_addr = get_phys(info, block); if (MALI_BLOCK_SIZE < left) { current_mapping_size = MALI_BLOCK_SIZE; } else { current_mapping_size = left; } mali_mem_block_mali_map(descriptor, phys_addr, mali_addr + offset, current_mapping_size); if (mali_mem_block_cpu_map(descriptor, vma, phys_addr, offset, current_mapping_size, info->cpu_usage_adjust)) { /* release all memory back to the pool */ while (last_allocated) { /* This relinks every block we've just allocated back into the free-list */ block = last_allocated->next; last_allocated->next = info->first_free; info->first_free = last_allocated; last_allocated = block; } mutex_unlock(&info->mutex); _mali_osk_mutex_signal(session->memory_lock); mali_mem_mali_map_free(descriptor); mali_mem_descriptor_destroy(descriptor); return NULL; } left -= current_mapping_size; offset += current_mapping_size; ret_allocation->mapping_length += current_mapping_size; --info->free_blocks; } mutex_unlock(&info->mutex); _mali_osk_mutex_signal(session->memory_lock); MALI_DEBUG_ASSERT(0 == left); /* Record all the information about this allocation */ ret_allocation->last_allocated = last_allocated; ret_allocation->info = info; return descriptor; }
_mali_osk_errcode_t _mali_ukk_map_external_mem(_mali_uk_map_external_mem_s *args) { struct mali_session_data *session; mali_mem_allocation * descriptor; int md; _mali_osk_errcode_t err; MALI_DEBUG_ASSERT_POINTER(args); MALI_CHECK_NON_NULL(args->ctx, _MALI_OSK_ERR_INVALID_ARGS); session = (struct mali_session_data *)args->ctx; MALI_CHECK_NON_NULL(session, _MALI_OSK_ERR_INVALID_ARGS); /* check arguments */ /* NULL might be a valid Mali address */ if (! args->size) MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS); /* size must be a multiple of the system page size */ if (args->size % _MALI_OSK_MALI_PAGE_SIZE) MALI_ERROR(_MALI_OSK_ERR_INVALID_ARGS); MALI_DEBUG_PRINT(3, ("Requested to map physical memory 0x%x-0x%x into virtual memory 0x%x\n", (void*)args->phys_addr, (void*)(args->phys_addr + args->size -1), (void*)args->mali_address) ); /* Validate the mali physical range */ if (_MALI_OSK_ERR_OK != mali_mem_validation_check(args->phys_addr, args->size)) { return _MALI_OSK_ERR_FAULT; } descriptor = mali_mem_descriptor_create(session, MALI_MEM_EXTERNAL); if (NULL == descriptor) MALI_ERROR(_MALI_OSK_ERR_NOMEM); descriptor->mali_mapping.addr = args->mali_address; descriptor->size = args->size; if (args->flags & _MALI_MAP_EXTERNAL_MAP_GUARD_PAGE) { descriptor->flags = MALI_MEM_FLAG_MALI_GUARD_PAGE; } _mali_osk_mutex_wait(session->memory_lock); { u32 virt = descriptor->mali_mapping.addr; u32 phys = args->phys_addr; u32 size = args->size; err = mali_mem_mali_map_prepare(descriptor); if (_MALI_OSK_ERR_OK != err) { _mali_osk_mutex_signal(session->memory_lock); mali_mem_descriptor_destroy(descriptor); return _MALI_OSK_ERR_NOMEM; } mali_mmu_pagedir_update(session->page_directory, virt, phys, size, MALI_MMU_FLAGS_DEFAULT); if (descriptor->flags & MALI_MEM_FLAG_MALI_GUARD_PAGE) { mali_mmu_pagedir_update(session->page_directory, virt + size, phys, _MALI_OSK_MALI_PAGE_SIZE, MALI_MMU_FLAGS_DEFAULT); } } _mali_osk_mutex_signal(session->memory_lock); if (_MALI_OSK_ERR_OK != mali_descriptor_mapping_allocate_mapping(session->descriptor_mapping, descriptor, &md)) { _mali_osk_mutex_wait(session->memory_lock); mali_mem_external_release(descriptor); _mali_osk_mutex_signal(session->memory_lock); mali_mem_descriptor_destroy(descriptor); MALI_ERROR(_MALI_OSK_ERR_FAULT); } args->cookie = md; MALI_SUCCESS; }