3 * IOCTL processing for DRM
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Gareth Hughes <gareth@valinux.com>
10 * Created: Fri Jan 8 09:01:26 1999 by faith@valinux.com
12 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
13 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
14 * All Rights Reserved.
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:
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
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.
39 #include "linux/pci.h"
44 * \param inode device inode.
45 * \param filp file pointer.
47 * \param arg user argument, pointing to a drm_unique structure.
48 * \return zero on success or a negative number on failure.
50 * Copies the bus id from drm_device::unique into user space.
52 int drm_getunique(struct inode
*inode
, struct file
*filp
,
53 unsigned int cmd
, unsigned long arg
)
55 drm_file_t
*priv
= filp
->private_data
;
56 drm_device_t
*dev
= priv
->head
->dev
;
57 drm_unique_t __user
*argp
= (void __user
*)arg
;
60 if (copy_from_user(&u
, argp
, sizeof(u
)))
62 if (u
.unique_len
>= dev
->unique_len
) {
63 if (copy_to_user(u
.unique
, dev
->unique
, dev
->unique_len
))
66 u
.unique_len
= dev
->unique_len
;
67 if (copy_to_user(argp
, &u
, sizeof(u
)))
75 * \param inode device inode.
76 * \param filp file pointer.
78 * \param arg user argument, pointing to a drm_unique structure.
79 * \return zero on success or a negative number on failure.
81 * Copies the bus id from userspace into drm_device::unique, and verifies that
82 * it matches the device this DRM is attached to (EINVAL otherwise). Deprecated
83 * in interface version 1.1 and will return EBUSY when setversion has requested
84 * version 1.1 or greater.
86 int drm_setunique(struct inode
*inode
, struct file
*filp
,
87 unsigned int cmd
, unsigned long arg
)
89 drm_file_t
*priv
= filp
->private_data
;
90 drm_device_t
*dev
= priv
->head
->dev
;
92 int domain
, bus
, slot
, func
, ret
;
94 if (dev
->unique_len
|| dev
->unique
)
97 if (copy_from_user(&u
, (drm_unique_t __user
*) arg
, sizeof(u
)))
100 if (!u
.unique_len
|| u
.unique_len
> 1024)
103 dev
->unique_len
= u
.unique_len
;
104 dev
->unique
= drm_alloc(u
.unique_len
+ 1, DRM_MEM_DRIVER
);
107 if (copy_from_user(dev
->unique
, u
.unique
, dev
->unique_len
))
110 dev
->unique
[dev
->unique_len
] = '\0';
113 drm_alloc(strlen(dev
->driver
->pci_driver
.name
) +
114 strlen(dev
->unique
) + 2, DRM_MEM_DRIVER
);
118 sprintf(dev
->devname
, "%s@%s", dev
->driver
->pci_driver
.name
,
121 /* Return error if the busid submitted doesn't match the device's actual
124 ret
= sscanf(dev
->unique
, "PCI:%d:%d:%d", &bus
, &slot
, &func
);
126 return DRM_ERR(EINVAL
);
130 if ((domain
!= drm_get_pci_domain(dev
)) ||
131 (bus
!= dev
->pdev
->bus
->number
) ||
132 (slot
!= PCI_SLOT(dev
->pdev
->devfn
)) ||
133 (func
!= PCI_FUNC(dev
->pdev
->devfn
)))
139 static int drm_set_busid(drm_device_t
* dev
)
143 if (dev
->unique
!= NULL
)
146 dev
->unique_len
= 40;
147 dev
->unique
= drm_alloc(dev
->unique_len
+ 1, DRM_MEM_DRIVER
);
148 if (dev
->unique
== NULL
)
151 len
= snprintf(dev
->unique
, dev
->unique_len
, "pci:%04x:%02x:%02x.%d",
152 drm_get_pci_domain(dev
), dev
->pdev
->bus
->number
,
153 PCI_SLOT(dev
->pdev
->devfn
),
154 PCI_FUNC(dev
->pdev
->devfn
));
156 if (len
> dev
->unique_len
)
157 DRM_ERROR("Unique buffer overflowed\n");
160 drm_alloc(strlen(dev
->driver
->pci_driver
.name
) + dev
->unique_len
+
162 if (dev
->devname
== NULL
)
165 sprintf(dev
->devname
, "%s@%s", dev
->driver
->pci_driver
.name
,
172 * Get a mapping information.
174 * \param inode device inode.
175 * \param filp file pointer.
176 * \param cmd command.
177 * \param arg user argument, pointing to a drm_map structure.
179 * \return zero on success or a negative number on failure.
181 * Searches for the mapping with the specified offset and copies its information
184 int drm_getmap(struct inode
*inode
, struct file
*filp
,
185 unsigned int cmd
, unsigned long arg
)
187 drm_file_t
*priv
= filp
->private_data
;
188 drm_device_t
*dev
= priv
->head
->dev
;
189 drm_map_t __user
*argp
= (void __user
*)arg
;
191 drm_map_list_t
*r_list
= NULL
;
192 struct list_head
*list
;
196 if (copy_from_user(&map
, argp
, sizeof(map
)))
200 mutex_lock(&dev
->struct_mutex
);
202 mutex_unlock(&dev
->struct_mutex
);
207 list_for_each(list
, &dev
->maplist
->head
) {
209 r_list
= list_entry(list
, drm_map_list_t
, head
);
214 if (!r_list
|| !r_list
->map
) {
215 mutex_unlock(&dev
->struct_mutex
);
219 map
.offset
= r_list
->map
->offset
;
220 map
.size
= r_list
->map
->size
;
221 map
.type
= r_list
->map
->type
;
222 map
.flags
= r_list
->map
->flags
;
223 map
.handle
= (void *)(unsigned long)r_list
->user_token
;
224 map
.mtrr
= r_list
->map
->mtrr
;
225 mutex_unlock(&dev
->struct_mutex
);
227 if (copy_to_user(argp
, &map
, sizeof(map
)))
233 * Get client information.
235 * \param inode device inode.
236 * \param filp file pointer.
237 * \param cmd command.
238 * \param arg user argument, pointing to a drm_client structure.
240 * \return zero on success or a negative number on failure.
242 * Searches for the client with the specified index and copies its information
245 int drm_getclient(struct inode
*inode
, struct file
*filp
,
246 unsigned int cmd
, unsigned long arg
)
248 drm_file_t
*priv
= filp
->private_data
;
249 drm_device_t
*dev
= priv
->head
->dev
;
250 drm_client_t __user
*argp
= (drm_client_t __user
*)arg
;
256 if (copy_from_user(&client
, argp
, sizeof(client
)))
259 mutex_lock(&dev
->struct_mutex
);
260 for (i
= 0, pt
= dev
->file_first
; i
< idx
&& pt
; i
++, pt
= pt
->next
) ;
263 mutex_unlock(&dev
->struct_mutex
);
266 client
.auth
= pt
->authenticated
;
267 client
.pid
= pt
->pid
;
268 client
.uid
= pt
->uid
;
269 client
.magic
= pt
->magic
;
270 client
.iocs
= pt
->ioctl_count
;
271 mutex_unlock(&dev
->struct_mutex
);
273 if (copy_to_user(argp
, &client
, sizeof(client
)))
279 * Get statistics information.
281 * \param inode device inode.
282 * \param filp file pointer.
283 * \param cmd command.
284 * \param arg user argument, pointing to a drm_stats structure.
286 * \return zero on success or a negative number on failure.
288 int drm_getstats(struct inode
*inode
, struct file
*filp
,
289 unsigned int cmd
, unsigned long arg
)
291 drm_file_t
*priv
= filp
->private_data
;
292 drm_device_t
*dev
= priv
->head
->dev
;
296 memset(&stats
, 0, sizeof(stats
));
298 mutex_lock(&dev
->struct_mutex
);
300 for (i
= 0; i
< dev
->counters
; i
++) {
301 if (dev
->types
[i
] == _DRM_STAT_LOCK
)
303 = (dev
->lock
.hw_lock
? dev
->lock
.hw_lock
->lock
: 0);
305 stats
.data
[i
].value
= atomic_read(&dev
->counts
[i
]);
306 stats
.data
[i
].type
= dev
->types
[i
];
309 stats
.count
= dev
->counters
;
311 mutex_unlock(&dev
->struct_mutex
);
313 if (copy_to_user((drm_stats_t __user
*) arg
, &stats
, sizeof(stats
)))
321 * \param inode device inode.
322 * \param filp file pointer.
323 * \param cmd command.
324 * \param arg user argument, pointing to a drm_lock structure.
325 * \return zero on success or negative number on failure.
327 * Sets the requested interface version
329 int drm_setversion(DRM_IOCTL_ARGS
)
332 drm_set_version_t sv
;
333 drm_set_version_t retv
;
335 drm_set_version_t __user
*argp
= (void __user
*)data
;
338 if (copy_from_user(&sv
, argp
, sizeof(sv
)))
341 retv
.drm_di_major
= DRM_IF_MAJOR
;
342 retv
.drm_di_minor
= DRM_IF_MINOR
;
343 retv
.drm_dd_major
= dev
->driver
->major
;
344 retv
.drm_dd_minor
= dev
->driver
->minor
;
346 if (copy_to_user(argp
, &retv
, sizeof(retv
)))
349 if (sv
.drm_di_major
!= -1) {
350 if (sv
.drm_di_major
!= DRM_IF_MAJOR
||
351 sv
.drm_di_minor
< 0 || sv
.drm_di_minor
> DRM_IF_MINOR
)
353 if_version
= DRM_IF_VERSION(sv
.drm_di_major
, sv
.drm_di_minor
);
354 dev
->if_version
= max(if_version
, dev
->if_version
);
355 if (sv
.drm_di_minor
>= 1) {
357 * Version 1.1 includes tying of DRM to specific device
359 ret
= drm_set_busid(dev
);
365 if (sv
.drm_dd_major
!= -1) {
366 if (sv
.drm_dd_major
!= dev
->driver
->major
||
368 || sv
.drm_dd_minor
> dev
->driver
->minor
)
371 if (dev
->driver
->set_version
)
372 dev
->driver
->set_version(dev
, &sv
);
378 int drm_noop(struct inode
*inode
, struct file
*filp
, unsigned int cmd
,