_mali_osk_errcode_t mali_scheduler_initialize(void)
{
_mali_osk_atomic_init(&mali_job_id_autonumber, 0);
_mali_osk_atomic_init(&mali_job_cache_order_autonumber, 0);
_MALI_OSK_INIT_LIST_HEAD(&job_queue_gp.normal_pri);
_MALI_OSK_INIT_LIST_HEAD(&job_queue_gp.high_pri);
job_queue_gp.depth = 0;
_MALI_OSK_INIT_LIST_HEAD(&job_queue_pp.normal_pri);
_MALI_OSK_INIT_LIST_HEAD(&job_queue_pp.high_pri);
job_queue_pp.depth = 0;
mali_scheduler_lock_obj = _mali_osk_spinlock_irq_init(
_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_SCHEDULER);
if (NULL == mali_scheduler_lock_obj) {
mali_scheduler_terminate();
}
#if defined(MALI_SCHEDULER_USE_DEFERRED_PP_JOB_DELETE)
scheduler_wq_pp_job_delete = _mali_osk_wq_create_work(
mali_scheduler_do_pp_job_delete, NULL);
if (NULL == scheduler_wq_pp_job_delete) {
mali_scheduler_terminate();
return _MALI_OSK_ERR_FAULT;
}
scheduler_pp_job_delete_lock = _mali_osk_spinlock_irq_init(
_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_SCHEDULER_DEFERRED);
if (NULL == scheduler_pp_job_delete_lock) {
mali_scheduler_terminate();
return _MALI_OSK_ERR_FAULT;
}
#endif /* defined(MALI_SCHEDULER_USE_DEFERRED_PP_JOB_DELETE) */
#if defined(MALI_SCHEDULER_USE_DEFERRED_PP_JOB_QUEUE)
scheduler_wq_pp_job_queue = _mali_osk_wq_create_work(
mali_scheduler_do_pp_job_queue, NULL);
if (NULL == scheduler_wq_pp_job_queue) {
mali_scheduler_terminate();
return _MALI_OSK_ERR_FAULT;
}
scheduler_pp_job_queue_lock = _mali_osk_spinlock_irq_init(
_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_SCHEDULER_DEFERRED);
if (NULL == scheduler_pp_job_queue_lock) {
mali_scheduler_terminate();
return _MALI_OSK_ERR_FAULT;
}
#endif /* defined(MALI_SCHEDULER_USE_DEFERRED_PP_JOB_QUEUE) */
return _MALI_OSK_ERR_OK;
}
struct mali_soft_job_system *mali_soft_job_system_create(struct mali_session_data *session)
{
struct mali_soft_job_system *system;
MALI_DEBUG_ASSERT_POINTER(session);
system = (struct mali_soft_job_system *) _mali_osk_calloc(1, sizeof(struct mali_soft_job_system));
if (NULL == system) {
return NULL;
}
system->session = session;
system->lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SCHEDULER);
if (NULL == system->lock) {
mali_soft_job_system_destroy(system);
return NULL;
}
system->lock_owner = 0;
system->last_job_id = 0;
_MALI_OSK_INIT_LIST_HEAD(&(system->jobs_used));
return system;
}
struct mali_soft_job_system *mali_soft_job_system_create(struct mali_session_data *session)
{
u32 i;
struct mali_soft_job_system *system;
struct mali_soft_job *job;
MALI_DEBUG_ASSERT_POINTER(session);
system = (struct mali_soft_job_system *) _mali_osk_calloc(1, sizeof(struct mali_soft_job_system));
if (NULL == system) {
return NULL;
}
system->session = session;
system->lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SCHEDULER);
if (NULL == system->lock) {
mali_soft_job_system_destroy(system);
return NULL;
}
system->lock_owner = 0;
_MALI_OSK_INIT_LIST_HEAD(&(system->jobs_free));
_MALI_OSK_INIT_LIST_HEAD(&(system->jobs_used));
for (i = 0; i < MALI_MAX_NUM_SOFT_JOBS; ++i) {
job = &(system->jobs[i]);
_mali_osk_list_add(&(job->system_list), &(system->jobs_free));
job->system = system;
job->state = MALI_SOFT_JOB_STATE_FREE;
job->id = i;
}
return system;
}
_mali_osk_errcode_t mali_session_initialize(void)
{
_MALI_OSK_INIT_LIST_HEAD(&mali_sessions);
mali_sessions_lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SESSIONS);
if (NULL == mali_sessions_lock) return _MALI_OSK_ERR_NOMEM;
return _MALI_OSK_ERR_OK;
}
_mali_osk_errcode_t mali_pm_initialize(void)
{
_mali_osk_errcode_t err;
struct mali_pmu_core *pmu;
pm_lock_state = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_PM_STATE);
if (NULL == pm_lock_state) {
mali_pm_terminate();
return _MALI_OSK_ERR_FAULT;
}
pm_lock_exec = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED,
_MALI_OSK_LOCK_ORDER_PM_STATE);
if (NULL == pm_lock_exec) {
mali_pm_terminate();
return _MALI_OSK_ERR_FAULT;
}
pm_work = _mali_osk_wq_create_work(mali_pm_update_work, NULL);
if (NULL == pm_work) {
mali_pm_terminate();
return _MALI_OSK_ERR_FAULT;
}
pmu = mali_pmu_get_global_pmu_core();
if (NULL != pmu) {
/*
* We have a Mali PMU, set the correct domain
* configuration (default or custom)
*/
u32 registered_cores_mask;
mali_pm_set_pmu_domain_config();
registered_cores_mask = mali_pm_get_registered_cores_mask();
mali_pmu_set_registered_cores_mask(pmu, registered_cores_mask);
MALI_DEBUG_ASSERT(0 == pd_mask_wanted);
}
/* Create all power domains needed (at least one dummy domain) */
err = mali_pm_create_pm_domains();
if (_MALI_OSK_ERR_OK != err) {
mali_pm_terminate();
return err;
}
// add by MTK
MTK_mali_osk_pm_dev_enable();
return _MALI_OSK_ERR_OK;
}
struct mali_spinlock_reentrant *mali_spinlock_reentrant_init(_mali_osk_lock_order_t lock_order)
{
struct mali_spinlock_reentrant *spinlock;
spinlock = _mali_osk_calloc(1, sizeof(struct mali_spinlock_reentrant));
if (NULL == spinlock) {
return NULL;
}
spinlock->lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, lock_order);
if (NULL == spinlock->lock) {
mali_spinlock_reentrant_term(spinlock);
return NULL;
}
return spinlock;
}
struct mali_pm_domain *mali_pm_domain_create(u32 pmu_mask)
{
struct mali_pm_domain* domain = NULL;
u32 domain_id = 0;
domain = mali_pm_domain_get_from_mask(pmu_mask);
if (NULL != domain) return domain;
MALI_DEBUG_PRINT(2, ("Mali PM domain: Creating Mali PM domain (mask=0x%08X)\n", pmu_mask));
domain = (struct mali_pm_domain *)_mali_osk_malloc(sizeof(struct mali_pm_domain));
if (NULL != domain) {
domain->lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_PM_DOMAIN);
if (NULL == domain->lock) {
_mali_osk_free(domain);
return NULL;
}
domain->state = MALI_PM_DOMAIN_ON;
domain->pmu_mask = pmu_mask;
domain->use_count = 0;
domain->group_list = NULL;
domain->group_count = 0;
domain->l2 = NULL;
domain_id = _mali_osk_fls(pmu_mask) - 1;
/* Verify the domain_id */
MALI_DEBUG_ASSERT(MALI_MAX_NUMBER_OF_DOMAINS > domain_id);
/* Verify that pmu_mask only one bit is set */
MALI_DEBUG_ASSERT((1 << domain_id) == pmu_mask);
mali_pm_domains[domain_id] = domain;
return domain;
} else {
MALI_DEBUG_PRINT_ERROR(("Unable to create PM domain\n"));
}
return NULL;
}
_mali_osk_errcode_t mali_gp_scheduler_initialize(void)
{
u32 num_groups;
u32 i;
_mali_osk_errcode_t ret = _MALI_OSK_ERR_OK;
#if defined(MALI_UPPER_HALF_SCHEDULING)
gp_scheduler_lock = _mali_osk_spinlock_irq_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SCHEDULER);
#else
gp_scheduler_lock = _mali_osk_spinlock_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_SCHEDULER);
#endif /* defined(MALI_UPPER_HALF_SCHEDULING) */
if (NULL == gp_scheduler_lock) {
ret = _MALI_OSK_ERR_NOMEM;
goto cleanup;
}
gp_scheduler_working_wait_queue = _mali_osk_wait_queue_init();
if (NULL == gp_scheduler_working_wait_queue) {
ret = _MALI_OSK_ERR_NOMEM;
goto cleanup;
}
/* Find all the available GP cores */
num_groups = mali_group_get_glob_num_groups();
for (i = 0; i < num_groups; i++) {
struct mali_group *group = mali_group_get_glob_group(i);
MALI_DEBUG_ASSERT(NULL != group);
if (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 is only one GP, no point in looking for more */
}
} else {
ret = _MALI_OSK_ERR_ITEM_NOT_FOUND;
goto cleanup;
}
}
return _MALI_OSK_ERR_OK;
cleanup:
if (NULL != gp_scheduler_working_wait_queue) {
_mali_osk_wait_queue_term(gp_scheduler_working_wait_queue);
gp_scheduler_working_wait_queue = NULL;
}
if (NULL != gp_scheduler_lock) {
#if defined(MALI_UPPER_HALF_SCHEDULING)
_mali_osk_spinlock_irq_term(gp_scheduler_lock);
#else
_mali_osk_spinlock_term(gp_scheduler_lock);
#endif /* defined(MALI_UPPER_HALF_SCHEDULING) */
gp_scheduler_lock = NULL;
}
return ret;
}
