drm_drv.c 27.9 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
#include <linux/srcu.h>
D
Daniel Vetter 已提交
36

37
#include <drm/drm_client.h>
D
Daniel Vetter 已提交
38
#include <drm/drm_drv.h>
39
#include <drm/drmP.h>
D
Daniel Vetter 已提交
40

41
#include "drm_crtc_internal.h"
42
#include "drm_legacy.h"
43
#include "drm_internal.h"
D
Daniel Vetter 已提交
44
#include "drm_crtc_internal.h"
L
Linus Torvalds 已提交
45

46 47 48 49 50
/*
 * drm_debug: Enable debug output.
 * Bitmask of DRM_UT_x. See include/drm/drmP.h for details.
 */
unsigned int drm_debug = 0;
L
Linus Torvalds 已提交
51 52
EXPORT_SYMBOL(drm_debug);

D
David Herrmann 已提交
53 54
MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");
MODULE_DESCRIPTION("DRM shared core routines");
L
Linus Torvalds 已提交
55
MODULE_LICENSE("GPL and additional rights");
56
MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n"
57 58 59 60 61 62 63 64
"\t\tBit 0 (0x01)  will enable CORE messages (drm core code)\n"
"\t\tBit 1 (0x02)  will enable DRIVER messages (drm controller code)\n"
"\t\tBit 2 (0x04)  will enable KMS messages (modesetting code)\n"
"\t\tBit 3 (0x08)  will enable PRIME messages (prime code)\n"
"\t\tBit 4 (0x10)  will enable ATOMIC messages (atomic code)\n"
"\t\tBit 5 (0x20)  will enable VBL messages (vblank code)\n"
"\t\tBit 7 (0x80)  will enable LEASE messages (leasing code)\n"
"\t\tBit 8 (0x100) will enable DP messages (displayport code)");
65
module_param_named(debug, drm_debug, int, 0600);
L
Linus Torvalds 已提交
66

67
static DEFINE_SPINLOCK(drm_minor_lock);
68
static struct idr drm_minors_idr;
69

70 71 72 73 74 75 76 77 78
/*
 * If the drm core fails to init for whatever reason,
 * we should prevent any drivers from registering with it.
 * It's best to check this at drm_dev_init(), as some drivers
 * prefer to embed struct drm_device into their own device
 * structure and call drm_dev_init() themselves.
 */
static bool drm_core_init_complete = false;

79
static struct dentry *drm_debugfs_root;
J
Joe Perches 已提交
80

81 82
DEFINE_STATIC_SRCU(drm_unplug_srcu);

83 84 85 86 87
/*
 * 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 已提交
88
 *
89 90 91 92 93
 * 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 已提交
94
 */
95

D
David Herrmann 已提交
96 97 98 99
static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
					     unsigned int type)
{
	switch (type) {
100
	case DRM_MINOR_PRIMARY:
D
David Herrmann 已提交
101 102 103 104
		return &dev->primary;
	case DRM_MINOR_RENDER:
		return &dev->render;
	default:
105
		BUG();
D
David Herrmann 已提交
106 107 108 109 110 111
	}
}

static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
{
	struct drm_minor *minor;
112 113
	unsigned long flags;
	int r;
D
David Herrmann 已提交
114 115 116 117 118 119 120 121

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

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

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
	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;

137 138 139 140 141 142
	minor->kdev = drm_sysfs_minor_alloc(minor);
	if (IS_ERR(minor->kdev)) {
		r = PTR_ERR(minor->kdev);
		goto err_index;
	}

D
David Herrmann 已提交
143 144
	*drm_minor_get_slot(dev, type) = minor;
	return 0;
145

146 147 148 149
err_index:
	spin_lock_irqsave(&drm_minor_lock, flags);
	idr_remove(&drm_minors_idr, minor->index);
	spin_unlock_irqrestore(&drm_minor_lock, flags);
150 151 152
err_free:
	kfree(minor);
	return r;
D
David Herrmann 已提交
153 154
}

155 156
static void drm_minor_free(struct drm_device *dev, unsigned int type)
{
157 158
	struct drm_minor **slot, *minor;
	unsigned long flags;
159 160

	slot = drm_minor_get_slot(dev, type);
161 162 163 164
	minor = *slot;
	if (!minor)
		return;

165
	put_device(minor->kdev);
166 167 168 169 170 171 172

	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;
173 174
}

