drm_drv.c 22.3 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6
/*
 * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
 *
 * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
 * All Rights Reserved.
 *
7 8
 * Author Rickard E. (Rik) Faith <faith@valinux.com>
 *
L
Linus Torvalds 已提交
9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice (including the next
 * paragraph) shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 */

29
#include <linux/debugfs.h>
30
#include <linux/fs.h>
L
Linus Torvalds 已提交
31 32
#include <linux/module.h>
#include <linux/moduleparam.h>
33
#include <linux/mount.h>
34
#include <linux/slab.h>
35 36
#include <drm/drmP.h>
#include <drm/drm_core.h>
37
#include "drm_legacy.h"
38
#include "drm_internal.h"
L
Linus Torvalds 已提交
39

D
Dave Airlie 已提交
40
unsigned int drm_debug = 0;	/* 1 to enable debug output */
L
Linus Torvalds 已提交
41 42
EXPORT_SYMBOL(drm_debug);

D
Dave Airlie 已提交
43 44
MODULE_AUTHOR(CORE_AUTHOR);
MODULE_DESCRIPTION(CORE_DESC);
L
Linus Torvalds 已提交
45 46
MODULE_LICENSE("GPL and additional rights");
MODULE_PARM_DESC(debug, "Enable debug output");
47
MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");
48
MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
49
MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
L
Linus Torvalds 已提交
50

51
module_param_named(debug, drm_debug, int, 0600);
L
Linus Torvalds 已提交
52

53
static DEFINE_SPINLOCK(drm_minor_lock);
54
static struct idr drm_minors_idr;
55

56
struct class *drm_class;
57
static struct dentry *drm_debugfs_root;
J
Joe Perches 已提交
58

59
void drm_err(const char *func, const char *format, ...)
J
Joe Perches 已提交
60 61 62 63 64 65 66 67 68
{
	struct va_format vaf;
	va_list args;

	va_start(args, format);

	vaf.fmt = format;
	vaf.va = &args;

69
	printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* %pV", func, &vaf);
J
Joe Perches 已提交
70 71 72 73 74

	va_end(args);
}
EXPORT_SYMBOL(drm_err);

75
void drm_ut_debug_printk(const char *function_name, const char *format, ...)
76
{
D
Daniel Vetter 已提交
77
	struct va_format vaf;
78
	va_list args;
L
Linus Torvalds 已提交
79

80 81 82 83
	va_start(args, format);
	vaf.fmt = format;
	vaf.va = &args;

84
	printk(KERN_DEBUG "[" DRM_NAME ":%s] %pV", function_name, &vaf);
85 86

	va_end(args);
87 88
}
EXPORT_SYMBOL(drm_ut_debug_printk);
J
Joe Perches 已提交
89

90 91
#define DRM_MAGIC_HASH_ORDER  4  /**< Size of key hash table. Must be power of 2. */

92 93 94 95
struct drm_master *drm_master_create(struct drm_minor *minor)
{
	struct drm_master *master;

96
	master = kzalloc(sizeof(*master), GFP_KERNEL);
97 98 99 100 101 102
	if (!master)
		return NULL;

	kref_init(&master->refcount);
	spin_lock_init(&master->lock.spinlock);
	init_waitqueue_head(&master->lock.lock_queue);
103 104 105 106
	if (drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER)) {
		kfree(master);
		return NULL;
	}
107 108 109 110 111 112 113 114 115 116 117
	INIT_LIST_HEAD(&master->magicfree);
	master->minor = minor;

	return master;
}

struct drm_master *drm_master_get(struct drm_master *master)
{
	kref_get(&master->refcount);
	return master;
}
118
EXPORT_SYMBOL(drm_master_get);
119 120 121 122 123

static void drm_master_destroy(struct kref *kref)
{
	struct drm_master *master = container_of(kref, struct drm_master, refcount);
	struct drm_device *dev = master->minor->dev;
124
	struct drm_map_list *r_list, *list_temp;
125

126
	mutex_lock(&dev->struct_mutex);
127 128 129
	if (dev->driver->master_destroy)
		dev->driver->master_destroy(dev, master);

130 131
	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
		if (r_list->master == master) {
132
			drm_legacy_rmmap_locked(dev, r_list->map);
133 134 135 136
			r_list = NULL;
		}
	}

