drivers/gpu/drm/vc4/vc4_perfmon.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Copyright (C) 2018 Broadcom
   4  */
   5
   6 /**
   7  * DOC: VC4 V3D performance monitor module
   8  *
   9  * The V3D block provides 16 hardware counters which can count various events.
  10  */
  11
  12 #include "vc4_drv.h"
  13 #include "vc4_regs.h"
  14
  15 #define VC4_PERFMONID_MIN       1
  16 #define VC4_PERFMONID_MAX       U32_MAX
  17
  18 void vc4_perfmon_get(struct vc4_perfmon *perfmon)
  19 {
  20         struct vc4_dev *vc4;
  21
  22         if (!perfmon)
  23                 return;
  24
  25         vc4 = perfmon->dev;
  26         if (WARN_ON_ONCE(vc4->is_vc5))
  27                 return;
  28
  29         refcount_inc(&perfmon->refcnt);
  30 }
  31
  32 void vc4_perfmon_put(struct vc4_perfmon *perfmon)
  33 {
  34         struct vc4_dev *vc4;
  35
  36         if (!perfmon)
  37                 return;
  38
  39         vc4 = perfmon->dev;
  40         if (WARN_ON_ONCE(vc4->is_vc5))
  41                 return;
  42
  43         if (refcount_dec_and_test(&perfmon->refcnt))
  44                 kfree(perfmon);
  45 }
  46
  47 void vc4_perfmon_start(struct vc4_dev *vc4, struct vc4_perfmon *perfmon)
  48 {
  49         unsigned int i;
  50         u32 mask;
  51
  52         if (WARN_ON_ONCE(vc4->is_vc5))
  53                 return;
  54
  55         if (WARN_ON_ONCE(!perfmon || vc4->active_perfmon))
  56                 return;
  57
  58         for (i = 0; i < perfmon->ncounters; i++)
  59                 V3D_WRITE(V3D_PCTRS(i), perfmon->events[i]);
  60
  61         mask = GENMASK(perfmon->ncounters - 1, 0);
  62         V3D_WRITE(V3D_PCTRC, mask);
  63         V3D_WRITE(V3D_PCTRE, V3D_PCTRE_EN | mask);
  64         vc4->active_perfmon = perfmon;
  65 }
  66
  67 void vc4_perfmon_stop(struct vc4_dev *vc4, struct vc4_perfmon *perfmon,
  68                       bool capture)
  69 {
  70         unsigned int i;
  71
  72         if (WARN_ON_ONCE(vc4->is_vc5))
  73                 return;
  74
  75         if (WARN_ON_ONCE(!vc4->active_perfmon ||
  76                          perfmon != vc4->active_perfmon))
  77                 return;
  78
  79         if (capture) {
  80                 for (i = 0; i < perfmon->ncounters; i++)
  81                         perfmon->counters[i] += V3D_READ(V3D_PCTR(i));
  82         }
  83
  84         V3D_WRITE(V3D_PCTRE, 0);
  85         vc4->active_perfmon = NULL;
  86 }
  87
  88 struct vc4_perfmon *vc4_perfmon_find(struct vc4_file *vc4file, int id)
  89 {
  90         struct vc4_dev *vc4 = vc4file->dev;
  91         struct vc4_perfmon *perfmon;
  92
  93         if (WARN_ON_ONCE(vc4->is_vc5))
  94                 return NULL;
  95
  96         mutex_lock(&vc4file->perfmon.lock);
  97         perfmon = idr_find(&vc4file->perfmon.idr, id);
  98         vc4_perfmon_get(perfmon);
  99         mutex_unlock(&vc4file->perfmon.lock);
 100
 101         return perfmon;
 102 }
 103
 104 void vc4_perfmon_open_file(struct vc4_file *vc4file)
 105 {
 106         struct vc4_dev *vc4 = vc4file->dev;
 107
 108         if (WARN_ON_ONCE(vc4->is_vc5))
 109                 return;
 110
 111         mutex_init(&vc4file->perfmon.lock);
 112         idr_init_base(&vc4file->perfmon.idr, VC4_PERFMONID_MIN);
 113         vc4file->dev = vc4;
 114 }
 115
 116 static int vc4_perfmon_idr_del(int id, void *elem, void *data)
 117 {
 118         struct vc4_perfmon *perfmon = elem;
 119
 120         vc4_perfmon_put(perfmon);
 121
 122         return 0;
 123 }
 124
 125 void vc4_perfmon_close_file(struct vc4_file *vc4file)
 126 {
 127         struct vc4_dev *vc4 = vc4file->dev;
 128
 129         if (WARN_ON_ONCE(vc4->is_vc5))
 130                 return;
 131
 132         mutex_lock(&vc4file->perfmon.lock);
 133         idr_for_each(&vc4file->perfmon.idr, vc4_perfmon_idr_del, NULL);
 134         idr_destroy(&vc4file->perfmon.idr);
 135         mutex_unlock(&vc4file->perfmon.lock);
 136 }
 137
 138 int vc4_perfmon_create_ioctl(struct drm_device *dev, void *data,
 139                              struct drm_file *file_priv)
 140 {
 141         struct vc4_dev *vc4 = to_vc4_dev(dev);
 142         struct vc4_file *vc4file = file_priv->driver_priv;
 143         struct drm_vc4_perfmon_create *req = data;
 144         struct vc4_perfmon *perfmon;
 145         unsigned int i;
 146         int ret;
 147
 148         if (WARN_ON_ONCE(vc4->is_vc5))
 149                 return -ENODEV;
 150
 151         if (!vc4->v3d) {
 152                 DRM_DEBUG("Creating perfmon no VC4 V3D probed\n");
 153                 return -ENODEV;
 154         }
 155
 156         /* Number of monitored counters cannot exceed HW limits. */
 157         if (req->ncounters > DRM_VC4_MAX_PERF_COUNTERS ||
 158             !req->ncounters)
 159                 return -EINVAL;
 160
 161         /* Make sure all events are valid. */
 162         for (i = 0; i < req->ncounters; i++) {
 163                 if (req->events[i] >= VC4_PERFCNT_NUM_EVENTS)
 164                         return -EINVAL;
 165         }
 166
 167         perfmon = kzalloc(struct_size(perfmon, counters, req->ncounters),
 168                           GFP_KERNEL);
 169         if (!perfmon)
 170                 return -ENOMEM;
 171         perfmon->dev = vc4;
 172
 173         for (i = 0; i < req->ncounters; i++)
 174                 perfmon->events[i] = req->events[i];
 175
 176         perfmon->ncounters = req->ncounters;
 177
 178         refcount_set(&perfmon->refcnt, 1);
 179
 180         mutex_lock(&vc4file->perfmon.lock);
 181         ret = idr_alloc(&vc4file->perfmon.idr, perfmon, VC4_PERFMONID_MIN,
 182                         VC4_PERFMONID_MAX, GFP_KERNEL);
 183         mutex_unlock(&vc4file->perfmon.lock);
 184
 185         if (ret < 0) {
 186                 kfree(perfmon);
 187                 return ret;
 188         }
 189
 190         req->id = ret;
 191         return 0;
 192 }
 193
 194 int vc4_perfmon_destroy_ioctl(struct drm_device *dev, void *data,
 195                               struct drm_file *file_priv)
 196 {
 197         struct vc4_dev *vc4 = to_vc4_dev(dev);
 198         struct vc4_file *vc4file = file_priv->driver_priv;
 199         struct drm_vc4_perfmon_destroy *req = data;
 200         struct vc4_perfmon *perfmon;
 201
 202         if (WARN_ON_ONCE(vc4->is_vc5))
 203                 return -ENODEV;
 204
 205         if (!vc4->v3d) {
 206                 DRM_DEBUG("Destroying perfmon no VC4 V3D probed\n");
 207                 return -ENODEV;
 208         }
 209
 210         mutex_lock(&vc4file->perfmon.lock);
 211         perfmon = idr_remove(&vc4file->perfmon.idr, req->id);
 212         mutex_unlock(&vc4file->perfmon.lock);
 213
 214         if (!perfmon)
 215                 return -EINVAL;
 216
 217         vc4_perfmon_put(perfmon);
 218         return 0;
 219 }
 220
 221 int vc4_perfmon_get_values_ioctl(struct drm_device *dev, void *data,
 222                                  struct drm_file *file_priv)
 223 {
 224         struct vc4_dev *vc4 = to_vc4_dev(dev);
 225         struct vc4_file *vc4file = file_priv->driver_priv;
 226         struct drm_vc4_perfmon_get_values *req = data;
 227         struct vc4_perfmon *perfmon;
 228         int ret;
 229
 230         if (WARN_ON_ONCE(vc4->is_vc5))
 231                 return -ENODEV;
 232
 233         if (!vc4->v3d) {
 234                 DRM_DEBUG("Getting perfmon no VC4 V3D probed\n");
 235                 return -ENODEV;
 236         }
 237
 238         mutex_lock(&vc4file->perfmon.lock);
 239         perfmon = idr_find(&vc4file->perfmon.idr, req->id);
 240         vc4_perfmon_get(perfmon);
 241         mutex_unlock(&vc4file->perfmon.lock);
 242
 243         if (!perfmon)
 244                 return -EINVAL;
 245
 246         if (copy_to_user(u64_to_user_ptr(req->values_ptr), perfmon->counters,
 247                          perfmon->ncounters * sizeof(u64)))
 248                 ret = -EFAULT;
 249         else
 250                 ret = 0;
 251
 252         vc4_perfmon_put(perfmon);
 253         return ret;
 254 }