1/*
2 * Copyright (C) 2009 Red Hat <bskeggs@redhat.com>
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining
5 * a copy of this software and associated documentation files (the
6 * "Software"), to deal in the Software without restriction, including
7 * without limitation the rights to use, copy, modify, merge, publish,
8 * distribute, sublicense, and/or sell copies of the Software, and to
9 * permit persons to whom the Software is furnished to do so, subject to
10 * the following conditions:
11 *
12 * The above copyright notice and this permission notice (including the
13 * next paragraph) shall be included in all copies or substantial
14 * portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
17 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
18 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
19 * IN NO EVENT SHALL THE COPYRIGHT OWNER(S) AND/OR ITS SUPPLIERS BE
20 * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
21 * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
22 * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
23 *
24 */
25
26/*
27 * Authors:
28 *  Ben Skeggs <bskeggs@redhat.com>
29 */
30
31#include <linux/debugfs.h>
32#include <nvif/class.h>
33#include <nvif/if0001.h>
34#include "nouveau_debugfs.h"
35#include "nouveau_drv.h"
36
37static int
38nouveau_debugfs_vbios_image(struct seq_file *m, void *data)
39{
40	struct drm_info_node *node = (struct drm_info_node *) m->private;
41	struct nouveau_drm *drm = nouveau_drm(node->minor->dev);
42	int i;
43
44	for (i = 0; i < drm->vbios.length; i++)
45		seq_printf(m, "%c", drm->vbios.data[i]);
46	return 0;
47}
48
49static int
50nouveau_debugfs_strap_peek(struct seq_file *m, void *data)
51{
52	struct drm_info_node *node = m->private;
53	struct nouveau_drm *drm = nouveau_drm(node->minor->dev);
54	int ret;
55
56	ret = pm_runtime_get_sync(drm->dev->dev);
57	if (ret < 0 && ret != -EACCES) {
58		pm_runtime_put_autosuspend(drm->dev->dev);
59		return ret;
60	}
61
62	seq_printf(m, "0x%08x\n",
63		   nvif_rd32(&drm->client.device.object, 0x101000));
64
65	pm_runtime_mark_last_busy(drm->dev->dev);
66	pm_runtime_put_autosuspend(drm->dev->dev);
67
68	return 0;
69}
70
71static int
72nouveau_debugfs_pstate_get(struct seq_file *m, void *data)
73{
74	struct drm_device *drm = m->private;
75	struct nouveau_debugfs *debugfs = nouveau_debugfs(drm);
76	struct nvif_object *ctrl = &debugfs->ctrl;
77	struct nvif_control_pstate_info_v0 info = {};
78	int ret, i;
79
80	if (!debugfs)
81		return -ENODEV;
82
83	ret = nvif_mthd(ctrl, NVIF_CONTROL_PSTATE_INFO, &info, sizeof(info));
84	if (ret)
85		return ret;
86
87	for (i = 0; i < info.count + 1; i++) {
88		const s32 state = i < info.count ? i :
89			NVIF_CONTROL_PSTATE_ATTR_V0_STATE_CURRENT;
90		struct nvif_control_pstate_attr_v0 attr = {
91			.state = state,
92			.index = 0,
93		};
94
95		ret = nvif_mthd(ctrl, NVIF_CONTROL_PSTATE_ATTR,
96				&attr, sizeof(attr));
97		if (ret)
98			return ret;
99
100		if (i < info.count)
101			seq_printf(m, "%02x:", attr.state);
102		else
103			seq_printf(m, "%s:", info.pwrsrc == 0 ? "DC" :
104					     info.pwrsrc == 1 ? "AC" : "--");
105
106		attr.index = 0;
107		do {
108			attr.state = state;
109			ret = nvif_mthd(ctrl, NVIF_CONTROL_PSTATE_ATTR,
110					&attr, sizeof(attr));
111			if (ret)
112				return ret;
113
114			seq_printf(m, " %s %d", attr.name, attr.min);
115			if (attr.min != attr.max)
116				seq_printf(m, "-%d", attr.max);
117			seq_printf(m, " %s", attr.unit);
118		} while (attr.index);
119
120		if (state >= 0) {
121			if (info.ustate_ac == state)
122				seq_printf(m, " AC");
123			if (info.ustate_dc == state)
124				seq_printf(m, " DC");
125			if (info.pstate == state)
126				seq_printf(m, " *");
127		} else {
128			if (info.ustate_ac < -1)
129				seq_printf(m, " AC");
130			if (info.ustate_dc < -1)
131				seq_printf(m, " DC");
132		}
133
134		seq_printf(m, "\n");
135	}
136
137	return 0;
138}
139
140static ssize_t
141nouveau_debugfs_pstate_set(struct file *file, const char __user *ubuf,
142			   size_t len, loff_t *offp)
143{
144	struct seq_file *m = file->private_data;
145	struct drm_device *drm = m->private;
146	struct nouveau_debugfs *debugfs = nouveau_debugfs(drm);
147	struct nvif_object *ctrl = &debugfs->ctrl;
148	struct nvif_control_pstate_user_v0 args = { .pwrsrc = -EINVAL };
149	char buf[32] = {}, *tmp, *cur = buf;
150	long value, ret;
151
152	if (!debugfs)
153		return -ENODEV;
154
155	if (len >= sizeof(buf))
156		return -EINVAL;
157
158	if (copy_from_user(buf, ubuf, len))
159		return -EFAULT;
160
161	if ((tmp = strchr(buf, '\n')))
162		*tmp = '\0';
163
164	if (!strncasecmp(cur, "dc:", 3)) {
165		args.pwrsrc = 0;
166		cur += 3;
167	} else
168	if (!strncasecmp(cur, "ac:", 3)) {
169		args.pwrsrc = 1;
170		cur += 3;
171	}
172
173	if (!strcasecmp(cur, "none"))
174		args.ustate = NVIF_CONTROL_PSTATE_USER_V0_STATE_UNKNOWN;
175	else
176	if (!strcasecmp(cur, "auto"))
177		args.ustate = NVIF_CONTROL_PSTATE_USER_V0_STATE_PERFMON;
178	else {
179		ret = kstrtol(cur, 16, &value);
180		if (ret)
181			return ret;
182		args.ustate = value;
183	}
184
185	ret = pm_runtime_get_sync(drm->dev);
186	if (ret < 0 && ret != -EACCES) {
187		pm_runtime_put_autosuspend(drm->dev);
188		return ret;
189	}
190
191	ret = nvif_mthd(ctrl, NVIF_CONTROL_PSTATE_USER, &args, sizeof(args));
192	pm_runtime_put_autosuspend(drm->dev);
193	if (ret < 0)
194		return ret;
195
196	return len;
197}
198
199static int
200nouveau_debugfs_pstate_open(struct inode *inode, struct file *file)
201{
202	return single_open(file, nouveau_debugfs_pstate_get, inode->i_private);
203}
204
205static const struct file_operations nouveau_pstate_fops = {
206	.owner = THIS_MODULE,
207	.open = nouveau_debugfs_pstate_open,
208	.read = seq_read,
209	.write = nouveau_debugfs_pstate_set,
210	.release = single_release,
211};
212
213static struct drm_info_list nouveau_debugfs_list[] = {
214	{ "vbios.rom",  nouveau_debugfs_vbios_image, 0, NULL },
215	{ "strap_peek", nouveau_debugfs_strap_peek, 0, NULL },
216};
217#define NOUVEAU_DEBUGFS_ENTRIES ARRAY_SIZE(nouveau_debugfs_list)
218
219static const struct nouveau_debugfs_files {
220	const char *name;
221	const struct file_operations *fops;
222} nouveau_debugfs_files[] = {
223	{"pstate", &nouveau_pstate_fops},
224};
225
226void
227nouveau_drm_debugfs_init(struct drm_minor *minor)
228{
229	struct nouveau_drm *drm = nouveau_drm(minor->dev);
230	struct dentry *dentry;
231	int i;
232
233	for (i = 0; i < ARRAY_SIZE(nouveau_debugfs_files); i++) {
234		debugfs_create_file(nouveau_debugfs_files[i].name,
235				    S_IRUGO | S_IWUSR,
236				    minor->debugfs_root, minor->dev,
237				    nouveau_debugfs_files[i].fops);
238	}
239
240	drm_debugfs_create_files(nouveau_debugfs_list,
241				 NOUVEAU_DEBUGFS_ENTRIES,
242				 minor->debugfs_root, minor);
243
244	/* Set the size of the vbios since we know it, and it's confusing to
245	 * userspace if it wants to seek() but the file has a length of 0
246	 */
247	dentry = debugfs_lookup("vbios.rom", minor->debugfs_root);
248	if (!dentry)
249		return;
250
251	d_inode(dentry)->i_size = drm->vbios.length;
252	dput(dentry);
253}
254
255int
256nouveau_debugfs_init(struct nouveau_drm *drm)
257{
258	int ret;
259
260	drm->debugfs = kzalloc(sizeof(*drm->debugfs), GFP_KERNEL);
261	if (!drm->debugfs)
262		return -ENOMEM;
263
264	ret = nvif_object_ctor(&drm->client.device.object, "debugfsCtrl", 0,
265			       NVIF_CLASS_CONTROL, NULL, 0,
266			       &drm->debugfs->ctrl);
267	if (ret)
268		return ret;
269
270	return 0;
271}
272
273void
274nouveau_debugfs_fini(struct nouveau_drm *drm)
275{
276	if (drm->debugfs && drm->debugfs->ctrl.priv)
277		nvif_object_dtor(&drm->debugfs->ctrl);
278
279	kfree(drm->debugfs);
280	drm->debugfs = NULL;
281}
282