175
static int drm_minor_register(struct drm_device *dev, unsigned int type)
L
Linus Torvalds 已提交
176
{
177
	struct drm_minor *minor;
178
	unsigned long flags;
L
Linus Torvalds 已提交
179 180 181 182
	int ret;

	DRM_DEBUG("\n");

183 184
	minor = *drm_minor_get_slot(dev, type);
	if (!minor)
D
David Herrmann 已提交
185 186
		return 0;

187
	ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
188
	if (ret) {
189
		DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
190
		goto err_debugfs;
191
	}
192

193 194
	ret = device_add(minor->kdev);
	if (ret)
D
Daniel Vetter 已提交
195
		goto err_debugfs;
196

197 198
	/* replace NULL with @minor so lookups will succeed from now on */
	spin_lock_irqsave(&drm_minor_lock, flags);
199
	idr_replace(&drm_minors_idr, minor, minor->index);
200
	spin_unlock_irqrestore(&drm_minor_lock, flags);
201

202
	DRM_DEBUG("new minor registered %d\n", minor->index);
203 204
	return 0;

D
Daniel Vetter 已提交
205
err_debugfs:
206
	drm_debugfs_cleanup(minor);
L
Linus Torvalds 已提交
207 208
	return ret;
}
D
Dave Airlie 已提交
209

210
static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
211
{
212
	struct drm_minor *minor;
213
	unsigned long flags;
214 215

	minor = *drm_minor_get_slot(dev, type);
216
	if (!minor || !device_is_registered(minor->kdev))
217 218
		return;

219
	/* replace @minor with NULL so lookups will fail from now on */
220
	spin_lock_irqsave(&drm_minor_lock, flags);
221
	idr_replace(&drm_minors_idr, NULL, minor->index);
222
	spin_unlock_irqrestore(&drm_minor_lock, flags);
223

224 225
	device_del(minor->kdev);
	dev_set_drvdata(minor->kdev, NULL); /* safety belt */
226
	drm_debugfs_cleanup(minor);
227 228
}

D
Daniel Vetter 已提交
229
/*
230 231 232 233 234 235 236
 * 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.
L
Linus Torvalds 已提交
237
 */
238
struct drm_minor *drm_minor_acquire(unsigned int minor_id)
L
Linus Torvalds 已提交
239
{
240
	struct drm_minor *minor;
241
	unsigned long flags;
242

243
	spin_lock_irqsave(&drm_minor_lock, flags);
244
	minor = idr_find(&drm_minors_idr, minor_id);
245
	if (minor)
246
		drm_dev_get(minor->dev);
247 248 249 250
	spin_unlock_irqrestore(&drm_minor_lock, flags);

	if (!minor) {
		return ERR_PTR(-ENODEV);
251
	} else if (drm_dev_is_unplugged(minor->dev)) {
252
		drm_dev_put(minor->dev);
253
		return ERR_PTR(-ENODEV);
254
	}
255

256 257
	return minor;
}
D
Dave Airlie 已提交
258

259 260
void drm_minor_release(struct drm_minor *minor)
{
261
	drm_dev_put(minor->dev);
L
Linus Torvalds 已提交
262
}
263

264 265 266
/**
 * DOC: driver instance overview
 *
267
 * A device instance for a drm driver is represented by &struct drm_device. This
268 269 270 271
 * is allocated with drm_dev_alloc(), usually from bus-specific ->probe()
 * callbacks implemented by the driver. The driver then needs to initialize all
 * the various subsystems for the drm device like memory management, vblank
 * handling, modesetting support and intial output configuration plus obviously
G
Gerd Hoffmann 已提交
272 273 274 275
 * initialize all the corresponding hardware bits. An important part of this is
 * also calling drm_dev_set_unique() to set the userspace-visible unique name of
 * this device instance. Finally when everything is up and running and ready for
 * userspace the device instance can be published using drm_dev_register().
276 277
 *
 * There is also deprecated support for initalizing device instances using
278
 * bus-specific helpers and the &drm_driver.load callback. But due to
279 280 281 282 283 284 285
 * backwards-compatibility needs the device instance have to be published too
 * early, which requires unpretty global locking to make safe and is therefore
 * only support for existing drivers not yet converted to the new scheme.
 *
 * When cleaning up a device instance everything needs to be done in reverse:
 * First unpublish the device instance with drm_dev_unregister(). Then clean up
 * any other resources allocated at device initialization and drop the driver's
286
 * reference to &drm_device using drm_dev_put().
287 288 289
 *
 * Note that the lifetime rules for &drm_device instance has still a lot of
 * historical baggage. Hence use the reference counting provided by
290
 * drm_dev_get() and drm_dev_put() only carefully.
291
 *
292
 * It is recommended that drivers embed &struct drm_device into their own device
293
 * structure, which is supported through drm_dev_init().
294 295
 */

