/* Called from mali_cluster_reset() when the system is re-turned on */
void mali_group_reset(struct mali_group *group)
{
mali_group_lock(group);
group->session = NULL;
if (NULL != group->mmu)
{
mali_mmu_reset(group->mmu);
}
if (NULL != group->gp_core)
{
mali_gp_reset(group->gp_core);
}
if (NULL != group->pp_core)
{
mali_pp_reset(group->pp_core);
}
mali_group_unlock(group);
}
struct mali_pp_core *mali_pp_create(const _mali_osk_resource_t *resource, struct mali_group *group, mali_bool is_virtual, u32 bcast_id)
{
struct mali_pp_core *core = NULL;
MALI_DEBUG_PRINT(2, ("Mali PP: Creating Mali PP core: %s\n", resource->description));
MALI_DEBUG_PRINT(2, ("Mali PP: Base address of PP core: 0x%x\n", resource->base));
if (mali_global_num_pp_cores >= MALI_MAX_NUMBER_OF_PP_CORES) {
MALI_PRINT_ERROR(("Mali PP: Too many PP core objects created\n"));
return NULL;
}
core = _mali_osk_calloc(1, sizeof(struct mali_pp_core));
if (NULL != core) {
core->core_id = mali_global_num_pp_cores;
core->bcast_id = bcast_id;
if (_MALI_OSK_ERR_OK == mali_hw_core_create(&core->hw_core, resource, MALI200_REG_SIZEOF_REGISTER_BANK)) {
_mali_osk_errcode_t ret;
if (!is_virtual) {
ret = mali_pp_reset(core);
} else {
ret = _MALI_OSK_ERR_OK;
}
if (_MALI_OSK_ERR_OK == ret) {
ret = mali_group_add_pp_core(group, core);
if (_MALI_OSK_ERR_OK == ret) {
/* Setup IRQ handlers (which will do IRQ probing if needed) */
MALI_DEBUG_ASSERT(!is_virtual || -1 != resource->irq);
core->irq = _mali_osk_irq_init(resource->irq,
mali_group_upper_half_pp,
group,
mali_pp_irq_probe_trigger,
mali_pp_irq_probe_ack,
core,
resource->description);
if (NULL != core->irq) {
mali_global_pp_cores[mali_global_num_pp_cores] = core;
mali_global_num_pp_cores++;
return core;
} else {
MALI_PRINT_ERROR(("Mali PP: Failed to setup interrupt handlers for PP core %s\n", core->hw_core.description));
}
mali_group_remove_pp_core(group);
} else {
MALI_PRINT_ERROR(("Mali PP: Failed to add core %s to group\n", core->hw_core.description));
}
}
mali_hw_core_delete(&core->hw_core);
}
_mali_osk_free(core);
} else {
MALI_PRINT_ERROR(("Mali PP: Failed to allocate memory for PP core\n"));
}
return NULL;
}
struct mali_pp_core *mali_pp_create(const _mali_osk_resource_t *resource, struct mali_group *group)
{
struct mali_pp_core* core = NULL;
MALI_DEBUG_PRINT(2, ("Mali PP: Creating Mali PP core: %s\n", resource->description));
MALI_DEBUG_PRINT(2, ("Mali PP: Base address of PP core: 0x%x\n", resource->base));
if (mali_global_num_pp_cores >= MALI_MAX_NUMBER_OF_PP_CORES)
{
MALI_PRINT_ERROR(("Mali PP: Too many PP core objects created\n"));
return NULL;
}
core = _mali_osk_malloc(sizeof(struct mali_pp_core));
if (NULL != core)
{
core->group = group;
core->core_id = mali_global_num_pp_cores;
core->running_job = NULL;
core->counter_src0 = MALI_HW_CORE_NO_COUNTER;
core->counter_src1 = MALI_HW_CORE_NO_COUNTER;
core->counter_src0_used = MALI_HW_CORE_NO_COUNTER;
core->counter_src1_used = MALI_HW_CORE_NO_COUNTER;
if (_MALI_OSK_ERR_OK == mali_hw_core_create(&core->hw_core, resource, MALI200_REG_SIZEOF_REGISTER_BANK))
{
_mali_osk_errcode_t ret;
mali_group_lock(group);
ret = mali_pp_reset(core);
mali_group_unlock(group);
if (_MALI_OSK_ERR_OK == ret)
{
/* Setup IRQ handlers (which will do IRQ probing if needed) */
core->irq = _mali_osk_irq_init(resource->irq,
mali_pp_upper_half,
mali_pp_bottom_half,
mali_pp_irq_probe_trigger,
mali_pp_irq_probe_ack,
core,
"mali_pp_irq_handlers");
if (NULL != core->irq)
{
/* Initialise the timeout timer */
core->timeout_timer = _mali_osk_timer_init();
if(NULL != core->timeout_timer)
{
_mali_osk_timer_setcallback(core->timeout_timer, mali_pp_timeout, (void *)core);
mali_global_pp_cores[mali_global_num_pp_cores] = core;
mali_global_num_pp_cores++;
return core;
}
else
{
MALI_PRINT_ERROR(("Failed to setup timeout timer for PP core %s\n", core->hw_core.description));
/* Release IRQ handlers */
_mali_osk_irq_term(core->irq);
}
}
else
{
MALI_PRINT_ERROR(("Mali PP: Failed to setup interrupt handlers for PP core %s\n", core->hw_core.description));
}
}
mali_hw_core_delete(&core->hw_core);
}
_mali_osk_free(core);
}
else
{
MALI_PRINT_ERROR(("Mali PP: Failed to allocate memory for PP core\n"));
}
return NULL;
}
/* Group lock need to be taken before calling mali_group_complete_jobs. Will release the lock here. */
static void mali_group_complete_jobs(struct mali_group *group, mali_bool complete_gp, mali_bool complete_pp, bool success)
{
mali_bool need_group_reset = MALI_FALSE;
mali_bool gp_success = success;
mali_bool pp_success = success;
MALI_ASSERT_GROUP_LOCKED(group);
if (complete_gp && !complete_pp)
{
MALI_DEBUG_ASSERT_POINTER(group->gp_core);
if (_MALI_OSK_ERR_OK == mali_gp_reset(group->gp_core))
{
struct mali_gp_job *gp_job_to_return = group->gp_running_job;
group->gp_state = MALI_GROUP_CORE_STATE_IDLE;
group->gp_running_job = NULL;
MALI_DEBUG_ASSERT_POINTER(gp_job_to_return);
mali_group_deactivate_page_directory(group, mali_gp_job_get_session(gp_job_to_return));
if(mali_group_other_reschedule_needed(group))
{
mali_group_unlock(group);
mali_pp_scheduler_do_schedule();
}
else
{
mali_group_unlock(group);
}
mali_gp_scheduler_job_done(group, gp_job_to_return, gp_success);
mali_pm_core_event(MALI_CORE_EVENT_GP_STOP); /* It is ok to do this after schedule, since START/STOP is simply ++ and -- anyways */
return;
}
else
{
need_group_reset = MALI_TRUE;
MALI_DEBUG_PRINT(3, ("Mali group: Failed to reset GP, need to reset entire group\n"));
pp_success = MALI_FALSE; /* This might kill PP as well, so this should fail */
}
}
if (complete_pp && !complete_gp)
{
MALI_DEBUG_ASSERT_POINTER(group->pp_core);
if (_MALI_OSK_ERR_OK == mali_pp_reset(group->pp_core))
{
struct mali_pp_job *pp_job_to_return = group->pp_running_job;
u32 pp_sub_job_to_return = group->pp_running_sub_job;
group->pp_state = MALI_GROUP_CORE_STATE_IDLE;
group->pp_running_job = NULL;
MALI_DEBUG_ASSERT_POINTER(pp_job_to_return);
mali_group_deactivate_page_directory(group, mali_pp_job_get_session(pp_job_to_return));
if(mali_group_other_reschedule_needed(group))
{
mali_group_unlock(group);
mali_gp_scheduler_do_schedule();
}
else
{
mali_group_unlock(group);
}
mali_pp_scheduler_job_done(group, pp_job_to_return, pp_sub_job_to_return, pp_success);
mali_pm_core_event(MALI_CORE_EVENT_PP_STOP); /* It is ok to do this after schedule, since START/STOP is simply ++ and -- anyways */
return;
}
else
{
need_group_reset = MALI_TRUE;
MALI_DEBUG_PRINT(3, ("Mali group: Failed to reset PP, need to reset entire group\n"));
gp_success = MALI_FALSE; /* This might kill GP as well, so this should fail */
}
}
else if (complete_gp && complete_pp)
{
need_group_reset = MALI_TRUE;
}
if (MALI_TRUE == need_group_reset)
{
struct mali_gp_job *gp_job_to_return = group->gp_running_job;
struct mali_pp_job *pp_job_to_return = group->pp_running_job;
u32 pp_sub_job_to_return = group->pp_running_sub_job;
mali_bool schedule_other = MALI_FALSE;
MALI_DEBUG_PRINT(3, ("Mali group: Resetting entire group\n"));
group->gp_state = MALI_GROUP_CORE_STATE_IDLE;
group->gp_running_job = NULL;
if (NULL != gp_job_to_return)
{
mali_group_deactivate_page_directory(group, mali_gp_job_get_session(gp_job_to_return));
}
group->pp_state = MALI_GROUP_CORE_STATE_IDLE;
group->pp_running_job = NULL;
if (NULL != pp_job_to_return)
{
mali_group_deactivate_page_directory(group, mali_pp_job_get_session(pp_job_to_return));
}
/* The reset has to be done after mali_group_deactivate_page_directory() */
mali_group_recovery_reset(group);
if (mali_group_other_reschedule_needed(group) && (NULL == gp_job_to_return || NULL == pp_job_to_return))
{
schedule_other = MALI_TRUE;
}
mali_group_unlock(group);
if (NULL != gp_job_to_return)
{
mali_gp_scheduler_job_done(group, gp_job_to_return, gp_success);
mali_pm_core_event(MALI_CORE_EVENT_GP_STOP); /* It is ok to do this after schedule, since START/STOP is simply ++ and -- anyways */
}
else if (schedule_other)
{
mali_pp_scheduler_do_schedule();
}
if (NULL != pp_job_to_return)
{
mali_pp_scheduler_job_done(group, pp_job_to_return, pp_sub_job_to_return, pp_success);
mali_pm_core_event(MALI_CORE_EVENT_PP_STOP); /* It is ok to do this after schedule, since START/STOP is simply ++ and -- anyways */
}
else if (schedule_other)
{
mali_gp_scheduler_do_schedule();
}
return;
}
mali_group_unlock(group);
}
