[deliverable/linux.git] / drivers / gpu / drm / drm_stub.c

/**
 * \file drm_stub.h
 * Stub support
 *
 * \author Rickard E. (Rik) Faith <faith@valinux.com>
 */

/*
 * Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
 *
 * Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
 * All Rights Reserved.
 *
 * 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.
 */

#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/slab.h>
#include <drm/drmP.h>
#include <drm/drm_core.h>

unsigned int drm_debug = 0;	/* 1 to enable debug output */
EXPORT_SYMBOL(drm_debug);

unsigned int drm_rnodes = 0;	/* 1 to enable experimental render nodes API */
EXPORT_SYMBOL(drm_rnodes);

unsigned int drm_vblank_offdelay = 5000;    /* Default to 5000 msecs. */
EXPORT_SYMBOL(drm_vblank_offdelay);

unsigned int drm_timestamp_precision = 20;  /* Default to 20 usecs. */
EXPORT_SYMBOL(drm_timestamp_precision);

/*
 * Default to use monotonic timestamps for wait-for-vblank and page-flip
 * complete events.
 */
unsigned int drm_timestamp_monotonic = 1;

MODULE_AUTHOR(CORE_AUTHOR);
MODULE_DESCRIPTION(CORE_DESC);
MODULE_LICENSE("GPL and additional rights");
MODULE_PARM_DESC(debug, "Enable debug output");
MODULE_PARM_DESC(rnodes, "Enable experimental render nodes API");
MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs]");
MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");

module_param_named(debug, drm_debug, int, 0600);
module_param_named(rnodes, drm_rnodes, int, 0600);
module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600);
module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600);
module_param_named(timestamp_monotonic, drm_timestamp_monotonic, int, 0600);

struct idr drm_minors_idr;

struct class *drm_class;
struct dentry *drm_debugfs_root;

int drm_err(const char *func, const char *format, ...)
{
	struct va_format vaf;
	va_list args;
	int r;

	va_start(args, format);

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

	r = printk(KERN_ERR "[" DRM_NAME ":%s] *ERROR* %pV", func, &vaf);

	va_end(args);

	return r;
}
EXPORT_SYMBOL(drm_err);

void drm_ut_debug_printk(unsigned int request_level,
			 const char *prefix,
			 const char *function_name,
			 const char *format, ...)
{
	va_list args;

	if (drm_debug & request_level) {
		if (function_name)
			printk(KERN_DEBUG "[%s:%s], ", prefix, function_name);
		va_start(args, format);
		vprintk(format, args);
		va_end(args);
	}
}
EXPORT_SYMBOL(drm_ut_debug_printk);

static int drm_minor_get_id(struct drm_device *dev, int type)
{
	int ret;
	int base = 0, limit = 63;

	if (type == DRM_MINOR_CONTROL) {
		base += 64;
		limit = base + 63;
	} else if (type == DRM_MINOR_RENDER) {
		base += 128;
		limit = base + 63;
	}

	mutex_lock(&dev->struct_mutex);
	ret = idr_alloc(&drm_minors_idr, NULL, base, limit, GFP_KERNEL);
	mutex_unlock(&dev->struct_mutex);

	return ret == -ENOSPC ? -EINVAL : ret;
}

struct drm_master *drm_master_create(struct drm_minor *minor)
{
	struct drm_master *master;

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

	kref_init(&master->refcount);
	spin_lock_init(&master->lock.spinlock);
	init_waitqueue_head(&master->lock.lock_queue);
	drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER);
	INIT_LIST_HEAD(&master->magicfree);
	master->minor = minor;

	list_add_tail(&master->head, &minor->master_list);

	return master;
}