296
/**
297 298
 * drm_put_dev - Unregister and release a DRM device
 * @dev: DRM device
299
 *
300
 * Called at module unload time or when a PCI device is unplugged.
301
 *
302
 * Cleans up all DRM device, calling drm_lastclose().
303 304
 *
 * Note: Use of this function is deprecated. It will eventually go away
305
 * completely.  Please use drm_dev_unregister() and drm_dev_put() explicitly
306 307 308
 * instead to make sure that the device isn't userspace accessible any more
 * while teardown is in progress, ensuring that userspace can't access an
 * inconsistent state.
309 310 311 312 313 314 315 316 317 318
 */
void drm_put_dev(struct drm_device *dev)
{
	DRM_DEBUG("\n");

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

319
	drm_dev_unregister(dev);
320
	drm_dev_put(dev);
321 322
}
EXPORT_SYMBOL(drm_put_dev);
323

324 325 326 327 328 329 330 331 332 333 334 335 336
/**
 * drm_dev_enter - Enter device critical section
 * @dev: DRM device
 * @idx: Pointer to index that will be passed to the matching drm_dev_exit()
 *
 * This function marks and protects the beginning of a section that should not
 * be entered after the device has been unplugged. The section end is marked
 * with drm_dev_exit(). Calls to this function can be nested.
 *
 * Returns:
 * True if it is OK to enter the section, false otherwise.
 */
bool drm_dev_enter(struct drm_device *dev, int *idx)
337
{
338 339 340 341 342 343 344 345
	*idx = srcu_read_lock(&drm_unplug_srcu);

	if (dev->unplugged) {
		srcu_read_unlock(&drm_unplug_srcu, *idx);
		return false;
	}

	return true;
346
}
347 348 349 350 351 352 353 354 355 356
EXPORT_SYMBOL(drm_dev_enter);

/**
 * drm_dev_exit - Exit device critical section
 * @idx: index returned from drm_dev_enter()
 *
 * This function marks the end of a section that should not be entered after
 * the device has been unplugged.
 */
void drm_dev_exit(int idx)
357
{
358
	srcu_read_unlock(&drm_unplug_srcu, idx);
359
}
360
EXPORT_SYMBOL(drm_dev_exit);
361 362 363 364 365 366

/**
 * drm_dev_unplug - unplug a DRM device
 * @dev: DRM device
 *
 * This unplugs a hotpluggable DRM device, which makes it inaccessible to
367 368
 * userspace operations. Entry-points can use drm_dev_enter() and
 * drm_dev_exit() to protect device resources in a race free manner. This
369 370 371 372
 * essentially unregisters the device like drm_dev_unregister(), but can be
 * called while there are still open users of @dev.
 */
void drm_dev_unplug(struct drm_device *dev)
373
{
374 375 376 377 378 379 380 381
	/*
	 * After synchronizing any critical read section is guaranteed to see
	 * the new value of ->unplugged, and any critical section which might
	 * still have seen the old value of ->unplugged is guaranteed to have
	 * finished.
	 */
	dev->unplugged = true;
	synchronize_srcu(&drm_unplug_srcu);
382 383 384 385 386 387 388

	drm_dev_unregister(dev);

	mutex_lock(&drm_global_mutex);
	if (dev->open_count == 0)
		drm_dev_put(dev);
	mutex_unlock(&drm_global_mutex);
389
}
390
EXPORT_SYMBOL(drm_dev_unplug);
D
David Herrmann 已提交
391

