From: Christian Gmeiner <[email protected]>

Userspace that converts GPU cycle counts to time needs the core clock
rate a job ran at. The trace event has this information, but only a
privileged tracer can read it.

Keep the last 256 clock changes per GPU in a ring buffer, 10 KiB per
GPU. A record is written together with the trace event. It has the
same times and flags, the rate after the change and a sequence number.
The ring only fills as fast as the thermal governor changes the
cooling state.

Add an ioctl that returns the records newer than a given sequence
number. It also returns the newest sequence number the kernel has, so
a reader knows when to call again. A reader that has fallen behind
sees a gap in the sequence numbers. The caller passes the size of its
record struct, so the record can grow later without a new ioctl. The
first clock setup after bind is recorded too, so a new process can
read the current rate.

Bump the minor version so userspace can check for the ioctl.

Signed-off-by: Christian Gmeiner <[email protected]>
---
 drivers/gpu/drm/etnaviv/etnaviv_drv.c | 20 ++++++++-
 drivers/gpu/drm/etnaviv/etnaviv_gpu.c | 83 +++++++++++++++++++++++++++++++++++
 drivers/gpu/drm/etnaviv/etnaviv_gpu.h |  9 ++++
 include/uapi/drm/etnaviv_drm.h        | 43 +++++++++++++++++-
 4 files changed, 153 insertions(+), 2 deletions(-)

diff --git a/drivers/gpu/drm/etnaviv/etnaviv_drv.c 
b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
index ec1352c1b09f..317362137e4a 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_drv.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_drv.c
@@ -473,6 +473,23 @@ static int etnaviv_ioctl_pm_query_sig(struct drm_device 
*dev, void *data,
        return etnaviv_pm_query_sig(gpu, args);
 }
 
