blob: 387a8de1bc7e51f60af11c903d5852a93bc98e15 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/**
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>
36#include "drmP.h"
37#include "drm_core.h"
38
Dave Airlieb5e89ed2005-09-25 14:28:13 +100039unsigned int drm_debug = 0; /* 1 to enable debug output */
Linus Torvalds1da177e2005-04-16 15:20:36 -070040EXPORT_SYMBOL(drm_debug);
41
Dave Airlieb5e89ed2005-09-25 14:28:13 +100042MODULE_AUTHOR(CORE_AUTHOR);
43MODULE_DESCRIPTION(CORE_DESC);
Linus Torvalds1da177e2005-04-16 15:20:36 -070044MODULE_LICENSE("GPL and additional rights");
Linus Torvalds1da177e2005-04-16 15:20:36 -070045MODULE_PARM_DESC(debug, "Enable debug output");
46
Dave Jonesc0758142005-10-03 15:02:20 -040047module_param_named(debug, drm_debug, int, 0600);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048
Dave Airlie2c14f282008-04-21 16:47:32 +100049struct idr drm_minors_idr;
50
Greg Kroah-Hartman0650fd52006-01-20 14:08:59 -080051struct class *drm_class;
Linus Torvalds1da177e2005-04-16 15:20:36 -070052struct proc_dir_entry *drm_proc_root;
Ben Gamari955b12d2009-02-17 20:08:49 -050053struct dentry *drm_debugfs_root;
yakui_zhao4fefcb22009-06-02 14:09:47 +080054void drm_ut_debug_printk(unsigned int request_level,
55 const char *prefix,
56 const char *function_name,
57 const char *format, ...)
58{
59 va_list args;
Linus Torvalds1da177e2005-04-16 15:20:36 -070060
yakui_zhao4fefcb22009-06-02 14:09:47 +080061 if (drm_debug & request_level) {
62 if (function_name)
63 printk(KERN_DEBUG "[%s:%s], ", prefix, function_name);
64 va_start(args, format);
65 vprintk(format, args);
66 va_end(args);
67 }
68}
69EXPORT_SYMBOL(drm_ut_debug_printk);
Dave Airlie2c14f282008-04-21 16:47:32 +100070static int drm_minor_get_id(struct drm_device *dev, int type)
71{
72 int new_id;
73 int ret;
74 int base = 0, limit = 63;
75
Dave Airlief453ba02008-11-07 14:05:41 -080076 if (type == DRM_MINOR_CONTROL) {
77 base += 64;
78 limit = base + 127;
79 } else if (type == DRM_MINOR_RENDER) {
80 base += 128;
81 limit = base + 255;
82 }
83
Dave Airlie2c14f282008-04-21 16:47:32 +100084again:
85 if (idr_pre_get(&drm_minors_idr, GFP_KERNEL) == 0) {
86 DRM_ERROR("Out of memory expanding drawable idr\n");
87 return -ENOMEM;
88 }
89 mutex_lock(&dev->struct_mutex);
90 ret = idr_get_new_above(&drm_minors_idr, NULL,
91 base, &new_id);
92 mutex_unlock(&dev->struct_mutex);
93 if (ret == -EAGAIN) {
94 goto again;
95 } else if (ret) {
96 return ret;
97 }
98
99 if (new_id >= limit) {
100 idr_remove(&drm_minors_idr, new_id);
101 return -EINVAL;
102 }
103 return new_id;
104}
105
Dave Airlie7c1c2872008-11-28 14:22:24 +1000106struct drm_master *drm_master_create(struct drm_minor *minor)
107{
108 struct drm_master *master;
109
110 master = drm_calloc(1, sizeof(*master), DRM_MEM_DRIVER);
111 if (!master)
112 return NULL;
113
114 kref_init(&master->refcount);
115 spin_lock_init(&master->lock.spinlock);
116 init_waitqueue_head(&master->lock.lock_queue);
117 drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER);
118 INIT_LIST_HEAD(&master->magicfree);
119 master->minor = minor;
120
121 list_add_tail(&master->head, &minor->master_list);
122
123 return master;
124}
125
126struct drm_master *drm_master_get(struct drm_master *master)
127{
128 kref_get(&master->refcount);
129 return master;
130}
131
132static void drm_master_destroy(struct kref *kref)
133{
134 struct drm_master *master = container_of(kref, struct drm_master, refcount);
135 struct drm_magic_entry *pt, *next;
136 struct drm_device *dev = master->minor->dev;
Dave Airliec1ff85d2009-01-19 17:17:58 +1000137 struct drm_map_list *r_list, *list_temp;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000138
139 list_del(&master->head);
140
141 if (dev->driver->master_destroy)
142 dev->driver->master_destroy(dev, master);
143
Dave Airliec1ff85d2009-01-19 17:17:58 +1000144 list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
145 if (r_list->master == master) {
146 drm_rmmap_locked(dev, r_list->map);
147 r_list = NULL;
148 }
149 }
150
Dave Airlie7c1c2872008-11-28 14:22:24 +1000151 if (master->unique) {
Vegard Nossum1147c9c2008-12-02 13:38:47 +1000152 drm_free(master->unique, master->unique_size, DRM_MEM_DRIVER);
Dave Airlie7c1c2872008-11-28 14:22:24 +1000153 master->unique = NULL;
154 master->unique_len = 0;
155 }
156
157 list_for_each_entry_safe(pt, next, &master->magicfree, head) {
158 list_del(&pt->head);
159 drm_ht_remove_item(&master->magiclist, &pt->hash_item);
160 drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
161 }
162
163 drm_ht_remove(&master->magiclist);
164
Dave Airlie7c1c2872008-11-28 14:22:24 +1000165 drm_free(master, sizeof(*master), DRM_MEM_DRIVER);
166}
167
168void drm_master_put(struct drm_master **master)
169{
170 kref_put(&(*master)->refcount, drm_master_destroy);
171 *master = NULL;
172}
173
174int drm_setmaster_ioctl(struct drm_device *dev, void *data,
175 struct drm_file *file_priv)
176{
Jonas Bonn6b008422009-04-16 09:00:02 +0200177 if (file_priv->is_master)
178 return 0;
179
Dave Airlie7c1c2872008-11-28 14:22:24 +1000180 if (file_priv->minor->master && file_priv->minor->master != file_priv->master)
181 return -EINVAL;
182
183 if (!file_priv->master)
184 return -EINVAL;
185
186 if (!file_priv->minor->master &&
187 file_priv->minor->master != file_priv->master) {
188 mutex_lock(&dev->struct_mutex);
189 file_priv->minor->master = drm_master_get(file_priv->master);
Jonas Bonn6b008422009-04-16 09:00:02 +0200190 file_priv->is_master = 1;
Helge Bahmann5ad8b7d2009-03-04 21:49:14 +1000191 mutex_unlock(&dev->struct_mutex);
Dave Airlie7c1c2872008-11-28 14:22:24 +1000192 }
193
194 return 0;
195}
196
197int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
198 struct drm_file *file_priv)
199{
Jonas Bonn6b008422009-04-16 09:00:02 +0200200 if (!file_priv->is_master)
Dave Airlie7c1c2872008-11-28 14:22:24 +1000201 return -EINVAL;
Jonas Bonn6b008422009-04-16 09:00:02 +0200202
Dave Airlie07f1c7a2009-04-20 09:32:50 +1000203 if (!file_priv->minor->master)
204 return -EINVAL;
205
Dave Airlie7c1c2872008-11-28 14:22:24 +1000206 mutex_lock(&dev->struct_mutex);
207 drm_master_put(&file_priv->minor->master);
Jonas Bonn6b008422009-04-16 09:00:02 +0200208 file_priv->is_master = 0;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000209 mutex_unlock(&dev->struct_mutex);
210 return 0;
211}
212
Dave Airlie84b1fd12007-07-11 15:53:27 +1000213static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000214 const struct pci_device_id *ent,
215 struct drm_driver *driver)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216{
217 int retcode;
218
Dave Airliebd1b3312007-05-26 05:01:51 +1000219 INIT_LIST_HEAD(&dev->filelist);
Dave Airlie7c158ac2007-07-11 12:05:36 +1000220 INIT_LIST_HEAD(&dev->ctxlist);
221 INIT_LIST_HEAD(&dev->vmalist);
222 INIT_LIST_HEAD(&dev->maplist);
223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 spin_lock_init(&dev->count_lock);
=?utf-8?q?Michel_D=C3=A4nzer?=bea56792006-10-24 23:04:19 +1000225 spin_lock_init(&dev->drw_lock);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000226 init_timer(&dev->timer);
Dave Airlie30e2fb12006-02-02 19:37:46 +1100227 mutex_init(&dev->struct_mutex);
228 mutex_init(&dev->ctxlist_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700229
Dave Airlie45ea5dcd2007-07-17 14:20:07 +1000230 idr_init(&dev->drw_idr);
231
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000232 dev->pdev = pdev;
Eric Anholt2f02cc32006-09-22 04:19:34 +1000233 dev->pci_device = pdev->device;
234 dev->pci_vendor = pdev->vendor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700235
236#ifdef __alpha__
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000237 dev->hose = pdev->sysdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700239
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000240 if (drm_ht_create(&dev->map_hash, 12)) {
Thomas Hellstrom8d153f72006-08-07 22:36:47 +1000241 return -ENOMEM;
242 }
Dave Airlie836cf042005-07-10 19:27:04 +1000243
Linus Torvalds1da177e2005-04-16 15:20:36 -0700244 /* the DRM has 6 basic counters */
245 dev->counters = 6;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000246 dev->types[0] = _DRM_STAT_LOCK;
247 dev->types[1] = _DRM_STAT_OPENS;
248 dev->types[2] = _DRM_STAT_CLOSES;
249 dev->types[3] = _DRM_STAT_IOCTLS;
250 dev->types[4] = _DRM_STAT_LOCKS;
251 dev->types[5] = _DRM_STAT_UNLOCKS;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252
253 dev->driver = driver;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000254
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 if (drm_core_has_AGP(dev)) {
Dave Airliecda17382005-07-10 17:31:26 +1000256 if (drm_device_is_agp(dev))
257 dev->agp = drm_agp_init(dev);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000258 if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP)
259 && (dev->agp == NULL)) {
260 DRM_ERROR("Cannot initialize the agpgart module.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700261 retcode = -EINVAL;
262 goto error_out_unreg;
263 }
264 if (drm_core_has_MTRR(dev)) {
265 if (dev->agp)
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000266 dev->agp->agp_mtrr =
267 mtrr_add(dev->agp->agp_info.aper_base,
268 dev->agp->agp_info.aper_size *
269 1024 * 1024, MTRR_TYPE_WRCOMB, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 }
271 }
272
Dave Airlie2716a022007-11-22 18:23:13 +1000273
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000274 retcode = drm_ctxbitmap_init(dev);
275 if (retcode) {
276 DRM_ERROR("Cannot allocate memory for context bitmap.\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700277 goto error_out_unreg;
278 }
279
Eric Anholt673a3942008-07-30 12:06:12 -0700280 if (driver->driver_features & DRIVER_GEM) {
281 retcode = drm_gem_init(dev);
282 if (retcode) {
283 DRM_ERROR("Cannot initialize graphics execution "
284 "manager (GEM)\n");
285 goto error_out_unreg;
286 }
287 }
288
Linus Torvalds1da177e2005-04-16 15:20:36 -0700289 return 0;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000290
291 error_out_unreg:
Dave Airlie22eae942005-11-10 22:16:34 +1100292 drm_lastclose(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 return retcode;
294}
295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297/**
298 * Get a secondary minor number.
299 *
300 * \param dev device data structure
301 * \param sec-minor structure to hold the assigned minor
302 * \return negative number on failure.
303 *
304 * Search an empty entry and initialize it to the given parameters, and
305 * create the proc init entry via proc_init(). This routines assigns
306 * minor numbers to secondary heads of multi-headed cards
307 */
Dave Airlie2c14f282008-04-21 16:47:32 +1000308static int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
Dave Airlie2c14f282008-04-21 16:47:32 +1000310 struct drm_minor *new_minor;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700311 int ret;
Dave Airlie2c14f282008-04-21 16:47:32 +1000312 int minor_id;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313
314 DRM_DEBUG("\n");
315
Dave Airlie2c14f282008-04-21 16:47:32 +1000316 minor_id = drm_minor_get_id(dev, type);
317 if (minor_id < 0)
318 return minor_id;
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000319
Dave Airlie2c14f282008-04-21 16:47:32 +1000320 new_minor = kzalloc(sizeof(struct drm_minor), GFP_KERNEL);
321 if (!new_minor) {
322 ret = -ENOMEM;
323 goto err_idr;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 }
Dave Airlie2c14f282008-04-21 16:47:32 +1000325
326 new_minor->type = type;
327 new_minor->device = MKDEV(DRM_MAJOR, minor_id);
328 new_minor->dev = dev;
329 new_minor->index = minor_id;
Dave Airlie7c1c2872008-11-28 14:22:24 +1000330 INIT_LIST_HEAD(&new_minor->master_list);
Dave Airlie2c14f282008-04-21 16:47:32 +1000331
332 idr_replace(&drm_minors_idr, new_minor, minor_id);
333
334 if (type == DRM_MINOR_LEGACY) {
335 ret = drm_proc_init(new_minor, minor_id, drm_proc_root);
336 if (ret) {
337 DRM_ERROR("DRM: Failed to initialize /proc/dri.\n");
338 goto err_mem;
339 }
340 } else
Ben Gamari955b12d2009-02-17 20:08:49 -0500341 new_minor->proc_root = NULL;
342
343#if defined(CONFIG_DEBUG_FS)
344 ret = drm_debugfs_init(new_minor, minor_id, drm_debugfs_root);
345 if (ret) {
GeunSik Lim156f5a72009-06-02 15:01:37 +0900346 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
Ben Gamari955b12d2009-02-17 20:08:49 -0500347 goto err_g2;
348 }
349#endif
Dave Airlie2c14f282008-04-21 16:47:32 +1000350
351 ret = drm_sysfs_device_add(new_minor);
352 if (ret) {
353 printk(KERN_ERR
354 "DRM: Error sysfs_device_add.\n");
355 goto err_g2;
356 }
357 *minor = new_minor;
358
359 DRM_DEBUG("new minor assigned %d\n", minor_id);
360 return 0;
361
362
363err_g2:
364 if (new_minor->type == DRM_MINOR_LEGACY)
365 drm_proc_cleanup(new_minor, drm_proc_root);
366err_mem:
367 kfree(new_minor);
368err_idr:
369 idr_remove(&drm_minors_idr, minor_id);
370 *minor = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 return ret;
372}
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000373
Dave Airliec94f7022005-07-07 21:03:38 +1000374/**
375 * Register.
376 *
377 * \param pdev - PCI device structure
378 * \param ent entry from the PCI ID table with device type flags
379 * \return zero on success or a negative number on failure.
380 *
381 * Attempt to gets inter module "drm" information. If we are first
382 * then register the character device and inter module information.
383 * Try and register, if we fail to register, backout previous work.
384 */
385int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000386 struct drm_driver *driver)
Dave Airliec94f7022005-07-07 21:03:38 +1000387{
Dave Airlie84b1fd12007-07-11 15:53:27 +1000388 struct drm_device *dev;
Dave Airliec94f7022005-07-07 21:03:38 +1000389 int ret;
390
391 DRM_DEBUG("\n");
392
393 dev = drm_calloc(1, sizeof(*dev), DRM_MEM_STUB);
394 if (!dev)
395 return -ENOMEM;
396
Jeff Garzik2c3f0ed2006-12-09 10:50:22 +1100397 ret = pci_enable_device(pdev);
398 if (ret)
399 goto err_g1;
Dave Airliec94f7022005-07-07 21:03:38 +1000400
Dave Airlie19a8f59a2008-02-07 14:48:32 +1000401 pci_set_master(pdev);
Dave Airliec94f7022005-07-07 21:03:38 +1000402 if ((ret = drm_fill_in_dev(dev, pdev, ent, driver))) {
403 printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
Jeff Garzik2c3f0ed2006-12-09 10:50:22 +1100404 goto err_g2;
Dave Airliec94f7022005-07-07 21:03:38 +1000405 }
Dave Airliebc5f4522007-11-05 12:50:58 +1000406
Dave Airlief453ba02008-11-07 14:05:41 -0800407 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
Kristian Høgsberg112b7152009-01-04 16:55:33 -0500408 pci_set_drvdata(pdev, dev);
Dave Airlief453ba02008-11-07 14:05:41 -0800409 ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL);
410 if (ret)
411 goto err_g2;
412 }
413
414 if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
415 goto err_g3;
416
417 if (dev->driver->load) {
418 ret = dev->driver->load(dev, ent->driver_data);
419 if (ret)
Ben Skeggs3788f482009-03-02 10:37:44 +1000420 goto err_g4;
Dave Airlief453ba02008-11-07 14:05:41 -0800421 }
422
423 /* setup the grouping for the legacy output */
424 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
425 ret = drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group);
426 if (ret)
Ben Skeggs3788f482009-03-02 10:37:44 +1000427 goto err_g4;
Dave Airlief453ba02008-11-07 14:05:41 -0800428 }
Dave Airliea9d51a52008-12-07 12:02:21 +1000429
Dave Airliee7f7ab42008-11-28 13:43:47 +1000430 list_add_tail(&dev->driver_item, &driver->device_list);
431
Benjamin Herrenschmidtcd00f952009-02-06 16:46:27 +1100432 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
Dave Airlie22eae942005-11-10 22:16:34 +1100433 driver->name, driver->major, driver->minor, driver->patchlevel,
Benjamin Herrenschmidtcd00f952009-02-06 16:46:27 +1100434 driver->date, pci_name(pdev), dev->primary->index);
Dave Airliec94f7022005-07-07 21:03:38 +1000435
436 return 0;
437
Ben Skeggs3788f482009-03-02 10:37:44 +1000438err_g4:
Dave Airliea9d51a52008-12-07 12:02:21 +1000439 drm_put_minor(&dev->primary);
Ben Skeggs3788f482009-03-02 10:37:44 +1000440err_g3:
441 if (drm_core_check_feature(dev, DRIVER_MODESET))
442 drm_put_minor(&dev->control);
Jeff Garzik2c3f0ed2006-12-09 10:50:22 +1100443err_g2:
444 pci_disable_device(pdev);
445err_g1:
Dave Airliec94f7022005-07-07 21:03:38 +1000446 drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
447 return ret;
448}
Kristian Høgsberg112b7152009-01-04 16:55:33 -0500449EXPORT_SYMBOL(drm_get_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450
451/**
452 * Put a secondary minor number.
453 *
454 * \param sec_minor - structure to be released
455 * \return always zero
456 *
457 * Cleans up the proc resources. Not legal for this to be the
458 * last minor released.
459 *
460 */
Dave Airlie2c14f282008-04-21 16:47:32 +1000461int drm_put_minor(struct drm_minor **minor_p)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462{
Dave Airlie2c14f282008-04-21 16:47:32 +1000463 struct drm_minor *minor = *minor_p;
Eric Anholt673a3942008-07-30 12:06:12 -0700464
Dave Airlie2c14f282008-04-21 16:47:32 +1000465 DRM_DEBUG("release secondary minor %d\n", minor->index);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000466
Dave Airlie2c14f282008-04-21 16:47:32 +1000467 if (minor->type == DRM_MINOR_LEGACY)
468 drm_proc_cleanup(minor, drm_proc_root);
Ben Gamari955b12d2009-02-17 20:08:49 -0500469#if defined(CONFIG_DEBUG_FS)
470 drm_debugfs_cleanup(minor);
471#endif
472
Dave Airlie2c14f282008-04-21 16:47:32 +1000473 drm_sysfs_device_remove(minor);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000474
Dave Airlie2c14f282008-04-21 16:47:32 +1000475 idr_remove(&drm_minors_idr, minor->index);
Dave Airlieb5e89ed2005-09-25 14:28:13 +1000476
Dave Airlie2c14f282008-04-21 16:47:32 +1000477 kfree(minor);
478 *minor_p = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 return 0;
480}
Kristian Høgsberg112b7152009-01-04 16:55:33 -0500481
482/**
483 * Called via drm_exit() at module unload time or when pci device is
484 * unplugged.
485 *
486 * Cleans up all DRM device, calling drm_lastclose().
487 *
488 * \sa drm_init
489 */
490void drm_put_dev(struct drm_device *dev)
491{
492 struct drm_driver *driver = dev->driver;
493 struct drm_map_list *r_list, *list_temp;
494
495 DRM_DEBUG("\n");
496
497 if (!dev) {
498 DRM_ERROR("cleanup called no dev\n");
499 return;
500 }
501
502 drm_vblank_cleanup(dev);
503
504 drm_lastclose(dev);
505
506 if (drm_core_has_MTRR(dev) && drm_core_has_AGP(dev) &&
507 dev->agp && dev->agp->agp_mtrr >= 0) {
508 int retval;
509 retval = mtrr_del(dev->agp->agp_mtrr,
510 dev->agp->agp_info.aper_base,
511 dev->agp->agp_info.aper_size * 1024 * 1024);
512 DRM_DEBUG("mtrr_del=%d\n", retval);
513 }
514
515 if (dev->driver->unload)
516 dev->driver->unload(dev);
517
518 if (drm_core_has_AGP(dev) && dev->agp) {
519 drm_free(dev->agp, sizeof(*dev->agp), DRM_MEM_AGPLISTS);
520 dev->agp = NULL;
521 }
522
Kristian Høgsberg112b7152009-01-04 16:55:33 -0500523 list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
524 drm_rmmap(dev, r_list->map);
Ben Skeggs30ddbd92009-03-02 11:13:04 +1000525 drm_ht_remove(&dev->map_hash);
526
527 drm_ctxbitmap_cleanup(dev);
Kristian Høgsberg112b7152009-01-04 16:55:33 -0500528
529 if (drm_core_check_feature(dev, DRIVER_MODESET))
530 drm_put_minor(&dev->control);
531
532 if (driver->driver_features & DRIVER_GEM)
533 drm_gem_destroy(dev);
534
535 drm_put_minor(&dev->primary);
536
537 if (dev->devname) {
538 drm_free(dev->devname, strlen(dev->devname) + 1,
539 DRM_MEM_DRIVER);
540 dev->devname = NULL;
541 }
542 drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
543}
544EXPORT_SYMBOL(drm_put_dev);