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

   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 #include <kbase/src/common/mali_kbase.h>
  21 #include <kbase/src/common/mali_kbase_jm.h>
  22
  23 #define CREATE_TRACE_POINTS
  24
  25 #ifdef CONFIG_MALI_TRACE_TIMELINE
  26 #include "mali_timeline.h"
  27
  28 #include <linux/debugfs.h>
  29 #include <linux/seq_file.h>
  30
  31 struct kbase_trace_timeline_desc
  32 {
  33         char *enum_str;
  34         char *desc;
  35         char *format;
  36         char *format_desc;
  37 };
  38
  39 struct kbase_trace_timeline_desc kbase_trace_timeline_desc_table[] =
  40 {
  41         #define KBASE_TIMELINE_TRACE_CODE(enum_val, desc, format, format_desc) { #enum_val, desc, format, format_desc }
  42         #include "mali_kbase_trace_timeline_defs.h"
  43         #undef KBASE_TIMELINE_TRACE_CODE
  44 };
  45
  46 #define KBASE_NR_TRACE_CODES ARRAY_SIZE(kbase_trace_timeline_desc_table)
  47
  48 STATIC void *kbasep_trace_timeline_seq_start(struct seq_file *s, loff_t *pos)
  49 {
  50         if (*pos >= KBASE_NR_TRACE_CODES)
  51                 return NULL;
  52
  53         return &kbase_trace_timeline_desc_table[*pos];
  54 }
  55
  56 STATIC void kbasep_trace_timeline_seq_stop(struct seq_file *s, void *data)
  57 {
  58 }
  59
  60 STATIC void *kbasep_trace_timeline_seq_next(struct seq_file *s, void *data, loff_t *pos)
  61 {
  62         (*pos)++;
  63
  64         if (*pos == KBASE_NR_TRACE_CODES)
  65                 return NULL;
  66
  67         return &kbase_trace_timeline_desc_table[*pos];
  68 }
  69
  70 STATIC int kbasep_trace_timeline_seq_show(struct seq_file *s, void *data)
  71 {
  72         struct kbase_trace_timeline_desc *trace_desc = data;
  73
  74         seq_printf(s, "%s#%s#%s#%s\n", trace_desc->enum_str, trace_desc->desc, trace_desc->format, trace_desc->format_desc);
  75         return 0;
  76 }
  77
  78
  79 static const struct seq_operations kbasep_trace_timeline_seq_ops = {
  80         .start = kbasep_trace_timeline_seq_start,
  81         .next = kbasep_trace_timeline_seq_next,
  82         .stop = kbasep_trace_timeline_seq_stop,
  83         .show = kbasep_trace_timeline_seq_show,
  84 };
  85
  86 STATIC int kbasep_trace_timeline_debugfs_open(struct inode *inode, struct file *file)
  87 {
  88         return seq_open(file, &kbasep_trace_timeline_seq_ops);
  89 }
  90
  91 static const struct file_operations kbasep_trace_timeline_debugfs_fops = {
  92         .open = kbasep_trace_timeline_debugfs_open,
  93         .read = seq_read,
  94         .llseek = seq_lseek,
  95         .release = seq_release_private,
  96 };
  97
  98 mali_error kbasep_trace_timeline_debugfs_init(kbase_device *kbdev)
  99 {
 100         kbdev->timeline.dentry = debugfs_create_file("mali_timeline_defs", S_IRUGO, NULL, NULL, &kbasep_trace_timeline_debugfs_fops);
 101         if (IS_ERR(kbdev->timeline.dentry))
 102                 return MALI_ERROR_FUNCTION_FAILED;
 103
 104         return MALI_ERROR_NONE;
 105 }
 106
 107 void kbasep_trace_timeline_debugfs_term(kbase_device *kbdev)
 108 {
 109         debugfs_remove(kbdev->timeline.dentry);
 110 }
 111
 112 void kbase_timeline_job_slot_submit(kbase_device *kbdev, kbase_context *kctx,
 113                                     kbase_jd_atom *katom, int js)
 114 {
 115         lockdep_assert_held(&kbdev->js_data.runpool_irq.lock);
 116
 117         if(kbdev->timeline.slot_atoms_submitted[js] > 0) {
 118                 KBASE_TIMELINE_JOB_START_NEXT(kctx, js, 1);
 119         } else {
 120                 base_atom_id atom_number = kbase_jd_atom_id(kctx, katom);
 121                 KBASE_TIMELINE_JOB_START_HEAD(kctx, js, 1);
 122                 KBASE_TIMELINE_JOB_START(kctx, js, atom_number);
 123         }
 124         ++kbdev->timeline.slot_atoms_submitted[js];
 125
 126         KBASE_TIMELINE_ATOMS_SUBMITTED(kctx, js, kbdev->timeline.slot_atoms_submitted[js]);
 127 }
 128
 129 void kbase_timeline_job_slot_done(kbase_device *kbdev, kbase_context *kctx,
 130                                   kbase_jd_atom *katom, int js,
 131                                   kbasep_js_atom_done_code done_code)
 132 {
 133         lockdep_assert_held(&kbdev->js_data.runpool_irq.lock);
 134
 135         if (done_code & KBASE_JS_ATOM_DONE_EVICTED_FROM_NEXT) {
 136                 KBASE_TIMELINE_JOB_START_NEXT(kctx, js, 0);
 137         } else {
 138                 /* Job finished in JSn_HEAD */
 139                 base_atom_id atom_number = kbase_jd_atom_id(kctx, katom);
 140                 KBASE_TIMELINE_JOB_START_HEAD(kctx, js, 0);
 141                 KBASE_TIMELINE_JOB_STOP(kctx, js, atom_number);
 142                 /* see if we need to trace the job in JSn_NEXT moving to JSn_HEAD */
 143                 if (kbdev->timeline.slot_atoms_submitted[js] > 1) {
 144                         /* Tag events with next_katom's kctx */
 145                         kbase_jm_slot *slot = &kbdev->jm_slots[js];
 146                         kbase_jd_atom *next_katom;
 147                         kbase_context *next_kctx;
 148                         KBASE_DEBUG_ASSERT(kbasep_jm_nr_jobs_submitted(slot) > 0);
 149
 150                         /* Peek the next atom - note that the atom in JSn_HEAD will already
 151                          * have been dequeued */
 152                         next_katom = kbasep_jm_peek_idx_submit_slot(slot, 0);
 153                         next_kctx = next_katom->kctx;
 154                         KBASE_TIMELINE_JOB_START_NEXT(next_kctx, js, 0);
 155                         KBASE_TIMELINE_JOB_START_HEAD(next_kctx, js, 1);
 156                         KBASE_TIMELINE_JOB_START(next_kctx, js, kbase_jd_atom_id(next_kctx, next_katom));
 157                 }
 158         }
 159
 160         --kbdev->timeline.slot_atoms_submitted[js];
 161
 162         KBASE_TIMELINE_ATOMS_SUBMITTED(kctx, js, kbdev->timeline.slot_atoms_submitted[js]);
 163 }
 164
 165 void kbase_timeline_pm_send_event(kbase_device *kbdev, kbase_timeline_pm_event event_sent)
 166 {
 167         int uid = 0;
 168         int old_uid;
 169
 170         /* If a producer already exists for the event, try to use their UID (multiple-producers) */
 171         uid = atomic_read(&kbdev->timeline.pm_event_uid[event_sent]);
 172         old_uid = uid;
 173
 174         /* Get a new non-zero UID if we don't have one yet */
 175         while (!uid)
 176                 uid = atomic_inc_return(&kbdev->timeline.pm_event_uid_counter);
 177
 178         /* Try to use this UID */
 179         if ( old_uid != atomic_cmpxchg(&kbdev->timeline.pm_event_uid[event_sent], old_uid, uid))
 180                 /* If it changed, raced with another producer: we've lost this UID */
 181                 uid = 0;
 182
 183         KBASE_TIMELINE_PM_SEND_EVENT(kbdev, event_sent, uid);
 184 }
 185
 186 void kbase_timeline_pm_check_handle_event(kbase_device *kbdev, kbase_timeline_pm_event event)
 187 {
 188         int uid = atomic_read(&kbdev->timeline.pm_event_uid[event]);
 189
 190         if (uid != 0) {
 191                 if (uid != atomic_cmpxchg(&kbdev->timeline.pm_event_uid[event], uid, 0))
 192                         /* If it changed, raced with another consumer: we've lost this UID */
 193                         uid = 0;
 194
 195                 KBASE_TIMELINE_PM_HANDLE_EVENT(kbdev, event, uid);
 196         }
 197 }
 198
 199 void kbase_timeline_pm_handle_event(kbase_device *kbdev, kbase_timeline_pm_event event)
 200 {
 201         int uid = atomic_read(&kbdev->timeline.pm_event_uid[event]);
 202
 203         if (uid != atomic_cmpxchg(&kbdev->timeline.pm_event_uid[event], uid, 0))
 204                 /* If it changed, raced with another consumer: we've lost this UID */
 205                 uid = 0;
 206
 207         KBASE_TIMELINE_PM_HANDLE_EVENT(kbdev, event, uid);
 208 }
 209
 210 void kbase_timeline_pm_l2_transition_start(kbase_device *kbdev)
 211 {
 212         lockdep_assert_held(&kbdev->pm.power_change_lock);
 213         /* Simply log the start of the transition */
 214         kbdev->timeline.l2_transitioning = MALI_TRUE;
 215         KBASE_TIMELINE_POWERING_L2(kbdev);
 216 }
 217
 218 void kbase_timeline_pm_l2_transition_done(kbase_device *kbdev)
 219 {
 220         lockdep_assert_held(&kbdev->pm.power_change_lock);
 221         /* Simply log the end of the transition */
 222         if( MALI_FALSE != kbdev->timeline.l2_transitioning )
 223         {
 224                 kbdev->timeline.l2_transitioning = MALI_FALSE;
 225                 KBASE_TIMELINE_POWERED_L2(kbdev);
 226         }
 227 }
 228
 229 #endif /* CONFIG_MALI_TRACE_TIMELINE */