struct drm_master *drm_master_get(struct drm_master *master)
{
	kref_get(&master->refcount);
	return master;
}
EXPORT_SYMBOL(drm_master_get);

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

	list_del(&master->head);

	if (dev->driver->master_destroy)
		dev->driver->master_destroy(dev, master);

	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
		if (r_list->master == master) {
			drm_rmmap_locked(dev, r_list->map);
			r_list = NULL;
		}
	}

	if (master->unique) {
		kfree(master->unique);
		master->unique = NULL;
		master->unique_len = 0;
	}

	kfree(dev->devname);
	dev->devname = NULL;

	list_for_each_entry_safe(pt, next, &master->magicfree, head) {
		list_del(&pt->head);
		drm_ht_remove_item(&master->magiclist, &pt->hash_item);
		kfree(pt);
	}

	drm_ht_remove(&master->magiclist);

	kfree(master);
}

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

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

	if (file_priv->is_master)
		return 0;

	if (file_priv->minor->master && file_priv->minor->master != file_priv->master)
		return -EINVAL;

	if (!file_priv->master)
		return -EINVAL;

	if (file_priv->minor->master)
		return -EINVAL;

	mutex_lock(&dev->struct_mutex);
	file_priv->minor->master = drm_master_get(file_priv->master);
	file_priv->is_master = 1;
	if (dev->driver->master_set) {
		ret = dev->driver->master_set(dev, file_priv, false);
		if (unlikely(ret != 0)) {
			file_priv->is_master = 0;
			drm_master_put(&file_priv->minor->master);
		}
	}
	mutex_unlock(&dev->struct_mutex);

	return ret;
}

int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
			 struct drm_file *file_priv)
{
	if (!file_priv->is_master)
		return -EINVAL;

	if (!file_priv->minor->master)
		return -EINVAL;

	mutex_lock(&dev->struct_mutex);
	if (dev->driver->master_drop)
		dev->driver->master_drop(dev, file_priv, false);
	drm_master_put(&file_priv->minor->master);
	file_priv->is_master = 0;
	mutex_unlock(&dev->struct_mutex);
	return 0;
}

int drm_fill_in_dev(struct drm_device *dev,
			   const struct pci_device_id *ent,
			   struct drm_driver *driver)
{
	int retcode;

	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);

	spin_lock_init(&dev->count_lock);
	spin_lock_init(&dev->event_lock);
	mutex_init(&dev->struct_mutex);
	mutex_init(&dev->ctxlist_mutex);

	if (drm_ht_create(&dev->map_hash, 12)) {
		return -ENOMEM;
	}

	/* the DRM has 6 basic counters */
	dev->counters = 6;
	dev->types[0] = _DRM_STAT_LOCK;
	dev->types[1] = _DRM_STAT_OPENS;
	dev->types[2] = _DRM_STAT_CLOSES;
	dev->types[3] = _DRM_STAT_IOCTLS;
	dev->types[4] = _DRM_STAT_LOCKS;
	dev->types[5] = _DRM_STAT_UNLOCKS;

	dev->driver = driver;

	if (dev->driver->bus->agp_init) {
		retcode = dev->driver->bus->agp_init(dev);
		if (retcode)
			goto error_out_unreg;
	}


	retcode = drm_ctxbitmap_init(dev);
	if (retcode) {
		DRM_ERROR("Cannot allocate memory for context bitmap.\n");
		goto error_out_unreg;
	}

	if (driver->driver_features & DRIVER_GEM) {
		retcode = drm_gem_init(dev);
		if (retcode) {
			DRM_ERROR("Cannot initialize graphics execution "
				  "manager (GEM)\n");
			goto error_out_unreg;
		}
	}

	return 0;

      error_out_unreg:
	drm_lastclose(dev);
	return retcode;
}
EXPORT_SYMBOL(drm_fill_in_dev);


/**
 * Get a secondary minor number.
 *
 * \param dev device data structure
 * \param sec-minor structure to hold the assigned minor
 * \return negative number on failure.
 *
 * Search an empty entry and initialize it to the given parameters. This
 * routines assigns minor numbers to secondary heads of multi-headed cards
 */
