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);
}
