hc
2023-11-06 e3e12f52b214121840b44c91de5b3e5af5d3eb84
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/*
 * Copyright (C) 2010-2012, 2014-2017 ARM Limited. All rights reserved.
 * 
 * This program is free software and is provided to you under the terms of the GNU General Public License version 2
 * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence.
 * 
 * A copy of the licence is included with the program, and can also be obtained from Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 */
 
#include "mali_kernel_utilization.h"
#include "mali_osk.h"
#include "mali_osk_mali.h"
#include "mali_kernel_common.h"
#include "mali_session.h"
#include "mali_dvfs_policy.h"
#include "mali_control_timer.h"
 
static u64 period_start_time = 0;
 
/** .KP : mali_control_timer */
static _mali_osk_timer_t mali_control_timer;
static mali_bool timer_running = MALI_FALSE;
 
/**
 * period_of_notifying_mali_utilization_to_platform_dependent_part,
 * ms 为单位.
 */
static u32 mali_control_timeout = 20;
 
void mali_control_timer_add(u32 timeout)/* 'timeout' : 以 ms 为单位. */
{
   _mali_osk_timer_add(&mali_control_timer, _mali_osk_time_mstoticks(timeout));
}
 
void mali_control_timer_mod(u32 timeout_in_ms)
{
   _mali_osk_timer_mod(&mali_control_timer, _mali_osk_time_mstoticks(timeout_in_ms));
}
 
static void mali_control_timer_callback(void *arg)
{
   if (mali_utilization_enabled()) {
       struct mali_gpu_utilization_data *util_data = NULL;
       u64 time_period = 0;
       mali_bool need_add_timer = MALI_TRUE;
 
       /* Calculate gpu utilization */
       util_data = mali_utilization_calculate(&period_start_time, &time_period, &need_add_timer);
 
       if (util_data) {
#if defined(CONFIG_MALI_DVFS)
           mali_dvfs_policy_realize(util_data, time_period);
#else
           mali_utilization_platform_realize(util_data);
#endif
 
       if (MALI_TRUE == timer_running)
           if (MALI_TRUE == need_add_timer) {
               mali_control_timer_mod(mali_control_timeout);
           }
       }
   }
}
 
/* Init a timer (for now it is used for GPU utilization and dvfs) */
_mali_osk_errcode_t mali_control_timer_init(void)
{
   _mali_osk_device_data data;
 
   if (_MALI_OSK_ERR_OK == _mali_osk_device_data_get(&data)) {
       /* Use device specific settings (if defined) */
       if (0 != data.control_interval) {
           mali_control_timeout = data.control_interval;
           MALI_DEBUG_PRINT(2, ("Mali GPU Timer: %u\n", mali_control_timeout));
       }
   }
 
   _mali_osk_timer_init(&mali_control_timer, mali_control_timer_callback);
 
   return _MALI_OSK_ERR_OK;
}
 
void mali_control_timer_term(void)
{
   _mali_osk_timer_del(&mali_control_timer);
   timer_running = MALI_FALSE;
}
 
mali_bool mali_control_timer_resume(u64 time_now)
{
   mali_utilization_data_assert_locked();
 
   if (timer_running != MALI_TRUE) {
       timer_running = MALI_TRUE;
 
       period_start_time = time_now;
 
       mali_utilization_reset();
 
       return MALI_TRUE;
   }
 
   return MALI_FALSE;
}
 
void mali_control_timer_pause(void)
{
   mali_utilization_data_assert_locked();
   if (timer_running == MALI_TRUE) {
       timer_running = MALI_FALSE;
   }
}
 
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();
   }
}