137
	if (master->unique) {
138
		kfree(master->unique);
139 140 141 142 143 144
		master->unique = NULL;
		master->unique_len = 0;
	}

	drm_ht_remove(&master->magiclist);

145
	mutex_unlock(&dev->struct_mutex);
146
	kfree(master);
147 148 149 150 151 152 153
}

void drm_master_put(struct drm_master **master)
{
	kref_put(&(*master)->refcount, drm_master_destroy);
	*master = NULL;
}
154
EXPORT_SYMBOL(drm_master_put);
155 156 157 158

int drm_setmaster_ioctl(struct drm_device *dev, void *data,
			struct drm_file *file_priv)
{
159
	int ret = 0;
160

161
	mutex_lock(&dev->master_mutex);
162
	if (file_priv->is_master)
163
		goto out_unlock;
164

165 166 167 168
	if (file_priv->minor->master) {
		ret = -EINVAL;
		goto out_unlock;
	}
169

170 171 172 173
	if (!file_priv->master) {
		ret = -EINVAL;
		goto out_unlock;
	}
174 175

	file_priv->minor->master = drm_master_get(file_priv->master);
176
	file_priv->is_master = 1;
177 178
	if (dev->driver->master_set) {
		ret = dev->driver->master_set(dev, file_priv, false);
179 180
		if (unlikely(ret != 0)) {
			file_priv->is_master = 0;
181
			drm_master_put(&file_priv->minor->master);
182
		}
183 184
	}

185 186
out_unlock:
	mutex_unlock(&dev->master_mutex);
187
	return ret;
188 189 190 191 192
}

int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
{
193 194 195
	int ret = -EINVAL;

	mutex_lock(&dev->master_mutex);
196
	if (!file_priv->is_master)
197
		goto out_unlock;
198

199
	if (!file_priv->minor->master)
200
		goto out_unlock;
201

202
	ret = 0;
203 204
	if (dev->driver->master_drop)
		dev->driver->master_drop(dev, file_priv, false);
205
	drm_master_put(&file_priv->minor->master);
206
	file_priv->is_master = 0;
207 208 209 210

out_unlock:
	mutex_unlock(&dev->master_mutex);
	return ret;
211 212
}

213 214 215 216 217
/*
 * DRM Minors
 * A DRM device can provide several char-dev interfaces on the DRM-Major. Each
 * of them is represented by a drm_minor object. Depending on the capabilities
 * of the device-driver, different interfaces are registered.
L
Linus Torvalds 已提交
218
 *
219 220 221 222 223
 * Minors can be accessed via dev->$minor_name. This pointer is either
 * NULL or a valid drm_minor pointer and stays valid as long as the device is
 * valid. This means, DRM minors have the same life-time as the underlying
 * device. However, this doesn't mean that the minor is active. Minors are
 * registered and unregistered dynamically according to device-state.
L
Linus Torvalds 已提交
224
 */
225

D
David Herrmann 已提交
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243
static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
					     unsigned int type)
{
	switch (type) {
	case DRM_MINOR_LEGACY:
		return &dev->primary;
	case DRM_MINOR_RENDER:
		return &dev->render;
	case DRM_MINOR_CONTROL:
		return &dev->control;
	default:
		return NULL;
	}
}

static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
{
	struct drm_minor *minor;
244 245
	unsigned long flags;
	int r;
D
David Herrmann 已提交
246 247 248 249 250 251 252 253

	minor = kzalloc(sizeof(*minor), GFP_KERNEL);
	if (!minor)
		return -ENOMEM;

	minor->type = type;
	minor->dev = dev;

254 255 256 257 258 259 260 261 262 263 264 265 266 267 268
	idr_preload(GFP_KERNEL);
	spin_lock_irqsave(&drm_minor_lock, flags);
	r = idr_alloc(&drm_minors_idr,
		      NULL,
		      64 * type,
		      64 * (type + 1),
		      GFP_NOWAIT);
	spin_unlock_irqrestore(&drm_minor_lock, flags);
	idr_preload_end();

	if (r < 0)
		goto err_free;

	minor->index = r;

269 270 271 272 273 274
	minor->kdev = drm_sysfs_minor_alloc(minor);
	if (IS_ERR(minor->kdev)) {
		r = PTR_ERR(minor->kdev);
		goto err_index;
	}

D
David Herrmann 已提交
275 276
	*drm_minor_get_slot(dev, type) = minor;
	return 0;
277

278 279 280 281
err_index:
	spin_lock_irqsave(&drm_minor_lock, flags);
	idr_remove(&drm_minors_idr, minor->index);
	spin_unlock_irqrestore(&drm_minor_lock, flags);
282 283 284
err_free:
	kfree(minor);
	return r;
D
David Herrmann 已提交
285 286
}