392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463
/*
 * 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 已提交
464
/**
465 466 467
 * drm_dev_init - Initialise new DRM device
 * @dev: DRM device
 * @driver: DRM driver
D
David Herrmann 已提交
468 469
 * @parent: Parent device object
 *
470
 * Initialize a new DRM device. No device registration is done.
471
 * Call drm_dev_register() to advertice the device to user space and register it
472 473 474
 * with other core subsystems. This should be done last in the device
 * initialization sequence to make sure userspace can't access an inconsistent
 * state.
D
David Herrmann 已提交
475
 *
476 477
 * The initial ref-count of the object is 1. Use drm_dev_get() and
 * drm_dev_put() to take and drop further ref-counts.
D
David Herrmann 已提交
478
 *
479 480
 * Note that for purely virtual devices @parent can be NULL.
 *
481
 * Drivers that do not want to allocate their own device struct
482 483
 * embedding &struct drm_device can call drm_dev_alloc() instead. For drivers
 * that do embed &struct drm_device it must be placed first in the overall
484 485
 * structure, and the overall structure must be allocated using kmalloc(): The
 * drm core's release function unconditionally calls kfree() on the @dev pointer
486 487 488 489
 * when the final reference is released. To override this behaviour, and so
 * allow embedding of the drm_device inside the driver's device struct at an
 * arbitrary offset, you must supply a &drm_driver.release callback and control
 * the finalization explicitly.
490
 *
D
David Herrmann 已提交
491
 * RETURNS:
492
 * 0 on success, or error code on failure.
D
David Herrmann 已提交
493
 */
494 495 496
int drm_dev_init(struct drm_device *dev,
		 struct drm_driver *driver,
		 struct device *parent)
D
David Herrmann 已提交
497 498 499
{
	int ret;

500 501 502 503 504
	if (!drm_core_init_complete) {
		DRM_ERROR("DRM core is not initialized\n");
		return -ENODEV;
	}

D
David Herrmann 已提交
505
	kref_init(&dev->ref);
D
David Herrmann 已提交
506 507 508
	dev->dev = parent;
	dev->driver = driver;

509 510 511
	/* no per-device feature limits by default */
	dev->driver_features = ~0u;

D
David Herrmann 已提交
512
	INIT_LIST_HEAD(&dev->filelist);
513 514
	INIT_LIST_HEAD(&dev->filelist_internal);
	INIT_LIST_HEAD(&dev->clientlist);
D
David Herrmann 已提交
515 516 517 518 519
	INIT_LIST_HEAD(&dev->ctxlist);
	INIT_LIST_HEAD(&dev->vmalist);
	INIT_LIST_HEAD(&dev->maplist);
	INIT_LIST_HEAD(&dev->vblank_event_list);

520
	spin_lock_init(&dev->buf_lock);
D
David Herrmann 已提交
521 522
	spin_lock_init(&dev->event_lock);
	mutex_init(&dev->struct_mutex);
523
	mutex_init(&dev->filelist_mutex);
524
	mutex_init(&dev->clientlist_mutex);
D
David Herrmann 已提交
525
	mutex_init(&dev->ctxlist_mutex);
526
	mutex_init(&dev->master_mutex);
D
David Herrmann 已提交
527

528 529 530 531
	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 已提交
532
		goto err_free;
533 534
	}

535
	if (drm_core_check_feature(dev, DRIVER_RENDER)) {
D
David Herrmann 已提交
536 537 538 539 540
		ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
		if (ret)
			goto err_minors;
	}

541
	ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
D
David Herrmann 已提交
542 543 544
	if (ret)
		goto err_minors;

545 546
	ret = drm_ht_create(&dev->map_hash, 12);
	if (ret)
D
David Herrmann 已提交
547
		goto err_minors;
D
David Herrmann 已提交
548

549
	drm_legacy_ctxbitmap_init(dev);
D
David Herrmann 已提交
550

551
	if (drm_core_check_feature(dev, DRIVER_GEM)) {
D
David Herrmann 已提交
552 553 554 555 556 557 558
		ret = drm_gem_init(dev);
		if (ret) {
			DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
			goto err_ctxbitmap;
		}
	}