int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type)
{
	struct drm_minor *new_minor;
	int ret;
	int minor_id;

	DRM_DEBUG("\n");

	minor_id = drm_minor_get_id(dev, type);
	if (minor_id < 0)
		return minor_id;

	new_minor = kzalloc(sizeof(struct drm_minor), GFP_KERNEL);
	if (!new_minor) {
		ret = -ENOMEM;
		goto err_idr;
	}

	new_minor->type = type;
	new_minor->device = MKDEV(DRM_MAJOR, minor_id);
	new_minor->dev = dev;
	new_minor->index = minor_id;
	INIT_LIST_HEAD(&new_minor->master_list);

	idr_replace(&drm_minors_idr, new_minor, minor_id);

#if defined(CONFIG_DEBUG_FS)
	ret = drm_debugfs_init(new_minor, minor_id, drm_debugfs_root);
	if (ret) {
		DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
		goto err_mem;
	}
#endif

	ret = drm_sysfs_device_add(new_minor);
	if (ret) {
		printk(KERN_ERR
		       "DRM: Error sysfs_device_add.\n");
		goto err_debugfs;
	}
	*minor = new_minor;

	DRM_DEBUG("new minor assigned %d\n", minor_id);
	return 0;


err_debugfs:
#if defined(CONFIG_DEBUG_FS)
	drm_debugfs_cleanup(new_minor);
err_mem:
#endif
	kfree(new_minor);
err_idr:
	idr_remove(&drm_minors_idr, minor_id);
	*minor = NULL;
	return ret;
}
EXPORT_SYMBOL(drm_get_minor);

/**
 * Put a secondary minor number.
 *
 * \param sec_minor - structure to be released
 * \return always zero
 */
int drm_put_minor(struct drm_minor **minor_p)
{
	struct drm_minor *minor = *minor_p;

	DRM_DEBUG("release secondary minor %d\n", minor->index);

#if defined(CONFIG_DEBUG_FS)
	drm_debugfs_cleanup(minor);
#endif

	drm_sysfs_device_remove(minor);

	idr_remove(&drm_minors_idr, minor->index);

	kfree(minor);
	*minor_p = NULL;
	return 0;
}
EXPORT_SYMBOL(drm_put_minor);

static void drm_unplug_minor(struct drm_minor *minor)
{
	drm_sysfs_device_remove(minor);
}

/**
 * Called via drm_exit() at module unload time or when pci device is
 * unplugged.
 *
 * Cleans up all DRM device, calling drm_lastclose().
 *
 */
void drm_put_dev(struct drm_device *dev)
{
	struct drm_driver *driver;
	struct drm_map_list *r_list, *list_temp;

	DRM_DEBUG("\n");

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

	drm_lastclose(dev);

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

	if (dev->driver->bus->agp_destroy)
		dev->driver->bus->agp_destroy(dev);

	drm_vblank_cleanup(dev);

	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
		drm_rmmap(dev, r_list->map);
	drm_ht_remove(&dev->map_hash);

	drm_ctxbitmap_cleanup(dev);

	if (drm_core_check_feature(dev, DRIVER_MODESET))
		drm_put_minor(&dev->control);

	if (dev->render)
		drm_put_minor(&dev->render);

	if (driver->driver_features & DRIVER_GEM)
		drm_gem_destroy(dev);

	drm_put_minor(&dev->primary);

	list_del(&dev->driver_item);
	kfree(dev->devname);
	kfree(dev);
}
EXPORT_SYMBOL(drm_put_dev);

void drm_unplug_dev(struct drm_device *dev)
{
	/* for a USB device */
	if (drm_core_check_feature(dev, DRIVER_MODESET))
		drm_unplug_minor(dev->control);
	if (dev->render)
		drm_unplug_minor(dev->render);
	drm_unplug_minor(dev->primary);

	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);
