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