xref: /linux/drivers/gpu/drm/drm_ioctl.c (revision b889fcf63cb62e7fdb7816565e28f44dbe4a76a5)
1 /**
2  * \file drm_ioctl.c
3  * IOCTL processing for DRM
4  *
5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
6  * \author Gareth Hughes <gareth@valinux.com>
7  */
8 
9 /*
10  * Created: Fri Jan  8 09:01:26 1999 by faith@valinux.com
11  *
12  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
13  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14  * All Rights Reserved.
15  *
16  * Permission is hereby granted, free of charge, to any person obtaining a
17  * copy of this software and associated documentation files (the "Software"),
18  * to deal in the Software without restriction, including without limitation
19  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
20  * and/or sell copies of the Software, and to permit persons to whom the
21  * Software is furnished to do so, subject to the following conditions:
22  *
23  * The above copyright notice and this permission notice (including the next
24  * paragraph) shall be included in all copies or substantial portions of the
25  * Software.
26  *
27  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
28  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
29  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
30  * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
31  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
32  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
33  * OTHER DEALINGS IN THE SOFTWARE.
34  */
35 
36 #include <drm/drmP.h>
37 #include <drm/drm_core.h>
38 
39 #include <linux/pci.h>
40 #include <linux/export.h>
41 
42 /**
43  * Get the bus id.
44  *
45  * \param inode device inode.
46  * \param file_priv DRM file private.
47  * \param cmd command.
48  * \param arg user argument, pointing to a drm_unique structure.
49  * \return zero on success or a negative number on failure.
50  *
51  * Copies the bus id from drm_device::unique into user space.
52  */
53 int drm_getunique(struct drm_device *dev, void *data,
54 		  struct drm_file *file_priv)
55 {
56 	struct drm_unique *u = data;
57 	struct drm_master *master = file_priv->master;
58 
59 	if (u->unique_len >= master->unique_len) {
60 		if (copy_to_user(u->unique, master->unique, master->unique_len))
61 			return -EFAULT;
62 	}
63 	u->unique_len = master->unique_len;
64 
65 	return 0;
66 }
67 
68 static void
69 drm_unset_busid(struct drm_device *dev,
70 		struct drm_master *master)
71 {
72 	kfree(dev->devname);
73 	dev->devname = NULL;
74 
75 	kfree(master->unique);
76 	master->unique = NULL;
77 	master->unique_len = 0;
78 	master->unique_size = 0;
79 }
80 
81 /**
82  * Set the bus id.
83  *
84  * \param inode device inode.
85  * \param file_priv DRM file private.
86  * \param cmd command.
87  * \param arg user argument, pointing to a drm_unique structure.
88  * \return zero on success or a negative number on failure.
89  *
90  * Copies the bus id from userspace into drm_device::unique, and verifies that
91  * it matches the device this DRM is attached to (EINVAL otherwise).  Deprecated
92  * in interface version 1.1 and will return EBUSY when setversion has requested
93  * version 1.1 or greater.
94  */
95 int drm_setunique(struct drm_device *dev, void *data,
96 		  struct drm_file *file_priv)
97 {
98 	struct drm_unique *u = data;
99 	struct drm_master *master = file_priv->master;
100 	int ret;
101 
102 	if (master->unique_len || master->unique)
103 		return -EBUSY;
104 
105 	if (!u->unique_len || u->unique_len > 1024)
106 		return -EINVAL;
107 
108 	if (!dev->driver->bus->set_unique)
109 		return -EINVAL;
110 
111 	ret = dev->driver->bus->set_unique(dev, master, u);
112 	if (ret)
113 		goto err;
114 
115 	return 0;
116 
117 err:
118 	drm_unset_busid(dev, master);
119 	return ret;
120 }
121 
122 static int drm_set_busid(struct drm_device *dev, struct drm_file *file_priv)
123 {
124 	struct drm_master *master = file_priv->master;
125 	int ret;
126 
127 	if (master->unique != NULL)
128 		drm_unset_busid(dev, master);
129 
130 	ret = dev->driver->bus->set_busid(dev, master);
131 	if (ret)
132 		goto err;
133 	return 0;
134 err:
135 	drm_unset_busid(dev, master);
136 	return ret;
137 }
138 
139 /**
140  * Get a mapping information.
141  *
142  * \param inode device inode.
143  * \param file_priv DRM file private.
144  * \param cmd command.
145  * \param arg user argument, pointing to a drm_map structure.
146  *
147  * \return zero on success or a negative number on failure.
148  *
149  * Searches for the mapping with the specified offset and copies its information
150  * into userspace
151  */
152 int drm_getmap(struct drm_device *dev, void *data,
153 	       struct drm_file *file_priv)
154 {
155 	struct drm_map *map = data;
156 	struct drm_map_list *r_list = NULL;
157 	struct list_head *list;
158 	int idx;
159 	int i;
160 
161 	idx = map->offset;
162 	if (idx < 0)
163 		return -EINVAL;
164 
165 	i = 0;
166 	mutex_lock(&dev->struct_mutex);
167 	list_for_each(list, &dev->maplist) {
168 		if (i == idx) {
169 			r_list = list_entry(list, struct drm_map_list, head);
170 			break;
171 		}
172 		i++;
173 	}
174 	if (!r_list || !r_list->map) {
175 		mutex_unlock(&dev->struct_mutex);
176 		return -EINVAL;
177 	}
178 
179 	map->offset = r_list->map->offset;
180 	map->size = r_list->map->size;
181 	map->type = r_list->map->type;
182 	map->flags = r_list->map->flags;
183 	map->handle = (void *)(unsigned long) r_list->user_token;
184 	map->mtrr = r_list->map->mtrr;
185 	mutex_unlock(&dev->struct_mutex);
186 
187 	return 0;
188 }
189 
190 /**
191  * Get client information.
192  *
193  * \param inode device inode.
194  * \param file_priv DRM file private.
195  * \param cmd command.
196  * \param arg user argument, pointing to a drm_client structure.
197  *
198  * \return zero on success or a negative number on failure.
199  *
200  * Searches for the client with the specified index and copies its information
201  * into userspace
202  */
203 int drm_getclient(struct drm_device *dev, void *data,
204 		  struct drm_file *file_priv)
205 {
206 	struct drm_client *client = data;
207 	struct drm_file *pt;
208 	int idx;
209 	int i;
210 
211 	idx = client->idx;
212 	i = 0;
213 
214 	mutex_lock(&dev->struct_mutex);
215 	list_for_each_entry(pt, &dev->filelist, lhead) {
216 		if (i++ >= idx) {
217 			client->auth = pt->authenticated;
218 			client->pid = pid_vnr(pt->pid);
219 			client->uid = from_kuid_munged(current_user_ns(), pt->uid);
220 			client->magic = pt->magic;
221 			client->iocs = pt->ioctl_count;
222 			mutex_unlock(&dev->struct_mutex);
223 
224 			return 0;
225 		}
226 	}
227 	mutex_unlock(&dev->struct_mutex);
228 
229 	return -EINVAL;
230 }
231 
232 /**
233  * Get statistics information.
234  *
235  * \param inode device inode.
236  * \param file_priv DRM file private.
237  * \param cmd command.
238  * \param arg user argument, pointing to a drm_stats structure.
239  *
240  * \return zero on success or a negative number on failure.
241  */
242 int drm_getstats(struct drm_device *dev, void *data,
243 		 struct drm_file *file_priv)
244 {
245 	struct drm_stats *stats = data;
246 	int i;
247 
248 	memset(stats, 0, sizeof(*stats));
249 
250 	for (i = 0; i < dev->counters; i++) {
251 		if (dev->types[i] == _DRM_STAT_LOCK)
252 			stats->data[i].value =
253 			    (file_priv->master->lock.hw_lock ? file_priv->master->lock.hw_lock->lock : 0);
254 		else
255 			stats->data[i].value = atomic_read(&dev->counts[i]);
256 		stats->data[i].type = dev->types[i];
257 	}
258 
259 	stats->count = dev->counters;
260 
261 	return 0;
262 }
263 
264 /**
265  * Get device/driver capabilities
266  */
267 int drm_getcap(struct drm_device *dev, void *data, struct drm_file *file_priv)
268 {
269 	struct drm_get_cap *req = data;
270 
271 	req->value = 0;
272 	switch (req->capability) {
273 	case DRM_CAP_DUMB_BUFFER:
274 		if (dev->driver->dumb_create)
275 			req->value = 1;
276 		break;
277 	case DRM_CAP_VBLANK_HIGH_CRTC:
278 		req->value = 1;
279 		break;
280 	case DRM_CAP_DUMB_PREFERRED_DEPTH:
281 		req->value = dev->mode_config.preferred_depth;
282 		break;
283 	case DRM_CAP_DUMB_PREFER_SHADOW:
284 		req->value = dev->mode_config.prefer_shadow;
285 		break;
286 	case DRM_CAP_PRIME:
287 		req->value |= dev->driver->prime_fd_to_handle ? DRM_PRIME_CAP_IMPORT : 0;
288 		req->value |= dev->driver->prime_handle_to_fd ? DRM_PRIME_CAP_EXPORT : 0;
289 		break;
290 	case DRM_CAP_TIMESTAMP_MONOTONIC:
291 		req->value = drm_timestamp_monotonic;
292 		break;
293 	default:
294 		return -EINVAL;
295 	}
296 	return 0;
297 }
298 
299 /**
300  * Setversion ioctl.
301  *
302  * \param inode device inode.
303  * \param file_priv DRM file private.
304  * \param cmd command.
305  * \param arg user argument, pointing to a drm_lock structure.
306  * \return zero on success or negative number on failure.
307  *
308  * Sets the requested interface version
309  */
310 int drm_setversion(struct drm_device *dev, void *data, struct drm_file *file_priv)
311 {
312 	struct drm_set_version *sv = data;
313 	int if_version, retcode = 0;
314 
315 	if (sv->drm_di_major != -1) {
316 		if (sv->drm_di_major != DRM_IF_MAJOR ||
317 		    sv->drm_di_minor < 0 || sv->drm_di_minor > DRM_IF_MINOR) {
318 			retcode = -EINVAL;
319 			goto done;
320 		}
321 		if_version = DRM_IF_VERSION(sv->drm_di_major,
322 					    sv->drm_di_minor);
323 		dev->if_version = max(if_version, dev->if_version);
324 		if (sv->drm_di_minor >= 1) {
325 			/*
326 			 * Version 1.1 includes tying of DRM to specific device
327 			 * Version 1.4 has proper PCI domain support
328 			 */
329 			retcode = drm_set_busid(dev, file_priv);
330 			if (retcode)
331 				goto done;
332 		}
333 	}
334 
335 	if (sv->drm_dd_major != -1) {
336 		if (sv->drm_dd_major != dev->driver->major ||
337 		    sv->drm_dd_minor < 0 || sv->drm_dd_minor >
338 		    dev->driver->minor) {
339 			retcode = -EINVAL;
340 			goto done;
341 		}
342 
343 		if (dev->driver->set_version)
344 			dev->driver->set_version(dev, sv);
345 	}
346 
347 done:
348 	sv->drm_di_major = DRM_IF_MAJOR;
349 	sv->drm_di_minor = DRM_IF_MINOR;
350 	sv->drm_dd_major = dev->driver->major;
351 	sv->drm_dd_minor = dev->driver->minor;
352 
353 	return retcode;
354 }
355 
356 /** No-op ioctl. */
357 int drm_noop(struct drm_device *dev, void *data,
358 	     struct drm_file *file_priv)
359 {
360 	DRM_DEBUG("\n");
361 	return 0;
362 }
363 EXPORT_SYMBOL(drm_noop);
364