Commit	Line	Data
1da177e4 LT	1	/**
	2	* \file drm_stub.h
	3	* Stub support
	4	*
	5	* \author Rickard E. (Rik) Faith <faith@valinux.com>
	6	*/
	7
	8	/*
	9	* Created: Fri Jan 19 10:48:35 2001 by faith@acm.org
	10	*
	11	* Copyright 2001 VA Linux Systems, Inc., Sunnyvale, California.
	12	* All Rights Reserved.
	13	*
	14	* Permission is hereby granted, free of charge, to any person obtaining a
	15	* copy of this software and associated documentation files (the "Software"),
	16	* to deal in the Software without restriction, including without limitation
	17	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
	18	* and/or sell copies of the Software, and to permit persons to whom the
	19	* Software is furnished to do so, subject to the following conditions:
	20	*
	21	* The above copyright notice and this permission notice (including the next
	22	* paragraph) shall be included in all copies or substantial portions of the
	23	* Software.
	24	*
	25	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	26	* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	27	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
	28	* PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
	29	* OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
	30	* ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
	31	* DEALINGS IN THE SOFTWARE.
	32	*/
	33
	34	#include <linux/module.h>
	35	#include <linux/moduleparam.h>
5a0e3ad6	36	#include <linux/slab.h>
760285e7 DH	37	#include <drm/drmP.h>
760285e7 DH	38	#include <drm/drm_core.h>
1da177e4	39
b5e89ed5	40	unsigned int drm_debug = 0; /* 1 to enable debug output */
1da177e4 LT	41	EXPORT_SYMBOL(drm_debug);
1da177e4 LT	42
1793126f DH	43	unsigned int drm_rnodes = 0; /* 1 to enable experimental render nodes API */
	44	EXPORT_SYMBOL(drm_rnodes);
	45
27641c3f MK	46	unsigned int drm_vblank_offdelay = 5000; /* Default to 5000 msecs. */
	47	EXPORT_SYMBOL(drm_vblank_offdelay);
	48
	49	unsigned int drm_timestamp_precision = 20; /* Default to 20 usecs. */
	50	EXPORT_SYMBOL(drm_timestamp_precision);
	51
c61eef72 ID	52	/*
	53	* Default to use monotonic timestamps for wait-for-vblank and page-flip
	54	* complete events.
	55	*/
	56	unsigned int drm_timestamp_monotonic = 1;
	57
b5e89ed5 DA	58	MODULE_AUTHOR(CORE_AUTHOR);
b5e89ed5 DA	59	MODULE_DESCRIPTION(CORE_DESC);
1da177e4	60	MODULE_LICENSE("GPL and additional rights");
1da177e4	61	MODULE_PARM_DESC(debug, "Enable debug output");
1793126f	62	MODULE_PARM_DESC(rnodes, "Enable experimental render nodes API");
27641c3f MK	63	MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs]");
27641c3f MK	64	MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
c61eef72	65	MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
1da177e4	66
c0758146	67	module_param_named(debug, drm_debug, int, 0600);
1793126f	68	module_param_named(rnodes, drm_rnodes, int, 0600);
27641c3f MK	69	module_param_named(vblankoffdelay, drm_vblank_offdelay, int, 0600);
27641c3f MK	70	module_param_named(timestamp_precision_usec, drm_timestamp_precision, int, 0600);
c61eef72	71	module_param_named(timestamp_monotonic, drm_timestamp_monotonic, int, 0600);
1da177e4	72
2c14f28b DA	73	struct idr drm_minors_idr;
2c14f28b DA	74
0650fd58	75	struct class *drm_class;
955b12de	76	struct dentry *drm_debugfs_root;
5ad3d883 JP	77
	78	int drm_err(const char func, const char format, ...)
	79	{
	80	struct va_format vaf;
	81	va_list args;
	82	int r;
	83
	84	va_start(args, format);
	85
	86	vaf.fmt = format;
	87	vaf.va = &args;
	88
	89	r = printk(KERN_ERR "[" DRM_NAME ":%s] ERROR %pV", func, &vaf);
	90
	91	va_end(args);
	92
	93	return r;
	94	}
	95	EXPORT_SYMBOL(drm_err);
	96
