drivers/gpu/arm/mali400/mali/linux/mali_profiling_internal.c

   1 /*
   2  * Copyright (C) 2010-2016 ARM Limited. All rights reserved.
   3  *
   4  * This program is free software and is provided to you under the terms of the GNU General Public License version 2
   5  * as published by the Free Software Foundation, and any use by you of this program is subject to the terms of such GNU licence.
   6  *
   7  * A copy of the licence is included with the program, and can also be obtained from Free Software
   8  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
   9  */
  10
  11 #include "mali_kernel_common.h"
  12 #include "mali_osk.h"
  13 #include "mali_osk_mali.h"
  14 #include "mali_ukk.h"
  15 #include "mali_timestamp.h"
  16 #include "mali_osk_profiling.h"
  17 #include "mali_user_settings_db.h"
  18 #include "mali_profiling_internal.h"
  19
  20 typedef struct mali_profiling_entry {
  21         u64 timestamp;
  22         u32 event_id;
  23         u32 data[5];
  24 } mali_profiling_entry;
  25
  26 typedef enum mali_profiling_state {
  27         MALI_PROFILING_STATE_UNINITIALIZED,
  28         MALI_PROFILING_STATE_IDLE,
  29         MALI_PROFILING_STATE_RUNNING,
  30         MALI_PROFILING_STATE_RETURN,
  31 } mali_profiling_state;
  32
  33 static _mali_osk_mutex_t *lock = NULL;
  34 static mali_profiling_state prof_state = MALI_PROFILING_STATE_UNINITIALIZED;
  35 static mali_profiling_entry *profile_entries = NULL;
  36 static _mali_osk_atomic_t profile_insert_index;
  37 static u32 profile_mask = 0;
  38
  39 static inline void add_event(u32 event_id, u32 data0, u32 data1, u32 data2, u32 data3, u32 data4);
  40
  41 void probe_mali_timeline_event(void *data, TP_PROTO(unsigned int event_id, unsigned int d0, unsigned int d1, unsigned
  42                                int d2, unsigned int d3, unsigned int d4))
  43 {
  44         add_event(event_id, d0, d1, d2, d3, d4);
  45 }
  46
  47 _mali_osk_errcode_t _mali_internal_profiling_init(mali_bool auto_start)
  48 {
  49         profile_entries = NULL;
  50         profile_mask = 0;
  51         _mali_osk_atomic_init(&profile_insert_index, 0);
  52
  53         lock = _mali_osk_mutex_init(_MALI_OSK_LOCKFLAG_ORDERED, _MALI_OSK_LOCK_ORDER_PROFILING);
  54         if (NULL == lock) {
  55                 return _MALI_OSK_ERR_FAULT;
  56         }
  57
  58         prof_state = MALI_PROFILING_STATE_IDLE;
  59
  60         if (MALI_TRUE == auto_start) {
  61                 u32 limit = MALI_PROFILING_MAX_BUFFER_ENTRIES; /* Use maximum buffer size */
  62
  63                 mali_set_user_setting(_MALI_UK_USER_SETTING_SW_EVENTS_ENABLE, MALI_TRUE);
  64                 if (_MALI_OSK_ERR_OK != _mali_internal_profiling_start(&limit)) {
  65                         return _MALI_OSK_ERR_FAULT;
  66                 }
  67         }
  68
  69         return _MALI_OSK_ERR_OK;
  70 }
  71
  72 void _mali_internal_profiling_term(void)
  73 {
  74         u32 count;
  75
  76         /* Ensure profiling is stopped */
  77         _mali_internal_profiling_stop(&count);
  78
  79         prof_state = MALI_PROFILING_STATE_UNINITIALIZED;
  80
  81         if (NULL != profile_entries) {
  82                 _mali_osk_vfree(profile_entries);
  83                 profile_entries = NULL;
  84         }
  85
  86         if (NULL != lock) {
  87                 _mali_osk_mutex_term(lock);
  88                 lock = NULL;
  89         }
  90 }
  91
  92 _mali_osk_errcode_t _mali_internal_profiling_start(u32 *limit)
  93 {
  94         _mali_osk_errcode_t ret;
  95         mali_profiling_entry *new_profile_entries;
  96
  97         _mali_osk_mutex_wait(lock);
  98
  99         if (MALI_PROFILING_STATE_RUNNING == prof_state) {
 100                 _mali_osk_mutex_signal(lock);
 101                 return _MALI_OSK_ERR_BUSY;
 102         }
 103
 104         new_profile_entries = _mali_osk_valloc(*limit * sizeof(mali_profiling_entry));
 105
 106         if (NULL == new_profile_entries) {
 107                 _mali_osk_mutex_signal(lock);
 108                 _mali_osk_vfree(new_profile_entries);
 109                 return _MALI_OSK_ERR_NOMEM;
 110         }
 111
 112         if (MALI_PROFILING_MAX_BUFFER_ENTRIES < *limit) {
 113                 *limit = MALI_PROFILING_MAX_BUFFER_ENTRIES;
 114         }
 115
 116         profile_mask = 1;
 117         while (profile_mask <= *limit) {
 118                 profile_mask <<= 1;
 119         }
 120         profile_mask >>= 1;
 121
 122         *limit = profile_mask;
 123
 124         profile_mask--; /* turns the power of two into a mask of one less */
 125
 126         if (MALI_PROFILING_STATE_IDLE != prof_state) {
 127                 _mali_osk_mutex_signal(lock);
 128                 _mali_osk_vfree(new_profile_entries);
 129                 return _MALI_OSK_ERR_INVALID_ARGS; /* invalid to call this function in this state */
 130         }
 131
 132         profile_entries = new_profile_entries;
 133
 134         ret = _mali_timestamp_reset();
 135
 136         if (_MALI_OSK_ERR_OK == ret) {
 137                 prof_state = MALI_PROFILING_STATE_RUNNING;
 138         } else {
 139                 _mali_osk_vfree(profile_entries);
 140                 profile_entries = NULL;
 141         }
 142
 143         register_trace_mali_timeline_event(probe_mali_timeline_event, NULL);
 144
 145         _mali_osk_mutex_signal(lock);
 146         return ret;
 147 }
 148
 149 static inline void add_event(u32 event_id, u32 data0, u32 data1, u32 data2, u32 data3, u32 data4)
 150 {
 151         u32 cur_index = (_mali_osk_atomic_inc_return(&profile_insert_index) - 1) & profile_mask;
 152
 153         profile_entries[cur_index].timestamp = _mali_timestamp_get();
 154         profile_entries[cur_index].event_id = event_id;
 155         profile_entries[cur_index].data[0] = data0;
 156         profile_entries[cur_index].data[1] = data1;
 157         profile_entries[cur_index].data[2] = data2;
 158         profile_entries[cur_index].data[3] = data3;
 159         profile_entries[cur_index].data[4] = data4;
 160
 161         /* If event is "leave API function", add current memory usage to the event
 162          * as data point 4.  This is used in timeline profiling to indicate how
 163          * much memory was used when leaving a function. */
 164         if (event_id == (MALI_PROFILING_EVENT_TYPE_SINGLE | MALI_PROFILING_EVENT_CHANNEL_SOFTWARE | MALI_PROFILING_EVENT_REASON_SINGLE_SW_LEAVE_API_FUNC)) {
 165                 profile_entries[cur_index].data[4] = _mali_ukk_report_memory_usage();
 166         }
 167 }
 168
 169 _mali_osk_errcode_t _mali_internal_profiling_stop(u32 *count)
 170 {
 171         _mali_osk_mutex_wait(lock);
 172
 173         if (MALI_PROFILING_STATE_RUNNING != prof_state) {
 174                 _mali_osk_mutex_signal(lock);
 175                 return _MALI_OSK_ERR_INVALID_ARGS; /* invalid to call this function in this state */
 176         }
 177
 178         /* go into return state (user to retreive events), no more events will be added after this */
 179         prof_state = MALI_PROFILING_STATE_RETURN;
 180
 181         unregister_trace_mali_timeline_event(probe_mali_timeline_event, NULL);
 182
 183         _mali_osk_mutex_signal(lock);
 184
 185         tracepoint_synchronize_unregister();
 186
 187         *count = _mali_osk_atomic_read(&profile_insert_index);
 188         if (*count > profile_mask) *count = profile_mask;
 189
 190         return _MALI_OSK_ERR_OK;
 191 }
 192
 193 u32 _mali_internal_profiling_get_count(void)
 194 {
 195         u32 retval = 0;
 196
 197         _mali_osk_mutex_wait(lock);
 198         if (MALI_PROFILING_STATE_RETURN == prof_state) {
 199                 retval = _mali_osk_atomic_read(&profile_insert_index);
 200                 if (retval > profile_mask) retval = profile_mask;
 201         }
 202         _mali_osk_mutex_signal(lock);
 203
 204         return retval;
 205 }
 206
 207 _mali_osk_errcode_t _mali_internal_profiling_get_event(u32 index, u64 *timestamp, u32 *event_id, u32 data[5])
 208 {
 209         u32 raw_index = _mali_osk_atomic_read(&profile_insert_index);
 210
 211         _mali_osk_mutex_wait(lock);
 212
 213         if (index < profile_mask) {
 214                 if ((raw_index & ~profile_mask) != 0) {
 215                         index += raw_index;
 216                         index &= profile_mask;
 217                 }
 218
 219                 if (prof_state != MALI_PROFILING_STATE_RETURN) {
 220                         _mali_osk_mutex_signal(lock);
 221                         return _MALI_OSK_ERR_INVALID_ARGS; /* invalid to call this function in this state */
 222                 }
 223
 224                 if (index >= raw_index) {
 225                         _mali_osk_mutex_signal(lock);
 226                         return _MALI_OSK_ERR_FAULT;
 227                 }
 228
 229                 *timestamp = profile_entries[index].timestamp;
 230                 *event_id = profile_entries[index].event_id;
 231                 data[0] = profile_entries[index].data[0];
 232                 data[1] = profile_entries[index].data[1];
 233                 data[2] = profile_entries[index].data[2];
 234                 data[3] = profile_entries[index].data[3];
 235                 data[4] = profile_entries[index].data[4];
 236         } else {
 237                 _mali_osk_mutex_signal(lock);
 238                 return _MALI_OSK_ERR_FAULT;
 239         }
 240
 241         _mali_osk_mutex_signal(lock);
 242         return _MALI_OSK_ERR_OK;
 243 }
 244
 245 _mali_osk_errcode_t _mali_internal_profiling_clear(void)
 246 {
 247         _mali_osk_mutex_wait(lock);
 248
 249         if (MALI_PROFILING_STATE_RETURN != prof_state) {
 250                 _mali_osk_mutex_signal(lock);
 251                 return _MALI_OSK_ERR_INVALID_ARGS; /* invalid to call this function in this state */
 252         }
 253
 254         prof_state = MALI_PROFILING_STATE_IDLE;
 255         profile_mask = 0;
 256         _mali_osk_atomic_init(&profile_insert_index, 0);
 257
 258         if (NULL != profile_entries) {
 259                 _mali_osk_vfree(profile_entries);
 260                 profile_entries = NULL;
 261         }
 262
 263         _mali_osk_mutex_signal(lock);
 264         return _MALI_OSK_ERR_OK;
 265 }
 266
 267 mali_bool _mali_internal_profiling_is_recording(void)
 268 {
 269         return prof_state == MALI_PROFILING_STATE_RUNNING ? MALI_TRUE : MALI_FALSE;
 270 }
 271
 272 mali_bool _mali_internal_profiling_have_recording(void)
 273 {
 274         return prof_state == MALI_PROFILING_STATE_RETURN ? MALI_TRUE : MALI_FALSE;
 275 }