287 288
static void drm_minor_free(struct drm_device *dev, unsigned int type)
{
289 290
	struct drm_minor **slot, *minor;
	unsigned long flags;
291 292

	slot = drm_minor_get_slot(dev, type);
293 294 295 296 297
	minor = *slot;
	if (!minor)
		return;

	drm_mode_group_destroy(&minor->mode_group);
298
	put_device(minor->kdev);
299 300 301 302 303 304 305

	spin_lock_irqsave(&drm_minor_lock, flags);
	idr_remove(&drm_minors_idr, minor->index);
	spin_unlock_irqrestore(&drm_minor_lock, flags);

	kfree(minor);
	*slot = NULL;
306 307
}

308
static int drm_minor_register(struct drm_device *dev, unsigned int type)
L
Linus Torvalds 已提交
309
{
310
	struct drm_minor *minor;
311
	unsigned long flags;
L
Linus Torvalds 已提交
312 313 314 315
	int ret;

	DRM_DEBUG("\n");

316 317
	minor = *drm_minor_get_slot(dev, type);
	if (!minor)
D
David Herrmann 已提交
318 319
		return 0;

320
	ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
321
	if (ret) {
322
		DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
323
		return ret;
324
	}
325

326 327
	ret = device_add(minor->kdev);
	if (ret)
D
Daniel Vetter 已提交
328
		goto err_debugfs;
329

330 331
	/* replace NULL with @minor so lookups will succeed from now on */
	spin_lock_irqsave(&drm_minor_lock, flags);
332
	idr_replace(&drm_minors_idr, minor, minor->index);
333
	spin_unlock_irqrestore(&drm_minor_lock, flags);
334

335
	DRM_DEBUG("new minor registered %d\n", minor->index);
336 337
	return 0;

D
Daniel Vetter 已提交
338
err_debugfs:
339
	drm_debugfs_cleanup(minor);
L
Linus Torvalds 已提交
340 341
	return ret;
}
D
Dave Airlie 已提交
342

343
static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
344
{
345
	struct drm_minor *minor;
346
	unsigned long flags;
347 348

	minor = *drm_minor_get_slot(dev, type);
349
	if (!minor || !device_is_registered(minor->kdev))
350 351
		return;

352
	/* replace @minor with NULL so lookups will fail from now on */
353
	spin_lock_irqsave(&drm_minor_lock, flags);
354
	idr_replace(&drm_minors_idr, NULL, minor->index);
355
	spin_unlock_irqrestore(&drm_minor_lock, flags);
356

357 358
	device_del(minor->kdev);
	dev_set_drvdata(minor->kdev, NULL); /* safety belt */
359
	drm_debugfs_cleanup(minor);
360 361 362
}

/**
363 364 365 366 367 368 369 370 371 372
 * drm_minor_acquire - Acquire a DRM minor
 * @minor_id: Minor ID of the DRM-minor
 *
 * Looks up the given minor-ID and returns the respective DRM-minor object. The
 * refence-count of the underlying device is increased so you must release this
 * object with drm_minor_release().
 *
 * As long as you hold this minor, it is guaranteed that the object and the
 * minor->dev pointer will stay valid! However, the device may get unplugged and
 * unregistered while you hold the minor.
373
 *
374 375 376
 * Returns:
 * Pointer to minor-object with increased device-refcount, or PTR_ERR on
 * failure.
L
Linus Torvalds 已提交
377
 */
378
struct drm_minor *drm_minor_acquire(unsigned int minor_id)
L
Linus Torvalds 已提交
379
{
380
	struct drm_minor *minor;
381
	unsigned long flags;
382

383
	spin_lock_irqsave(&drm_minor_lock, flags);
384
	minor = idr_find(&drm_minors_idr, minor_id);
385 386 387 388 389 390 391 392
	if (minor)
		drm_dev_ref(minor->dev);
	spin_unlock_irqrestore(&drm_minor_lock, flags);

	if (!minor) {
		return ERR_PTR(-ENODEV);
	} else if (drm_device_is_unplugged(minor->dev)) {
		drm_dev_unref(minor->dev);
393
		return ERR_PTR(-ENODEV);
394
	}
395

396 397
	return minor;
}
D
Dave Airlie 已提交
398