4fefcb27	97	void drm_ut_debug_printk(unsigned int request_level,
	98	const char *prefix,
	99	const char *function_name,
	100	const char *format, ...)
	101	{
	102	va_list args;
1da177e4	103
4fefcb27	104	if (drm_debug & request_level) {
	105	if (function_name)
	106	printk(KERN_DEBUG "[%s:%s], ", prefix, function_name);
	107	va_start(args, format);
	108	vprintk(format, args);
	109	va_end(args);
	110	}
	111	}
	112	EXPORT_SYMBOL(drm_ut_debug_printk);
5ad3d883	113
2c14f28b DA	114	static int drm_minor_get_id(struct drm_device *dev, int type)
2c14f28b DA	115	{
2c14f28b DA	116	int ret;
	117	int base = 0, limit = 63;
	118
f453ba04	119	if (type == DRM_MINOR_CONTROL) {
24f40032 KH	120	base += 64;
	121	limit = base + 63;
	122	} else if (type == DRM_MINOR_RENDER) {
	123	base += 128;
	124	limit = base + 63;
	125	}
f453ba04	126
2c14f28b	127	mutex_lock(&dev->struct_mutex);
2e928815	128	ret = idr_alloc(&drm_minors_idr, NULL, base, limit, GFP_KERNEL);
2c14f28b	129	mutex_unlock(&dev->struct_mutex);
2e928815 TH	130
2e928815 TH	131	return ret == -ENOSPC ? -EINVAL : ret;
2c14f28b DA	132	}
2c14f28b DA	133
7c1c2871 DA	134	struct drm_master drm_master_create(struct drm_minor minor)
	135	{
	136	struct drm_master *master;
	137
9a298b2a	138	master = kzalloc(sizeof(*master), GFP_KERNEL);
7c1c2871 DA	139	if (!master)
	140	return NULL;
	141
	142	kref_init(&master->refcount);
	143	spin_lock_init(&master->lock.spinlock);
	144	init_waitqueue_head(&master->lock.lock_queue);
	145	drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER);
	146	INIT_LIST_HEAD(&master->magicfree);
	147	master->minor = minor;
	148
	149	list_add_tail(&master->head, &minor->master_list);
	150
	151	return master;
	152	}
	153
	154	struct drm_master drm_master_get(struct drm_master master)
	155	{
	156	kref_get(&master->refcount);
	157	return master;
	158	}
85bb0c37	159	EXPORT_SYMBOL(drm_master_get);
7c1c2871 DA	160
	161	static void drm_master_destroy(struct kref *kref)
	162	{
	163	struct drm_master *master = container_of(kref, struct drm_master, refcount);
	164	struct drm_magic_entry pt, next;
	165	struct drm_device *dev = master->minor->dev;
c1ff85d9	166	struct drm_map_list r_list, list_temp;
7c1c2871 DA	167
	168	list_del(&master->head);
	169
	170	if (dev->driver->master_destroy)
	171	dev->driver->master_destroy(dev, master);
	172
c1ff85d9 DA	173	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
	174	if (r_list->master == master) {
	175	drm_rmmap_locked(dev, r_list->map);
	176	r_list = NULL;
	177	}
	178	}
	179
7c1c2871	180	if (master->unique) {
9a298b2a	181	kfree(master->unique);
7c1c2871 DA	182	master->unique = NULL;
	183	master->unique_len = 0;
	184	}
	185
6e35023f CW	186	kfree(dev->devname);
	187	dev->devname = NULL;
	188
7c1c2871 DA	189	list_for_each_entry_safe(pt, next, &master->magicfree, head) {
	190	list_del(&pt->head);
	191	drm_ht_remove_item(&master->magiclist, &pt->hash_item);
9a298b2a	192	kfree(pt);
7c1c2871 DA	193	}
	194
	195	drm_ht_remove(&master->magiclist);
	196
9a298b2a	197	kfree(master);
7c1c2871 DA	198	}
	199
	200	void drm_master_put(struct drm_master **master)
	201	{
	202	kref_put(&(*master)->refcount, drm_master_destroy);
	203	*master = NULL;
	204	}
