_mali_osk_errcode_t mali_mmu_initialize(void)
{
/* allocate the helper pages */
mali_empty_page_directory_phys = mali_allocate_empty_page(&mali_empty_page_directory_virt);
if (0 == mali_empty_page_directory_phys) {
MALI_DEBUG_PRINT_ERROR(("Mali MMU: Could not allocate empty page directory.\n"));
mali_empty_page_directory_phys = MALI_INVALID_PAGE;
return _MALI_OSK_ERR_NOMEM;
}
if (_MALI_OSK_ERR_OK != mali_create_fault_flush_pages(&mali_page_fault_flush_page_directory,
&mali_page_fault_flush_page_directory_mapping,
&mali_page_fault_flush_page_table,
&mali_page_fault_flush_page_table_mapping,
&mali_page_fault_flush_data_page,
&mali_page_fault_flush_data_page_mapping)) {
MALI_DEBUG_PRINT_ERROR(("Mali MMU: Could not allocate fault flush pages\n"));
mali_free_empty_page(mali_empty_page_directory_phys, mali_empty_page_directory_virt);
mali_empty_page_directory_phys = MALI_INVALID_PAGE;
mali_empty_page_directory_virt = NULL;
return _MALI_OSK_ERR_NOMEM;
}
return _MALI_OSK_ERR_OK;
}
_mali_osk_errcode_t mali_core_signal_power_down( mali_pmm_core_id core, mali_bool immediate_only )
{
switch( core )
{
case MALI_PMM_CORE_GP:
MALI_CHECK_NO_ERROR(maligp_signal_power_down(immediate_only));
break;
#if defined USING_MALI400_L2_CACHE
case MALI_PMM_CORE_L2:
/* Nothing to do */
break;
#endif
case MALI_PMM_CORE_PP0:
MALI_CHECK_NO_ERROR(malipp_signal_power_down(0, immediate_only));
break;
case MALI_PMM_CORE_PP1:
MALI_CHECK_NO_ERROR(malipp_signal_power_down(1, immediate_only));
break;
case MALI_PMM_CORE_PP2:
MALI_CHECK_NO_ERROR(malipp_signal_power_down(2, immediate_only));
break;
case MALI_PMM_CORE_PP3:
MALI_CHECK_NO_ERROR(malipp_signal_power_down(3, immediate_only));
break;
default:
/* Unknown core */
MALI_DEBUG_PRINT_ERROR( ("Unknown core signalled with power down: %d\n", core) );
MALI_ERROR( _MALI_OSK_ERR_INVALID_ARGS );
}
MALI_SUCCESS;
}
int soft_job_start_wrapper(struct mali_session_data *session, _mali_uk_soft_job_start_s __user *uargs)
{
_mali_uk_soft_job_start_s kargs;
u32 type, point;
u64 user_job;
struct mali_timeline_fence fence;
struct mali_soft_job *job = NULL;
u32 __user *job_id_ptr = NULL;
/* If the job was started successfully, 0 is returned. If there was an error, but the job
* was started, we return -ENOENT. For anything else returned, the job was not started. */
MALI_CHECK_NON_NULL(uargs, -EINVAL);
MALI_CHECK_NON_NULL(session, -EINVAL);
MALI_DEBUG_ASSERT_POINTER(session->soft_job_system);
if (0 != copy_from_user(&kargs, uargs, sizeof(kargs))) {
return -EFAULT;
}
type = kargs.type;
user_job = kargs.user_job;
job_id_ptr = (u32 __user *)(uintptr_t)kargs.job_id_ptr;
mali_timeline_fence_copy_uk_fence(&fence, &kargs.fence);
if ((MALI_SOFT_JOB_TYPE_USER_SIGNALED != type) && (MALI_SOFT_JOB_TYPE_SELF_SIGNALED != type)) {
MALI_DEBUG_PRINT_ERROR(("Invalid soft job type specified\n"));
return -EINVAL;
}
/* Create soft job. */
job = mali_soft_job_create(session->soft_job_system, (enum mali_soft_job_type)type, user_job);
if (unlikely(NULL == job)) {
return map_errcode(_MALI_OSK_ERR_NOMEM);
}
/* Write job id back to user space. */
if (0 != put_user(job->id, job_id_ptr)) {
MALI_PRINT_ERROR(("Mali Soft Job: failed to put job id"));
mali_soft_job_destroy(job);
return map_errcode(_MALI_OSK_ERR_NOMEM);
}
/* Start soft job. */
point = mali_soft_job_start(job, &fence);
if (0 != put_user(point, &uargs->point)) {
/* Let user space know that something failed after the job was started. */
return -ENOENT;
}
return 0;
}
_mali_osk_errcode_t mali_core_signal_power_up( mali_pmm_core_id core, mali_bool queue_only )
{
switch( core )
{
case MALI_PMM_CORE_GP:
MALI_CHECK_NO_ERROR(maligp_signal_power_up(queue_only));
break;
#if defined USING_MALI400_L2_CACHE
case MALI_PMM_CORE_L2:
if( !queue_only )
{
/* Enable L2 cache due to power up */
mali_kernel_l2_cache_do_enable();
/* Invalidate the cache on power up */
MALI_DEBUG_PRINT(5, ("L2 Cache: Invalidate all\n"));
MALI_CHECK_NO_ERROR(mali_kernel_l2_cache_invalidate_all());
}
break;
#endif
case MALI_PMM_CORE_PP0:
MALI_CHECK_NO_ERROR(malipp_signal_power_up(0, queue_only));
break;
case MALI_PMM_CORE_PP1:
MALI_CHECK_NO_ERROR(malipp_signal_power_up(1, queue_only));
break;
case MALI_PMM_CORE_PP2:
MALI_CHECK_NO_ERROR(malipp_signal_power_up(2, queue_only));
break;
case MALI_PMM_CORE_PP3:
MALI_CHECK_NO_ERROR(malipp_signal_power_up(3, queue_only));
break;
default:
/* Unknown core */
MALI_DEBUG_PRINT_ERROR( ("Unknown core signalled with power up: %d\n", core) );
MALI_ERROR( _MALI_OSK_ERR_INVALID_ARGS );
}
MALI_SUCCESS;
}
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;
}
