1/*
2 * Copyright (C) 2013 Red Hat
3 * Author: Rob Clark <robdclark@gmail.com>
4 *
5 * This program is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 as published by
7 * the Free Software Foundation.
8 *
9 * This program is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
12 * more details.
13 *
14 * You should have received a copy of the GNU General Public License along with
15 * this program.  If not, see <http://www.gnu.org/licenses/>.
16 */
17
18/* For profiling, userspace can:
19 *
20 *   tail -f /sys/kernel/debug/dri/<minor>/gpu
21 *
22 * This will enable performance counters/profiling to track the busy time
23 * and any gpu specific performance counters that are supported.
24 */
25
26#ifdef CONFIG_DEBUG_FS
27
28#include <linux/debugfs.h>
29
30#include "msm_drv.h"
31#include "msm_gpu.h"
32
33struct msm_perf_state {
34	struct drm_device *dev;
35
36	bool open;
37	int cnt;
38	struct mutex read_lock;
39
40	char buf[256];
41	int buftot, bufpos;
42
43	unsigned long next_jiffies;
44
45	struct dentry *ent;
46	struct drm_info_node *node;
47};
48
49#define SAMPLE_TIME (HZ/4)
50
51/* wait for next sample time: */
52static int wait_sample(struct msm_perf_state *perf)
53{
54	unsigned long start_jiffies = jiffies;
55
56	if (time_after(perf->next_jiffies, start_jiffies)) {
57		unsigned long remaining_jiffies =
58			perf->next_jiffies - start_jiffies;
59		int ret = schedule_timeout_interruptible(remaining_jiffies);
60		if (ret > 0) {
61			/* interrupted */
62			return -ERESTARTSYS;
63		}
64	}
65	perf->next_jiffies += SAMPLE_TIME;
66	return 0;
67}
68
69static int refill_buf(struct msm_perf_state *perf)
70{
71	struct msm_drm_private *priv = perf->dev->dev_private;
72	struct msm_gpu *gpu = priv->gpu;
73	char *ptr = perf->buf;
74	int rem = sizeof(perf->buf);
75	int i, n;
76
77	if ((perf->cnt++ % 32) == 0) {
78		/* Header line: */
79		n = snprintf(ptr, rem, "%%BUSY");
80		ptr += n;
81		rem -= n;
82
83		for (i = 0; i < gpu->num_perfcntrs; i++) {
84			const struct msm_gpu_perfcntr *perfcntr = &gpu->perfcntrs[i];
85			n = snprintf(ptr, rem, "\t%s", perfcntr->name);
86			ptr += n;
87			rem -= n;
88		}
89	} else {
90		/* Sample line: */
91		uint32_t activetime = 0, totaltime = 0;
92		uint32_t cntrs[5];
93		uint32_t val;
94		int ret;
95
96		/* sleep until next sample time: */
97		ret = wait_sample(perf);
98		if (ret)
99			return ret;
100
101		ret = msm_gpu_perfcntr_sample(gpu, &activetime, &totaltime,
102				ARRAY_SIZE(cntrs), cntrs);
103		if (ret < 0)
104			return ret;
105
106		val = totaltime ? 1000 * activetime / totaltime : 0;
107		n = snprintf(ptr, rem, "%3d.%d%%", val / 10, val % 10);
108		ptr += n;
109		rem -= n;
110
111		for (i = 0; i < ret; i++) {
112			/* cycle counters (I think).. convert to MHz.. */
113			val = cntrs[i] / 10000;
114			n = snprintf(ptr, rem, "\t%5d.%02d",
115					val / 100, val % 100);
116			ptr += n;
117			rem -= n;
118		}
119	}
120
121	n = snprintf(ptr, rem, "\n");
122	ptr += n;
123	rem -= n;
124
125	perf->bufpos = 0;
126	perf->buftot = ptr - perf->buf;
127
128	return 0;
129}
130
131static ssize_t perf_read(struct file *file, char __user *buf,
132		size_t sz, loff_t *ppos)
133{
134	struct msm_perf_state *perf = file->private_data;
135	int n = 0, ret;
136
137	mutex_lock(&perf->read_lock);
138
139	if (perf->bufpos >= perf->buftot) {
140		ret = refill_buf(perf);
141		if (ret)
142			goto out;
143	}
144
145	n = min((int)sz, perf->buftot - perf->bufpos);
146	ret = copy_to_user(buf, &perf->buf[perf->bufpos], n);
147	if (ret)
148		goto out;
149
150	perf->bufpos += n;
151	*ppos += n;
152
153out:
154	mutex_unlock(&perf->read_lock);
155	if (ret)
156		return ret;
157	return n;
158}
159
160static int perf_open(struct inode *inode, struct file *file)
161{
162	struct msm_perf_state *perf = inode->i_private;
163	struct drm_device *dev = perf->dev;
164	struct msm_drm_private *priv = dev->dev_private;
165	struct msm_gpu *gpu = priv->gpu;
166	int ret = 0;
167
168	mutex_lock(&dev->struct_mutex);
169
170	if (perf->open || !gpu) {
171		ret = -EBUSY;
172		goto out;
173	}
174
175	file->private_data = perf;
176	perf->open = true;
177	perf->cnt = 0;
178	perf->buftot = 0;
179	perf->bufpos = 0;
180	msm_gpu_perfcntr_start(gpu);
181	perf->next_jiffies = jiffies + SAMPLE_TIME;
182
183out:
184	mutex_unlock(&dev->struct_mutex);
185	return ret;
186}
187
188static int perf_release(struct inode *inode, struct file *file)
189{
190	struct msm_perf_state *perf = inode->i_private;
191	struct msm_drm_private *priv = perf->dev->dev_private;
192	msm_gpu_perfcntr_stop(priv->gpu);
193	perf->open = false;
194	return 0;
195}
196
197
198static const struct file_operations perf_debugfs_fops = {
199	.owner = THIS_MODULE,
200	.open = perf_open,
201	.read = perf_read,
202	.llseek = no_llseek,
203	.release = perf_release,
204};
205
206int msm_perf_debugfs_init(struct drm_minor *minor)
207{
208	struct msm_drm_private *priv = minor->dev->dev_private;
209	struct msm_perf_state *perf;
210
211	/* only create on first minor: */
212	if (priv->perf)
213		return 0;
214
215	perf = kzalloc(sizeof(*perf), GFP_KERNEL);
216	if (!perf)
217		return -ENOMEM;
218
219	perf->dev = minor->dev;
220
221	mutex_init(&perf->read_lock);
222	priv->perf = perf;
223
224	perf->node = kzalloc(sizeof(*perf->node), GFP_KERNEL);
225	if (!perf->node)
226		goto fail;
227
228	perf->ent = debugfs_create_file("perf", S_IFREG | S_IRUGO,
229			minor->debugfs_root, perf, &perf_debugfs_fops);
230	if (!perf->ent) {
231		DRM_ERROR("Cannot create /sys/kernel/debug/dri/%s/perf\n",
232				minor->debugfs_root->d_name.name);
233		goto fail;
234	}
235
236	perf->node->minor = minor;
237	perf->node->dent  = perf->ent;
238	perf->node->info_ent = NULL;
239
240	mutex_lock(&minor->debugfs_lock);
241	list_add(&perf->node->list, &minor->debugfs_list);
242	mutex_unlock(&minor->debugfs_lock);
243
244	return 0;
245
246fail:
247	msm_perf_debugfs_cleanup(minor);
248	return -1;
249}
250
251void msm_perf_debugfs_cleanup(struct drm_minor *minor)
252{
253	struct msm_drm_private *priv = minor->dev->dev_private;
254	struct msm_perf_state *perf = priv->perf;
255
256	if (!perf)
257		return;
258
259	priv->perf = NULL;
260
261	debugfs_remove(perf->ent);
262
263	if (perf->node) {
264		mutex_lock(&minor->debugfs_lock);
265		list_del(&perf->node->list);
266		mutex_unlock(&minor->debugfs_lock);
267		kfree(perf->node);
268	}
269
270	mutex_destroy(&perf->read_lock);
271
272	kfree(perf);
273}
274
275#endif
276