void mali_pp_scheduler_terminate(void) { struct mali_group *group, *temp; /* Delete all groups owned by scheduler */ if (NULL != virtual_group) { mali_group_delete(virtual_group); } MALI_DEBUG_ASSERT(_mali_osk_list_empty(&group_list_working)); _MALI_OSK_LIST_FOREACHENTRY(group, temp, &group_list_idle, struct mali_group, pp_scheduler_list) { mali_group_delete(group); } #if defined(MALI_PP_SCHEDULER_USE_DEFERRED_JOB_DELETE) _mali_osk_lock_term(pp_scheduler_job_delete_lock); _mali_osk_wq_delete_work(pp_scheduler_wq_job_delete); #endif _mali_osk_wq_delete_work(pp_scheduler_wq_schedule); _mali_osk_wait_queue_term(pp_scheduler_working_wait_queue); _mali_osk_lock_term(pp_scheduler_lock); }
void mali_l2_cache_delete(struct mali_l2_cache_core *cache) { u32 i; /* reset to defaults */ mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_MAX_READS, (u32)MALI400_L2_MAX_READS_DEFAULT); mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_ENABLE, (u32)MALI400_L2_CACHE_ENABLE_DEFAULT); _mali_osk_lock_term(cache->counter_lock); _mali_osk_lock_term(cache->command_lock); mali_hw_core_delete(&cache->hw_core); for (i = 0; i < mali_global_num_l2_cache_cores; i++) { if (mali_global_l2_cache_cores[i] == cache) { mali_global_l2_cache_cores[i] = NULL; mali_global_num_l2_cache_cores--; if (i != mali_global_num_l2_cache_cores) { /* We removed a l2 cache from the middle of the array -- move the last * l2 cache to the current position to close the gap */ mali_global_l2_cache_cores[i] = mali_global_l2_cache_cores[mali_global_num_l2_cache_cores]; mali_global_l2_cache_cores[mali_global_num_l2_cache_cores] = NULL; } break; } } _mali_osk_free(cache); }
void mali_pm_terminate(void) { mali_platform_deinit(); _mali_osk_irq_term(wq_irq); _mali_osk_timer_del(idle_timer); _mali_osk_timer_term(idle_timer); _mali_osk_lock_term(mali_pm_lock_execute_state_change); _mali_osk_lock_term(mali_pm_lock_set_next_state); _mali_osk_lock_term(mali_pm_lock_set_core_states); }
static _mali_osk_errcode_t initialize_subsystems(void) { int i, j; _mali_osk_errcode_t err = _MALI_OSK_ERR_FAULT; /* default error code */ MALI_CHECK_NON_NULL(system_info_lock = _mali_osk_lock_init( (_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_SPINLOCK | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE), 0, 0 ), _MALI_OSK_ERR_FAULT); #ifdef MALI_SESSION_MEMORY_USAGE MALI_CHECK_NON_NULL(session_data_lock = _mali_osk_lock_init( (_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE), 0, 0 ), _MALI_OSK_ERR_FAULT); _MALI_OSK_INIT_LIST_HEAD(&session_data_head); #endif for (i = 0; i < (int)SUBSYSTEMS_COUNT; ++i) { if (NULL != subsystems[i]->startup) { /* the subsystem has a startup function defined */ err = subsystems[i]->startup(i); /* the subsystem identifier is the offset in our subsystems array */ if (_MALI_OSK_ERR_OK != err) goto cleanup; } } for (j = 0; j < (int)SUBSYSTEMS_COUNT; ++j) { if (NULL != subsystems[j]->load_complete) { /* the subsystem has a load_complete function defined */ err = subsystems[j]->load_complete(j); if (_MALI_OSK_ERR_OK != err) goto cleanup; } } /* All systems loaded and resources registered */ /* Build system info */ if (_MALI_OSK_ERR_OK != build_system_info()) goto cleanup; MALI_SUCCESS; /* all ok */ cleanup: /* i is index of subsystem which failed to start, all indices before that has to be shut down */ for (i = i - 1; i >= 0; --i) { /* the subsystem identifier is the offset in our subsystems array */ /* Call possible shutdown notficiation functions */ if (NULL != subsystems[i]->shutdown) subsystems[i]->shutdown(i); } #ifdef MALI_SESSION_MEMORY_USAGE _mali_osk_lock_term( session_data_lock ); #endif _mali_osk_lock_term( system_info_lock ); MALI_ERROR(err); /* err is what the module which failed its startup returned, or the default */ }
_mali_osk_errcode_t mali_pm_initialize(void) { mali_pm_lock_execute_state_change = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_ORDERED |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_PM_EXECUTE); if (NULL != mali_pm_lock_execute_state_change ) { mali_pm_lock_set_next_state = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ONELOCK| _MALI_OSK_LOCKFLAG_SPINLOCK_IRQ |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_LAST); if (NULL != mali_pm_lock_set_next_state) { mali_pm_lock_set_core_states = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_PM_CORE_STATE); if (NULL != mali_pm_lock_set_core_states) { idle_timer = _mali_osk_timer_init(); if (NULL != idle_timer) { wq_irq = _mali_osk_irq_init(_MALI_OSK_IRQ_NUMBER_PMM, mali_pm_upper_half, mali_pm_bottom_half, NULL, NULL, (void *)NULL, "Mali PM deferred work"); if (NULL != wq_irq) { if (_MALI_OSK_ERR_OK == mali_platform_init()) { #if MALI_PMM_RUNTIME_JOB_CONTROL_ON _mali_osk_pm_dev_enable(); mali_pm_powerup(); #endif return _MALI_OSK_ERR_OK; } _mali_osk_irq_term(wq_irq); } _mali_osk_timer_del(idle_timer); _mali_osk_timer_term(idle_timer); } _mali_osk_lock_term(mali_pm_lock_set_core_states); } _mali_osk_lock_term(mali_pm_lock_set_next_state); } _mali_osk_lock_term(mali_pm_lock_execute_state_change); } return _MALI_OSK_ERR_FAULT; }
void mali_group_delete(struct mali_group *group) { u32 i; /* Delete the resources that this group owns */ if (NULL != group->gp_core) { mali_gp_delete(group->gp_core); } if (NULL != group->pp_core) { mali_pp_delete(group->pp_core); } if (NULL != group->mmu) { mali_mmu_delete(group->mmu); } for (i = 0; i < mali_global_num_groups; i++) { if (mali_global_groups[i] == group) { mali_global_groups[i] = NULL; mali_global_num_groups--; break; } } _mali_osk_lock_term(group->lock); _mali_osk_free(group); }
void malipmm_kernel_subsystem_terminate( mali_kernel_subsystem_identifier id ) { /* Check this is the right system */ MALI_DEBUG_ASSERT( id == mali_subsystem_pmm_id ); MALI_DEBUG_ASSERT_POINTER(pmm_state); if( pmm_state ) { _mali_osk_resource_type_t t = PMU; #if PMM_OS_TEST power_test_end(); #endif /* Get the lock so we can shutdown */ MALI_PMM_LOCK(pmm_state); pmm_state->status = MALI_PMM_STATUS_OFF; MALI_PMM_UNLOCK(pmm_state); pmm_policy_term(pmm_state); _mali_osk_irq_term( pmm_state->irq ); #ifdef CONFIG_SMP _mali_osk_lock_term(mali_pmm_lock); #endif /* CONFIG_SMP */ _mali_osk_notification_queue_term( pmm_state->queue ); _mali_osk_notification_queue_term( pmm_state->iqueue ); if( pmm_state->pmu_initialized ) mali_platform_deinit(&t); _mali_osk_atomic_term( &(pmm_state->messages_queued) ); MALI_PMM_LOCK_TERM(pmm_state); _mali_osk_free(pmm_state); pmm_state = NULL; } MALIPMM_DEBUG_PRINT( ("PMM: subsystem terminated\n") ); }
/** This function is called when Mali GPU device is unloaded */ void _mali_dev_platform_unregister(void) { _mali_osk_lock_term(lock); platform_driver_unregister(&mali_plat_driver); platform_device_unregister(&mali_gpu_device); }
static void terminate_subsystems(void) { int i; /* shut down subsystems in reverse order from startup */ for (i = SUBSYSTEMS_COUNT - 1; i >= 0; --i) { /* the subsystem identifier is the offset in our subsystems array */ if (NULL != subsystems[i]->shutdown) subsystems[i]->shutdown(i); } #ifdef MALI_SESSION_MEMORY_USAGE if (session_data_lock) _mali_osk_lock_term( session_data_lock ); #endif if (system_info_lock) _mali_osk_lock_term( system_info_lock ); /* Free _mali_system_info struct */ cleanup_system_info(system_info); }
void mali_gp_scheduler_terminate(void) { MALI_DEBUG_ASSERT(MALI_GP_SLOT_STATE_IDLE == slot.state); MALI_DEBUG_ASSERT_POINTER(slot.group); mali_group_delete(slot.group); _mali_osk_wait_queue_term(gp_scheduler_working_wait_queue); _mali_osk_lock_term(gp_scheduler_lock); }
static void os_allocator_destroy(mali_physical_memory_allocator * allocator) { os_allocator * info; MALI_DEBUG_ASSERT_POINTER(allocator); MALI_DEBUG_ASSERT_POINTER(allocator->ctx); info = (os_allocator*)allocator->ctx; _mali_osk_lock_term(info->mutex); _mali_osk_free(info); _mali_osk_free(allocator); }
static void terminate_subsystems(void) { int i; /* shut down subsystems in reverse order from startup */ for (i = SUBSYSTEMS_COUNT - 1; i >= 0; --i) { /* the subsystem identifier is the offset in our subsystems array */ if (NULL != subsystems[i]->shutdown) subsystems[i]->shutdown(i); } if (system_info_lock) _mali_osk_lock_term( system_info_lock ); }
void mali_pmu_delete(struct mali_pmu_core *pmu) { MALI_DEBUG_ASSERT_POINTER(pmu); MALI_DEBUG_ASSERT(pmu == mali_global_pmu_core); MALI_DEBUG_PRINT(2, ("Mali PMU: Deleting Mali PMU core\n")); _mali_osk_lock_term(pmu->lock); mali_hw_core_delete(&pmu->hw_core); _mali_osk_free(pmu); mali_global_pmu_core = NULL; }
void mali_l2_cache_delete(struct mali_l2_cache_core *cache) { u32 i; /* reset to defaults */ mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_MAX_READS, (u32)MALI400_L2_MAX_READS_DEFAULT); mali_hw_core_register_write(&cache->hw_core, MALI400_L2_CACHE_REGISTER_ENABLE, (u32)MALI400_L2_CACHE_ENABLE_DEFAULT); _mali_osk_lock_term(cache->counter_lock); _mali_osk_lock_term(cache->command_lock); mali_hw_core_delete(&cache->hw_core); for (i = 0; i < mali_global_num_l2_cache_cores; i++) { if (mali_global_l2_cache_cores[i] == cache) { mali_global_l2_cache_cores[i] = NULL; mali_global_num_l2_cache_cores--; } } _mali_osk_free(cache); }
_mali_osk_errcode_t mali_pp_scheduler_initialize(void) { u32 i; _MALI_OSK_INIT_LIST_HEAD(&job_queue); pp_scheduler_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER); if (NULL == pp_scheduler_lock) { return _MALI_OSK_ERR_NOMEM; } pp_scheduler_working_wait_queue = _mali_osk_wait_queue_init(); if (NULL == pp_scheduler_working_wait_queue) { _mali_osk_lock_term(pp_scheduler_lock); return _MALI_OSK_ERR_NOMEM; } /* Find all the available PP cores */ for (i = 0; i < mali_cluster_get_glob_num_clusters(); i++) { u32 group_id = 0; struct mali_cluster *curr_cluster = mali_cluster_get_global_cluster(i); struct mali_group *group = mali_cluster_get_group(curr_cluster, group_id); while (NULL != group) { struct mali_pp_core *pp_core = mali_group_get_pp_core(group); if (NULL != pp_core) { if (0 == pp_version) { /* Retrieve PP version from first avaiable PP core */ pp_version = mali_pp_core_get_version(pp_core); } slots[num_slots].group = group; slots[num_slots].state = MALI_PP_SLOT_STATE_IDLE; slots[num_slots].session = NULL; num_slots++; num_slots_idle++; } group_id++; group = mali_cluster_get_group(curr_cluster, group_id); } } return _MALI_OSK_ERR_OK; }
_mali_osk_errcode_t mali_gp_scheduler_initialize(void) { u32 i; _MALI_OSK_INIT_LIST_HEAD(&job_queue); gp_scheduler_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER); gp_scheduler_working_wait_queue = _mali_osk_wait_queue_init(); if (NULL == gp_scheduler_lock) { return _MALI_OSK_ERR_NOMEM; } if (NULL == gp_scheduler_working_wait_queue) { _mali_osk_lock_term(gp_scheduler_lock); return _MALI_OSK_ERR_NOMEM; } /* Find all the available GP cores */ for (i = 0; i < mali_cluster_get_glob_num_clusters(); i++) { u32 group_id = 0; struct mali_cluster *curr_cluster = mali_cluster_get_global_cluster(i); struct mali_group *group = mali_cluster_get_group(curr_cluster, group_id); while (NULL != group) { struct mali_gp_core *gp_core = mali_group_get_gp_core(group); if (NULL != gp_core) { if (0 == gp_version) { /* Retrieve GP version */ gp_version = mali_gp_core_get_version(gp_core); } slot.group = group; slot.state = MALI_GP_SLOT_STATE_IDLE; break; /* There are only one GP, no point in looking for more */ } group_id++; group = mali_cluster_get_group(curr_cluster, group_id); } } return _MALI_OSK_ERR_OK; }
void _mali_osk_pm_dev_disable(void) { #if MALI_LICENSE_IS_GPL if (mali_pm_wq) { flush_workqueue(mali_pm_wq); destroy_workqueue(mali_pm_wq); mali_pm_wq = NULL; } #else flush_scheduled_work(); #endif _mali_osk_atomic_term(&mali_pm_ref_count); _mali_osk_atomic_term(&mali_suspend_called); _mali_osk_timer_term(pm_timer); _mali_osk_lock_term(pm_lock); }
/** This function is called when Mali GPU device is initialized */ int _mali_dev_platform_register(void) { int err=0; #if MALI_PMM_RUNTIME_JOB_CONTROL_ON /*set_mali_parent_power_domain((void *)&mali_gpu_device);*/ #endif /*err = platform_device_register(&mali_gpu_device);*/ lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)( _MALI_OSK_LOCKFLAG_READERWRITER | _MALI_OSK_LOCKFLAG_ORDERED), 0, 0); if (!err) { err = platform_driver_register(&mali_plat_driver); if (err) { _mali_osk_lock_term(lock); platform_device_unregister(&mali_gpu_device); } } return err; }
void _mali_osk_profiling_term(void) { prof_state = MALI_PROFILING_STATE_UNINITIALIZED; /* wait for all elements to be completely inserted into array */ while (_mali_osk_atomic_read(&profile_insert_index) != _mali_osk_atomic_read(&profile_entries_written)) { /* do nothing */; } if (NULL != profile_entries) { _mali_osk_vfree(profile_entries); profile_entries = NULL; } if (NULL != lock) { _mali_osk_lock_term(lock); lock = NULL; } }
struct mali_pmu_core *mali_pmu_create(_mali_osk_resource_t *resource, u32 number_of_pp_cores, u32 number_of_l2_caches) { struct mali_pmu_core* pmu; MALI_DEBUG_ASSERT(NULL == mali_global_pmu_core); MALI_DEBUG_PRINT(2, ("Mali PMU: Creating Mali PMU core\n")); pmu = (struct mali_pmu_core *)_mali_osk_malloc(sizeof(struct mali_pmu_core)); if (NULL != pmu) { pmu->lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_SPINLOCK | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_PMU); if (NULL != pmu->lock) { pmu->registered_cores_mask = mali_pmu_detect_mask(number_of_pp_cores, number_of_l2_caches); pmu->active_cores_mask = pmu->registered_cores_mask; if (_MALI_OSK_ERR_OK == mali_hw_core_create(&pmu->hw_core, resource, PMU_REGISTER_ADDRESS_SPACE_SIZE)) { _mali_osk_errcode_t err; struct _mali_osk_device_data data = { 0, }; err = _mali_osk_device_data_get(&data); if (_MALI_OSK_ERR_OK == err) { pmu->switch_delay = data.pmu_switch_delay; mali_global_pmu_core = pmu; return pmu; } mali_hw_core_delete(&pmu->hw_core); } _mali_osk_lock_term(pmu->lock); } _mali_osk_free(pmu); } return NULL; }
struct mali_l2_cache_core *mali_l2_cache_create(_mali_osk_resource_t *resource) { struct mali_l2_cache_core *cache = NULL; _mali_osk_lock_flags_t lock_flags; #if defined(MALI_UPPER_HALF_SCHEDULING) lock_flags = _MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_SPINLOCK_IRQ | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE; #else lock_flags = _MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_SPINLOCK | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE; #endif MALI_DEBUG_PRINT(2, ("Mali L2 cache: Creating Mali L2 cache: %s\n", resource->description)); if (mali_global_num_l2_cache_cores >= MALI_MAX_NUMBER_OF_L2_CACHE_CORES) { MALI_PRINT_ERROR(("Mali L2 cache: Too many L2 cache core objects created\n")); return NULL; } cache = _mali_osk_malloc(sizeof(struct mali_l2_cache_core)); if (NULL != cache) { cache->core_id = mali_global_num_l2_cache_cores; cache->counter_src0 = MALI_HW_CORE_NO_COUNTER; cache->counter_src1 = MALI_HW_CORE_NO_COUNTER; cache->pm_domain = NULL; cache->mali_l2_status = MALI_L2_NORMAL; if (_MALI_OSK_ERR_OK == mali_hw_core_create(&cache->hw_core, resource, MALI400_L2_CACHE_REGISTERS_SIZE)) { cache->command_lock = _mali_osk_lock_init(lock_flags, 0, _MALI_OSK_LOCK_ORDER_L2_COMMAND); if (NULL != cache->command_lock) { cache->counter_lock = _mali_osk_lock_init(lock_flags, 0, _MALI_OSK_LOCK_ORDER_L2_COUNTER); if (NULL != cache->counter_lock) { mali_l2_cache_reset(cache); cache->last_invalidated_id = 0; mali_global_l2_cache_cores[mali_global_num_l2_cache_cores] = cache; mali_global_num_l2_cache_cores++; return cache; } else { MALI_PRINT_ERROR(("Mali L2 cache: Failed to create counter lock for L2 cache core %s\n", cache->hw_core.description)); } _mali_osk_lock_term(cache->command_lock); } else { MALI_PRINT_ERROR(("Mali L2 cache: Failed to create command lock for L2 cache core %s\n", cache->hw_core.description)); } mali_hw_core_delete(&cache->hw_core); } _mali_osk_free(cache); } else { MALI_PRINT_ERROR(("Mali L2 cache: Failed to allocate memory for L2 cache core\n")); } return NULL; }
_mali_osk_errcode_t mali_pp_scheduler_initialize(void) { struct mali_group *group; struct mali_pp_core *pp_core; _mali_osk_lock_flags_t lock_flags; u32 num_groups; u32 i; #if defined(MALI_UPPER_HALF_SCHEDULING) lock_flags = _MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_SPINLOCK_IRQ | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE; #else lock_flags = _MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_SPINLOCK | _MALI_OSK_LOCKFLAG_NONINTERRUPTABLE; #endif _MALI_OSK_INIT_LIST_HEAD(&job_queue); _MALI_OSK_INIT_LIST_HEAD(&group_list_working); _MALI_OSK_INIT_LIST_HEAD(&group_list_idle); _MALI_OSK_INIT_LIST_HEAD(&virtual_job_queue); pp_scheduler_lock = _mali_osk_lock_init(lock_flags, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER); if (NULL == pp_scheduler_lock) { return _MALI_OSK_ERR_NOMEM; } pp_scheduler_working_wait_queue = _mali_osk_wait_queue_init(); if (NULL == pp_scheduler_working_wait_queue) { _mali_osk_lock_term(pp_scheduler_lock); return _MALI_OSK_ERR_NOMEM; } pp_scheduler_wq_schedule = _mali_osk_wq_create_work(mali_pp_scheduler_do_schedule, NULL); if (NULL == pp_scheduler_wq_schedule) { _mali_osk_wait_queue_term(pp_scheduler_working_wait_queue); _mali_osk_lock_term(pp_scheduler_lock); return _MALI_OSK_ERR_NOMEM; } #if defined(MALI_PP_SCHEDULER_USE_DEFERRED_JOB_DELETE) pp_scheduler_wq_job_delete = _mali_osk_wq_create_work(mali_pp_scheduler_do_job_delete, NULL); if (NULL == pp_scheduler_wq_job_delete) { _mali_osk_wq_delete_work(pp_scheduler_wq_schedule); _mali_osk_wait_queue_term(pp_scheduler_working_wait_queue); _mali_osk_lock_term(pp_scheduler_lock); return _MALI_OSK_ERR_NOMEM; } pp_scheduler_job_delete_lock = _mali_osk_lock_init(_MALI_OSK_LOCKFLAG_ORDERED | _MALI_OSK_LOCKFLAG_SPINLOCK_IRQ |_MALI_OSK_LOCKFLAG_NONINTERRUPTABLE, 0, _MALI_OSK_LOCK_ORDER_SCHEDULER_DEFERRED); if (NULL == pp_scheduler_job_delete_lock) { _mali_osk_wq_delete_work(pp_scheduler_wq_job_delete); _mali_osk_wq_delete_work(pp_scheduler_wq_schedule); _mali_osk_wait_queue_term(pp_scheduler_working_wait_queue); _mali_osk_lock_term(pp_scheduler_lock); return _MALI_OSK_ERR_NOMEM; } #endif num_groups = mali_group_get_glob_num_groups(); /* Do we have a virtual group? */ for (i = 0; i < num_groups; i++) { group = mali_group_get_glob_group(i); if (mali_group_is_virtual(group)) { MALI_DEBUG_PRINT(3, ("Found virtual group %p\n", group)); virtual_group = group; break; } } /* Find all the available PP cores */ for (i = 0; i < num_groups; i++) { group = mali_group_get_glob_group(i); pp_core = mali_group_get_pp_core(group); if (NULL != pp_core && !mali_group_is_virtual(group)) { if (0 == pp_version) { /* Retrieve PP version from the first available PP core */ pp_version = mali_pp_core_get_version(pp_core); } if (NULL != virtual_group) { /* Add all physical PP cores to the virtual group */ mali_group_lock(virtual_group); group->state = MALI_GROUP_STATE_JOINING_VIRTUAL; mali_group_add_group(virtual_group, group); mali_group_unlock(virtual_group); } else { _mali_osk_list_add(&group->pp_scheduler_list, &group_list_idle); } num_cores++; } } return _MALI_OSK_ERR_OK; }
mali_physical_memory_allocator * mali_block_allocator_create(u32 base_address, u32 cpu_usage_adjust, u32 size, const char *name) { mali_physical_memory_allocator * allocator; block_allocator * info; u32 usable_size; u32 num_blocks; usable_size = size & ~(MALI_BLOCK_SIZE - 1); MALI_DEBUG_PRINT(3, ("Mali block allocator create for region starting at 0x%08X length 0x%08X\n", base_address, size)); MALI_DEBUG_PRINT(4, ("%d usable bytes\n", usable_size)); num_blocks = usable_size / MALI_BLOCK_SIZE; MALI_DEBUG_PRINT(4, ("which becomes %d blocks\n", num_blocks)); if (usable_size == 0) { MALI_DEBUG_PRINT(1, ("Memory block of size %d is unusable\n", size)); return NULL; } allocator = _mali_osk_malloc(sizeof(mali_physical_memory_allocator)); if (NULL != allocator) { info = _mali_osk_malloc(sizeof(block_allocator)); if (NULL != info) { info->mutex = _mali_osk_lock_init( _MALI_OSK_LOCKFLAG_ORDERED, 0, 105); if (NULL != info->mutex) { info->all_blocks = _mali_osk_malloc(sizeof(block_info) * num_blocks); if (NULL != info->all_blocks) { u32 i; info->first_free = NULL; info->num_blocks = num_blocks; info->base = base_address; info->cpu_usage_adjust = cpu_usage_adjust; for ( i = 0; i < num_blocks; i++) { info->all_blocks[i].next = info->first_free; info->first_free = &info->all_blocks[i]; } allocator->allocate = block_allocator_allocate; allocator->allocate_page_table_block = block_allocator_allocate_page_table_block; allocator->destroy = block_allocator_destroy; allocator->stat = block_allocator_stat; allocator->ctx = info; allocator->name = name; return allocator; } _mali_osk_lock_term(info->mutex); } _mali_osk_free(info); } _mali_osk_free(allocator); } return NULL; }
_mali_osk_errcode_t malipmm_create(_mali_osk_resource_t *resource) { /* Create PMM state memory */ MALI_DEBUG_ASSERT( pmm_state == NULL ); pmm_state = (_mali_pmm_internal_state_t *) _mali_osk_malloc(sizeof(*pmm_state)); MALI_CHECK_NON_NULL( pmm_state, _MALI_OSK_ERR_NOMEM ); /* All values get 0 as default */ _mali_osk_memset(pmm_state, 0, sizeof(*pmm_state)); /* Set up the initial PMM state */ pmm_state->waiting = 0; pmm_state->status = MALI_PMM_STATUS_IDLE; pmm_state->state = MALI_PMM_STATE_UNAVAILABLE; /* Until a core registers */ /* Set up policy via compile time option for the moment */ #if MALI_PMM_ALWAYS_ON pmm_state->policy = MALI_PMM_POLICY_ALWAYS_ON; #else pmm_state->policy = MALI_PMM_POLICY_JOB_CONTROL; #endif #if MALI_PMM_TRACE _mali_pmm_trace_policy_change( MALI_PMM_POLICY_NONE, pmm_state->policy ); #endif /* Set up assumes all values are initialized to NULL or MALI_FALSE, so * we can exit halfway through set up and perform clean up */ #if !MALI_PMM_NO_PMU if( mali_platform_init(resource) != _MALI_OSK_ERR_OK ) goto pmm_fail_cleanup; pmm_state->pmu_initialized = MALI_TRUE; #endif pmm_state->queue = _mali_osk_notification_queue_init(); if( !pmm_state->queue ) goto pmm_fail_cleanup; pmm_state->iqueue = _mali_osk_notification_queue_init(); if( !pmm_state->iqueue ) goto pmm_fail_cleanup; /* We are creating an IRQ handler just for the worker thread it gives us */ pmm_state->irq = _mali_osk_irq_init( _MALI_OSK_IRQ_NUMBER_PMM, malipmm_irq_uhandler, malipmm_irq_bhandler, NULL, NULL, (void *)pmm_state, /* PMM state is passed to IRQ */ "PMM handler" ); if( !pmm_state->irq ) goto pmm_fail_cleanup; #ifdef CONFIG_SMP mali_pmm_lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)( _MALI_OSK_LOCKFLAG_READERWRITER | _MALI_OSK_LOCKFLAG_ORDERED), 0, 0); if( !mali_pmm_lock ) goto pmm_fail_cleanup; #endif /* CONFIG_SMP */ pmm_state->lock = _mali_osk_lock_init((_mali_osk_lock_flags_t)(_MALI_OSK_LOCKFLAG_READERWRITER | _MALI_OSK_LOCKFLAG_ORDERED), 0, 75); if( !pmm_state->lock ) goto pmm_fail_cleanup; if( _mali_osk_atomic_init( &(pmm_state->messages_queued), 0 ) != _MALI_OSK_ERR_OK ) { goto pmm_fail_cleanup; } MALIPMM_DEBUG_PRINT( ("PMM: subsystem created, policy=%d\n", pmm_state->policy) ); MALI_SUCCESS; pmm_fail_cleanup: MALI_PRINT_ERROR( ("PMM: subsystem failed to be created\n") ); if( pmm_state ) { _mali_osk_resource_type_t t = PMU; if( pmm_state->lock ) _mali_osk_lock_term( pmm_state->lock ); if( pmm_state->irq ) _mali_osk_irq_term( pmm_state->irq ); if( pmm_state->queue ) _mali_osk_notification_queue_term( pmm_state->queue ); if( pmm_state->iqueue ) _mali_osk_notification_queue_term( pmm_state->iqueue ); if( pmm_state->pmu_initialized ) ( mali_platform_deinit(&t) ); _mali_osk_free(pmm_state); pmm_state = NULL; } MALI_ERROR( _MALI_OSK_ERR_FAULT ); }
void mali_gp_scheduler_terminate(void) { _mali_osk_wait_queue_term(gp_scheduler_working_wait_queue); _mali_osk_lock_term(gp_scheduler_lock); }
void mali_descriptor_mapping_destroy(mali_descriptor_mapping * map) { descriptor_table_free(map->table); _mali_osk_lock_term(map->lock); _mali_osk_free(map); }
void mali_session_terminate(void) { _mali_osk_lock_term(mali_sessions_lock); }