559 560 561 562 563
	/* Use the parent device name as DRM device unique identifier, but fall
	 * back to the driver name for virtual devices like vgem. */
	ret = drm_dev_set_unique(dev, parent ? dev_name(parent) : driver->name);
	if (ret)
		goto err_setunique;
564

565
	return 0;
D
David Herrmann 已提交
566

567 568 569
err_setunique:
	if (drm_core_check_feature(dev, DRIVER_GEM))
		drm_gem_destroy(dev);
D
David Herrmann 已提交
570
err_ctxbitmap:
571
	drm_legacy_ctxbitmap_cleanup(dev);
D
David Herrmann 已提交
572
	drm_ht_remove(&dev->map_hash);
D
David Herrmann 已提交
573
err_minors:
574
	drm_minor_free(dev, DRM_MINOR_PRIMARY);
575
	drm_minor_free(dev, DRM_MINOR_RENDER);
576
	drm_fs_inode_free(dev->anon_inode);
D
David Herrmann 已提交
577
err_free:
578
	mutex_destroy(&dev->master_mutex);
579
	mutex_destroy(&dev->ctxlist_mutex);
580
	mutex_destroy(&dev->clientlist_mutex);
581 582
	mutex_destroy(&dev->filelist_mutex);
	mutex_destroy(&dev->struct_mutex);
583 584 585 586
	return ret;
}
EXPORT_SYMBOL(drm_dev_init);

587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613 614
/**
 * drm_dev_fini - Finalize a dead DRM device
 * @dev: DRM device
 *
 * Finalize a dead DRM device. This is the converse to drm_dev_init() and
 * frees up all data allocated by it. All driver private data should be
 * finalized first. Note that this function does not free the @dev, that is
 * left to the caller.
 *
 * The ref-count of @dev must be zero, and drm_dev_fini() should only be called
 * from a &drm_driver.release callback.
 */
void drm_dev_fini(struct drm_device *dev)
{
	drm_vblank_cleanup(dev);

	if (drm_core_check_feature(dev, DRIVER_GEM))
		drm_gem_destroy(dev);

	drm_legacy_ctxbitmap_cleanup(dev);
	drm_ht_remove(&dev->map_hash);
	drm_fs_inode_free(dev->anon_inode);

	drm_minor_free(dev, DRM_MINOR_PRIMARY);
	drm_minor_free(dev, DRM_MINOR_RENDER);

	mutex_destroy(&dev->master_mutex);
	mutex_destroy(&dev->ctxlist_mutex);
615
	mutex_destroy(&dev->clientlist_mutex);
616 617 618 619 620 621
	mutex_destroy(&dev->filelist_mutex);
	mutex_destroy(&dev->struct_mutex);
	kfree(dev->unique);
}
EXPORT_SYMBOL(drm_dev_fini);

622 623 624 625 626 627 628 629 630 631 632
/**
 * drm_dev_alloc - Allocate new DRM device
 * @driver: DRM driver to allocate device for
 * @parent: Parent device object
 *
 * Allocate and initialize a new DRM device. No device registration is done.
 * Call drm_dev_register() to advertice the device to user space and register it
 * with other core subsystems. This should be done last in the device
 * initialization sequence to make sure userspace can't access an inconsistent
 * state.
 *
633 634
 * The initial ref-count of the object is 1. Use drm_dev_get() and
 * drm_dev_put() to take and drop further ref-counts.
635 636 637
 *
 * Note that for purely virtual devices @parent can be NULL.
 *
638
 * Drivers that wish to subclass or embed &struct drm_device into their
639 640 641
 * own struct should look at using drm_dev_init() instead.
 *
 * RETURNS:
642
 * Pointer to new DRM device, or ERR_PTR on failure.
643 644 645 646 647 648 649 650 651
 */
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)
652
		return ERR_PTR(-ENOMEM);
653 654 655 656

	ret = drm_dev_init(dev, driver, parent);
	if (ret) {
		kfree(dev);
657
		return ERR_PTR(ret);
658 659 660
	}

	return dev;
D
David Herrmann 已提交
661 662
}
EXPORT_SYMBOL(drm_dev_alloc);
663