85bb0c37	205	EXPORT_SYMBOL(drm_master_put);
7c1c2871 DA	206
	207	int drm_setmaster_ioctl(struct drm_device dev, void data,
	208	struct drm_file *file_priv)
	209	{
53ef1600	210	int ret = 0;
862302ff	211
6b008426 JB	212	if (file_priv->is_master)
	213	return 0;
	214
7c1c2871 DA	215	if (file_priv->minor->master && file_priv->minor->master != file_priv->master)
	216	return -EINVAL;
	217
	218	if (!file_priv->master)
	219	return -EINVAL;
	220
08bec5b4 DH	221	if (file_priv->minor->master)
	222	return -EINVAL;
	223
	224	mutex_lock(&dev->struct_mutex);
	225	file_priv->minor->master = drm_master_get(file_priv->master);
	226	file_priv->is_master = 1;
	227	if (dev->driver->master_set) {
	228	ret = dev->driver->master_set(dev, file_priv, false);
	229	if (unlikely(ret != 0)) {
	230	file_priv->is_master = 0;
	231	drm_master_put(&file_priv->minor->master);
862302ff	232	}
7c1c2871	233	}
08bec5b4	234	mutex_unlock(&dev->struct_mutex);
7c1c2871	235
53ef1600	236	return ret;
7c1c2871 DA	237	}
	238
	239	int drm_dropmaster_ioctl(struct drm_device dev, void data,
	240	struct drm_file *file_priv)
	241	{
6b008426	242	if (!file_priv->is_master)
7c1c2871	243	return -EINVAL;
6b008426	244
07f1c7a7 DA	245	if (!file_priv->minor->master)
	246	return -EINVAL;
	247
7c1c2871	248	mutex_lock(&dev->struct_mutex);
862302ff TH	249	if (dev->driver->master_drop)
862302ff TH	250	dev->driver->master_drop(dev, file_priv, false);
7c1c2871	251	drm_master_put(&file_priv->minor->master);
6b008426	252	file_priv->is_master = 0;
7c1c2871 DA	253	mutex_unlock(&dev->struct_mutex);
	254	return 0;
	255	}
	256