399 400 401 402 403 404 405 406 407
/**
 * drm_minor_release - Release DRM minor
 * @minor: Pointer to DRM minor object
 *
 * Release a minor that was previously acquired via drm_minor_acquire().
 */
void drm_minor_release(struct drm_minor *minor)
{
	drm_dev_unref(minor->dev);
L
Linus Torvalds 已提交
408
}
409 410

/**
411 412
 * drm_put_dev - Unregister and release a DRM device
 * @dev: DRM device
413
 *
414
 * Called at module unload time or when a PCI device is unplugged.
415
 *
416 417 418 419
 * Use of this function is discouraged. It will eventually go away completely.
 * Please use drm_dev_unregister() and drm_dev_unref() explicitly instead.
 *
 * Cleans up all DRM device, calling drm_lastclose().
420 421 422 423 424 425 426 427 428 429
 */
void drm_put_dev(struct drm_device *dev)
{
	DRM_DEBUG("\n");

	if (!dev) {
		DRM_ERROR("cleanup called no dev\n");
		return;
	}

430
	drm_dev_unregister(dev);
D
David Herrmann 已提交
431
	drm_dev_unref(dev);
432 433
}
EXPORT_SYMBOL(drm_put_dev);
434 435 436 437

void drm_unplug_dev(struct drm_device *dev)
{
	/* for a USB device */
438 439 440
	drm_minor_unregister(dev, DRM_MINOR_LEGACY);
	drm_minor_unregister(dev, DRM_MINOR_RENDER);
	drm_minor_unregister(dev, DRM_MINOR_CONTROL);
441 442 443 444 445 446 447 448 449 450 451

	mutex_lock(&drm_global_mutex);

	drm_device_set_unplugged(dev);

	if (dev->open_count == 0) {
		drm_put_dev(dev);
	}
	mutex_unlock(&drm_global_mutex);
}
EXPORT_SYMBOL(drm_unplug_dev);
D
David Herrmann 已提交
452

453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524
/*
 * DRM internal mount
 * We want to be able to allocate our own "struct address_space" to control
 * memory-mappings in VRAM (or stolen RAM, ...). However, core MM does not allow
 * stand-alone address_space objects, so we need an underlying inode. As there
 * is no way to allocate an independent inode easily, we need a fake internal
 * VFS mount-point.
 *
 * The drm_fs_inode_new() function allocates a new inode, drm_fs_inode_free()
 * frees it again. You are allowed to use iget() and iput() to get references to
 * the inode. But each drm_fs_inode_new() call must be paired with exactly one
 * drm_fs_inode_free() call (which does not have to be the last iput()).
 * We use drm_fs_inode_*() to manage our internal VFS mount-point and share it
 * between multiple inode-users. You could, technically, call
 * iget() + drm_fs_inode_free() directly after alloc and sometime later do an
 * iput(), but this way you'd end up with a new vfsmount for each inode.
 */

static int drm_fs_cnt;
static struct vfsmount *drm_fs_mnt;

static const struct dentry_operations drm_fs_dops = {
	.d_dname	= simple_dname,
};

static const struct super_operations drm_fs_sops = {
	.statfs		= simple_statfs,
};

static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags,
				   const char *dev_name, void *data)
{
	return mount_pseudo(fs_type,
			    "drm:",
			    &drm_fs_sops,
			    &drm_fs_dops,
			    0x010203ff);
}

static struct file_system_type drm_fs_type = {
	.name		= "drm",
	.owner		= THIS_MODULE,
	.mount		= drm_fs_mount,
	.kill_sb	= kill_anon_super,
};

static struct inode *drm_fs_inode_new(void)
{
	struct inode *inode;
	int r;

	r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);
	if (r < 0) {
		DRM_ERROR("Cannot mount pseudo fs: %d\n", r);
		return ERR_PTR(r);
	}

	inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);
	if (IS_ERR(inode))
		simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);

	return inode;
}

static void drm_fs_inode_free(struct inode *inode)
{
	if (inode) {
		iput(inode);
		simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
	}
}

