xref: /openbmc/linux/drivers/gpu/drm/vc4/vc4_perfmon.c (revision f59a3ee6)
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 	mutex_destroy(&vc4file->perfmon.lock);
137 }
138 
139 int vc4_perfmon_create_ioctl(struct drm_device *dev, void *data,
140 			     struct drm_file *file_priv)
141 {
142 	struct vc4_dev *vc4 = to_vc4_dev(dev);
143 	struct vc4_file *vc4file = file_priv->driver_priv;
144 	struct drm_vc4_perfmon_create *req = data;
145 	struct vc4_perfmon *perfmon;
146 	unsigned int i;
147 	int ret;
148 
149 	if (WARN_ON_ONCE(vc4->is_vc5))
150 		return -ENODEV;
151 
152 	if (!vc4->v3d) {
153 		DRM_DEBUG("Creating perfmon no VC4 V3D probed\n");
154 		return -ENODEV;
155 	}
156 
157 	/* Number of monitored counters cannot exceed HW limits. */
158 	if (req->ncounters > DRM_VC4_MAX_PERF_COUNTERS ||
159 	    !req->ncounters)
160 		return -EINVAL;
161 
162 	/* Make sure all events are valid. */
163 	for (i = 0; i < req->ncounters; i++) {
164 		if (req->events[i] >= VC4_PERFCNT_NUM_EVENTS)
165 			return -EINVAL;
166 	}
167 
168 	perfmon = kzalloc(struct_size(perfmon, counters, req->ncounters),
169 			  GFP_KERNEL);
170 	if (!perfmon)
171 		return -ENOMEM;
172 	perfmon->dev = vc4;
173 
174 	for (i = 0; i < req->ncounters; i++)
175 		perfmon->events[i] = req->events[i];
176 
177 	perfmon->ncounters = req->ncounters;
178 
179 	refcount_set(&perfmon->refcnt, 1);
180 
181 	mutex_lock(&vc4file->perfmon.lock);
182 	ret = idr_alloc(&vc4file->perfmon.idr, perfmon, VC4_PERFMONID_MIN,
183 			VC4_PERFMONID_MAX, GFP_KERNEL);
184 	mutex_unlock(&vc4file->perfmon.lock);
185 
186 	if (ret < 0) {
187 		kfree(perfmon);
188 		return ret;
189 	}
190 
191 	req->id = ret;
192 	return 0;
193 }
194 
195 int vc4_perfmon_destroy_ioctl(struct drm_device *dev, void *data,
196 			      struct drm_file *file_priv)
197 {
198 	struct vc4_dev *vc4 = to_vc4_dev(dev);
199 	struct vc4_file *vc4file = file_priv->driver_priv;
200 	struct drm_vc4_perfmon_destroy *req = data;
201 	struct vc4_perfmon *perfmon;
202 
203 	if (WARN_ON_ONCE(vc4->is_vc5))
204 		return -ENODEV;
205 
206 	if (!vc4->v3d) {
207 		DRM_DEBUG("Destroying perfmon no VC4 V3D probed\n");
208 		return -ENODEV;
209 	}
210 
211 	mutex_lock(&vc4file->perfmon.lock);
212 	perfmon = idr_remove(&vc4file->perfmon.idr, req->id);
213 	mutex_unlock(&vc4file->perfmon.lock);
214 
215 	if (!perfmon)
216 		return -EINVAL;
217 
218 	vc4_perfmon_put(perfmon);
219 	return 0;
220 }
221 
222 int vc4_perfmon_get_values_ioctl(struct drm_device *dev, void *data,
223 				 struct drm_file *file_priv)
224 {
225 	struct vc4_dev *vc4 = to_vc4_dev(dev);
226 	struct vc4_file *vc4file = file_priv->driver_priv;
227 	struct drm_vc4_perfmon_get_values *req = data;
228 	struct vc4_perfmon *perfmon;
229 	int ret;
230 
231 	if (WARN_ON_ONCE(vc4->is_vc5))
232 		return -ENODEV;
233 
234 	if (!vc4->v3d) {
235 		DRM_DEBUG("Getting perfmon no VC4 V3D probed\n");
236 		return -ENODEV;
237 	}
238 
239 	mutex_lock(&vc4file->perfmon.lock);
240 	perfmon = idr_find(&vc4file->perfmon.idr, req->id);
241 	vc4_perfmon_get(perfmon);
242 	mutex_unlock(&vc4file->perfmon.lock);
243 
244 	if (!perfmon)
245 		return -EINVAL;
246 
247 	if (copy_to_user(u64_to_user_ptr(req->values_ptr), perfmon->counters,
248 			 perfmon->ncounters * sizeof(u64)))
249 		ret = -EFAULT;
250 	else
251 		ret = 0;
252 
253 	vc4_perfmon_put(perfmon);
254 	return ret;
255 }
256