D
David Herrmann 已提交
664
static void drm_dev_release(struct kref *ref)
665
{
D
David Herrmann 已提交
666
	struct drm_device *dev = container_of(ref, struct drm_device, ref);
667

668 669 670 671 672 673
	if (dev->driver->release) {
		dev->driver->release(dev);
	} else {
		drm_dev_fini(dev);
		kfree(dev);
	}
674
}
D
David Herrmann 已提交
675 676

/**
677
 * drm_dev_get - Take reference of a DRM device
D
David Herrmann 已提交
678 679 680
 * @dev: device to take reference of or NULL
 *
 * This increases the ref-count of @dev by one. You *must* already own a
681
 * reference when calling this. Use drm_dev_put() to drop this reference
D
David Herrmann 已提交
682 683 684 685 686 687
 * 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.
 */
688
void drm_dev_get(struct drm_device *dev)
D
David Herrmann 已提交
689 690 691 692
{
	if (dev)
		kref_get(&dev->ref);
}
693
EXPORT_SYMBOL(drm_dev_get);
D
David Herrmann 已提交
694 695

/**
696
 * drm_dev_put - Drop reference of a DRM device
D
David Herrmann 已提交
697 698 699 700 701
 * @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.
 */
702
void drm_dev_put(struct drm_device *dev)
D
David Herrmann 已提交
703 704 705 706
{
	if (dev)
		kref_put(&dev->ref, drm_dev_release);
}
707 708 709 710 711 712 713 714 715 716 717 718 719
EXPORT_SYMBOL(drm_dev_put);

/**
 * drm_dev_unref - Drop reference of a DRM device
 * @dev: device to drop reference of or NULL
 *
 * This is a compatibility alias for drm_dev_put() and should not be used by new
 * code.
 */
void drm_dev_unref(struct drm_device *dev)
{
	drm_dev_put(dev);
}
D
David Herrmann 已提交
720
EXPORT_SYMBOL(drm_dev_unref);
721

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768
static int create_compat_control_link(struct drm_device *dev)
{
	struct drm_minor *minor;
	char *name;
	int ret;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return 0;

	minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
	if (!minor)
		return 0;

	/*
	 * Some existing userspace out there uses the existing of the controlD*
	 * sysfs files to figure out whether it's a modeset driver. It only does
	 * readdir, hence a symlink is sufficient (and the least confusing
	 * option). Otherwise controlD* is entirely unused.
	 *
	 * Old controlD chardev have been allocated in the range
	 * 64-127.
	 */
	name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
	if (!name)
		return -ENOMEM;

	ret = sysfs_create_link(minor->kdev->kobj.parent,
				&minor->kdev->kobj,
				name);

	kfree(name);

	return ret;
}

static void remove_compat_control_link(struct drm_device *dev)
{
	struct drm_minor *minor;
	char *name;

	if (!drm_core_check_feature(dev, DRIVER_MODESET))
		return;

	minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
	if (!minor)
		return;

769
	name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
770 771 772 773 774 775 776 777
	if (!name)
		return;

	sysfs_remove_link(minor->kdev->kobj.parent, name);

	kfree(name);
}

778 779 780
/**
 * drm_dev_register - Register DRM device
 * @dev: Device to register
781
 * @flags: Flags passed to the driver's .load() function
782 783 784
 *
 * 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()
785
 * previously.
786 787 788
 *
 * Never call this twice on any device!
 *
789
 * NOTE: To ensure backward compatibility with existing drivers method this
790 791 792
 * function calls the &drm_driver.load method after registering the device
 * nodes, creating race conditions. Usage of the &drm_driver.load methods is
 * therefore deprecated, drivers must perform all initialization before calling
793 794
 * drm_dev_register().
 *
795 796 797 798 799
 * RETURNS:
 * 0 on success, negative error code on failure.
 */