D
David Herrmann 已提交
525
/**
526
 * drm_dev_alloc - Allocate new DRM device
D
David Herrmann 已提交
527 528 529 530
 * @driver: DRM driver to allocate device for
 * @parent: Parent device object
 *
 * Allocate and initialize a new DRM device. No device registration is done.
531 532
 * Call drm_dev_register() to advertice the device to user space and register it
 * with other core subsystems.
D
David Herrmann 已提交
533
 *
D
David Herrmann 已提交
534 535 536
 * The initial ref-count of the object is 1. Use drm_dev_ref() and
 * drm_dev_unref() to take and drop further ref-counts.
 *
D
David Herrmann 已提交
537 538 539 540 541 542 543 544 545 546 547 548 549
 * RETURNS:
 * Pointer to new DRM device, or NULL if out of memory.
 */
struct drm_device *drm_dev_alloc(struct drm_driver *driver,
				 struct device *parent)
{
	struct drm_device *dev;
	int ret;

	dev = kzalloc(sizeof(*dev), GFP_KERNEL);
	if (!dev)
		return NULL;

D
David Herrmann 已提交
550
	kref_init(&dev->ref);
D
David Herrmann 已提交
551 552 553 554 555 556 557 558 559
	dev->dev = parent;
	dev->driver = driver;

	INIT_LIST_HEAD(&dev->filelist);
	INIT_LIST_HEAD(&dev->ctxlist);
	INIT_LIST_HEAD(&dev->vmalist);
	INIT_LIST_HEAD(&dev->maplist);
	INIT_LIST_HEAD(&dev->vblank_event_list);

560
	spin_lock_init(&dev->buf_lock);
D
David Herrmann 已提交
561 562 563
	spin_lock_init(&dev->event_lock);
	mutex_init(&dev->struct_mutex);
	mutex_init(&dev->ctxlist_mutex);
564
	mutex_init(&dev->master_mutex);
D
David Herrmann 已提交
565

566 567 568 569
	dev->anon_inode = drm_fs_inode_new();
	if (IS_ERR(dev->anon_inode)) {
		ret = PTR_ERR(dev->anon_inode);
		DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);
D
David Herrmann 已提交
570
		goto err_free;
571 572
	}

D
David Herrmann 已提交
573 574 575 576 577 578
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		ret = drm_minor_alloc(dev, DRM_MINOR_CONTROL);
		if (ret)
			goto err_minors;
	}

579
	if (drm_core_check_feature(dev, DRIVER_RENDER)) {
D
David Herrmann 已提交
580 581 582 583 584 585 586 587 588
		ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
		if (ret)
			goto err_minors;
	}

	ret = drm_minor_alloc(dev, DRM_MINOR_LEGACY);
	if (ret)
		goto err_minors;

589
	if (drm_ht_create(&dev->map_hash, 12))
D
David Herrmann 已提交
590
		goto err_minors;
D
David Herrmann 已提交
591

592
	ret = drm_legacy_ctxbitmap_init(dev);
D
David Herrmann 已提交
593 594 595 596 597
	if (ret) {
		DRM_ERROR("Cannot allocate memory for context bitmap.\n");
		goto err_ht;
	}

598
	if (drm_core_check_feature(dev, DRIVER_GEM)) {
D
David Herrmann 已提交
599 600 601 602 603 604 605 606 607 608
		ret = drm_gem_init(dev);
		if (ret) {
			DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
			goto err_ctxbitmap;
		}
	}

	return dev;

err_ctxbitmap:
609
	drm_legacy_ctxbitmap_cleanup(dev);
D
David Herrmann 已提交
610 611
err_ht:
	drm_ht_remove(&dev->map_hash);
D
David Herrmann 已提交
612
err_minors:
613 614 615
	drm_minor_free(dev, DRM_MINOR_LEGACY);
	drm_minor_free(dev, DRM_MINOR_RENDER);
	drm_minor_free(dev, DRM_MINOR_CONTROL);
616
	drm_fs_inode_free(dev->anon_inode);
D
David Herrmann 已提交
617
err_free:
618
	mutex_destroy(&dev->master_mutex);
D
David Herrmann 已提交
619 620 621 622
	kfree(dev);
	return NULL;
}
EXPORT_SYMBOL(drm_dev_alloc);
623

