void mali_control_timer_suspend(mali_bool suspend) { mali_utilization_data_lock(); if (timer_running == MALI_TRUE) { timer_running = MALI_FALSE; mali_utilization_data_unlock(); if (suspend == MALI_TRUE) { _mali_osk_timer_del(mali_control_timer); mali_utilization_reset(); } } else { mali_utilization_data_unlock(); } }
struct mali_gpu_utilization_data *mali_utilization_calculate(u64 *start_time, u64 *time_period, mali_bool *need_add_timer) { u64 time_now; u32 leading_zeroes; u32 shift_val; u32 work_normalized_gpu; u32 work_normalized_gp; u32 work_normalized_pp; u32 period_normalized; u32 utilization_gpu; u32 utilization_gp; u32 utilization_pp; mali_utilization_data_lock(); time_now = _mali_osk_time_get_ns(); *time_period = time_now - *start_time; if (accumulated_work_time_gpu == 0 && work_start_time_gpu == 0) { mali_control_timer_pause(); /* * No work done for this period * - No need to reschedule timer * - Report zero usage */ last_utilization_gpu = 0; last_utilization_gp = 0; last_utilization_pp = 0; mali_util_data.utilization_gpu = last_utilization_gpu; mali_util_data.utilization_gp = last_utilization_gp; mali_util_data.utilization_pp = last_utilization_pp; mali_utilization_data_unlock(); *need_add_timer = MALI_FALSE; mali_executor_hint_disable(MALI_EXECUTOR_HINT_GP_BOUND); MALI_DEBUG_PRINT(4, ("last_utilization_gpu = %d \n", last_utilization_gpu)); MALI_DEBUG_PRINT(4, ("last_utilization_gp = %d \n", last_utilization_gp)); MALI_DEBUG_PRINT(4, ("last_utilization_pp = %d \n", last_utilization_pp)); return &mali_util_data; } /* If we are currently busy, update working period up to now */ if (work_start_time_gpu != 0) { accumulated_work_time_gpu += (time_now - work_start_time_gpu); work_start_time_gpu = time_now; /* GP and/or PP will also be busy if the GPU is busy at this point */ if (work_start_time_gp != 0) { accumulated_work_time_gp += (time_now - work_start_time_gp); work_start_time_gp = time_now; } if (work_start_time_pp != 0) { accumulated_work_time_pp += (time_now - work_start_time_pp); work_start_time_pp = time_now; } } /* * We have two 64-bit values, a dividend and a divisor. * To avoid dependencies to a 64-bit divider, we shift down the two values * equally first. * We shift the dividend up and possibly the divisor down, making the result X in 256. */ /* Shift the 64-bit values down so they fit inside a 32-bit integer */ leading_zeroes = _mali_osk_clz((u32)(*time_period >> 32)); shift_val = 32 - leading_zeroes; work_normalized_gpu = (u32)(accumulated_work_time_gpu >> shift_val); work_normalized_gp = (u32)(accumulated_work_time_gp >> shift_val); work_normalized_pp = (u32)(accumulated_work_time_pp >> shift_val); period_normalized = (u32)(*time_period >> shift_val); /* * Now, we should report the usage in parts of 256 * this means we must shift up the dividend or down the divisor by 8 * (we could do a combination, but we just use one for simplicity, * but the end result should be good enough anyway) */ if (period_normalized > 0x00FFFFFF) { /* The divisor is so big that it is safe to shift it down */ period_normalized >>= 8; } else {