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>
36 #include "drmP.h"
37 #include "drm_core.h"
38
39 unsigned int drm_debug = 0; /* 1 to enable debug output */
40 EXPORT_SYMBOL(drm_debug);
41
42 MODULE_AUTHOR(CORE_AUTHOR);
43 MODULE_DESCRIPTION(CORE_DESC);
44 MODULE_LICENSE("GPL and additional rights");
45 MODULE_PARM_DESC(debug, "Enable debug output");
46
47 module_param_named(debug, drm_debug, int, 0600);
48
49 struct idr drm_minors_idr;
50
51 struct class *drm_class;
52 struct proc_dir_entry *drm_proc_root;
53
drm_minor_get_id(struct drm_device * dev,int type)54 static int drm_minor_get_id(struct drm_device *dev, int type)
55 {
56 int new_id;
57 int ret;
58 int base = 0, limit = 63;
59
60 if (type == DRM_MINOR_CONTROL) {
61 base += 64;
62 limit = base + 127;
63 } else if (type == DRM_MINOR_RENDER) {
64 base += 128;
65 limit = base + 255;
66 }
67
68 again:
69 if (idr_pre_get(&drm_minors_idr, GFP_KERNEL) == 0) {
70 DRM_ERROR("Out of memory expanding drawable idr\n");
71 return -ENOMEM;
72 }
73 mutex_lock(&dev->struct_mutex);
74 ret = idr_get_new_above(&drm_minors_idr, NULL,
75 base, &new_id);
76 mutex_unlock(&dev->struct_mutex);
77 if (ret == -EAGAIN) {
78 goto again;
79 } else if (ret) {
80 return ret;
81 }
82
83 if (new_id >= limit) {
84 idr_remove(&drm_minors_idr, new_id);
85 return -EINVAL;
86 }
87 return new_id;
88 }
89
drm_master_create(struct drm_minor * minor)90 struct drm_master *drm_master_create(struct drm_minor *minor)
91 {
92 struct drm_master *master;
93
94 master = drm_calloc(1, sizeof(*master), DRM_MEM_DRIVER);
95 if (!master)
96 return NULL;
97
98 kref_init(&master->refcount);
99 spin_lock_init(&master->lock.spinlock);
100 init_waitqueue_head(&master->lock.lock_queue);
101 drm_ht_create(&master->magiclist, DRM_MAGIC_HASH_ORDER);
102 INIT_LIST_HEAD(&master->magicfree);
103 master->minor = minor;
104
105 list_add_tail(&master->head, &minor->master_list);
106
107 return master;
108 }
109
drm_master_get(struct drm_master * master)110 struct drm_master *drm_master_get(struct drm_master *master)
111 {
112 kref_get(&master->refcount);
113 return master;
114 }
115
drm_master_destroy(struct kref * kref)116 static void drm_master_destroy(struct kref *kref)
117 {
118 struct drm_master *master = container_of(kref, struct drm_master, refcount);
119 struct drm_magic_entry *pt, *next;
120 struct drm_device *dev = master->minor->dev;
121 struct drm_map_list *r_list, *list_temp;
122
123 list_del(&master->head);
124
125 if (dev->driver->master_destroy)
126 dev->driver->master_destroy(dev, master);
127
128 list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
129 if (r_list->master == master) {
130 drm_rmmap_locked(dev, r_list->map);
131 r_list = NULL;
132 }
133 }
134
135 if (master->unique) {
136 drm_free(master->unique, master->unique_size, DRM_MEM_DRIVER);
137 master->unique = NULL;
138 master->unique_len = 0;
139 }
140
141 list_for_each_entry_safe(pt, next, &master->magicfree, head) {
142 list_del(&pt->head);
143 drm_ht_remove_item(&master->magiclist, &pt->hash_item);
144 drm_free(pt, sizeof(*pt), DRM_MEM_MAGIC);
145 }
146
147 drm_ht_remove(&master->magiclist);
148
149 drm_free(master, sizeof(*master), DRM_MEM_DRIVER);
150 }
151
drm_master_put(struct drm_master ** master)152 void drm_master_put(struct drm_master **master)
153 {
154 kref_put(&(*master)->refcount, drm_master_destroy);
155 *master = NULL;
156 }
157
drm_setmaster_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)158 int drm_setmaster_ioctl(struct drm_device *dev, void *data,
159 struct drm_file *file_priv)
160 {
161 if (file_priv->minor->master && file_priv->minor->master != file_priv->master)
162 return -EINVAL;
163
164 if (!file_priv->master)
165 return -EINVAL;
166
167 if (!file_priv->minor->master &&
168 file_priv->minor->master != file_priv->master) {
169 mutex_lock(&dev->struct_mutex);
170 file_priv->minor->master = drm_master_get(file_priv->master);
171 mutex_unlock(&dev->struct_mutex);
172 }
173
174 return 0;
175 }
176
drm_dropmaster_ioctl(struct drm_device * dev,void * data,struct drm_file * file_priv)177 int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
178 struct drm_file *file_priv)
179 {
180 if (!file_priv->master)
181 return -EINVAL;
182 mutex_lock(&dev->struct_mutex);
183 drm_master_put(&file_priv->minor->master);
184 mutex_unlock(&dev->struct_mutex);
185 return 0;
186 }
187
drm_fill_in_dev(struct drm_device * dev,struct pci_dev * pdev,const struct pci_device_id * ent,struct drm_driver * driver)188 static int drm_fill_in_dev(struct drm_device * dev, struct pci_dev *pdev,
189 const struct pci_device_id *ent,
190 struct drm_driver *driver)
191 {
192 int retcode;
193
194 INIT_LIST_HEAD(&dev->filelist);
195 INIT_LIST_HEAD(&dev->ctxlist);
196 INIT_LIST_HEAD(&dev->vmalist);
197 INIT_LIST_HEAD(&dev->maplist);
198
199 spin_lock_init(&dev->count_lock);
200 spin_lock_init(&dev->drw_lock);
201 init_timer(&dev->timer);
202 mutex_init(&dev->struct_mutex);
203 mutex_init(&dev->ctxlist_mutex);
204
205 idr_init(&dev->drw_idr);
206
207 dev->pdev = pdev;
208 dev->pci_device = pdev->device;
209 dev->pci_vendor = pdev->vendor;
210
211 #ifdef __alpha__
212 dev->hose = pdev->sysdata;
213 #endif
214
215 if (drm_ht_create(&dev->map_hash, 12)) {
216 return -ENOMEM;
217 }
218
219 /* the DRM has 6 basic counters */
220 dev->counters = 6;
221 dev->types[0] = _DRM_STAT_LOCK;
222 dev->types[1] = _DRM_STAT_OPENS;
223 dev->types[2] = _DRM_STAT_CLOSES;
224 dev->types[3] = _DRM_STAT_IOCTLS;
225 dev->types[4] = _DRM_STAT_LOCKS;
226 dev->types[5] = _DRM_STAT_UNLOCKS;
227
228 dev->driver = driver;
229
230 if (drm_core_has_AGP(dev)) {
231 if (drm_device_is_agp(dev))
232 dev->agp = drm_agp_init(dev);
233 if (drm_core_check_feature(dev, DRIVER_REQUIRE_AGP)
234 && (dev->agp == NULL)) {
235 DRM_ERROR("Cannot initialize the agpgart module.\n");
236 retcode = -EINVAL;
237 goto error_out_unreg;
238 }
239 if (drm_core_has_MTRR(dev)) {
240 if (dev->agp)
241 dev->agp->agp_mtrr =
242 mtrr_add(dev->agp->agp_info.aper_base,
243 dev->agp->agp_info.aper_size *
244 1024 * 1024, MTRR_TYPE_WRCOMB, 1);
245 }
246 }
247
248
249 retcode = drm_ctxbitmap_init(dev);
250 if (retcode) {
251 DRM_ERROR("Cannot allocate memory for context bitmap.\n");
252 goto error_out_unreg;
253 }
254
255 if (driver->driver_features & DRIVER_GEM) {
256 retcode = drm_gem_init(dev);
257 if (retcode) {
258 DRM_ERROR("Cannot initialize graphics execution "
259 "manager (GEM)\n");
260 goto error_out_unreg;
261 }
262 }
263
264 return 0;
265
266 error_out_unreg:
267 drm_lastclose(dev);
268 return retcode;
269 }
270
271
272 /**
273 * Get a secondary minor number.
274 *
275 * \param dev device data structure
276 * \param sec-minor structure to hold the assigned minor
277 * \return negative number on failure.
278 *
279 * Search an empty entry and initialize it to the given parameters, and
280 * create the proc init entry via proc_init(). This routines assigns
281 * minor numbers to secondary heads of multi-headed cards
282 */
drm_get_minor(struct drm_device * dev,struct drm_minor ** minor,int type)283 static int drm_get_minor(struct drm_device *dev, struct drm_minor **minor, int type)
284 {
285 struct drm_minor *new_minor;
286 int ret;
287 int minor_id;
288
289 DRM_DEBUG("\n");
290
291 minor_id = drm_minor_get_id(dev, type);
292 if (minor_id < 0)
293 return minor_id;
294
295 new_minor = kzalloc(sizeof(struct drm_minor), GFP_KERNEL);
296 if (!new_minor) {
297 ret = -ENOMEM;
298 goto err_idr;
299 }
300
301 new_minor->type = type;
302 new_minor->device = MKDEV(DRM_MAJOR, minor_id);
303 new_minor->dev = dev;
304 new_minor->index = minor_id;
305 INIT_LIST_HEAD(&new_minor->master_list);
306
307 idr_replace(&drm_minors_idr, new_minor, minor_id);
308
309 if (type == DRM_MINOR_LEGACY) {
310 ret = drm_proc_init(new_minor, minor_id, drm_proc_root);
311 if (ret) {
312 DRM_ERROR("DRM: Failed to initialize /proc/dri.\n");
313 goto err_mem;
314 }
315 } else
316 new_minor->dev_root = NULL;
317
318 ret = drm_sysfs_device_add(new_minor);
319 if (ret) {
320 printk(KERN_ERR
321 "DRM: Error sysfs_device_add.\n");
322 goto err_g2;
323 }
324 *minor = new_minor;
325
326 DRM_DEBUG("new minor assigned %d\n", minor_id);
327 return 0;
328
329
330 err_g2:
331 if (new_minor->type == DRM_MINOR_LEGACY)
332 drm_proc_cleanup(new_minor, drm_proc_root);
333 err_mem:
334 kfree(new_minor);
335 err_idr:
336 idr_remove(&drm_minors_idr, minor_id);
337 *minor = NULL;
338 return ret;
339 }
340
341 /**
342 * Register.
343 *
344 * \param pdev - PCI device structure
345 * \param ent entry from the PCI ID table with device type flags
346 * \return zero on success or a negative number on failure.
347 *
348 * Attempt to gets inter module "drm" information. If we are first
349 * then register the character device and inter module information.
350 * Try and register, if we fail to register, backout previous work.
351 */
drm_get_dev(struct pci_dev * pdev,const struct pci_device_id * ent,struct drm_driver * driver)352 int drm_get_dev(struct pci_dev *pdev, const struct pci_device_id *ent,
353 struct drm_driver *driver)
354 {
355 struct drm_device *dev;
356 int ret;
357
358 DRM_DEBUG("\n");
359
360 dev = drm_calloc(1, sizeof(*dev), DRM_MEM_STUB);
361 if (!dev)
362 return -ENOMEM;
363
364 ret = pci_enable_device(pdev);
365 if (ret)
366 goto err_g1;
367
368 pci_set_master(pdev);
369 if ((ret = drm_fill_in_dev(dev, pdev, ent, driver))) {
370 printk(KERN_ERR "DRM: Fill_in_dev failed.\n");
371 goto err_g2;
372 }
373
374 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
375 ret = drm_get_minor(dev, &dev->control, DRM_MINOR_CONTROL);
376 if (ret)
377 goto err_g2;
378 }
379
380 if ((ret = drm_get_minor(dev, &dev->primary, DRM_MINOR_LEGACY)))
381 goto err_g3;
382
383 if (dev->driver->load) {
384 ret = dev->driver->load(dev, ent->driver_data);
385 if (ret)
386 goto err_g3;
387 }
388
389 /* setup the grouping for the legacy output */
390 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
391 ret = drm_mode_group_init_legacy_group(dev, &dev->primary->mode_group);
392 if (ret)
393 goto err_g3;
394 }
395
396 list_add_tail(&dev->driver_item, &driver->device_list);
397
398 DRM_INFO("Initialized %s %d.%d.%d %s on minor %d\n",
399 driver->name, driver->major, driver->minor, driver->patchlevel,
400 driver->date, dev->primary->index);
401
402 return 0;
403
404 err_g3:
405 drm_put_minor(&dev->primary);
406 err_g2:
407 pci_disable_device(pdev);
408 err_g1:
409 drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
410 return ret;
411 }
412
413 /**
414 * Put a device minor number.
415 *
416 * \param dev device data structure
417 * \return always zero
418 *
419 * Cleans up the proc resources. If it is the last minor then release the foreign
420 * "drm" data, otherwise unregisters the "drm" data, frees the dev list and
421 * unregisters the character device.
422 */
drm_put_dev(struct drm_device * dev)423 int drm_put_dev(struct drm_device * dev)
424 {
425 DRM_DEBUG("release primary %s\n", dev->driver->pci_driver.name);
426
427 if (dev->devname) {
428 drm_free(dev->devname, strlen(dev->devname) + 1,
429 DRM_MEM_DRIVER);
430 dev->devname = NULL;
431 }
432 drm_free(dev, sizeof(*dev), DRM_MEM_STUB);
433 return 0;
434 }
435
436 /**
437 * Put a secondary minor number.
438 *
439 * \param sec_minor - structure to be released
440 * \return always zero
441 *
442 * Cleans up the proc resources. Not legal for this to be the
443 * last minor released.
444 *
445 */
drm_put_minor(struct drm_minor ** minor_p)446 int drm_put_minor(struct drm_minor **minor_p)
447 {
448 struct drm_minor *minor = *minor_p;
449
450 DRM_DEBUG("release secondary minor %d\n", minor->index);
451
452 if (minor->type == DRM_MINOR_LEGACY)
453 drm_proc_cleanup(minor, drm_proc_root);
454 drm_sysfs_device_remove(minor);
455
456 idr_remove(&drm_minors_idr, minor->index);
457
458 kfree(minor);
459 *minor_p = NULL;
460 return 0;
461 }
462