D
David Herrmann 已提交
624
static void drm_dev_release(struct kref *ref)
625
{
D
David Herrmann 已提交
626
	struct drm_device *dev = container_of(ref, struct drm_device, ref);
627

628
	if (drm_core_check_feature(dev, DRIVER_GEM))
629 630
		drm_gem_destroy(dev);

631
	drm_legacy_ctxbitmap_cleanup(dev);
632
	drm_ht_remove(&dev->map_hash);
633
	drm_fs_inode_free(dev->anon_inode);
634

635 636 637 638
	drm_minor_free(dev, DRM_MINOR_LEGACY);
	drm_minor_free(dev, DRM_MINOR_RENDER);
	drm_minor_free(dev, DRM_MINOR_CONTROL);

639
	mutex_destroy(&dev->master_mutex);
640
	kfree(dev->unique);
641 642
	kfree(dev);
}
D
David Herrmann 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675

/**
 * drm_dev_ref - Take reference of a DRM device
 * @dev: device to take reference of or NULL
 *
 * This increases the ref-count of @dev by one. You *must* already own a
 * reference when calling this. Use drm_dev_unref() to drop this reference
 * again.
 *
 * This function never fails. However, this function does not provide *any*
 * guarantee whether the device is alive or running. It only provides a
 * reference to the object and the memory associated with it.
 */
void drm_dev_ref(struct drm_device *dev)
{
	if (dev)
		kref_get(&dev->ref);
}
EXPORT_SYMBOL(drm_dev_ref);

/**
 * drm_dev_unref - Drop reference of a DRM device
 * @dev: device to drop reference of or NULL
 *
 * This decreases the ref-count of @dev by one. The device is destroyed if the
 * ref-count drops to zero.
 */
void drm_dev_unref(struct drm_device *dev)
{
	if (dev)
		kref_put(&dev->ref, drm_dev_release);
}
EXPORT_SYMBOL(drm_dev_unref);
676

677 678 679
/**
 * drm_dev_register - Register DRM device
 * @dev: Device to register
680
 * @flags: Flags passed to the driver's .load() function
681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696
 *
 * Register the DRM device @dev with the system, advertise device to user-space
 * and start normal device operation. @dev must be allocated via drm_dev_alloc()
 * previously.
 *
 * Never call this twice on any device!
 *
 * RETURNS:
 * 0 on success, negative error code on failure.
 */
int drm_dev_register(struct drm_device *dev, unsigned long flags)
{
	int ret;

	mutex_lock(&drm_global_mutex);

697
	ret = drm_minor_register(dev, DRM_MINOR_CONTROL);
D
David Herrmann 已提交
698 699
	if (ret)
		goto err_minors;
700

701
	ret = drm_minor_register(dev, DRM_MINOR_RENDER);
D
David Herrmann 已提交
702 703
	if (ret)
		goto err_minors;
704

705
	ret = drm_minor_register(dev, DRM_MINOR_LEGACY);
706
	if (ret)
D
David Herrmann 已提交
707
		goto err_minors;
708 709 710 711

	if (dev->driver->load) {
		ret = dev->driver->load(dev, flags);
		if (ret)
D
David Herrmann 已提交
712
			goto err_minors;
713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728
	}

	/* setup grouping for legacy outputs */
	if (drm_core_check_feature(dev, DRIVER_MODESET)) {
		ret = drm_mode_group_init_legacy_group(dev,
				&dev->primary->mode_group);
		if (ret)
			goto err_unload;
	}

	ret = 0;
	goto out_unlock;

err_unload:
	if (dev->driver->unload)
		dev->driver->unload(dev);
D
David Herrmann 已提交
729
err_minors:
730 731 732
	drm_minor_unregister(dev, DRM_MINOR_LEGACY);
	drm_minor_unregister(dev, DRM_MINOR_RENDER);
	drm_minor_unregister(dev, DRM_MINOR_CONTROL);
733 734 735 736 737
out_unlock:
	mutex_unlock(&drm_global_mutex);
	return ret;
}
EXPORT_SYMBOL(drm_dev_register);
738 739 740 741 742 743 744

/**
 * drm_dev_unregister - Unregister DRM device
 * @dev: Device to unregister
 *
 * Unregister the DRM device from the system. This does the reverse of
 * drm_dev_register() but does not deallocate the device. The caller must call
D
David Herrmann 已提交
745
 * drm_dev_unref() to drop their final reference.
746 747 748 749 750 751 752 753 754 755
 */
