drivers/gpu/arm/t6xx/kbase/src/common/mali_kbase_trace_timeline.h

   1 /*
   2  *
   3  * (C) COPYRIGHT ARM Limited. All rights reserved.
   4  *
   5  * This program is free software and is provided to you under the terms of the
   6  * GNU General Public License version 2 as published by the Free Software
   7  * Foundation, and any use by you of this program is subject to the terms
   8  * of such GNU licence.
   9  *
  10  * A copy of the licence is included with the program, and can also be obtained
  11  * from Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  12  * Boston, MA  02110-1301, USA.
  13  *
  14  */
  15
  16
  17
  18
  19
  20 #if !defined(_KBASE_TRACE_TIMELINE_H)
  21 #define _KBASE_TRACE_TIMELINE_H
  22
  23 #ifdef CONFIG_MALI_TRACE_TIMELINE
  24
  25 typedef enum
  26 {
  27         #define KBASE_TIMELINE_TRACE_CODE(enum_val, desc, format, format_desc) enum_val
  28         #include "mali_kbase_trace_timeline_defs.h"
  29         #undef KBASE_TIMELINE_TRACE_CODE
  30 } kbase_trace_timeline_code;
  31
  32 /** Initialize Timeline DebugFS entries */
  33 mali_error kbasep_trace_timeline_debugfs_init(kbase_device *kbdev);
  34 /** Terminate Timeline DebugFS entries */
  35 void kbasep_trace_timeline_debugfs_term(kbase_device *kbdev);
  36
  37 /* mali_timeline.h defines kernel tracepoints used by the KBASE_TIMELINE
  38  * functions.
  39  * Output is timestamped by either sched_clock() (default), local_clock(), or
  40  * cpu_clock(), depending on /sys/kernel/debug/tracing/trace_clock */
  41 #include "mali_timeline.h"
  42
  43 /* Trace number of atoms in flight for kctx (atoms either not completed, or in
  44    process of being returned to user */
  45 #define KBASE_TIMELINE_ATOMS_IN_FLIGHT(kctx, count)                                 \
  46         do                                                                          \
  47         {                                                                           \
  48                 struct timespec ts;                                                 \
  49                 getnstimeofday(&ts);                                                \
  50                 trace_mali_timeline_atoms_in_flight(ts.tv_sec, ts.tv_nsec,          \
  51                                                             (int)kctx->timeline.owner_tgid, \
  52                                                             count);                         \
  53         } while (0)
  54
  55 /* Trace atom_id being Ready to Run */
  56 #define KBASE_TIMELINE_ATOM_READY(kctx, atom_id)                   \
  57         do                                                             \
  58         {                                                              \
  59                 struct timespec ts;                                        \
  60                 getnstimeofday(&ts);                                       \
  61                 trace_mali_timeline_atom(ts.tv_sec, ts.tv_nsec,            \
  62                                          CTX_FLOW_ATOM_READY,              \
  63                                          (int)kctx->timeline.owner_tgid,   \
  64                                          atom_id);                         \
  65         } while (0)
  66
  67
  68 /* Trace number of atoms submitted to job slot js
  69  *
  70  * NOTE: This uses a different tracepoint to the head/next/soft-stop actions,
  71  * so that those actions can be filtered out separately from this
  72  *
  73  * This is because this is more useful, as we can use it to calculate general
  74  * utilization easily and accurately */
  75 #define KBASE_TIMELINE_ATOMS_SUBMITTED(kctx, js, count)                             \
  76         do                                                                          \
  77         {                                                                           \
  78                 struct timespec ts;                                                 \
  79                 getnstimeofday(&ts);                                                \
  80                 trace_mali_timeline_gpu_slot_active(ts.tv_sec, ts.tv_nsec,          \
  81                                                     SW_SET_GPU_SLOT_ACTIVE,         \
  82                                                     (int)kctx->timeline.owner_tgid, \
  83                                                     js, count);                     \
  84         } while (0)
  85
  86
  87 /* Trace atoms present in JSn_NEXT */
  88 #define KBASE_TIMELINE_JOB_START_NEXT(kctx, js, count)                             \
  89         do                                                                          \
  90         {                                                                           \
  91                 struct timespec ts;                                                 \
  92                 getnstimeofday(&ts);                                                \
  93                 trace_mali_timeline_gpu_slot_action(ts.tv_sec, ts.tv_nsec,          \
  94                                                     SW_SET_GPU_SLOT_NEXT, \
  95                                                     (int)kctx->timeline.owner_tgid, \
  96                                                     js, count);                     \
  97         } while (0)
  98
  99 /* Trace atoms present in JSn_HEAD */
 100 #define KBASE_TIMELINE_JOB_START_HEAD(kctx, js, count)                             \
 101         do                                                                          \
 102         {                                                                           \
 103                 struct timespec ts;                                                 \
 104                 getnstimeofday(&ts);                                                \
 105                 trace_mali_timeline_gpu_slot_action(ts.tv_sec, ts.tv_nsec,          \
 106                                                     SW_SET_GPU_SLOT_HEAD,           \
 107                                                     (int)kctx->timeline.owner_tgid, \
 108                                                     js, count);                     \
 109         } while (0)
 110
 111 /* Trace that a soft stop/evict from next is being attempted on a slot */
 112 #define KBASE_TIMELINE_TRY_SOFT_STOP(kctx, js, count) \
 113         do                                                                          \
 114         {                                                                           \
 115                 struct timespec ts;                                                 \
 116                 getnstimeofday(&ts);                                                \
 117                 trace_mali_timeline_gpu_slot_action(ts.tv_sec, ts.tv_nsec,          \
 118                                                     SW_SET_GPU_SLOT_STOPPING,       \
 119                                                     (kctx)?(int)kctx->timeline.owner_tgid:0, \
 120                                                     js, count);                     \
 121         } while (0)
 122
 123
 124
 125 /* Trace state of overall GPU power */
 126 #define KBASE_TIMELINE_GPU_POWER(kbdev, active)                                    \
 127         do                                                                         \
 128         {                                                                          \
 129                 struct timespec ts;                                                \
 130                 getnstimeofday(&ts);                                               \
 131                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,        \
 132                                                      SW_SET_GPU_POWER_ACTIVE, active); \
 133         } while (0)
 134
 135 /* Trace state of tiler power */
 136 #define KBASE_TIMELINE_POWER_TILER(kbdev, bitmap)                               \
 137         do                                                                      \
 138         {                                                                       \
 139                 struct timespec ts;                                             \
 140                 getnstimeofday(&ts);                                            \
 141                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,     \
 142                                                      SW_SET_GPU_POWER_TILER_ACTIVE, \
 143                                                      hweight64(bitmap));        \
 144         } while (0)
 145
 146 /* Trace number of shaders currently powered */
 147 #define KBASE_TIMELINE_POWER_SHADER(kbdev, bitmap)                               \
 148         do                                                                       \
 149         {                                                                        \
 150                 struct timespec ts;                                              \
 151                 getnstimeofday(&ts);                                             \
 152                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,      \
 153                                                      SW_SET_GPU_POWER_SHADER_ACTIVE, \
 154                                                      hweight64(bitmap));         \
 155         } while (0)
 156
 157 /* Trace state of L2 power */
 158 #define KBASE_TIMELINE_POWER_L2(kbdev, bitmap)                              \
 159         do                                                                      \
 160         {                                                                       \
 161                 struct timespec ts;                                                 \
 162                 getnstimeofday(&ts);                                                \
 163                 trace_mali_timeline_gpu_power_active(ts.tv_sec, ts.tv_nsec,         \
 164                                                              SW_SET_GPU_POWER_L2_ACTIVE,    \
 165                                                              hweight64(bitmap));            \
 166         }while(0)
 167
 168 /* Trace state of L2 cache*/
 169 #define KBASE_TIMELINE_POWERING_L2(kbdev)                                   \
 170         do                                                                      \
 171         {                                                                       \
 172                 struct timespec ts;                                                 \
 173                 getnstimeofday(&ts);                                                \
 174                 trace_mali_timeline_l2_power_active(ts.tv_sec, ts.tv_nsec,              \
 175                                                     SW_FLOW_GPU_POWER_L2_POWERING,  \
 176                                                     1);                             \
 177         }while(0)
 178
 179 #define KBASE_TIMELINE_POWERED_L2(kbdev)                                    \
 180         do                                                                      \
 181         {                                                                       \
 182                 struct timespec ts;                                                 \
 183                 getnstimeofday(&ts);                                                \
 184                 trace_mali_timeline_l2_power_active(ts.tv_sec, ts.tv_nsec,          \
 185                                                     SW_FLOW_GPU_POWER_L2_ACTIVE,    \
 186                                                      1);                            \
 187         }while(0)
 188
 189 /* Trace kbase_pm_send_event message send */
 190 #define KBASE_TIMELINE_PM_SEND_EVENT(kbdev, event_type, pm_event_id) \
 191         do                                                               \
 192         {                                                                \
 193                 struct timespec ts;                                          \
 194                 getnstimeofday(&ts);                                         \
 195                 trace_mali_timeline_pm_event(ts.tv_sec, ts.tv_nsec,          \
 196                                              SW_FLOW_PM_SEND_EVENT,          \
 197                                              event_type, pm_event_id);       \
 198         } while (0)
 199
 200 /* Trace kbase_pm_worker message receive */
 201 #define KBASE_TIMELINE_PM_HANDLE_EVENT(kbdev, event_type, pm_event_id) \
 202         do                                                                 \
 203         {                                                                  \
 204                 struct timespec ts;                                            \
 205                 getnstimeofday(&ts);                                           \
 206                 trace_mali_timeline_pm_event(ts.tv_sec, ts.tv_nsec,            \
 207                                              SW_FLOW_PM_HANDLE_EVENT,          \
 208                                              event_type, pm_event_id);        \
 209         } while (0)
 210
 211
 212 /* Trace atom_id starting in JSn_HEAD */
 213 #define KBASE_TIMELINE_JOB_START(kctx, js, _consumerof_atom_number)     \
 214         do                                                                  \
 215         {                                                                   \
 216                 struct timespec ts;                                             \
 217                 getnstimeofday(&ts);                                            \
 218                 trace_mali_timeline_slot_atom(ts.tv_sec, ts.tv_nsec,            \
 219                                               HW_START_GPU_JOB_CHAIN_SW_APPROX, \
 220                                               (int)kctx->timeline.owner_tgid,   \
 221                                               js, _consumerof_atom_number);     \
 222         } while (0)
 223
 224 /* Trace atom_id stopping on JSn_HEAD */
 225 #define KBASE_TIMELINE_JOB_STOP(kctx, js, _producerof_atom_number_completed) \
 226         do                                                                  \
 227         {                                                                   \
 228                 struct timespec ts;                                             \
 229                 getnstimeofday(&ts);                                            \
 230                 trace_mali_timeline_slot_atom(ts.tv_sec, ts.tv_nsec,            \
 231                                               HW_STOP_GPU_JOB_CHAIN_SW_APPROX,  \
 232                                               (int)kctx->timeline.owner_tgid,   \
 233                                               js, _producerof_atom_number_completed);     \
 234         } while (0)
 235
 236 /** Trace beginning/end of a call to kbase_pm_check_transitions_nolock from a
 237  * certin caller */
 238 #define KBASE_TIMELINE_PM_CHECKTRANS(kbdev, trace_code) \
 239         do                                                                  \
 240         {                                                                   \
 241                 struct timespec ts;                                             \
 242                 getnstimeofday(&ts);                                            \
 243                 trace_mali_timeline_pm_checktrans(ts.tv_sec, ts.tv_nsec,        \
 244                                                   trace_code, \
 245                                                   1);     \
 246         } while (0)
 247
 248 /* NOTE: kbase_timeline_pm_cores_func() is in mali_kbase_pm_policy.c */
 249
 250 /**
 251  * Trace that an atom is starting on a job slot
 252  *
 253  * The caller must be holding kbasep_js_device_data::runpool_irq::lock
 254  */
 255 void kbase_timeline_job_slot_submit(kbase_device *kbdev, kbase_context *kctx,
 256                                     kbase_jd_atom *katom, int js);
 257
 258 /**
 259  * Trace that an atom has done on a job slot
 260  *
 261  * 'Done' in this sense can occur either because:
 262  * - the atom in JSn_HEAD finished
 263  * - the atom in JSn_NEXT was evicted
 264  *
 265  * Whether the atom finished or was evicted is passed in @a done_code
 266  *
 267  * It is assumed that the atom has already been removed from the submit slot,
 268  * with either:
 269  * - kbasep_jm_dequeue_submit_slot()
 270  * - kbasep_jm_dequeue_tail_submit_slot()
 271  *
 272  * The caller must be holding kbasep_js_device_data::runpool_irq::lock
 273  */
 274 void kbase_timeline_job_slot_done(kbase_device *kbdev, kbase_context *kctx,
 275                                   kbase_jd_atom *katom, int js,
 276                                   kbasep_js_atom_done_code done_code);
 277
 278
 279 /** Trace a pm event starting */
 280 void kbase_timeline_pm_send_event(kbase_device *kbdev,
 281                                   kbase_timeline_pm_event event_sent);
 282
 283 /** Trace a pm event finishing */
 284 void kbase_timeline_pm_check_handle_event(kbase_device *kbdev, kbase_timeline_pm_event event);
 285
 286 /** Check whether a pm event was present, and if so trace finishing it */
 287 void kbase_timeline_pm_handle_event(kbase_device *kbdev, kbase_timeline_pm_event event);
 288
 289 /** Trace L2 power-up start */
 290 void kbase_timeline_pm_l2_transition_start(kbase_device *kbdev);
 291
 292 /** Trace L2 power-up done */
 293 void kbase_timeline_pm_l2_transition_done(kbase_device *kbdev);
 294
 295 #else
 296
 297 #define KBASE_TIMELINE_ATOMS_IN_FLIGHT(kctx, count) CSTD_NOP()
 298
 299 #define KBASE_TIMELINE_ATOM_READY(kctx, atom_id) CSTD_NOP()
 300
 301 #define KBASE_TIMELINE_ATOMS_SUBMITTED(kctx, js, count) CSTD_NOP()
 302
 303 #define KBASE_TIMELINE_JOB_START_NEXT(kctx, js, count) CSTD_NOP()
 304
 305 #define KBASE_TIMELINE_JOB_START_HEAD(kctx, js, count) CSTD_NOP()
 306
 307 #define KBASE_TIMELINE_TRY_SOFT_STOP(kctx, js, count) CSTD_NOP()
 308
 309 #define KBASE_TIMELINE_GPU_POWER(kbdev, active) CSTD_NOP()
 310
 311 #define KBASE_TIMELINE_POWER_TILER(kbdev, bitmap) CSTD_NOP()
 312
 313 #define KBASE_TIMELINE_POWER_SHADER(kbdev, bitmap) CSTD_NOP()
 314
 315 #define KBASE_TIMELINE_POWER_L2(kbdev, active) CSTD_NOP()
 316
 317 #define KBASE_TIMELINE_POWERING_L2(kbdev) CSTD_NOP()
 318
 319 #define KBASE_TIMELINE_POWERED_L2(kbdev)  CSTD_NOP()
 320
 321 #define KBASE_TIMELINE_PM_SEND_EVENT(kbdev, event_type, pm_event_id) CSTD_NOP()
 322
 323 #define KBASE_TIMELINE_PM_HANDLE_EVENT(kbdev, event_type, pm_event_id) CSTD_NOP()
 324
 325 #define KBASE_TIMELINE_JOB_START(kctx, js, _consumerof_atom_number) CSTD_NOP()
 326
 327 #define KBASE_TIMELINE_JOB_STOP(kctx, js, _producerof_atom_number_completed) CSTD_NOP()
 328
 329 #define KBASE_TIMELINE_PM_CHECKTRANS(kbdev, trace_code) CSTD_NOP()
 330
 331 static INLINE void kbase_timeline_job_slot_submit(kbase_device *kbdev, kbase_context *kctx,
 332                                     kbase_jd_atom *katom, int js)
 333 {
 334         lockdep_assert_held(&kbdev->js_data.runpool_irq.lock);
 335 }
 336
 337 static INLINE void kbase_timeline_job_slot_done(kbase_device *kbdev, kbase_context *kctx,
 338                                     kbase_jd_atom *katom, int js,
 339                                     kbasep_js_atom_done_code done_code)
 340 {
 341         lockdep_assert_held(&kbdev->js_data.runpool_irq.lock);
 342 }
 343
 344 static INLINE void kbase_timeline_pm_send_event(kbase_device *kbdev, kbase_timeline_pm_event event_sent)
 345 {
 346 }
 347
 348 static INLINE void kbase_timeline_pm_check_handle_event(kbase_device *kbdev, kbase_timeline_pm_event event)
 349 {
 350 }
 351
 352 static INLINE void kbase_timeline_pm_handle_event(kbase_device *kbdev, kbase_timeline_pm_event event)
 353 {
 354 }
 355
 356 static INLINE void kbase_timeline_pm_l2_transition_start(kbase_device *kbdev)
 357 {
 358
 359 }
 360
 361 static INLINE void kbase_timeline_pm_l2_transition_done(kbase_device *kbdev)
 362 {
 363
 364 }
 365 #endif                          /* CONFIG_MALI_TRACE_TIMELINE */
 366
 367 #endif                          /* _KBASE_TRACE_TIMELINE_H */
 368