2 * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
4 * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
7 * Author Rickard E. (Rik) Faith <faith@valinux.com>
9 * Permission is hereby granted, free of charge, to any person obtaining a
10 * copy of this software and associated documentation files (the "Software"),
11 * to deal in the Software without restriction, including without limitation
12 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
13 * and/or sell copies of the Software, and to permit persons to whom the
14 * Software is furnished to do so, subject to the following conditions:
16 * The above copyright notice and this permission notice (including the next
17 * paragraph) shall be included in all copies or substantial portions of the
20 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
21 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
22 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
23 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
24 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
25 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
26 * DEALINGS IN THE SOFTWARE.
29 #include <linux/module.h>
30 #include <linux/moduleparam.h>
32 #include <drm/drm_core.h>
33 #include "drm_legacy.h"
34 #include "drm_internal.h"
36 /* Provides three levels of debug: off, minimal, verbose */
38 #if DRM_DEBUG_DEFAULT_ON == 1
39 #define DRM_DEBUGBITS_ON (DRM_UT_CORE | DRM_UT_DRIVER | DRM_UT_KMS | \
40 DRM_UT_PRIME| DRM_UT_ATOMIC | DRM_UT_FIOCTL)
41 #elif DRM_DEBUG_DEFAULT_ON == 2
42 #define DRM_DEBUGBITS_ON (DRM_UT_CORE | DRM_UT_DRIVER | DRM_UT_KMS | \
43 DRM_UT_PRIME| DRM_UT_ATOMIC | DRM_UT_FIOCTL | \
44 DRM_UT_PID | DRM_UT_IOCTL | DRM_UT_VBLANK)
46 #define DRM_DEBUGBITS_ON (0x0)
48 unsigned int drm_debug
= DRM_DEBUGBITS_ON
; /* defaults to 0 */
50 unsigned int drm_debug
= 0; /* bitmask of DRM_UT_x */
51 #endif /* __DragonFly__ */
52 EXPORT_SYMBOL(drm_debug
);
54 MODULE_AUTHOR(CORE_AUTHOR
);
55 MODULE_DESCRIPTION(CORE_DESC
);
56 MODULE_PARM_DESC(debug
, "Enable debug output");
57 module_param_named(debug
, drm_debug
, int, 0600);
60 static DEFINE_SPINLOCK(drm_minor_lock
);
61 static struct idr drm_minors_idr
;
65 static struct dentry
*drm_debugfs_root
;
68 void drm_err(const char *func
, const char *format
, ...)
72 kprintf("error: [" DRM_NAME
":pid%d:%s] *ERROR* ", DRM_CURRENTPID
, func
);
74 __va_start(args
, format
);
75 kvprintf(format
, args
);
78 EXPORT_SYMBOL(drm_err
);
80 void drm_ut_debug_printk(const char *function_name
, const char *format
, ...)
84 if (unlikely(drm_debug
& DRM_UT_PID
)) {
85 kprintf("[" DRM_NAME
":pid%d:%s] ",
86 DRM_CURRENTPID
, function_name
);
88 kprintf("[" DRM_NAME
":%s] ", function_name
);
91 __va_start(args
, format
);
92 kvprintf(format
, args
);
95 EXPORT_SYMBOL(drm_ut_debug_printk
);
98 struct drm_master
*drm_master_create(struct drm_minor
*minor
)
100 struct drm_master
*master
;
102 master
= kzalloc(sizeof(*master
), GFP_KERNEL
);
106 kref_init(&master
->refcount
);
107 spin_lock_init(&master
->lock
.spinlock
);
108 init_waitqueue_head(&master
->lock
.lock_queue
);
109 if (drm_ht_create(&master
->magiclist
, DRM_MAGIC_HASH_ORDER
)) {
113 master
->minor
= minor
;
118 struct drm_master
*drm_master_get(struct drm_master
*master
)
120 kref_get(&master
->refcount
);
123 EXPORT_SYMBOL(drm_master_get
);
125 static void drm_master_destroy(struct kref
*kref
)
127 struct drm_master
*master
= container_of(kref
, struct drm_master
, refcount
);
128 struct drm_device
*dev
= master
->minor
->dev
;
129 struct drm_map_list
*r_list
, *list_temp
;
131 mutex_lock(&dev
->struct_mutex
);
132 if (dev
->driver
->master_destroy
)
133 dev
->driver
->master_destroy(dev
, master
);
135 list_for_each_entry_safe(r_list
, list_temp
, &dev
->maplist
, head
) {
136 if (r_list
->master
== master
) {
137 drm_legacy_rmmap_locked(dev
, r_list
->map
);
142 if (master
->unique
) {
143 kfree(master
->unique
);
144 master
->unique
= NULL
;
145 master
->unique_len
= 0;
148 drm_ht_remove(&master
->magiclist
);
150 mutex_unlock(&dev
->struct_mutex
);
154 void drm_master_put(struct drm_master
**master
)
156 kref_put(&(*master
)->refcount
, drm_master_destroy
);
159 EXPORT_SYMBOL(drm_master_put
);
162 int drm_setmaster_ioctl(struct drm_device
*dev
, void *data
,
163 struct drm_file
*file_priv
)
165 DRM_DEBUG("setmaster\n");
167 if (file_priv
->master
!= 0)
173 int drm_dropmaster_ioctl(struct drm_device
*dev
, void *data
,
174 struct drm_file
*file_priv
)
176 DRM_DEBUG("dropmaster\n");
177 if (file_priv
->master
!= 0)
185 * A DRM device can provide several char-dev interfaces on the DRM-Major. Each
186 * of them is represented by a drm_minor object. Depending on the capabilities
187 * of the device-driver, different interfaces are registered.
189 * Minors can be accessed via dev->$minor_name. This pointer is either
190 * NULL or a valid drm_minor pointer and stays valid as long as the device is
191 * valid. This means, DRM minors have the same life-time as the underlying
192 * device. However, this doesn't mean that the minor is active. Minors are
193 * registered and unregistered dynamically according to device-state.
196 static struct drm_minor
**drm_minor_get_slot(struct drm_device
*dev
,
200 case DRM_MINOR_LEGACY
:
201 return &dev
->primary
;
202 case DRM_MINOR_RENDER
:
204 case DRM_MINOR_CONTROL
:
205 return &dev
->control
;
211 static int drm_minor_alloc(struct drm_device
*dev
, unsigned int type
)
213 struct drm_minor
*minor
;
217 minor
= kzalloc(sizeof(*minor
), GFP_KERNEL
);
224 idr_preload(GFP_KERNEL
);
225 spin_lock_irqsave(&drm_minor_lock
, flags
);
226 r
= idr_alloc(&drm_minors_idr
,
231 spin_unlock_irqrestore(&drm_minor_lock
, flags
);
239 minor
->kdev
= drm_sysfs_minor_alloc(minor
);
240 if (IS_ERR(minor
->kdev
)) {
241 r
= PTR_ERR(minor
->kdev
);
245 *drm_minor_get_slot(dev
, type
) = minor
;
249 spin_lock_irqsave(&drm_minor_lock
, flags
);
250 idr_remove(&drm_minors_idr
, minor
->index
);
251 spin_unlock_irqrestore(&drm_minor_lock
, flags
);
257 static void drm_minor_free(struct drm_device
*dev
, unsigned int type
)
259 struct drm_minor
**slot
, *minor
;
262 slot
= drm_minor_get_slot(dev
, type
);
267 put_device(minor
->kdev
);
269 spin_lock_irqsave(&drm_minor_lock
, flags
);
270 idr_remove(&drm_minors_idr
, minor
->index
);
271 spin_unlock_irqrestore(&drm_minor_lock
, flags
);
277 static int drm_minor_register(struct drm_device
*dev
, unsigned int type
)
279 struct drm_minor
*minor
;
285 minor
= *drm_minor_get_slot(dev
, type
);
289 ret
= drm_debugfs_init(minor
, minor
->index
, drm_debugfs_root
);
291 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
295 ret
= device_add(minor
->kdev
);
299 /* replace NULL with @minor so lookups will succeed from now on */
300 spin_lock_irqsave(&drm_minor_lock
, flags
);
301 idr_replace(&drm_minors_idr
, minor
, minor
->index
);
302 spin_unlock_irqrestore(&drm_minor_lock
, flags
);
304 DRM_DEBUG("new minor registered %d\n", minor
->index
);
308 drm_debugfs_cleanup(minor
);
312 static void drm_minor_unregister(struct drm_device
*dev
, unsigned int type
)
314 struct drm_minor
*minor
;
317 minor
= *drm_minor_get_slot(dev
, type
);
318 if (!minor
|| !device_is_registered(minor
->kdev
))
321 /* replace @minor with NULL so lookups will fail from now on */
322 spin_lock_irqsave(&drm_minor_lock
, flags
);
323 idr_replace(&drm_minors_idr
, NULL
, minor
->index
);
324 spin_unlock_irqrestore(&drm_minor_lock
, flags
);
326 device_del(minor
->kdev
);
327 dev_set_drvdata(minor
->kdev
, NULL
); /* safety belt */
328 drm_debugfs_cleanup(minor
);
332 * drm_minor_acquire - Acquire a DRM minor
333 * @minor_id: Minor ID of the DRM-minor
335 * Looks up the given minor-ID and returns the respective DRM-minor object. The
336 * refence-count of the underlying device is increased so you must release this
337 * object with drm_minor_release().
339 * As long as you hold this minor, it is guaranteed that the object and the
340 * minor->dev pointer will stay valid! However, the device may get unplugged and
341 * unregistered while you hold the minor.
344 * Pointer to minor-object with increased device-refcount, or PTR_ERR on
347 struct drm_minor
*drm_minor_acquire(unsigned int minor_id
)
349 struct drm_minor
*minor
;
352 spin_lock_irqsave(&drm_minor_lock
, flags
);
353 minor
= idr_find(&drm_minors_idr
, minor_id
);
355 drm_dev_ref(minor
->dev
);
356 spin_unlock_irqrestore(&drm_minor_lock
, flags
);
359 return ERR_PTR(-ENODEV
);
360 } else if (drm_device_is_unplugged(minor
->dev
)) {
361 drm_dev_unref(minor
->dev
);
362 return ERR_PTR(-ENODEV
);
369 * drm_minor_release - Release DRM minor
370 * @minor: Pointer to DRM minor object
372 * Release a minor that was previously acquired via drm_minor_acquire().
374 void drm_minor_release(struct drm_minor
*minor
)
376 drm_dev_unref(minor
->dev
);
380 * DOC: driver instance overview
382 * A device instance for a drm driver is represented by struct &drm_device. This
383 * is allocated with drm_dev_alloc(), usually from bus-specific ->probe()
384 * callbacks implemented by the driver. The driver then needs to initialize all
385 * the various subsystems for the drm device like memory management, vblank
386 * handling, modesetting support and intial output configuration plus obviously
387 * initialize all the corresponding hardware bits. An important part of this is
388 * also calling drm_dev_set_unique() to set the userspace-visible unique name of
389 * this device instance. Finally when everything is up and running and ready for
390 * userspace the device instance can be published using drm_dev_register().
392 * There is also deprecated support for initalizing device instances using
393 * bus-specific helpers and the ->load() callback. But due to
394 * backwards-compatibility needs the device instance have to be published too
395 * early, which requires unpretty global locking to make safe and is therefore
396 * only support for existing drivers not yet converted to the new scheme.
398 * When cleaning up a device instance everything needs to be done in reverse:
399 * First unpublish the device instance with drm_dev_unregister(). Then clean up
400 * any other resources allocated at device initialization and drop the driver's
401 * reference to &drm_device using drm_dev_unref().
403 * Note that the lifetime rules for &drm_device instance has still a lot of
404 * historical baggage. Hence use the reference counting provided by
405 * drm_dev_ref() and drm_dev_unref() only carefully.
407 * Also note that embedding of &drm_device is currently not (yet) supported (but
408 * it would be easy to add). Drivers can store driver-private data in the
409 * dev_priv field of &drm_device.
413 * drm_put_dev - Unregister and release a DRM device
416 * Called at module unload time or when a PCI device is unplugged.
418 * Cleans up all DRM device, calling drm_lastclose().
420 * Note: Use of this function is deprecated. It will eventually go away
421 * completely. Please use drm_dev_unregister() and drm_dev_unref() explicitly
422 * instead to make sure that the device isn't userspace accessible any more
423 * while teardown is in progress, ensuring that userspace can't access an
424 * inconsistent state.
426 void drm_put_dev(struct drm_device
*dev
)
431 DRM_ERROR("cleanup called no dev\n");
435 drm_dev_unregister(dev
);
438 EXPORT_SYMBOL(drm_put_dev
);
440 void drm_unplug_dev(struct drm_device
*dev
)
442 /* for a USB device */
443 drm_minor_unregister(dev
, DRM_MINOR_LEGACY
);
444 drm_minor_unregister(dev
, DRM_MINOR_RENDER
);
445 drm_minor_unregister(dev
, DRM_MINOR_CONTROL
);
447 mutex_lock(&drm_global_mutex
);
449 drm_device_set_unplugged(dev
);
451 if (dev
->open_count
== 0) {
454 mutex_unlock(&drm_global_mutex
);
456 EXPORT_SYMBOL(drm_unplug_dev
);
460 * We want to be able to allocate our own "struct address_space" to control
461 * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow
462 * stand-alone address_space objects, so we need an underlying inode. As there
463 * is no way to allocate an independent inode easily, we need a fake internal
466 * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free()
467 * frees it again. You are allowed to use iget() and iput() to get references to
468 * the inode. But each drm_fs_inode_new() call must be paired with exactly one
469 * drm_fs_inode_free() call (which does not have to be the last iput()).
470 * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it
471 * between multiple inode-users. You could, technically, call
472 * iget() + drm_fs_inode_free() directly after alloc and sometime later do an
473 * iput(), but this way you'd end up with a new vfsmount for each inode.
476 static int drm_fs_cnt
;
477 static struct vfsmount
*drm_fs_mnt
;
479 static const struct dentry_operations drm_fs_dops
= {
480 .d_dname
= simple_dname
,
483 static const struct super_operations drm_fs_sops
= {
484 .statfs
= simple_statfs
,
487 static struct dentry
*drm_fs_mount(struct file_system_type
*fs_type
, int flags
,
488 const char *dev_name
, void *data
)
490 return mount_pseudo(fs_type
,
497 static struct file_system_type drm_fs_type
= {
499 .owner
= THIS_MODULE
,
500 .mount
= drm_fs_mount
,
501 .kill_sb
= kill_anon_super
,
504 static struct inode
*drm_fs_inode_new(void)
509 r
= simple_pin_fs(&drm_fs_type
, &drm_fs_mnt
, &drm_fs_cnt
);
511 DRM_ERROR("Cannot mount pseudo fs: %d\n", r
);
515 inode
= alloc_anon_inode(drm_fs_mnt
->mnt_sb
);
517 simple_release_fs(&drm_fs_mnt
, &drm_fs_cnt
);
522 static void drm_fs_inode_free(struct inode
*inode
)
526 simple_release_fs(&drm_fs_mnt
, &drm_fs_cnt
);
531 * drm_dev_alloc - Allocate new DRM device
532 * @driver: DRM driver to allocate device for
533 * @parent: Parent device object
535 * Allocate and initialize a new DRM device. No device registration is done.
536 * Call drm_dev_register() to advertice the device to user space and register it
537 * with other core subsystems. This should be done last in the device
538 * initialization sequence to make sure userspace can't access an inconsistent
541 * The initial ref-count of the object is 1. Use drm_dev_ref() and
542 * drm_dev_unref() to take and drop further ref-counts.
544 * Note that for purely virtual devices @parent can be NULL.
547 * Pointer to new DRM device, or NULL if out of memory.
549 struct drm_device
*drm_dev_alloc(struct drm_driver
*driver
,
550 struct device
*parent
)
552 struct drm_device
*dev
;
555 dev
= kzalloc(sizeof(*dev
), GFP_KERNEL
);
559 kref_init(&dev
->ref
);
561 dev
->driver
= driver
;
563 INIT_LIST_HEAD(&dev
->filelist
);
564 INIT_LIST_HEAD(&dev
->ctxlist
);
565 INIT_LIST_HEAD(&dev
->vmalist
);
566 INIT_LIST_HEAD(&dev
->maplist
);
567 INIT_LIST_HEAD(&dev
->vblank_event_list
);
569 spin_lock_init(&dev
->buf_lock
);
570 spin_lock_init(&dev
->event_lock
);
571 mutex_init(&dev
->struct_mutex
);
572 mutex_init(&dev
->ctxlist_mutex
);
573 mutex_init(&dev
->master_mutex
);
575 dev
->anon_inode
= drm_fs_inode_new();
576 if (IS_ERR(dev
->anon_inode
)) {
577 ret
= PTR_ERR(dev
->anon_inode
);
578 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret
);
582 if (drm_core_check_feature(dev
, DRIVER_MODESET
)) {
583 ret
= drm_minor_alloc(dev
, DRM_MINOR_CONTROL
);
587 WARN_ON(driver
->suspend
|| driver
->resume
);
590 if (drm_core_check_feature(dev
, DRIVER_RENDER
)) {
591 ret
= drm_minor_alloc(dev
, DRM_MINOR_RENDER
);
596 ret
= drm_minor_alloc(dev
, DRM_MINOR_LEGACY
);
600 if (drm_ht_create(&dev
->map_hash
, 12))
603 drm_legacy_ctxbitmap_init(dev
);
605 if (drm_core_check_feature(dev
, DRIVER_GEM
)) {
606 ret
= drm_gem_init(dev
);
608 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
614 ret
= drm_dev_set_unique(dev
, dev_name(parent
));
622 if (drm_core_check_feature(dev
, DRIVER_GEM
))
623 drm_gem_destroy(dev
);
625 drm_legacy_ctxbitmap_cleanup(dev
);
626 drm_ht_remove(&dev
->map_hash
);
628 drm_minor_free(dev
, DRM_MINOR_LEGACY
);
629 drm_minor_free(dev
, DRM_MINOR_RENDER
);
630 drm_minor_free(dev
, DRM_MINOR_CONTROL
);
631 drm_fs_inode_free(dev
->anon_inode
);
633 mutex_destroy(&dev
->master_mutex
);
637 EXPORT_SYMBOL(drm_dev_alloc
);
639 static void drm_dev_release(struct kref
*ref
)
641 struct drm_device
*dev
= container_of(ref
, struct drm_device
, ref
);
643 if (drm_core_check_feature(dev
, DRIVER_GEM
))
644 drm_gem_destroy(dev
);
646 drm_legacy_ctxbitmap_cleanup(dev
);
647 drm_ht_remove(&dev
->map_hash
);
648 drm_fs_inode_free(dev
->anon_inode
);
650 drm_minor_free(dev
, DRM_MINOR_LEGACY
);
651 drm_minor_free(dev
, DRM_MINOR_RENDER
);
652 drm_minor_free(dev
, DRM_MINOR_CONTROL
);
654 mutex_destroy(&dev
->master_mutex
);
660 * drm_dev_ref - Take reference of a DRM device
661 * @dev: device to take reference of or NULL
663 * This increases the ref-count of @dev by one. You *must* already own a
664 * reference when calling this. Use drm_dev_unref() to drop this reference
667 * This function never fails. However, this function does not provide *any*
668 * guarantee whether the device is alive or running. It only provides a
669 * reference to the object and the memory associated with it.
671 void drm_dev_ref(struct drm_device
*dev
)
676 EXPORT_SYMBOL(drm_dev_ref
);
679 * drm_dev_unref - Drop reference of a DRM device
680 * @dev: device to drop reference of or NULL
682 * This decreases the ref-count of @dev by one. The device is destroyed if the
683 * ref-count drops to zero.
685 void drm_dev_unref(struct drm_device
*dev
)
688 kref_put(&dev
->ref
, drm_dev_release
);
690 EXPORT_SYMBOL(drm_dev_unref
);
693 * drm_dev_register - Register DRM device
694 * @dev: Device to register
695 * @flags: Flags passed to the driver's .load() function
697 * Register the DRM device @dev with the system, advertise device to user-space
698 * and start normal device operation. @dev must be allocated via drm_dev_alloc()
701 * Never call this twice on any device!
703 * NOTE: To ensure backward compatibility with existing drivers method this
704 * function calls the ->load() method after registering the device nodes,
705 * creating race conditions. Usage of the ->load() methods is therefore
706 * deprecated, drivers must perform all initialization before calling
707 * drm_dev_register().
710 * 0 on success, negative error code on failure.
712 int drm_dev_register(struct drm_device
*dev
, unsigned long flags
)
716 mutex_lock(&drm_global_mutex
);
718 ret
= drm_minor_register(dev
, DRM_MINOR_CONTROL
);
722 ret
= drm_minor_register(dev
, DRM_MINOR_RENDER
);
726 ret
= drm_minor_register(dev
, DRM_MINOR_LEGACY
);
730 if (dev
->driver
->load
) {
731 ret
= dev
->driver
->load(dev
, flags
);
740 drm_minor_unregister(dev
, DRM_MINOR_LEGACY
);
741 drm_minor_unregister(dev
, DRM_MINOR_RENDER
);
742 drm_minor_unregister(dev
, DRM_MINOR_CONTROL
);
744 mutex_unlock(&drm_global_mutex
);
747 EXPORT_SYMBOL(drm_dev_register
);
750 * drm_dev_unregister - Unregister DRM device
751 * @dev: Device to unregister
753 * Unregister the DRM device from the system. This does the reverse of
754 * drm_dev_register() but does not deallocate the device. The caller must call
755 * drm_dev_unref() to drop their final reference.
757 * This should be called first in the device teardown code to make sure
758 * userspace can't access the device instance any more.
760 void drm_dev_unregister(struct drm_device
*dev
)
762 struct drm_map_list
*r_list
, *list_temp
;
766 if (dev
->driver
->unload
)
767 dev
->driver
->unload(dev
);
770 drm_pci_agp_destroy(dev
);
772 drm_vblank_cleanup(dev
);
774 list_for_each_entry_safe(r_list
, list_temp
, &dev
->maplist
, head
)
775 drm_legacy_rmmap(dev
, r_list
->map
);
777 drm_minor_unregister(dev
, DRM_MINOR_LEGACY
);
778 drm_minor_unregister(dev
, DRM_MINOR_RENDER
);
779 drm_minor_unregister(dev
, DRM_MINOR_CONTROL
);
781 EXPORT_SYMBOL(drm_dev_unregister
);
784 * drm_dev_set_unique - Set the unique name of a DRM device
785 * @dev: device of which to set the unique name
788 * Sets the unique name of a DRM device using the specified string. Drivers
789 * can use this at driver probe time if the unique name of the devices they
792 * Return: 0 on success or a negative error code on failure.
794 int drm_dev_set_unique(struct drm_device
*dev
, const char *name
)
797 dev
->unique
= kstrdup(name
, GFP_KERNEL
);
799 return dev
->unique
? 0 : -ENOMEM
;
801 EXPORT_SYMBOL(drm_dev_set_unique
);
806 * The DRM core module initializes all global DRM objects and makes them
807 * available to drivers. Once setup, drivers can probe their respective
809 * Currently, core management includes:
810 * - The "DRM-Global" key/value database
811 * - Global ID management for connectors
812 * - DRM major number allocation
813 * - DRM minor management
817 * Furthermore, the DRM core provides dynamic char-dev lookups. For each
818 * interface registered on a DRM device, you can request minor numbers from DRM
819 * core. DRM core takes care of major-number management and char-dev
820 * registration. A stub ->open() callback forwards any open() requests to the
825 static int drm_stub_open(struct inode
*inode
, struct file
*filp
)
827 const struct file_operations
*new_fops
;
828 struct drm_minor
*minor
;
833 mutex_lock(&drm_global_mutex
);
834 minor
= drm_minor_acquire(iminor(inode
));
836 err
= PTR_ERR(minor
);
840 new_fops
= fops_get(minor
->dev
->driver
->fops
);
846 replace_fops(filp
, new_fops
);
847 if (filp
->f_op
->open
)
848 err
= filp
->f_op
->open(inode
, filp
);
853 drm_minor_release(minor
);
855 mutex_unlock(&drm_global_mutex
);
859 static const struct file_operations drm_stub_fops
= {
860 .owner
= THIS_MODULE
,
861 .open
= drm_stub_open
,
862 .llseek
= noop_llseek
,
865 static int __init
drm_core_init(void)
870 drm_connector_ida_init();
871 idr_init(&drm_minors_idr
);
873 if (register_chrdev(DRM_MAJOR
, "drm", &drm_stub_fops
))
876 ret
= drm_sysfs_init();
878 printk(KERN_ERR
"DRM: Error creating drm class.\n");
882 drm_debugfs_root
= debugfs_create_dir("dri", NULL
);
883 if (!drm_debugfs_root
) {
884 DRM_ERROR("Cannot create /sys/kernel/debug/dri\n");
889 DRM_INFO("Initialized %s %d.%d.%d %s\n",
890 CORE_NAME
, CORE_MAJOR
, CORE_MINOR
, CORE_PATCHLEVEL
, CORE_DATE
);
895 unregister_chrdev(DRM_MAJOR
, "drm");
897 idr_destroy(&drm_minors_idr
);
902 static void __exit
drm_core_exit(void)
904 debugfs_remove(drm_debugfs_root
);
907 unregister_chrdev(DRM_MAJOR
, "drm");
909 drm_connector_ida_destroy();
910 idr_destroy(&drm_minors_idr
);
913 module_init(drm_core_init
);
914 module_exit(drm_core_exit
);
917 #include <sys/devfs.h>
919 #include <linux/export.h>
920 #include <linux/dmi.h>
921 #include <drm/drmP.h>
922 #include <drm/drm_core.h>
924 static int drm_load(struct drm_device
*dev
);
925 drm_pci_id_list_t
*drm_find_description(int vendor
, int device
,
926 drm_pci_id_list_t
*idlist
);
928 #define DRIVER_SOFTC(unit) \
929 ((struct drm_device *)devclass_get_softc(drm_devclass, unit))
932 drm_modevent(module_t mod
, int type
, void *data
)
937 TUNABLE_INT_FETCH("drm.debug", &drm_debug
);
943 static moduledata_t drm_mod
= {
948 DECLARE_MODULE(drm
, drm_mod
, SI_SUB_DRIVERS
, SI_ORDER_FIRST
);
949 MODULE_VERSION(drm
, 1);
950 MODULE_DEPEND(drm
, agp
, 1, 1, 1);
951 MODULE_DEPEND(drm
, pci
, 1, 1, 1);
952 MODULE_DEPEND(drm
, iicbus
, 1, 1, 1);
954 static struct dev_ops drm_cdevsw
= {
955 { "drm", 0, D_TRACKCLOSE
| D_MPSAFE
},
957 .d_close
= drm_close
,
959 .d_ioctl
= drm_ioctl
,
960 .d_kqfilter
= drm_kqfilter
,
962 .d_mmap_single
= drm_mmap_single
,
965 SYSCTL_NODE(_hw
, OID_AUTO
, drm
, CTLFLAG_RW
, NULL
, "DRM device");
966 SYSCTL_INT(_hw_drm
, OID_AUTO
, debug
, CTLFLAG_RW
, &drm_debug
, 0,
969 int drm_probe(device_t kdev
, drm_pci_id_list_t
*idlist
)
971 drm_pci_id_list_t
*id_entry
;
974 vendor
= pci_get_vendor(kdev
);
975 device
= pci_get_device(kdev
);
977 if (pci_get_class(kdev
) != PCIC_DISPLAY
)
980 id_entry
= drm_find_description(vendor
, device
, idlist
);
981 if (id_entry
!= NULL
) {
982 if (!device_get_desc(kdev
)) {
983 device_set_desc(kdev
, id_entry
->name
);
984 DRM_DEBUG("desc : %s\n", device_get_desc(kdev
));
992 int drm_attach(device_t kdev
, drm_pci_id_list_t
*idlist
)
994 struct drm_device
*dev
;
995 drm_pci_id_list_t
*id_entry
;
1000 unit
= device_get_unit(kdev
);
1001 dev
= device_get_softc(kdev
);
1003 /* Initialize Linux struct device */
1004 dev
->dev
= kzalloc(sizeof(struct device
), GFP_KERNEL
);
1006 if (!strcmp(device_get_name(kdev
), "drmsub"))
1007 dev
->dev
->bsddev
= device_get_parent(kdev
);
1009 dev
->dev
->bsddev
= kdev
;
1011 dev
->pci_domain
= pci_get_domain(dev
->dev
->bsddev
);
1012 dev
->pci_bus
= pci_get_bus(dev
->dev
->bsddev
);
1013 dev
->pci_slot
= pci_get_slot(dev
->dev
->bsddev
);
1014 dev
->pci_func
= pci_get_function(dev
->dev
->bsddev
);
1015 drm_init_pdev(dev
->dev
->bsddev
, &dev
->pdev
);
1017 id_entry
= drm_find_description(dev
->pdev
->vendor
,
1018 dev
->pdev
->device
, idlist
);
1019 dev
->id_entry
= id_entry
;
1021 if (drm_core_check_feature(dev
, DRIVER_HAVE_IRQ
)) {
1024 dev
->irq_type
= pci_alloc_1intr(dev
->dev
->bsddev
, msi_enable
,
1025 &dev
->irqrid
, &irq_flags
);
1027 dev
->irqr
= bus_alloc_resource_any(dev
->dev
->bsddev
, SYS_RES_IRQ
,
1028 &dev
->irqrid
, irq_flags
);
1034 dev
->irq
= (int) rman_get_start(dev
->irqr
);
1035 dev
->pdev
->irq
= dev
->irq
; /* for i915 */
1038 /* Print the contents of pdev struct. */
1039 drm_print_pdev(dev
->pdev
);
1041 lockinit(&dev
->dev_lock
, "drmdev", 0, LK_CANRECURSE
);
1042 lwkt_serialize_init(&dev
->irq_lock
);
1043 lockinit(&dev
->event_lock
, "drmev", 0, LK_CANRECURSE
);
1044 lockinit(&dev
->struct_mutex
, "drmslk", 0, LK_CANRECURSE
);
1046 error
= drm_load(dev
);
1050 error
= drm_create_cdevs(kdev
);
1057 bus_release_resource(dev
->dev
->bsddev
, SYS_RES_IRQ
,
1058 dev
->irqrid
, dev
->irqr
);
1060 if (dev
->irq_type
== PCI_INTR_TYPE_MSI
) {
1061 pci_release_msi(dev
->dev
->bsddev
);
1067 drm_create_cdevs(device_t kdev
)
1069 struct drm_device
*dev
;
1072 unit
= device_get_unit(kdev
);
1073 dev
= device_get_softc(kdev
);
1075 dev
->devnode
= make_dev(&drm_cdevsw
, unit
, DRM_DEV_UID
, DRM_DEV_GID
,
1076 DRM_DEV_MODE
, "dri/card%d", unit
);
1079 dev
->devnode
->si_drv1
= dev
;
1083 #ifndef DRM_DEV_NAME
1084 #define DRM_DEV_NAME "drm"
1087 devclass_t drm_devclass
;
1089 drm_pci_id_list_t
*drm_find_description(int vendor
, int device
,
1090 drm_pci_id_list_t
*idlist
)
1094 for (i
= 0; idlist
[i
].vendor
!= 0; i
++) {
1095 if ((idlist
[i
].vendor
== vendor
) &&
1096 ((idlist
[i
].device
== device
) ||
1097 (idlist
[i
].device
== 0))) {
1104 static int drm_load(struct drm_device
*dev
)
1110 INIT_LIST_HEAD(&dev
->maplist
);
1112 drm_sysctl_init(dev
);
1113 INIT_LIST_HEAD(&dev
->filelist
);
1116 dev
->types
[0] = _DRM_STAT_LOCK
;
1117 dev
->types
[1] = _DRM_STAT_OPENS
;
1118 dev
->types
[2] = _DRM_STAT_CLOSES
;
1119 dev
->types
[3] = _DRM_STAT_IOCTLS
;
1120 dev
->types
[4] = _DRM_STAT_LOCKS
;
1121 dev
->types
[5] = _DRM_STAT_UNLOCKS
;
1123 for (i
= 0; i
< ARRAY_SIZE(dev
->counts
); i
++)
1124 atomic_set(&dev
->counts
[i
], 0);
1126 INIT_LIST_HEAD(&dev
->vblank_event_list
);
1128 if (drm_core_check_feature(dev
, DRIVER_USE_AGP
)) {
1129 if (drm_pci_device_is_agp(dev
))
1130 dev
->agp
= drm_agp_init(dev
);
1133 if (dev
->driver
->driver_features
& DRIVER_GEM
) {
1134 retcode
= drm_gem_init(dev
);
1136 DRM_ERROR("Cannot initialize graphics execution "
1142 if (dev
->driver
->load
!= NULL
) {
1144 /* Shared code returns -errno. */
1145 retcode
= -dev
->driver
->load(dev
,
1146 dev
->id_entry
->driver_private
);
1147 if (pci_enable_busmaster(dev
->dev
->bsddev
))
1148 DRM_ERROR("Request to enable bus-master failed.\n");
1154 DRM_INFO("Initialized %s %d.%d.%d %s\n",
1158 dev
->driver
->patchlevel
,
1164 drm_gem_destroy(dev
);
1165 drm_sysctl_cleanup(dev
);
1169 if (dev
->devnode
!= NULL
)
1170 destroy_dev(dev
->devnode
);
1172 lockuninit(&dev
->vbl_lock
);
1173 lockuninit(&dev
->dev_lock
);
1174 lockuninit(&dev
->event_lock
);
1175 lockuninit(&dev
->struct_mutex
);
1181 * Stub is needed for devfs
1183 int drm_close(struct dev_close_args
*ap
)
1188 void drm_cdevpriv_dtor(void *cd
)
1190 struct drm_file
*file_priv
= cd
;
1191 struct drm_device
*dev
= file_priv
->dev
;
1194 DRM_DEBUG("open_count = %d\n", dev
->open_count
);
1198 if (dev
->driver
->preclose
!= NULL
)
1199 dev
->driver
->preclose(dev
, file_priv
);
1201 /* ========================================================
1202 * Begin inline drm_release
1205 DRM_DEBUG("pid = %d, device = 0x%lx, open_count = %d\n",
1206 DRM_CURRENTPID
, (long)dev
->dev
, dev
->open_count
);
1208 if (dev
->driver
->driver_features
& DRIVER_GEM
)
1209 drm_gem_release(dev
, file_priv
);
1211 if (drm_core_check_feature(dev
, DRIVER_HAVE_DMA
) &&
1212 !dev
->driver
->reclaim_buffers_locked
)
1213 drm_legacy_reclaim_buffers(dev
, file_priv
);
1215 funsetown(&dev
->buf_sigio
);
1217 if (dev
->driver
->postclose
!= NULL
)
1218 dev
->driver
->postclose(dev
, file_priv
);
1219 list_del(&file_priv
->lhead
);
1222 /* ========================================================
1223 * End inline drm_release
1226 atomic_inc(&dev
->counts
[_DRM_STAT_CLOSES
]);
1227 device_unbusy(dev
->dev
->bsddev
);
1228 if (--dev
->open_count
== 0) {
1229 retcode
= drm_lastclose(dev
);
1236 drm_add_busid_modesetting(struct drm_device
*dev
, struct sysctl_ctx_list
*ctx
,
1237 struct sysctl_oid
*top
)
1239 struct sysctl_oid
*oid
;
1241 ksnprintf(dev
->busid_str
, sizeof(dev
->busid_str
),
1242 "pci:%04x:%02x:%02x.%d", dev
->pci_domain
, dev
->pci_bus
,
1243 dev
->pci_slot
, dev
->pci_func
);
1244 oid
= SYSCTL_ADD_STRING(ctx
, SYSCTL_CHILDREN(top
), OID_AUTO
, "busid",
1245 CTLFLAG_RD
, dev
->busid_str
, 0, NULL
);
1248 dev
->modesetting
= (dev
->driver
->driver_features
& DRIVER_MODESET
) != 0;
1249 oid
= SYSCTL_ADD_INT(ctx
, SYSCTL_CHILDREN(top
), OID_AUTO
,
1250 "modesetting", CTLFLAG_RD
, &dev
->modesetting
, 0, NULL
);
1258 drm_mmap_single(struct dev_mmap_single_args
*ap
)
1260 struct drm_device
*dev
;
1261 struct cdev
*kdev
= ap
->a_head
.a_dev
;
1262 vm_ooffset_t
*offset
= ap
->a_offset
;
1263 vm_size_t size
= ap
->a_size
;
1264 struct vm_object
**obj_res
= ap
->a_object
;
1265 int nprot
= ap
->a_nprot
;
1267 dev
= drm_get_device_from_kdev(kdev
);
1268 if (dev
->drm_ttm_bdev
!= NULL
) {
1269 return (ttm_bo_mmap_single(dev
->drm_ttm_bdev
, offset
, size
,
1271 } else if ((dev
->driver
->driver_features
& DRIVER_GEM
) != 0) {
1272 return (drm_gem_mmap_single(dev
, offset
, size
, obj_res
, nprot
));
1278 /* XXX broken code */
1281 #include <sys/sysproto.h>
1283 MODULE_DEPEND(DRIVER_NAME
, linux
, 1, 1, 1);
1285 #define LINUX_IOCTL_DRM_MIN 0x6400
1286 #define LINUX_IOCTL_DRM_MAX 0x64ff
1288 static linux_ioctl_function_t drm_linux_ioctl
;
1289 static struct linux_ioctl_handler drm_handler
= {drm_linux_ioctl
,
1290 LINUX_IOCTL_DRM_MIN
, LINUX_IOCTL_DRM_MAX
};
1292 /* The bits for in/out are switched on Linux */
1293 #define LINUX_IOC_IN IOC_OUT
1294 #define LINUX_IOC_OUT IOC_IN
1297 drm_linux_ioctl(DRM_STRUCTPROC
*p
, struct linux_ioctl_args
* args
)
1300 int cmd
= args
->cmd
;
1302 args
->cmd
&= ~(LINUX_IOC_IN
| LINUX_IOC_OUT
);
1303 if (cmd
& LINUX_IOC_IN
)
1304 args
->cmd
|= IOC_IN
;
1305 if (cmd
& LINUX_IOC_OUT
)
1306 args
->cmd
|= IOC_OUT
;
1308 error
= ioctl(p
, (struct ioctl_args
*)args
);
1312 #endif /* DRM_LINUX */
1315 drm_core_init(void *arg
)
1321 linux_ioctl_register_handler(&drm_handler
);
1322 #endif /* DRM_LINUX */
1324 DRM_INFO("Initialized %s %d.%d.%d %s\n",
1325 CORE_NAME
, CORE_MAJOR
, CORE_MINOR
, CORE_PATCHLEVEL
, CORE_DATE
);
1330 drm_core_exit(void *arg
)
1334 linux_ioctl_unregister_handler(&drm_handler
);
1335 #endif /* DRM_LINUX */
1337 drm_global_release();
1340 SYSINIT(drm_register
, SI_SUB_DRIVERS
, SI_ORDER_MIDDLE
,
1341 drm_core_init
, NULL
);
1342 SYSUNINIT(drm_unregister
, SI_SUB_DRIVERS
, SI_ORDER_MIDDLE
,
1343 drm_core_exit
, NULL
);
1346 #include <linux/dmi.h>
1349 * Check if dmi_system_id structure matches system DMI data
1352 dmi_found(const struct dmi_system_id
*dsi
)
1356 char *sys_vendor
, *board_vendor
, *product_name
, *board_name
;
1358 sys_vendor
= kgetenv("smbios.system.maker");
1359 board_vendor
= kgetenv("smbios.planar.maker");
1360 product_name
= kgetenv("smbios.system.product");
1361 board_name
= kgetenv("smbios.planar.product");
1363 for (i
= 0; i
< NELEM(dsi
->matches
); i
++) {
1364 slot
= dsi
->matches
[i
].slot
;
1368 case DMI_SYS_VENDOR
:
1369 if (sys_vendor
!= NULL
&&
1370 !strcmp(sys_vendor
, dsi
->matches
[i
].substr
))
1374 case DMI_BOARD_VENDOR
:
1375 if (board_vendor
!= NULL
&&
1376 !strcmp(board_vendor
, dsi
->matches
[i
].substr
))
1380 case DMI_PRODUCT_NAME
:
1381 if (product_name
!= NULL
&&
1382 !strcmp(product_name
, dsi
->matches
[i
].substr
))
1386 case DMI_BOARD_NAME
:
1387 if (board_name
!= NULL
&&
1388 !strcmp(board_name
, dsi
->matches
[i
].substr
))
1399 if (sys_vendor
!= NULL
)
1400 kfreeenv(sys_vendor
);
1401 if (board_vendor
!= NULL
)
1402 kfreeenv(board_vendor
);
1403 if (product_name
!= NULL
)
1404 kfreeenv(product_name
);
1405 if (board_name
!= NULL
)
1406 kfreeenv(board_name
);
1411 int dmi_check_system(const struct dmi_system_id
*sysid
)
1413 const struct dmi_system_id
*dsi
;
1416 for (dsi
= sysid
; dsi
->matches
[0].slot
!= 0 ; dsi
++) {
1417 if (dmi_found(dsi
)) {
1419 if (dsi
->callback
&& dsi
->callback(dsi
))