void drm_dev_unregister(struct drm_device *dev)
{
	struct drm_map_list *r_list, *list_temp;

	drm_lastclose(dev);

	if (dev->driver->unload)
		dev->driver->unload(dev);

756 757
	if (dev->agp)
		drm_pci_agp_destroy(dev);
758 759 760 761

	drm_vblank_cleanup(dev);

	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
762
		drm_legacy_rmmap(dev, r_list->map);
763

764 765 766
	drm_minor_unregister(dev, DRM_MINOR_LEGACY);
	drm_minor_unregister(dev, DRM_MINOR_RENDER);
	drm_minor_unregister(dev, DRM_MINOR_CONTROL);
767 768
}
EXPORT_SYMBOL(drm_dev_unregister);
769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793

/**
 * drm_dev_set_unique - Set the unique name of a DRM device
 * @dev: device of which to set the unique name
 * @fmt: format string for unique name
 *
 * Sets the unique name of a DRM device using the specified format string and
 * a variable list of arguments. Drivers can use this at driver probe time if
 * the unique name of the devices they drive is static.
 *
 * Return: 0 on success or a negative error code on failure.
 */
int drm_dev_set_unique(struct drm_device *dev, const char *fmt, ...)
{
	va_list ap;

	kfree(dev->unique);

	va_start(ap, fmt);
	dev->unique = kvasprintf(GFP_KERNEL, fmt, ap);
	va_end(ap);

	return dev->unique ? 0 : -ENOMEM;
}
EXPORT_SYMBOL(drm_dev_set_unique);
794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905

/*
 * DRM Core
 * The DRM core module initializes all global DRM objects and makes them
 * available to drivers. Once setup, drivers can probe their respective
 * devices.
 * Currently, core management includes:
 *  - The "DRM-Global" key/value database
 *  - Global ID management for connectors
 *  - DRM major number allocation
 *  - DRM minor management
 *  - DRM sysfs class
 *  - DRM debugfs root
 *
 * Furthermore, the DRM core provides dynamic char-dev lookups. For each
 * interface registered on a DRM device, you can request minor numbers from DRM
 * core. DRM core takes care of major-number management and char-dev
 * registration. A stub ->open() callback forwards any open() requests to the
 * registered minor.
 */

static int drm_stub_open(struct inode *inode, struct file *filp)
{
	const struct file_operations *new_fops;
	struct drm_minor *minor;
	int err;

	DRM_DEBUG("\n");

	mutex_lock(&drm_global_mutex);
	minor = drm_minor_acquire(iminor(inode));
	if (IS_ERR(minor)) {
		err = PTR_ERR(minor);
		goto out_unlock;
	}

	new_fops = fops_get(minor->dev->driver->fops);
	if (!new_fops) {
		err = -ENODEV;
		goto out_release;
	}

	replace_fops(filp, new_fops);
	if (filp->f_op->open)
		err = filp->f_op->open(inode, filp);
	else
		err = 0;

out_release:
	drm_minor_release(minor);
out_unlock:
	mutex_unlock(&drm_global_mutex);
	return err;
}

static const struct file_operations drm_stub_fops = {
	.owner = THIS_MODULE,
	.open = drm_stub_open,
	.llseek = noop_llseek,
};

static int __init drm_core_init(void)
{
	int ret = -ENOMEM;

	drm_global_init();
	drm_connector_ida_init();
	idr_init(&drm_minors_idr);

	if (register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops))
		goto err_p1;

	drm_class = drm_sysfs_create(THIS_MODULE, "drm");
	if (IS_ERR(drm_class)) {
		printk(KERN_ERR "DRM: Error creating drm class.\n");
		ret = PTR_ERR(drm_class);
		goto err_p2;
	}

	drm_debugfs_root = debugfs_create_dir("dri", NULL);
	if (!drm_debugfs_root) {
		DRM_ERROR("Cannot create /sys/kernel/debug/dri\n");
		ret = -1;
		goto err_p3;
	}

	DRM_INFO("Initialized %s %d.%d.%d %s\n",
		 CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
	return 0;
err_p3:
	drm_sysfs_destroy();
err_p2:
	unregister_chrdev(DRM_MAJOR, "drm");

	idr_destroy(&drm_minors_idr);
err_p1:
	return ret;
}

static void __exit drm_core_exit(void)
{
	debugfs_remove(drm_debugfs_root);
	drm_sysfs_destroy();

	unregister_chrdev(DRM_MAJOR, "drm");

	drm_connector_ida_destroy();
	idr_destroy(&drm_minors_idr);
}

module_init(drm_core_init);
module_exit(drm_core_exit);