int drm_dev_register(struct drm_device *dev, unsigned long flags)
{
800
	struct drm_driver *driver = dev->driver;
801 802 803 804
	int ret;

	mutex_lock(&drm_global_mutex);

805
	ret = drm_minor_register(dev, DRM_MINOR_RENDER);
D
David Herrmann 已提交
806 807
	if (ret)
		goto err_minors;
808

809
	ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
810
	if (ret)
D
David Herrmann 已提交
811
		goto err_minors;
812

813 814 815 816
	ret = create_compat_control_link(dev);
	if (ret)
		goto err_minors;

817 818
	dev->registered = true;

819 820 821
	if (dev->driver->load) {
		ret = dev->driver->load(dev, flags);
		if (ret)
D
David Herrmann 已提交
822
			goto err_minors;
823 824
	}

825
	if (drm_core_check_feature(dev, DRIVER_MODESET))
826
		drm_modeset_register_all(dev);
827

828
	ret = 0;
829 830 831

	DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
		 driver->name, driver->major, driver->minor,
832 833
		 driver->patchlevel, driver->date,
		 dev->dev ? dev_name(dev->dev) : "virtual device",
834 835
		 dev->primary->index);

836 837
	goto out_unlock;

D
David Herrmann 已提交
838
err_minors:
839
	remove_compat_control_link(dev);
840
	drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
841
	drm_minor_unregister(dev, DRM_MINOR_RENDER);
842 843 844 845 846
out_unlock:
	mutex_unlock(&drm_global_mutex);
	return ret;
}
EXPORT_SYMBOL(drm_dev_register);
847 848 849 850 851 852 853

/**
 * 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
854
 * drm_dev_put() to drop their final reference.
855
 *
856 857 858
 * A special form of unregistering for hotpluggable devices is drm_dev_unplug(),
 * which can be called while there are still open users of @dev.
 *
859 860
 * This should be called first in the device teardown code to make sure
 * userspace can't access the device instance any more.
861 862 863 864 865
 */
void drm_dev_unregister(struct drm_device *dev)
{
	struct drm_map_list *r_list, *list_temp;

866 867
	if (drm_core_check_feature(dev, DRIVER_LEGACY))
		drm_lastclose(dev);
868

869 870
	dev->registered = false;

871 872
	drm_client_dev_unregister(dev);

873
	if (drm_core_check_feature(dev, DRIVER_MODESET))
874
		drm_modeset_unregister_all(dev);
875

876 877 878
	if (dev->driver->unload)
		dev->driver->unload(dev);

879 880
	if (dev->agp)
		drm_pci_agp_destroy(dev);
881 882

	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
883
		drm_legacy_rmmap(dev, r_list->map);
884

885
	remove_compat_control_link(dev);
886
	drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
887
	drm_minor_unregister(dev, DRM_MINOR_RENDER);
888 889
}
EXPORT_SYMBOL(drm_dev_unregister);
890

G
Gerd Hoffmann 已提交
891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910
/**
 * drm_dev_set_unique - Set the unique name of a DRM device
 * @dev: device of which to set the unique name
 * @name: unique name
 *
 * Sets the unique name of a DRM device using the specified string. 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 *name)
{
	kfree(dev->unique);
	dev->unique = kstrdup(name, GFP_KERNEL);

	return dev->unique ? 0 : -ENOMEM;
}
EXPORT_SYMBOL(drm_dev_set_unique);

911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970
/*
 * 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,
};

971 972 973 974 975 976 977 978 979
static void drm_core_exit(void)
{
	unregister_chrdev(DRM_MAJOR, "drm");
	debugfs_remove(drm_debugfs_root);
	drm_sysfs_destroy();
	idr_destroy(&drm_minors_idr);
	drm_connector_ida_destroy();
}

980 981
static int __init drm_core_init(void)
{
982
	int ret;
983 984 985 986

	drm_connector_ida_init();
	idr_init(&drm_minors_idr);

987 988
	ret = drm_sysfs_init();
	if (ret < 0) {
989 990
		DRM_ERROR("Cannot create DRM class: %d\n", ret);
		goto error;
991 992 993 994
	}

	drm_debugfs_root = debugfs_create_dir("dri", NULL);
	if (!drm_debugfs_root) {
995 996 997
		ret = -ENOMEM;
		DRM_ERROR("Cannot create debugfs-root: %d\n", ret);
		goto error;
998 999
	}

1000 1001 1002 1003
	ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);
	if (ret < 0)
		goto error;

1004 1005
	drm_core_init_complete = true;

1006
	DRM_DEBUG("Initialized\n");
1007 1008
	return 0;

1009 1010
error:
	drm_core_exit();
1011 1012 1013 1014 1015
	return ret;
}

module_init(drm_core_init);
module_exit(drm_core_exit);