dcdb1674	257	int drm_fill_in_dev(struct drm_device *dev,
b5e89ed5 DA	258	const struct pci_device_id *ent,
b5e89ed5 DA	259	struct drm_driver *driver)
1da177e4 LT	260	{
	261	int retcode;
	262
bd1b331f	263	INIT_LIST_HEAD(&dev->filelist);
7c158ace DA	264	INIT_LIST_HEAD(&dev->ctxlist);
	265	INIT_LIST_HEAD(&dev->vmalist);
	266	INIT_LIST_HEAD(&dev->maplist);
c9a9c5e0	267	INIT_LIST_HEAD(&dev->vblank_event_list);
7c158ace	268
1da177e4	269	spin_lock_init(&dev->count_lock);
c9a9c5e0	270	spin_lock_init(&dev->event_lock);
30e2fb18 DA	271	mutex_init(&dev->struct_mutex);
30e2fb18 DA	272	mutex_init(&dev->ctxlist_mutex);
1da177e4	273
8d153f71	274	if (drm_ht_create(&dev->map_hash, 12)) {
8d153f71 TH	275	return -ENOMEM;
8d153f71 TH	276	}
836cf046	277
1da177e4 LT	278	/* the DRM has 6 basic counters */
1da177e4 LT	279	dev->counters = 6;
b5e89ed5 DA	280	dev->types[0] = _DRM_STAT_LOCK;
	281	dev->types[1] = _DRM_STAT_OPENS;
	282	dev->types[2] = _DRM_STAT_CLOSES;
	283	dev->types[3] = _DRM_STAT_IOCTLS;
	284	dev->types[4] = _DRM_STAT_LOCKS;
	285	dev->types[5] = _DRM_STAT_UNLOCKS;
1da177e4 LT	286
1da177e4 LT	287	dev->driver = driver;
b5e89ed5	288
8410ea3b DA	289	if (dev->driver->bus->agp_init) {
	290	retcode = dev->driver->bus->agp_init(dev);
	291	if (retcode)
1da177e4	292	goto error_out_unreg;
1da177e4 LT	293	}
1da177e4 LT	294
c21eb21c DA	295
	296
	297	retcode = drm_ctxbitmap_init(dev);
	298	if (retcode) {
	299	DRM_ERROR("Cannot allocate memory for context bitmap.\n");
	300	goto error_out_unreg;
	301	}
1da177e4	302
673a394b EA	303	if (driver->driver_features & DRIVER_GEM) {
	304	retcode = drm_gem_init(dev);
	305	if (retcode) {
	306	DRM_ERROR("Cannot initialize graphics execution "
	307	"manager (GEM)\n");
	308	goto error_out_unreg;
	309	}
	310	}
	311
1da177e4	312	return 0;
b5e89ed5 DA	313
b5e89ed5 DA	314	error_out_unreg:
22eae947	315	drm_lastclose(dev);
1da177e4 LT	316	return retcode;
1da177e4 LT	317	}
9c1dfc55	318	EXPORT_SYMBOL(drm_fill_in_dev);
1da177e4	319
1da177e4	320
1da177e4 LT	321	/**
	322	* Get a secondary minor number.
	323	*
	324	* \param dev device data structure
	325	* \param sec-minor structure to hold the assigned minor
	326	* \return negative number on failure.
	327	*
cb6458f9 DV	328	* Search an empty entry and initialize it to the given parameters. This
cb6458f9 DV	329	* routines assigns minor numbers to secondary heads of multi-headed cards
1da177e4	330	*/
dcdb1674	331	int drm_get_minor(struct drm_device dev, struct drm_minor *minor, int type)
1da177e4	332	{
2c14f28b	333	struct drm_minor *new_minor;
1da177e4	334	int ret;
2c14f28b	335	int minor_id;
1da177e4 LT	336
	337	DRM_DEBUG("\n");
	338
2c14f28b DA	339	minor_id = drm_minor_get_id(dev, type);
	340	if (minor_id < 0)
	341	return minor_id;
	342
	343	new_minor = kzalloc(sizeof(struct drm_minor), GFP_KERNEL);
	344	if (!new_minor) {
	345	ret = -ENOMEM;
	346	goto err_idr;
	347	}
	348
	349	new_minor->type = type;
	350	new_minor->device = MKDEV(DRM_MAJOR, minor_id);
	351	new_minor->dev = dev;
	352	new_minor->index = minor_id;
7c1c2871	353	INIT_LIST_HEAD(&new_minor->master_list);
2c14f28b DA	354
	355	idr_replace(&drm_minors_idr, new_minor, minor_id);
	356
955b12de BG	357	#if defined(CONFIG_DEBUG_FS)
	358	ret = drm_debugfs_init(new_minor, minor_id, drm_debugfs_root);
	359	if (ret) {
156f5a78	360	DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
cb6458f9	361	goto err_mem;
955b12de BG	362	}
955b12de BG	363	#endif
2c14f28b DA	364
	365	ret = drm_sysfs_device_add(new_minor);
	366	if (ret) {
	367	printk(KERN_ERR
	368	"DRM: Error sysfs_device_add.\n");
cb6458f9	369	goto err_debugfs;
1da177e4	370	}
2c14f28b DA	371	*minor = new_minor;
	372
	373	DRM_DEBUG("new minor assigned %d\n", minor_id);
	374	return 0;
	375
	376
cb6458f9 DV	377	err_debugfs:
	378	#if defined(CONFIG_DEBUG_FS)
	379	drm_debugfs_cleanup(new_minor);
2c14f28b	380	err_mem:
cb6458f9	381	#endif
2c14f28b DA	382	kfree(new_minor);
	383	err_idr:
	384	idr_remove(&drm_minors_idr, minor_id);
	385	*minor = NULL;
1da177e4 LT	386	return ret;
1da177e4 LT	387	}
9c1dfc55	388	EXPORT_SYMBOL(drm_get_minor);
b5e89ed5	389
1da177e4 LT	390	/**
	391	* Put a secondary minor number.
	392	*
	393	* \param sec_minor - structure to be released
	394	* \return always zero
1da177e4	395	*/
2c14f28b	396	int drm_put_minor(struct drm_minor **minor_p)
1da177e4	397	{
2c14f28b	398	struct drm_minor minor = minor_p;
673a394b	399
2c14f28b	400	DRM_DEBUG("release secondary minor %d\n", minor->index);
b5e89ed5	401
955b12de BG	402	#if defined(CONFIG_DEBUG_FS)
	403	drm_debugfs_cleanup(minor);
	404	#endif
	405
2c14f28b	406	drm_sysfs_device_remove(minor);
1da177e4	407
2c14f28b	408	idr_remove(&drm_minors_idr, minor->index);
b5e89ed5	409
2c14f28b DA	410	kfree(minor);
2c14f28b DA	411	*minor_p = NULL;
1da177e4 LT	412	return 0;
1da177e4 LT	413	}
9c1dfc55	414	EXPORT_SYMBOL(drm_put_minor);
112b715e	415
2c07a21d DA	416	static void drm_unplug_minor(struct drm_minor *minor)
	417	{
	418	drm_sysfs_device_remove(minor);
	419	}
	420
