3 * File operations for DRM
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 * \author Daryll Strauss <daryll@valinux.com>
7 * \author Gareth Hughes <gareth@valinux.com>
11 * Created: Mon Jan 4 08:58:31 1999 by faith@valinux.com
13 * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
14 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
15 * All Rights Reserved.
17 * Permission is hereby granted, free of charge, to any person obtaining a
18 * copy of this software and associated documentation files (the "Software"),
19 * to deal in the Software without restriction, including without limitation
20 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
21 * and/or sell copies of the Software, and to permit persons to whom the
22 * Software is furnished to do so, subject to the following conditions:
24 * The above copyright notice and this permission notice (including the next
25 * paragraph) shall be included in all copies or substantial portions of the
28 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
29 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
30 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
31 * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
32 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
33 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
34 * OTHER DEALINGS IN THE SOFTWARE.
38 #include <linux/poll.h>
40 static int drm_open_helper(struct inode
*inode
, struct file
*filp
,
43 static int drm_setup(drm_device_t
* dev
)
48 if (dev
->driver
->presetup
) {
49 ret
= dev
->driver
->presetup(dev
);
54 atomic_set(&dev
->ioctl_count
, 0);
55 atomic_set(&dev
->vma_count
, 0);
57 atomic_set(&dev
->buf_alloc
, 0);
59 if (drm_core_check_feature(dev
, DRIVER_HAVE_DMA
)) {
60 i
= drm_dma_setup(dev
);
65 for (i
= 0; i
< DRM_ARRAY_SIZE(dev
->counts
); i
++)
66 atomic_set(&dev
->counts
[i
], 0);
68 for (i
= 0; i
< DRM_HASH_SIZE
; i
++) {
69 dev
->magiclist
[i
].head
= NULL
;
70 dev
->magiclist
[i
].tail
= NULL
;
73 dev
->ctxlist
= drm_alloc(sizeof(*dev
->ctxlist
), DRM_MEM_CTXLIST
);
74 if (dev
->ctxlist
== NULL
)
76 memset(dev
->ctxlist
, 0, sizeof(*dev
->ctxlist
));
77 INIT_LIST_HEAD(&dev
->ctxlist
->head
);
80 dev
->sigdata
.lock
= dev
->lock
.hw_lock
= NULL
;
81 init_waitqueue_head(&dev
->lock
.lock_queue
);
83 dev
->queue_reserved
= 0;
85 dev
->queuelist
= NULL
;
87 dev
->context_flag
= 0;
88 dev
->interrupt_flag
= 0;
90 dev
->last_context
= 0;
92 dev
->last_checked
= 0;
93 init_waitqueue_head(&dev
->context_wait
);
99 dev
->buf_async
= NULL
;
100 init_waitqueue_head(&dev
->buf_readers
);
101 init_waitqueue_head(&dev
->buf_writers
);
106 * The kernel's context could be created here, but is now created
107 * in drm_dma_enqueue. This is more resource-efficient for
108 * hardware that does not do DMA, but may mean that
109 * drm_select_queue fails between the time the interrupt is
110 * initialized and the time the queues are initialized.
112 if (dev
->driver
->postsetup
)
113 dev
->driver
->postsetup(dev
);
121 * \param inode device inode
122 * \param filp file pointer.
123 * \return zero on success or a negative number on failure.
125 * Searches the DRM device with the same minor number, calls open_helper(), and
126 * increments the device open count. If the open count was previous at zero,
127 * i.e., it's the first that the device is open, then calls setup().
129 int drm_open(struct inode
*inode
, struct file
*filp
)
131 drm_device_t
*dev
= NULL
;
132 int minor
= iminor(inode
);
135 if (!((minor
>= 0) && (minor
< drm_cards_limit
)))
138 if (!drm_heads
[minor
])
141 if (!(dev
= drm_heads
[minor
]->dev
))
144 retcode
= drm_open_helper(inode
, filp
, dev
);
146 atomic_inc(&dev
->counts
[_DRM_STAT_OPENS
]);
147 spin_lock(&dev
->count_lock
);
148 if (!dev
->open_count
++) {
149 spin_unlock(&dev
->count_lock
);
150 return drm_setup(dev
);
152 spin_unlock(&dev
->count_lock
);
158 EXPORT_SYMBOL(drm_open
);
163 * \param inode device inode
164 * \param filp file pointer.
165 * \return zero on success or a negative number on failure.
167 * If the hardware lock is held then free it, and take it again for the kernel
168 * context since it's necessary to reclaim buffers. Unlink the file private
169 * data from its list and free it. Decreases the open count and if it reaches
170 * zero calls takedown().
172 int drm_release(struct inode
*inode
, struct file
*filp
)
174 drm_file_t
*priv
= filp
->private_data
;
179 dev
= priv
->head
->dev
;
181 DRM_DEBUG("open_count = %d\n", dev
->open_count
);
183 if (dev
->driver
->prerelease
)
184 dev
->driver
->prerelease(dev
, filp
);
186 /* ========================================================
187 * Begin inline drm_release
190 DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
191 current
->pid
, (long)old_encode_dev(priv
->head
->device
),
194 if (priv
->lock_count
&& dev
->lock
.hw_lock
&&
195 _DRM_LOCK_IS_HELD(dev
->lock
.hw_lock
->lock
) &&
196 dev
->lock
.filp
== filp
) {
197 DRM_DEBUG("File %p released, freeing lock for context %d\n",
198 filp
, _DRM_LOCKING_CONTEXT(dev
->lock
.hw_lock
->lock
));
200 if (dev
->driver
->release
)
201 dev
->driver
->release(dev
, filp
);
203 drm_lock_free(dev
, &dev
->lock
.hw_lock
->lock
,
204 _DRM_LOCKING_CONTEXT(dev
->lock
.hw_lock
->lock
));
206 /* FIXME: may require heavy-handed reset of
207 hardware at this point, possibly
208 processed via a callback to the X
210 } else if (dev
->driver
->release
&& priv
->lock_count
211 && dev
->lock
.hw_lock
) {
212 /* The lock is required to reclaim buffers */
213 DECLARE_WAITQUEUE(entry
, current
);
215 add_wait_queue(&dev
->lock
.lock_queue
, &entry
);
217 __set_current_state(TASK_INTERRUPTIBLE
);
218 if (!dev
->lock
.hw_lock
) {
219 /* Device has been unregistered */
223 if (drm_lock_take(&dev
->lock
.hw_lock
->lock
,
224 DRM_KERNEL_CONTEXT
)) {
225 dev
->lock
.filp
= filp
;
226 dev
->lock
.lock_time
= jiffies
;
227 atomic_inc(&dev
->counts
[_DRM_STAT_LOCKS
]);
228 break; /* Got lock */
232 if (signal_pending(current
)) {
233 retcode
= -ERESTARTSYS
;
237 __set_current_state(TASK_RUNNING
);
238 remove_wait_queue(&dev
->lock
.lock_queue
, &entry
);
240 if (dev
->driver
->release
)
241 dev
->driver
->release(dev
, filp
);
242 drm_lock_free(dev
, &dev
->lock
.hw_lock
->lock
,
247 if (drm_core_check_feature(dev
, DRIVER_HAVE_DMA
)
248 && !dev
->driver
->release
) {
249 dev
->driver
->reclaim_buffers(dev
, filp
);
252 drm_fasync(-1, filp
, 0);
254 down(&dev
->ctxlist_sem
);
255 if (dev
->ctxlist
&& (!list_empty(&dev
->ctxlist
->head
))) {
256 drm_ctx_list_t
*pos
, *n
;
258 list_for_each_entry_safe(pos
, n
, &dev
->ctxlist
->head
, head
) {
259 if (pos
->tag
== priv
&&
260 pos
->handle
!= DRM_KERNEL_CONTEXT
) {
261 if (dev
->driver
->context_dtor
)
262 dev
->driver
->context_dtor(dev
,
265 drm_ctxbitmap_free(dev
, pos
->handle
);
267 list_del(&pos
->head
);
268 drm_free(pos
, sizeof(*pos
), DRM_MEM_CTXLIST
);
273 up(&dev
->ctxlist_sem
);
275 down(&dev
->struct_sem
);
276 if (priv
->remove_auth_on_close
== 1) {
277 drm_file_t
*temp
= dev
->file_first
;
279 temp
->authenticated
= 0;
284 priv
->prev
->next
= priv
->next
;
286 dev
->file_first
= priv
->next
;
289 priv
->next
->prev
= priv
->prev
;
291 dev
->file_last
= priv
->prev
;
293 up(&dev
->struct_sem
);
295 if (dev
->driver
->free_filp_priv
)
296 dev
->driver
->free_filp_priv(dev
, priv
);
298 drm_free(priv
, sizeof(*priv
), DRM_MEM_FILES
);
300 /* ========================================================
301 * End inline drm_release
304 atomic_inc(&dev
->counts
[_DRM_STAT_CLOSES
]);
305 spin_lock(&dev
->count_lock
);
306 if (!--dev
->open_count
) {
307 if (atomic_read(&dev
->ioctl_count
) || dev
->blocked
) {
308 DRM_ERROR("Device busy: %d %d\n",
309 atomic_read(&dev
->ioctl_count
), dev
->blocked
);
310 spin_unlock(&dev
->count_lock
);
314 spin_unlock(&dev
->count_lock
);
316 return drm_takedown(dev
);
318 spin_unlock(&dev
->count_lock
);
325 EXPORT_SYMBOL(drm_release
);
328 * Called whenever a process opens /dev/drm.
330 * \param inode device inode.
331 * \param filp file pointer.
333 * \return zero on success or a negative number on failure.
335 * Creates and initializes a drm_file structure for the file private data in \p
336 * filp and add it into the double linked list in \p dev.
338 static int drm_open_helper(struct inode
*inode
, struct file
*filp
,
341 int minor
= iminor(inode
);
345 if (filp
->f_flags
& O_EXCL
)
346 return -EBUSY
; /* No exclusive opens */
347 if (!drm_cpu_valid())
350 DRM_DEBUG("pid = %d, minor = %d\n", current
->pid
, minor
);
352 priv
= drm_alloc(sizeof(*priv
), DRM_MEM_FILES
);
356 memset(priv
, 0, sizeof(*priv
));
357 filp
->private_data
= priv
;
358 priv
->uid
= current
->euid
;
359 priv
->pid
= current
->pid
;
361 priv
->head
= drm_heads
[minor
];
362 priv
->ioctl_count
= 0;
363 priv
->authenticated
= capable(CAP_SYS_ADMIN
);
364 priv
->lock_count
= 0;
366 if (dev
->driver
->open_helper
) {
367 ret
= dev
->driver
->open_helper(dev
, priv
);
372 down(&dev
->struct_sem
);
373 if (!dev
->file_last
) {
376 dev
->file_first
= priv
;
377 dev
->file_last
= priv
;
380 priv
->prev
= dev
->file_last
;
381 dev
->file_last
->next
= priv
;
382 dev
->file_last
= priv
;
384 up(&dev
->struct_sem
);
391 struct pci_dev
*pci_dev
;
392 pci_dev
= pci_get_class(PCI_CLASS_DISPLAY_VGA
<< 8, NULL
);
394 dev
->hose
= pci_dev
->sysdata
;
395 pci_dev_put(pci_dev
);
398 struct pci_bus
*b
= pci_bus_b(pci_root_buses
.next
);
400 dev
->hose
= b
->sysdata
;
407 drm_free(priv
, sizeof(*priv
), DRM_MEM_FILES
);
408 filp
->private_data
= NULL
;
413 int drm_flush(struct file
*filp
)
415 drm_file_t
*priv
= filp
->private_data
;
416 drm_device_t
*dev
= priv
->head
->dev
;
418 DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
419 current
->pid
, (long)old_encode_dev(priv
->head
->device
),
424 EXPORT_SYMBOL(drm_flush
);
427 int drm_fasync(int fd
, struct file
*filp
, int on
)
429 drm_file_t
*priv
= filp
->private_data
;
430 drm_device_t
*dev
= priv
->head
->dev
;
433 DRM_DEBUG("fd = %d, device = 0x%lx\n", fd
,
434 (long)old_encode_dev(priv
->head
->device
));
435 retcode
= fasync_helper(fd
, filp
, on
, &dev
->buf_async
);
441 EXPORT_SYMBOL(drm_fasync
);
444 unsigned int drm_poll(struct file
*filp
, struct poll_table_struct
*wait
)
449 EXPORT_SYMBOL(drm_poll
);