1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29#include <linux/debugfs.h>
30#include <linux/fs.h>
31#include <linux/module.h>
32#include <linux/moduleparam.h>
33#include <linux/mount.h>
34#include <linux/slab.h>
35#include <drm/drmP.h>
36#include <drm/drm_core.h>
37#include "drm_legacy.h"
38#include "drm_internal.h"
39
40unsigned int drm_debug = 0;
41EXPORT_SYMBOL(drm_debug);
42
43bool drm_atomic = 0;
44
45MODULE_AUTHOR(CORE_AUTHOR);
46MODULE_DESCRIPTION(CORE_DESC);
47MODULE_LICENSE("GPL and additional rights");
48MODULE_PARM_DESC(debug, "Enable debug output");
49MODULE_PARM_DESC(vblankoffdelay, "Delay until vblank irq auto-disable [msecs] (0: never disable, <0: disable immediately)");
50MODULE_PARM_DESC(timestamp_precision_usec, "Max. error on timestamps [usecs]");
51MODULE_PARM_DESC(timestamp_monotonic, "Use monotonic timestamps");
52
53module_param_named(debug, drm_debug, int, 0600);
54
55static DEFINE_SPINLOCK(drm_minor_lock);
56static struct idr drm_minors_idr;
57
58struct class *drm_class;
59static struct dentry *drm_debugfs_root;
60
61void drm_err(const char *format, ...)
62{
63 struct va_format vaf;
64 va_list args;
65
66 va_start(args, format);
67
68 vaf.fmt = format;
69 vaf.va = &args;
70
71 printk(KERN_ERR "[" DRM_NAME ":%ps] *ERROR* %pV",
72 __builtin_return_address(0), &vaf);
73
74 va_end(args);
75}
76EXPORT_SYMBOL(drm_err);
77
78void drm_ut_debug_printk(const char *function_name, const char *format, ...)
79{
80 struct va_format vaf;
81 va_list args;
82
83 va_start(args, format);
84 vaf.fmt = format;
85 vaf.va = &args;
86
87 printk(KERN_DEBUG "[" DRM_NAME ":%s] %pV", function_name, &vaf);
88
89 va_end(args);
90}
91EXPORT_SYMBOL(drm_ut_debug_printk);
92
93struct drm_master *drm_master_create(struct drm_minor *minor)
94{
95 struct drm_master *master;
96
97 master = kzalloc(sizeof(*master), GFP_KERNEL);
98 if (!master)
99 return NULL;
100
101 kref_init(&master->refcount);
102 spin_lock_init(&master->lock.spinlock);
103 init_waitqueue_head(&master->lock.lock_queue);
104 idr_init(&master->magic_map);
105 master->minor = minor;
106
107 return master;
108}
109
110struct drm_master *drm_master_get(struct drm_master *master)
111{
112 kref_get(&master->refcount);
113 return master;
114}
115EXPORT_SYMBOL(drm_master_get);
116
117static void drm_master_destroy(struct kref *kref)
118{
119 struct drm_master *master = container_of(kref, struct drm_master, refcount);
120 struct drm_device *dev = master->minor->dev;
121 struct drm_map_list *r_list, *list_temp;
122
123 mutex_lock(&dev->struct_mutex);
124 if (dev->driver->master_destroy)
125 dev->driver->master_destroy(dev, master);
126
127 list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head) {
128 if (r_list->master == master) {
129 drm_legacy_rmmap_locked(dev, r_list->map);
130 r_list = NULL;
131 }
132 }
133 mutex_unlock(&dev->struct_mutex);
134
135 idr_destroy(&master->magic_map);
136 kfree(master->unique);
137 kfree(master);
138}
139
140void drm_master_put(struct drm_master **master)
141{
142 kref_put(&(*master)->refcount, drm_master_destroy);
143 *master = NULL;
144}
145EXPORT_SYMBOL(drm_master_put);
146
147int drm_setmaster_ioctl(struct drm_device *dev, void *data,
148 struct drm_file *file_priv)
149{
150 int ret = 0;
151
152 mutex_lock(&dev->master_mutex);
153 if (file_priv->is_master)
154 goto out_unlock;
155
156 if (file_priv->minor->master) {
157 ret = -EINVAL;
158 goto out_unlock;
159 }
160
161 if (!file_priv->master) {
162 ret = -EINVAL;
163 goto out_unlock;
164 }
165
166 file_priv->minor->master = drm_master_get(file_priv->master);
167 file_priv->is_master = 1;
168 if (dev->driver->master_set) {
169 ret = dev->driver->master_set(dev, file_priv, false);
170 if (unlikely(ret != 0)) {
171 file_priv->is_master = 0;
172 drm_master_put(&file_priv->minor->master);
173 }
174 }
175
176out_unlock:
177 mutex_unlock(&dev->master_mutex);
178 return ret;
179}
180
181int drm_dropmaster_ioctl(struct drm_device *dev, void *data,
182 struct drm_file *file_priv)
183{
184 int ret = -EINVAL;
185
186 mutex_lock(&dev->master_mutex);
187 if (!file_priv->is_master)
188 goto out_unlock;
189
190 if (!file_priv->minor->master)
191 goto out_unlock;
192
193 ret = 0;
194 if (dev->driver->master_drop)
195 dev->driver->master_drop(dev, file_priv, false);
196 drm_master_put(&file_priv->minor->master);
197 file_priv->is_master = 0;
198
199out_unlock:
200 mutex_unlock(&dev->master_mutex);
201 return ret;
202}
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
218 unsigned int type)
219{
220 switch (type) {
221 case DRM_MINOR_LEGACY:
222 return &dev->primary;
223 case DRM_MINOR_RENDER:
224 return &dev->render;
225 case DRM_MINOR_CONTROL:
226 return &dev->control;
227 default:
228 return NULL;
229 }
230}
231
232static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
233{
234 struct drm_minor *minor;
235 unsigned long flags;
236 int r;
237
238 minor = kzalloc(sizeof(*minor), GFP_KERNEL);
239 if (!minor)
240 return -ENOMEM;
241
242 minor->type = type;
243 minor->dev = dev;
244
245 idr_preload(GFP_KERNEL);
246 spin_lock_irqsave(&drm_minor_lock, flags);
247 r = idr_alloc(&drm_minors_idr,
248 NULL,
249 64 * type,
250 64 * (type + 1),
251 GFP_NOWAIT);
252 spin_unlock_irqrestore(&drm_minor_lock, flags);
253 idr_preload_end();
254
255 if (r < 0)
256 goto err_free;
257
258 minor->index = r;
259
260 minor->kdev = drm_sysfs_minor_alloc(minor);
261 if (IS_ERR(minor->kdev)) {
262 r = PTR_ERR(minor->kdev);
263 goto err_index;
264 }
265
266 *drm_minor_get_slot(dev, type) = minor;
267 return 0;
268
269err_index:
270 spin_lock_irqsave(&drm_minor_lock, flags);
271 idr_remove(&drm_minors_idr, minor->index);
272 spin_unlock_irqrestore(&drm_minor_lock, flags);
273err_free:
274 kfree(minor);
275 return r;
276}
277
278static void drm_minor_free(struct drm_device *dev, unsigned int type)
279{
280 struct drm_minor **slot, *minor;
281 unsigned long flags;
282
283 slot = drm_minor_get_slot(dev, type);
284 minor = *slot;
285 if (!minor)
286 return;
287
288 put_device(minor->kdev);
289
290 spin_lock_irqsave(&drm_minor_lock, flags);
291 idr_remove(&drm_minors_idr, minor->index);
292 spin_unlock_irqrestore(&drm_minor_lock, flags);
293
294 kfree(minor);
295 *slot = NULL;
296}
297
298static int drm_minor_register(struct drm_device *dev, unsigned int type)
299{
300 struct drm_minor *minor;
301 unsigned long flags;
302 int ret;
303
304 DRM_DEBUG("\n");
305
306 minor = *drm_minor_get_slot(dev, type);
307 if (!minor)
308 return 0;
309
310 ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
311 if (ret) {
312 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
313 return ret;
314 }
315
316 ret = device_add(minor->kdev);
317 if (ret)
318 goto err_debugfs;
319
320
321 spin_lock_irqsave(&drm_minor_lock, flags);
322 idr_replace(&drm_minors_idr, minor, minor->index);
323 spin_unlock_irqrestore(&drm_minor_lock, flags);
324
325 DRM_DEBUG("new minor registered %d\n", minor->index);
326 return 0;
327
328err_debugfs:
329 drm_debugfs_cleanup(minor);
330 return ret;
331}
332
333static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
334{
335 struct drm_minor *minor;
336 unsigned long flags;
337
338 minor = *drm_minor_get_slot(dev, type);
339 if (!minor || !device_is_registered(minor->kdev))
340 return;
341
342
343 spin_lock_irqsave(&drm_minor_lock, flags);
344 idr_replace(&drm_minors_idr, NULL, minor->index);
345 spin_unlock_irqrestore(&drm_minor_lock, flags);
346
347 device_del(minor->kdev);
348 dev_set_drvdata(minor->kdev, NULL);
349 drm_debugfs_cleanup(minor);
350}
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368struct drm_minor *drm_minor_acquire(unsigned int minor_id)
369{
370 struct drm_minor *minor;
371 unsigned long flags;
372
373 spin_lock_irqsave(&drm_minor_lock, flags);
374 minor = idr_find(&drm_minors_idr, minor_id);
375 if (minor)
376 drm_dev_ref(minor->dev);
377 spin_unlock_irqrestore(&drm_minor_lock, flags);
378
379 if (!minor) {
380 return ERR_PTR(-ENODEV);
381 } else if (drm_device_is_unplugged(minor->dev)) {
382 drm_dev_unref(minor->dev);
383 return ERR_PTR(-ENODEV);
384 }
385
386 return minor;
387}
388
389
390
391
392
393
394
395void drm_minor_release(struct drm_minor *minor)
396{
397 drm_dev_unref(minor->dev);
398}
399
400
401
402
403
404
405
406
407
408
409
410
411void drm_put_dev(struct drm_device *dev)
412{
413 DRM_DEBUG("\n");
414
415 if (!dev) {
416 DRM_ERROR("cleanup called no dev\n");
417 return;
418 }
419
420 drm_dev_unregister(dev);
421 drm_dev_unref(dev);
422}
423EXPORT_SYMBOL(drm_put_dev);
424
425void drm_unplug_dev(struct drm_device *dev)
426{
427
428 drm_minor_unregister(dev, DRM_MINOR_LEGACY);
429 drm_minor_unregister(dev, DRM_MINOR_RENDER);
430 drm_minor_unregister(dev, DRM_MINOR_CONTROL);
431
432 mutex_lock(&drm_global_mutex);
433
434 drm_device_set_unplugged(dev);
435
436 if (dev->open_count == 0) {
437 drm_put_dev(dev);
438 }
439 mutex_unlock(&drm_global_mutex);
440}
441EXPORT_SYMBOL(drm_unplug_dev);
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461static int drm_fs_cnt;
462static struct vfsmount *drm_fs_mnt;
463
464static const struct dentry_operations drm_fs_dops = {
465 .d_dname = simple_dname,
466};
467
468static const struct super_operations drm_fs_sops = {
469 .statfs = simple_statfs,
470};
471
472static struct dentry *drm_fs_mount(struct file_system_type *fs_type, int flags,
473 const char *dev_name, void *data)
474{
475 return mount_pseudo(fs_type,
476 "drm:",
477 &drm_fs_sops,
478 &drm_fs_dops,
479 0x010203ff);
480}
481
482static struct file_system_type drm_fs_type = {
483 .name = "drm",
484 .owner = THIS_MODULE,
485 .mount = drm_fs_mount,
486 .kill_sb = kill_anon_super,
487};
488
489static struct inode *drm_fs_inode_new(void)
490{
491 struct inode *inode;
492 int r;
493
494 r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);
495 if (r < 0) {
496 DRM_ERROR("Cannot mount pseudo fs: %d\n", r);
497 return ERR_PTR(r);
498 }
499
500 inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);
501 if (IS_ERR(inode))
502 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
503
504 return inode;
505}
506
507static void drm_fs_inode_free(struct inode *inode)
508{
509 if (inode) {
510 iput(inode);
511 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
512 }
513}
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532struct drm_device *drm_dev_alloc(struct drm_driver *driver,
533 struct device *parent)
534{
535 struct drm_device *dev;
536 int ret;
537
538 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
539 if (!dev)
540 return NULL;
541
542 kref_init(&dev->ref);
543 dev->dev = parent;
544 dev->driver = driver;
545
546 INIT_LIST_HEAD(&dev->filelist);
547 INIT_LIST_HEAD(&dev->ctxlist);
548 INIT_LIST_HEAD(&dev->vmalist);
549 INIT_LIST_HEAD(&dev->maplist);
550 INIT_LIST_HEAD(&dev->vblank_event_list);
551
552 spin_lock_init(&dev->buf_lock);
553 spin_lock_init(&dev->event_lock);
554 mutex_init(&dev->struct_mutex);
555 mutex_init(&dev->ctxlist_mutex);
556 mutex_init(&dev->master_mutex);
557
558 dev->anon_inode = drm_fs_inode_new();
559 if (IS_ERR(dev->anon_inode)) {
560 ret = PTR_ERR(dev->anon_inode);
561 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);
562 goto err_free;
563 }
564
565 if (drm_core_check_feature(dev, DRIVER_MODESET)) {
566 ret = drm_minor_alloc(dev, DRM_MINOR_CONTROL);
567 if (ret)
568 goto err_minors;
569 }
570
571 if (drm_core_check_feature(dev, DRIVER_RENDER)) {
572 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
573 if (ret)
574 goto err_minors;
575 }
576
577 ret = drm_minor_alloc(dev, DRM_MINOR_LEGACY);
578 if (ret)
579 goto err_minors;
580
581 if (drm_ht_create(&dev->map_hash, 12))
582 goto err_minors;
583
584 drm_legacy_ctxbitmap_init(dev);
585
586 if (drm_core_check_feature(dev, DRIVER_GEM)) {
587 ret = drm_gem_init(dev);
588 if (ret) {
589 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
590 goto err_ctxbitmap;
591 }
592 }
593
594 return dev;
595
596err_ctxbitmap:
597 drm_legacy_ctxbitmap_cleanup(dev);
598 drm_ht_remove(&dev->map_hash);
599err_minors:
600 drm_minor_free(dev, DRM_MINOR_LEGACY);
601 drm_minor_free(dev, DRM_MINOR_RENDER);
602 drm_minor_free(dev, DRM_MINOR_CONTROL);
603 drm_fs_inode_free(dev->anon_inode);
604err_free:
605 mutex_destroy(&dev->master_mutex);
606 kfree(dev);
607 return NULL;
608}
609EXPORT_SYMBOL(drm_dev_alloc);
610
611static void drm_dev_release(struct kref *ref)
612{
613 struct drm_device *dev = container_of(ref, struct drm_device, ref);
614
615 if (drm_core_check_feature(dev, DRIVER_GEM))
616 drm_gem_destroy(dev);
617
618 drm_legacy_ctxbitmap_cleanup(dev);
619 drm_ht_remove(&dev->map_hash);
620 drm_fs_inode_free(dev->anon_inode);
621
622 drm_minor_free(dev, DRM_MINOR_LEGACY);
623 drm_minor_free(dev, DRM_MINOR_RENDER);
624 drm_minor_free(dev, DRM_MINOR_CONTROL);
625
626 mutex_destroy(&dev->master_mutex);
627 kfree(dev->unique);
628 kfree(dev);
629}
630
631
632
633
634
635
636
637
638
639
640
641
642
643void drm_dev_ref(struct drm_device *dev)
644{
645 if (dev)
646 kref_get(&dev->ref);
647}
648EXPORT_SYMBOL(drm_dev_ref);
649
650
651
652
653
654
655
656
657void drm_dev_unref(struct drm_device *dev)
658{
659 if (dev)
660 kref_put(&dev->ref, drm_dev_release);
661}
662EXPORT_SYMBOL(drm_dev_unref);
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678int drm_dev_register(struct drm_device *dev, unsigned long flags)
679{
680 int ret;
681
682 mutex_lock(&drm_global_mutex);
683
684 ret = drm_minor_register(dev, DRM_MINOR_CONTROL);
685 if (ret)
686 goto err_minors;
687
688 ret = drm_minor_register(dev, DRM_MINOR_RENDER);
689 if (ret)
690 goto err_minors;
691
692 ret = drm_minor_register(dev, DRM_MINOR_LEGACY);
693 if (ret)
694 goto err_minors;
695
696 if (dev->driver->load) {
697 ret = dev->driver->load(dev, flags);
698 if (ret)
699 goto err_minors;
700 }
701
702 ret = 0;
703 goto out_unlock;
704
705err_minors:
706 drm_minor_unregister(dev, DRM_MINOR_LEGACY);
707 drm_minor_unregister(dev, DRM_MINOR_RENDER);
708 drm_minor_unregister(dev, DRM_MINOR_CONTROL);
709out_unlock:
710 mutex_unlock(&drm_global_mutex);
711 return ret;
712}
713EXPORT_SYMBOL(drm_dev_register);
714
715
716
717
718
719
720
721
722
723void drm_dev_unregister(struct drm_device *dev)
724{
725 struct drm_map_list *r_list, *list_temp;
726
727 drm_lastclose(dev);
728
729 if (dev->driver->unload)
730 dev->driver->unload(dev);
731
732 if (dev->agp)
733 drm_pci_agp_destroy(dev);
734
735 drm_vblank_cleanup(dev);
736
737 list_for_each_entry_safe(r_list, list_temp, &dev->maplist, head)
738 drm_legacy_rmmap(dev, r_list->map);
739
740 drm_minor_unregister(dev, DRM_MINOR_LEGACY);
741 drm_minor_unregister(dev, DRM_MINOR_RENDER);
742 drm_minor_unregister(dev, DRM_MINOR_CONTROL);
743}
744EXPORT_SYMBOL(drm_dev_unregister);
745
746
747
748
749
750
751
752
753
754
755
756
757int drm_dev_set_unique(struct drm_device *dev, const char *fmt, ...)
758{
759 va_list ap;
760
761 kfree(dev->unique);
762
763 va_start(ap, fmt);
764 dev->unique = kvasprintf(GFP_KERNEL, fmt, ap);
765 va_end(ap);
766
767 return dev->unique ? 0 : -ENOMEM;
768}
769EXPORT_SYMBOL(drm_dev_set_unique);
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791static int drm_stub_open(struct inode *inode, struct file *filp)
792{
793 const struct file_operations *new_fops;
794 struct drm_minor *minor;
795 int err;
796
797 DRM_DEBUG("\n");
798
799 mutex_lock(&drm_global_mutex);
800 minor = drm_minor_acquire(iminor(inode));
801 if (IS_ERR(minor)) {
802 err = PTR_ERR(minor);
803 goto out_unlock;
804 }
805
806 new_fops = fops_get(minor->dev->driver->fops);
807 if (!new_fops) {
808 err = -ENODEV;
809 goto out_release;
810 }
811
812 replace_fops(filp, new_fops);
813 if (filp->f_op->open)
814 err = filp->f_op->open(inode, filp);
815 else
816 err = 0;
817
818out_release:
819 drm_minor_release(minor);
820out_unlock:
821 mutex_unlock(&drm_global_mutex);
822 return err;
823}
824
825static const struct file_operations drm_stub_fops = {
826 .owner = THIS_MODULE,
827 .open = drm_stub_open,
828 .llseek = noop_llseek,
829};
830
831static int __init drm_core_init(void)
832{
833 int ret = -ENOMEM;
834
835 drm_global_init();
836 drm_connector_ida_init();
837 idr_init(&drm_minors_idr);
838
839 if (register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops))
840 goto err_p1;
841
842 drm_class = drm_sysfs_create(THIS_MODULE, "drm");
843 if (IS_ERR(drm_class)) {
844 printk(KERN_ERR "DRM: Error creating drm class.\n");
845 ret = PTR_ERR(drm_class);
846 goto err_p2;
847 }
848
849 drm_debugfs_root = debugfs_create_dir("dri", NULL);
850 if (!drm_debugfs_root) {
851 DRM_ERROR("Cannot create /sys/kernel/debug/dri\n");
852 ret = -1;
853 goto err_p3;
854 }
855
856 DRM_INFO("Initialized %s %d.%d.%d %s\n",
857 CORE_NAME, CORE_MAJOR, CORE_MINOR, CORE_PATCHLEVEL, CORE_DATE);
858 return 0;
859err_p3:
860 drm_sysfs_destroy();
861err_p2:
862 unregister_chrdev(DRM_MAJOR, "drm");
863
864 idr_destroy(&drm_minors_idr);
865err_p1:
866 return ret;
867}
868
869static void __exit drm_core_exit(void)
870{
871 debugfs_remove(drm_debugfs_root);
872 drm_sysfs_destroy();
873
874 unregister_chrdev(DRM_MAJOR, "drm");
875
876 drm_connector_ida_destroy();
877 idr_destroy(&drm_minors_idr);
878}
879
880module_init(drm_core_init);
881module_exit(drm_core_exit);
882