drm: add some caps for userspace to discover more info for dumb KMS driver (v2)
[linux-2.6.git] / drivers / gpu / drm / drm_ioctl.c
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 "drmP.h"
37 #include "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 = pt->pid;
219                         client->uid = 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         default:
287                 return -EINVAL;
288         }
289         return 0;
290 }
291
292 /**
293  * Setversion ioctl.
294  *
295  * \param inode device inode.
296  * \param file_priv DRM file private.
297  * \param cmd command.
298  * \param arg user argument, pointing to a drm_lock structure.
299  * \return zero on success or negative number on failure.
300  *
301  * Sets the requested interface version
302  */
303 int drm_setversion(struct drm_device *dev, void *data, struct drm_file *file_priv)
304 {
305         struct drm_set_version *sv = data;
306         int if_version, retcode = 0;
307
308         if (sv->drm_di_major != -1) {
309                 if (sv->drm_di_major != DRM_IF_MAJOR ||
310                     sv->drm_di_minor < 0 || sv->drm_di_minor > DRM_IF_MINOR) {
311                         retcode = -EINVAL;
312                         goto done;
313                 }
314                 if_version = DRM_IF_VERSION(sv->drm_di_major,
315                                             sv->drm_di_minor);
316                 dev->if_version = max(if_version, dev->if_version);
317                 if (sv->drm_di_minor >= 1) {
318                         /*
319                          * Version 1.1 includes tying of DRM to specific device
320                          * Version 1.4 has proper PCI domain support
321                          */
322                         retcode = drm_set_busid(dev, file_priv);
323                         if (retcode)
324                                 goto done;
325                 }
326         }
327
328         if (sv->drm_dd_major != -1) {
329                 if (sv->drm_dd_major != dev->driver->major ||
330                     sv->drm_dd_minor < 0 || sv->drm_dd_minor >
331                     dev->driver->minor) {
332                         retcode = -EINVAL;
333                         goto done;
334                 }
335
336                 if (dev->driver->set_version)
337                         dev->driver->set_version(dev, sv);
338         }
339
340 done:
341         sv->drm_di_major = DRM_IF_MAJOR;
342         sv->drm_di_minor = DRM_IF_MINOR;
343         sv->drm_dd_major = dev->driver->major;
344         sv->drm_dd_minor = dev->driver->minor;
345
346         return retcode;
347 }
348
349 /** No-op ioctl. */
350 int drm_noop(struct drm_device *dev, void *data,
351              struct drm_file *file_priv)
352 {
353         DRM_DEBUG("\n");
354         return 0;
355 }
356 EXPORT_SYMBOL(drm_noop);