112b715e KH	421	/**
	422	* Called via drm_exit() at module unload time or when pci device is
	423	* unplugged.
	424	*
	425	* Cleans up all DRM device, calling drm_lastclose().
	426	*
112b715e KH	427	*/
	428	void drm_put_dev(struct drm_device *dev)
	429	{
ecca0683	430	struct drm_driver *driver;
112b715e KH	431	struct drm_map_list r_list, list_temp;
	432
	433	DRM_DEBUG("\n");
	434
	435	if (!dev) {
	436	DRM_ERROR("cleanup called no dev\n");
	437	return;
	438	}
ecca0683	439	driver = dev->driver;
112b715e	440
112b715e KH	441	drm_lastclose(dev);
112b715e KH	442
112b715e KH	443	if (dev->driver->unload)
	444	dev->driver->unload(dev);
	445
28ec711c DH	446	if (dev->driver->bus->agp_destroy)
28ec711c DH	447	dev->driver->bus->agp_destroy(dev);
112b715e	448
b78315f0 JB	449	drm_vblank_cleanup(dev);
b78315f0 JB	450
112b715e KH	451	list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
112b715e KH	452	drm_rmmap(dev, r_list->map);
30ddbd94 BS	453	drm_ht_remove(&dev->map_hash);
30ddbd94 BS	454
c21eb21c	455	drm_ctxbitmap_cleanup(dev);
112b715e KH	456
	457	if (drm_core_check_feature(dev, DRIVER_MODESET))
	458	drm_put_minor(&dev->control);
	459
1793126f DH	460	if (dev->render)
	461	drm_put_minor(&dev->render);
	462
112b715e KH	463	if (driver->driver_features & DRIVER_GEM)
	464	drm_gem_destroy(dev);
	465
	466	drm_put_minor(&dev->primary);
	467
a250b9fd	468	list_del(&dev->driver_item);
66141d3d	469	kfree(dev->devname);
9a298b2a	470	kfree(dev);
112b715e KH	471	}
112b715e KH	472	EXPORT_SYMBOL(drm_put_dev);
2c07a21d DA	473
	474	void drm_unplug_dev(struct drm_device *dev)
	475	{
	476	/* for a USB device */
	477	if (drm_core_check_feature(dev, DRIVER_MODESET))
	478	drm_unplug_minor(dev->control);
1793126f DH	479	if (dev->render)
1793126f DH	480	drm_unplug_minor(dev->render);
2c07a21d DA	481	drm_unplug_minor(dev->primary);
	482
	483	mutex_lock(&drm_global_mutex);
	484
	485	drm_device_set_unplugged(dev);
	486
	487	if (dev->open_count == 0) {
	488	drm_put_dev(dev);
	489	}
	490	mutex_unlock(&drm_global_mutex);
	491	}
	492	EXPORT_SYMBOL(drm_unplug_dev);