void mali_pp_scheduler_do_schedule(void)
{
mali_pp_scheduler_lock();
mali_pp_scheduler_schedule();
mali_pp_scheduler_unlock();
}
void mali_pp_scheduler_resume(void)
{
mali_pp_scheduler_lock();
pause_count--; /* Decrement pause_count to allow scheduling again (if it reaches 0) */
if (0 == pause_count)
{
mali_pp_scheduler_schedule();
}
mali_pp_scheduler_unlock();
}
void mali_pp_scheduler_job_done(struct mali_group *group, struct mali_pp_job *job, u32 sub_job, mali_bool success)
{
u32 i;
mali_bool job_is_done;
MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Job %u (0x%08X) part %u/%u completed (%s)\n", mali_pp_job_get_id(job), job, sub_job + 1, mali_pp_job_get_sub_job_count(job), success ? "success" : "failure"));
mali_pp_scheduler_lock();
/* Find slot which was running this job */
for (i = 0; i < num_slots; i++)
{
if (slots[i].group == group)
{
MALI_DEBUG_ASSERT(MALI_PP_SLOT_STATE_WORKING == slots[i].state);
slots[i].state = MALI_PP_SLOT_STATE_IDLE;
slots[i].session = NULL;
num_slots_idle++;
mali_pp_job_mark_sub_job_completed(job, success);
}
}
/* If paused, then this was the last job, so wake up sleeping workers */
if (pause_count > 0)
{
/* Wake up sleeping workers. Their wake-up condition is that
* num_slots == num_slots_idle, so unless we are done working, no
* threads will actually be woken up.
*/
_mali_osk_wait_queue_wake_up(pp_scheduler_working_wait_queue);
}
else
{
mali_pp_scheduler_schedule();
}
job_is_done = mali_pp_job_is_complete(job);
mali_pp_scheduler_unlock();
if (job_is_done)
{
/* Send notification back to user space */
MALI_DEBUG_PRINT(4, ("Mali PP scheduler: All parts completed for job %u (0x%08X)\n", mali_pp_job_get_id(job), job));
mali_pp_scheduler_return_job_to_user(job);
}
}
_mali_osk_errcode_t _mali_ukk_pp_start_job(_mali_uk_pp_start_job_s *args)
{
struct mali_session_data *session;
struct mali_pp_job *job;
MALI_DEBUG_ASSERT_POINTER(args);
MALI_DEBUG_ASSERT_POINTER(args->ctx);
session = (struct mali_session_data*)args->ctx;
job = mali_pp_job_create(session, args, mali_scheduler_get_new_id());
if (NULL == job)
{
return _MALI_OSK_ERR_NOMEM;
}
if (_MALI_OSK_ERR_OK != mali_pp_job_check(job))
{
/* Not a valid job, return to user immediately */
mali_pp_job_mark_sub_job_completed(job, MALI_FALSE); /* Flagging the job as failed. */
mali_pp_scheduler_return_job_to_user(job); /* This will also delete the job object */
return _MALI_OSK_ERR_OK; /* User is notified via a notification, so this call is ok */
}
#if PROFILING_SKIP_PP_JOBS || PROFILING_SKIP_PP_AND_GP_JOBS
#warning PP jobs will not be executed
mali_pp_scheduler_return_job_to_user(job);
return _MALI_OSK_ERR_OK;
#endif
mali_pp_scheduler_lock();
_mali_osk_list_addtail(&job->list, &job_queue);
MALI_DEBUG_PRINT(3, ("Mali PP scheduler: Job %u (0x%08X) with %u parts queued\n", mali_pp_job_get_id(job), job, mali_pp_job_get_sub_job_count(job)));
mali_pp_scheduler_schedule();
mali_pp_scheduler_unlock();
return _MALI_OSK_ERR_OK;
}
void mali_scheduler_schedule_from_mask(mali_scheduler_mask mask, mali_bool deferred_schedule)
{
if (MALI_SCHEDULER_MASK_GP & mask) {
/* GP needs scheduling. */
if (deferred_schedule) {
/* Schedule GP deferred. */
_mali_osk_wq_schedule_work_high_pri(gp_scheduler_wq_high_pri);
} else {
/* Schedule GP now. */
mali_gp_scheduler_schedule();
}
}
if (MALI_SCHEDULER_MASK_PP & mask) {
/* PP needs scheduling. */
if (deferred_schedule) {
/* Schedule PP deferred. */
_mali_osk_wq_schedule_work_high_pri(pp_scheduler_wq_high_pri);
} else {
/* Schedule PP now. */
mali_pp_scheduler_schedule();
}
}
}
static void mali_scheduler_wq_schedule_pp(void *arg)
{
MALI_IGNORE(arg);
mali_pp_scheduler_schedule();
}