+static int etnaviv_ioctl_clock_history(struct drm_device *dev, void *data,
+       struct drm_file *file)
+{
+       struct etnaviv_drm_private *priv = dev->dev_private;
+       struct drm_etnaviv_clock_history *args = data;
+       struct etnaviv_gpu *gpu;
+
+       if (args->pipe >= ETNA_MAX_PIPES)
+               return -EINVAL;
+
+       gpu = priv->gpu[args->pipe];
+       if (!gpu)
+               return -ENXIO;
+
+       return etnaviv_gpu_clock_history(gpu, args);
+}
+
 static const struct drm_ioctl_desc etnaviv_ioctls[] = {
 #define ETNA_IOCTL(n, func, flags) \
        DRM_IOCTL_DEF_DRV(ETNAVIV_##n, etnaviv_ioctl_##func, flags)
@@ -487,6 +504,7 @@ static const struct drm_ioctl_desc etnaviv_ioctls[] = {
        ETNA_IOCTL(GEM_WAIT,     gem_wait,     DRM_RENDER_ALLOW),
        ETNA_IOCTL(PM_QUERY_DOM, pm_query_dom, DRM_RENDER_ALLOW),
        ETNA_IOCTL(PM_QUERY_SIG, pm_query_sig, DRM_RENDER_ALLOW),
+       ETNA_IOCTL(CLOCK_HISTORY, clock_history, DRM_RENDER_ALLOW),
 };
 
 static void etnaviv_show_fdinfo(struct drm_printer *p, struct drm_file *file)
@@ -515,7 +533,7 @@ static const struct drm_driver etnaviv_drm_driver = {
        .name               = "etnaviv",
        .desc               = "etnaviv DRM",
        .major              = 1,
-       .minor              = 4,
+       .minor              = 5,
 };
 
 /*
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gpu.c 
b/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
index 03075f289c69..2af1af33287a 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
+++ b/drivers/gpu/drm/etnaviv/etnaviv_gpu.c
@@ -506,6 +506,80 @@ static void etnaviv_gpu_load_clock(struct etnaviv_gpu 
*gpu, u32 clock)
        gpu_write(gpu, VIVS_HI_CLOCK_CONTROL, clock);
 }
 
+static void etnaviv_gpu_record_clock(struct etnaviv_gpu *gpu, u32 flags,
+                                    u64 begin_ns, u64 end_ns,
+                                    unsigned long rate)
+{
+       spin_lock(&gpu->clock_lock);
+       gpu->clock_seq++;
+       gpu->clock_records[gpu->clock_seq % ETNA_NR_CLOCK_RECORDS] =
+               (struct drm_etnaviv_clock_record){
+                       .begin_ns = begin_ns,
+                       .end_ns = end_ns,
+                       .rate = rate,
+                       .seq = gpu->clock_seq,
+                       .flags = flags,
+               };
+       spin_unlock(&gpu->clock_lock);
+}
+
+static u64 etnaviv_gpu_clock_oldest(u64 last)
+{
+       if (last > ETNA_NR_CLOCK_RECORDS)
+               return last - ETNA_NR_CLOCK_RECORDS + 1;
+
+       return 1;
+}
+
+int etnaviv_gpu_clock_history(struct etnaviv_gpu *gpu,
+                             struct drm_etnaviv_clock_history *args)
+{
+       u64 last, start;
+       u32 size, n = 0, i;
+
+       if (args->flags)
+               return -EINVAL;
+
+       /* records can grow, a reader gets the part of each one it knows */
+       if (args->record_size <
+           offsetofend(struct drm_etnaviv_clock_record, pad))
+               return -EINVAL;
+       size = min_t(u32, args->record_size,
+                    sizeof(struct drm_etnaviv_clock_record));
+
+       spin_lock(&gpu->clock_lock);
+       last = gpu->clock_seq;
+       spin_unlock(&gpu->clock_lock);
+
+       if (args->since_seq < last) {
+               start = max(args->since_seq + 1, 
etnaviv_gpu_clock_oldest(last));
+               n = min_t(u64, last - start + 1, args->count);
+       }
+
+       for (i = 0; i < n; i++) {
+               void __user *dst = u64_to_user_ptr(args->records +
+                                                  (u64)i * args->record_size);
+               struct drm_etnaviv_clock_record record;
+
+               spin_lock(&gpu->clock_lock);
+               record = gpu->clock_records[(start + i) % 
ETNA_NR_CLOCK_RECORDS];
+               spin_unlock(&gpu->clock_lock);
+
+               /* overwritten since clock_seq was read */
+               if (record.seq != start + i)
+                       break;
+
+               if (copy_to_user(dst, &record, size))
+                       return -EFAULT;
+       }
+
+       args->count = i;
+       args->record_size = size;
+       args->last_seq = last;
+
+       return 0;
+}
+
 /* begin_ns is when the switch, or the restart that includes it, began */
 static void etnaviv_gpu_update_clock(struct etnaviv_gpu *gpu, u32 flags,
                                     u64 begin_ns)
@@ -538,6 +612,8 @@ static void etnaviv_gpu_update_clock(struct etnaviv_gpu 
*gpu, u32 flags,
 
        /* a resume or reset that keeps the rate is not worth a report */
        if (scaled || rate_before != gpu->core_rate) {
+               etnaviv_gpu_record_clock(gpu, flags, begin_ns, end_ns,
+                                        gpu->core_rate);
                trace_etnaviv_gpu_clock_change(gpu->dev, flags, begin_ns,
                                               end_ns, rate_before,
                                               gpu->core_rate);
@@ -2008,8 +2084,15 @@ static int etnaviv_gpu_platform_probe(struct 
platform_device *pdev)
 
        gpu->dev = dev;
        mutex_init(&gpu->lock);
+       spin_lock_init(&gpu->clock_lock);
        mutex_init(&gpu->sched_lock);
 
+       gpu->clock_records = devm_kcalloc(dev, ETNA_NR_CLOCK_RECORDS,
+                                         sizeof(*gpu->clock_records),
+                                         GFP_KERNEL);
+       if (!gpu->clock_records)
+               return -ENOMEM;
+
        /* Map registers: */
        gpu->mmio = devm_platform_ioremap_resource(pdev, 0);
        if (IS_ERR(gpu->mmio))
diff --git a/drivers/gpu/drm/etnaviv/etnaviv_gpu.h 
b/drivers/gpu/drm/etnaviv/etnaviv_gpu.h
index c8d537c3dee7..ac619f3020bb 100644
--- a/drivers/gpu/drm/etnaviv/etnaviv_gpu.h
+++ b/drivers/gpu/drm/etnaviv/etnaviv_gpu.h
@@ -96,6 +96,7 @@ struct clk;
 struct reset_control;
 
 #define ETNA_NR_EVENTS 30
+#define ETNA_NR_CLOCK_RECORDS 256
 
 enum etnaviv_gpu_state {
        ETNA_GPU_STATE_UNKNOWN = 0,
@@ -168,6 +169,11 @@ struct etnaviv_gpu {
        unsigned long base_rate_core;
        unsigned long core_rate;
        unsigned long base_rate_shader;
+
+       /* protects clock_seq and clock_records */
+       spinlock_t clock_lock;
+       u64 clock_seq;
+       struct drm_etnaviv_clock_record *clock_records;
 };
 
 static inline void gpu_write(struct etnaviv_gpu *gpu, u32 reg, u32 data)
@@ -237,4 +243,7 @@ void etnaviv_gpu_start_fe(struct etnaviv_gpu *gpu, u32 
address, u16 prefetch);
 
 extern struct platform_driver etnaviv_gpu_driver;
 
+int etnaviv_gpu_clock_history(struct etnaviv_gpu *gpu,
+                             struct drm_etnaviv_clock_history *args);
+
 #endif /* __ETNAVIV_GPU_H__ */
diff --git a/include/uapi/drm/etnaviv_drm.h b/include/uapi/drm/etnaviv_drm.h
index 83c58d94d36b..2f039836e7a9 100644
--- a/include/uapi/drm/etnaviv_drm.h
+++ b/include/uapi/drm/etnaviv_drm.h
@@ -284,6 +284,45 @@ struct drm_etnaviv_pm_signal {
 #define ETNA_CLOCK_RESET               0x0002
 #define ETNA_CLOCK_BUSY                0x0004
 
+/*
+ * The kernel also records the clock changes. The switch happens between
+ * begin_ns and end_ns. For RESUME and RESET the window covers the whole
+ * restart, from before the first reset attempt or the clock enable. That
+ * is wider than needed, but no job runs in it.
+ *
+ * The first record is written when the GPU is initialized after it is
+ * bound. So a GPU has at least one record, unless its core clock rate is
+ * unknown.
+ *
+ * DRM_IOCTL_ETNAVIV_CLOCK_HISTORY returns the records after since_seq, oldest
+ * first. It can return fewer than requested even if more exist, call it again
+ * until the last returned seq reaches last_seq. A reader that fell behind
+ * sees a gap between since_seq and the first seq returned.
+ *
+ * record_size is the stride of the records array and at least the size of
+ * the record below. So that the record can grow, the kernel writes the
+ * smaller of record_size and its own record size to each element and returns
+ * that size in record_size.
+ */
+struct drm_etnaviv_clock_record {
+       __u64 begin_ns;    /* CLOCK_MONOTONIC right before the switch */
+       __u64 end_ns;      /* CLOCK_MONOTONIC right after the switch */
+       __u64 rate;        /* core clock rate after the switch, in Hz */
+       __u64 seq;         /* increments by one per record, starts at 1 */
+       __u32 flags;       /* ETNA_CLOCK_x */
+       __u32 pad;         /* out, zero */
+};
+
+struct drm_etnaviv_clock_history {
+       __u32 pipe;        /* in */
+       __u32 count;       /* in, capacity of records, out, records returned */
+       __u32 record_size; /* in, stride of records, out, bytes written each */
+       __u32 flags;       /* in, must be zero */
+       __u64 since_seq;   /* in, return records with seq > since_seq */
+       __u64 last_seq;    /* out, newest record */
+       __u64 records;     /* in, pointer to struct drm_etnaviv_clock_record */
+};
+
 #define DRM_ETNAVIV_GET_PARAM          0x00
 /* placeholder:
 #define DRM_ETNAVIV_SET_PARAM          0x01
@@ -298,7 +337,8 @@ struct drm_etnaviv_pm_signal {
 #define DRM_ETNAVIV_GEM_WAIT           0x09
 #define DRM_ETNAVIV_PM_QUERY_DOM       0x0a
 #define DRM_ETNAVIV_PM_QUERY_SIG       0x0b
-#define DRM_ETNAVIV_NUM_IOCTLS         0x0c
+#define DRM_ETNAVIV_CLOCK_HISTORY      0x0c
+#define DRM_ETNAVIV_NUM_IOCTLS         0x0d
 
 #define DRM_IOCTL_ETNAVIV_GET_PARAM    DRM_IOWR(DRM_COMMAND_BASE + 
DRM_ETNAVIV_GET_PARAM, struct drm_etnaviv_param)
 #define DRM_IOCTL_ETNAVIV_GEM_NEW      DRM_IOWR(DRM_COMMAND_BASE + 
DRM_ETNAVIV_GEM_NEW, struct drm_etnaviv_gem_new)
@@ -311,6 +351,7 @@ struct drm_etnaviv_pm_signal {
 #define DRM_IOCTL_ETNAVIV_GEM_WAIT     DRM_IOW(DRM_COMMAND_BASE + 
DRM_ETNAVIV_GEM_WAIT, struct drm_etnaviv_gem_wait)
 #define DRM_IOCTL_ETNAVIV_PM_QUERY_DOM DRM_IOWR(DRM_COMMAND_BASE + 
DRM_ETNAVIV_PM_QUERY_DOM, struct drm_etnaviv_pm_domain)
 #define DRM_IOCTL_ETNAVIV_PM_QUERY_SIG DRM_IOWR(DRM_COMMAND_BASE + 
DRM_ETNAVIV_PM_QUERY_SIG, struct drm_etnaviv_pm_signal)
+#define DRM_IOCTL_ETNAVIV_CLOCK_HISTORY DRM_IOWR(DRM_COMMAND_BASE + 
DRM_ETNAVIV_CLOCK_HISTORY, struct drm_etnaviv_clock_history)
 
 #if defined(__cplusplus)
 }

-- 
2.56.0

Reply via email to