Commit | Line | Data |
---|---|---|
70c70f09 RC |
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 | ||
33 | struct 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: */ | |
52 | static 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 | ||
69 | static 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 | ||
131 | static 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 | ||
153 | out: | |
154 | mutex_unlock(&perf->read_lock); | |
155 | if (ret) | |
156 | return ret; | |
157 | return n; | |
158 | } | |
159 | ||
160 | static 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 | ||
183 | out: | |
184 | mutex_unlock(&dev->struct_mutex); | |
185 | return ret; | |
186 | } | |
187 | ||
188 | static 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 | ||
198 | static 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 | ||
206 | int 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 | ||
246 | fail: | |
247 | msm_perf_debugfs_cleanup(minor); | |
248 | return -1; | |
249 | } | |
250 | ||
251 | void 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 |