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/pseudo_fs.h>
35#include <linux/slab.h>
36#include <linux/srcu.h>
37
38#include <drm/drm_client.h>
39#include <drm/drm_color_mgmt.h>
40#include <drm/drm_drv.h>
41#include <drm/drm_file.h>
42#include <drm/drm_mode_object.h>
43#include <drm/drm_print.h>
44
45#include "drm_crtc_internal.h"
46#include "drm_internal.h"
47#include "drm_legacy.h"
48
49
50
51
52
53unsigned int drm_debug = 0;
54EXPORT_SYMBOL(drm_debug);
55
56MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");
57MODULE_DESCRIPTION("DRM shared core routines");
58MODULE_LICENSE("GPL and additional rights");
59MODULE_PARM_DESC(debug, "Enable debug output, where each bit enables a debug category.\n"
60"\t\tBit 0 (0x01) will enable CORE messages (drm core code)\n"
61"\t\tBit 1 (0x02) will enable DRIVER messages (drm controller code)\n"
62"\t\tBit 2 (0x04) will enable KMS messages (modesetting code)\n"
63"\t\tBit 3 (0x08) will enable PRIME messages (prime code)\n"
64"\t\tBit 4 (0x10) will enable ATOMIC messages (atomic code)\n"
65"\t\tBit 5 (0x20) will enable VBL messages (vblank code)\n"
66"\t\tBit 7 (0x80) will enable LEASE messages (leasing code)\n"
67"\t\tBit 8 (0x100) will enable DP messages (displayport code)");
68module_param_named(debug, drm_debug, int, 0600);
69
70static DEFINE_SPINLOCK(drm_minor_lock);
71static struct idr drm_minors_idr;
72
73
74
75
76
77
78
79
80static bool drm_core_init_complete = false;
81
82static struct dentry *drm_debugfs_root;
83
84DEFINE_STATIC_SRCU(drm_unplug_srcu);
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
100 unsigned int type)
101{
102 switch (type) {
103 case DRM_MINOR_PRIMARY:
104 return &dev->primary;
105 case DRM_MINOR_RENDER:
106 return &dev->render;
107 default:
108 BUG();
109 }
110}
111
112static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
113{
114 struct drm_minor *minor;
115 unsigned long flags;
116 int r;
117
118 minor = kzalloc(sizeof(*minor), GFP_KERNEL);
119 if (!minor)
120 return -ENOMEM;
121
122 minor->type = type;
123 minor->dev = dev;
124
125 idr_preload(GFP_KERNEL);
126 spin_lock_irqsave(&drm_minor_lock, flags);
127 r = idr_alloc(&drm_minors_idr,
128 NULL,
129 64 * type,
130 64 * (type + 1),
131 GFP_NOWAIT);
132 spin_unlock_irqrestore(&drm_minor_lock, flags);
133 idr_preload_end();
134
135 if (r < 0)
136 goto err_free;
137
138 minor->index = r;
139
140 minor->kdev = drm_sysfs_minor_alloc(minor);
141 if (IS_ERR(minor->kdev)) {
142 r = PTR_ERR(minor->kdev);
143 goto err_index;
144 }
145
146 *drm_minor_get_slot(dev, type) = minor;
147 return 0;
148
149err_index:
150 spin_lock_irqsave(&drm_minor_lock, flags);
151 idr_remove(&drm_minors_idr, minor->index);
152 spin_unlock_irqrestore(&drm_minor_lock, flags);
153err_free:
154 kfree(minor);
155 return r;
156}
157
158static void drm_minor_free(struct drm_device *dev, unsigned int type)
159{
160 struct drm_minor **slot, *minor;
161 unsigned long flags;
162
163 slot = drm_minor_get_slot(dev, type);
164 minor = *slot;
165 if (!minor)
166 return;
167
168 put_device(minor->kdev);
169
170 spin_lock_irqsave(&drm_minor_lock, flags);
171 idr_remove(&drm_minors_idr, minor->index);
172 spin_unlock_irqrestore(&drm_minor_lock, flags);
173
174 kfree(minor);
175 *slot = NULL;
176}
177
178static int drm_minor_register(struct drm_device *dev, unsigned int type)
179{
180 struct drm_minor *minor;
181 unsigned long flags;
182 int ret;
183
184 DRM_DEBUG("\n");
185
186 minor = *drm_minor_get_slot(dev, type);
187 if (!minor)
188 return 0;
189
190 ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
191 if (ret) {
192 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
193 goto err_debugfs;
194 }
195
196 ret = device_add(minor->kdev);
197 if (ret)
198 goto err_debugfs;
199
200
201 spin_lock_irqsave(&drm_minor_lock, flags);
202 idr_replace(&drm_minors_idr, minor, minor->index);
203 spin_unlock_irqrestore(&drm_minor_lock, flags);
204
205 DRM_DEBUG("new minor registered %d\n", minor->index);
206 return 0;
207
208err_debugfs:
209 drm_debugfs_cleanup(minor);
210 return ret;
211}
212
213static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
214{
215 struct drm_minor *minor;
216 unsigned long flags;
217
218 minor = *drm_minor_get_slot(dev, type);
219 if (!minor || !device_is_registered(minor->kdev))
220 return;
221
222
223 spin_lock_irqsave(&drm_minor_lock, flags);
224 idr_replace(&drm_minors_idr, NULL, minor->index);
225 spin_unlock_irqrestore(&drm_minor_lock, flags);
226
227 device_del(minor->kdev);
228 dev_set_drvdata(minor->kdev, NULL);
229 drm_debugfs_cleanup(minor);
230}
231
232
233
234
235
236
237
238
239
240
241struct drm_minor *drm_minor_acquire(unsigned int minor_id)
242{
243 struct drm_minor *minor;
244 unsigned long flags;
245
246 spin_lock_irqsave(&drm_minor_lock, flags);
247 minor = idr_find(&drm_minors_idr, minor_id);
248 if (minor)
249 drm_dev_get(minor->dev);
250 spin_unlock_irqrestore(&drm_minor_lock, flags);
251
252 if (!minor) {
253 return ERR_PTR(-ENODEV);
254 } else if (drm_dev_is_unplugged(minor->dev)) {
255 drm_dev_put(minor->dev);
256 return ERR_PTR(-ENODEV);
257 }
258
259 return minor;
260}
261
262void drm_minor_release(struct drm_minor *minor)
263{
264 drm_dev_put(minor->dev);
265}
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
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
441void drm_put_dev(struct drm_device *dev)
442{
443 DRM_DEBUG("\n");
444
445 if (!dev) {
446 DRM_ERROR("cleanup called no dev\n");
447 return;
448 }
449
450 drm_dev_unregister(dev);
451 drm_dev_put(dev);
452}
453EXPORT_SYMBOL(drm_put_dev);
454
455
456
457
458
459
460
461
462
463
464
465
466
467bool drm_dev_enter(struct drm_device *dev, int *idx)
468{
469 *idx = srcu_read_lock(&drm_unplug_srcu);
470
471 if (dev->unplugged) {
472 srcu_read_unlock(&drm_unplug_srcu, *idx);
473 return false;
474 }
475
476 return true;
477}
478EXPORT_SYMBOL(drm_dev_enter);
479
480
481
482
483
484
485
486
487void drm_dev_exit(int idx)
488{
489 srcu_read_unlock(&drm_unplug_srcu, idx);
490}
491EXPORT_SYMBOL(drm_dev_exit);
492
493
494
495
496
497
498
499
500
501
502
503void drm_dev_unplug(struct drm_device *dev)
504{
505
506
507
508
509
510
511 dev->unplugged = true;
512 synchronize_srcu(&drm_unplug_srcu);
513
514 drm_dev_unregister(dev);
515}
516EXPORT_SYMBOL(drm_dev_unplug);
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536static int drm_fs_cnt;
537static struct vfsmount *drm_fs_mnt;
538
539static int drm_fs_init_fs_context(struct fs_context *fc)
540{
541 return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM;
542}
543
544static struct file_system_type drm_fs_type = {
545 .name = "drm",
546 .owner = THIS_MODULE,
547 .init_fs_context = drm_fs_init_fs_context,
548 .kill_sb = kill_anon_super,
549};
550
551static struct inode *drm_fs_inode_new(void)
552{
553 struct inode *inode;
554 int r;
555
556 r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);
557 if (r < 0) {
558 DRM_ERROR("Cannot mount pseudo fs: %d\n", r);
559 return ERR_PTR(r);
560 }
561
562 inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);
563 if (IS_ERR(inode))
564 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
565
566 return inode;
567}
568
569static void drm_fs_inode_free(struct inode *inode)
570{
571 if (inode) {
572 iput(inode);
573 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
574 }
575}
576
577
578
579
580
581
582
583
584
585
586
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
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633int drm_dev_init(struct drm_device *dev,
634 struct drm_driver *driver,
635 struct device *parent)
636{
637 int ret;
638
639 if (!drm_core_init_complete) {
640 DRM_ERROR("DRM core is not initialized\n");
641 return -ENODEV;
642 }
643
644 BUG_ON(!parent);
645
646 kref_init(&dev->ref);
647 dev->dev = get_device(parent);
648 dev->driver = driver;
649
650
651 dev->driver_features = ~0u;
652
653 drm_legacy_init_members(dev);
654 INIT_LIST_HEAD(&dev->filelist);
655 INIT_LIST_HEAD(&dev->filelist_internal);
656 INIT_LIST_HEAD(&dev->clientlist);
657 INIT_LIST_HEAD(&dev->vblank_event_list);
658
659 spin_lock_init(&dev->event_lock);
660 mutex_init(&dev->struct_mutex);
661 mutex_init(&dev->filelist_mutex);
662 mutex_init(&dev->clientlist_mutex);
663 mutex_init(&dev->master_mutex);
664
665 dev->anon_inode = drm_fs_inode_new();
666 if (IS_ERR(dev->anon_inode)) {
667 ret = PTR_ERR(dev->anon_inode);
668 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);
669 goto err_free;
670 }
671
672 if (drm_core_check_feature(dev, DRIVER_RENDER)) {
673 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
674 if (ret)
675 goto err_minors;
676 }
677
678 ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
679 if (ret)
680 goto err_minors;
681
682 ret = drm_legacy_create_map_hash(dev);
683 if (ret)
684 goto err_minors;
685
686 drm_legacy_ctxbitmap_init(dev);
687
688 if (drm_core_check_feature(dev, DRIVER_GEM)) {
689 ret = drm_gem_init(dev);
690 if (ret) {
691 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
692 goto err_ctxbitmap;
693 }
694 }
695
696 ret = drm_dev_set_unique(dev, dev_name(parent));
697 if (ret)
698 goto err_setunique;
699
700 return 0;
701
702err_setunique:
703 if (drm_core_check_feature(dev, DRIVER_GEM))
704 drm_gem_destroy(dev);
705err_ctxbitmap:
706 drm_legacy_ctxbitmap_cleanup(dev);
707 drm_legacy_remove_map_hash(dev);
708err_minors:
709 drm_minor_free(dev, DRM_MINOR_PRIMARY);
710 drm_minor_free(dev, DRM_MINOR_RENDER);
711 drm_fs_inode_free(dev->anon_inode);
712err_free:
713 put_device(dev->dev);
714 mutex_destroy(&dev->master_mutex);
715 mutex_destroy(&dev->clientlist_mutex);
716 mutex_destroy(&dev->filelist_mutex);
717 mutex_destroy(&dev->struct_mutex);
718 drm_legacy_destroy_members(dev);
719 return ret;
720}
721EXPORT_SYMBOL(drm_dev_init);
722
723static void devm_drm_dev_init_release(void *data)
724{
725 drm_dev_put(data);
726}
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741int devm_drm_dev_init(struct device *parent,
742 struct drm_device *dev,
743 struct drm_driver *driver)
744{
745 int ret;
746
747 if (WARN_ON(!parent || !driver->release))
748 return -EINVAL;
749
750 ret = drm_dev_init(dev, driver, parent);
751 if (ret)
752 return ret;
753
754 ret = devm_add_action(parent, devm_drm_dev_init_release, dev);
755 if (ret)
756 devm_drm_dev_init_release(dev);
757
758 return ret;
759}
760EXPORT_SYMBOL(devm_drm_dev_init);
761
762
763
764
765
766
767
768
769
770
771
772
773
774void drm_dev_fini(struct drm_device *dev)
775{
776 drm_vblank_cleanup(dev);
777
778 if (drm_core_check_feature(dev, DRIVER_GEM))
779 drm_gem_destroy(dev);
780
781 drm_legacy_ctxbitmap_cleanup(dev);
782 drm_legacy_remove_map_hash(dev);
783 drm_fs_inode_free(dev->anon_inode);
784
785 drm_minor_free(dev, DRM_MINOR_PRIMARY);
786 drm_minor_free(dev, DRM_MINOR_RENDER);
787
788 put_device(dev->dev);
789
790 mutex_destroy(&dev->master_mutex);
791 mutex_destroy(&dev->clientlist_mutex);
792 mutex_destroy(&dev->filelist_mutex);
793 mutex_destroy(&dev->struct_mutex);
794 drm_legacy_destroy_members(dev);
795 kfree(dev->unique);
796}
797EXPORT_SYMBOL(drm_dev_fini);
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821struct drm_device *drm_dev_alloc(struct drm_driver *driver,
822 struct device *parent)
823{
824 struct drm_device *dev;
825 int ret;
826
827 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
828 if (!dev)
829 return ERR_PTR(-ENOMEM);
830
831 ret = drm_dev_init(dev, driver, parent);
832 if (ret) {
833 kfree(dev);
834 return ERR_PTR(ret);
835 }
836
837 return dev;
838}
839EXPORT_SYMBOL(drm_dev_alloc);
840
841static void drm_dev_release(struct kref *ref)
842{
843 struct drm_device *dev = container_of(ref, struct drm_device, ref);
844
845 if (dev->driver->release) {
846 dev->driver->release(dev);
847 } else {
848 drm_dev_fini(dev);
849 kfree(dev);
850 }
851}
852
853
854
855
856
857
858
859
860
861
862
863
864
865void drm_dev_get(struct drm_device *dev)
866{
867 if (dev)
868 kref_get(&dev->ref);
869}
870EXPORT_SYMBOL(drm_dev_get);
871
872
873
874
875
876
877
878
879void drm_dev_put(struct drm_device *dev)
880{
881 if (dev)
882 kref_put(&dev->ref, drm_dev_release);
883}
884EXPORT_SYMBOL(drm_dev_put);
885
886static int create_compat_control_link(struct drm_device *dev)
887{
888 struct drm_minor *minor;
889 char *name;
890 int ret;
891
892 if (!drm_core_check_feature(dev, DRIVER_MODESET))
893 return 0;
894
895 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
896 if (!minor)
897 return 0;
898
899
900
901
902
903
904
905
906
907
908 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
909 if (!name)
910 return -ENOMEM;
911
912 ret = sysfs_create_link(minor->kdev->kobj.parent,
913 &minor->kdev->kobj,
914 name);
915
916 kfree(name);
917
918 return ret;
919}
920
921static void remove_compat_control_link(struct drm_device *dev)
922{
923 struct drm_minor *minor;
924 char *name;
925
926 if (!drm_core_check_feature(dev, DRIVER_MODESET))
927 return;
928
929 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
930 if (!minor)
931 return;
932
933 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
934 if (!name)
935 return;
936
937 sysfs_remove_link(minor->kdev->kobj.parent, name);
938
939 kfree(name);
940}
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962int drm_dev_register(struct drm_device *dev, unsigned long flags)
963{
964 struct drm_driver *driver = dev->driver;
965 int ret;
966
967 mutex_lock(&drm_global_mutex);
968
969 ret = drm_minor_register(dev, DRM_MINOR_RENDER);
970 if (ret)
971 goto err_minors;
972
973 ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
974 if (ret)
975 goto err_minors;
976
977 ret = create_compat_control_link(dev);
978 if (ret)
979 goto err_minors;
980
981 dev->registered = true;
982
983 if (dev->driver->load) {
984 ret = dev->driver->load(dev, flags);
985 if (ret)
986 goto err_minors;
987 }
988
989 if (drm_core_check_feature(dev, DRIVER_MODESET))
990 drm_modeset_register_all(dev);
991
992 ret = 0;
993
994 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
995 driver->name, driver->major, driver->minor,
996 driver->patchlevel, driver->date,
997 dev->dev ? dev_name(dev->dev) : "virtual device",
998 dev->primary->index);
999
1000 goto out_unlock;
1001
1002err_minors:
1003 remove_compat_control_link(dev);
1004 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
1005 drm_minor_unregister(dev, DRM_MINOR_RENDER);
1006out_unlock:
1007 mutex_unlock(&drm_global_mutex);
1008 return ret;
1009}
1010EXPORT_SYMBOL(drm_dev_register);
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026void drm_dev_unregister(struct drm_device *dev)
1027{
1028 if (drm_core_check_feature(dev, DRIVER_LEGACY))
1029 drm_lastclose(dev);
1030
1031 dev->registered = false;
1032
1033 drm_client_dev_unregister(dev);
1034
1035 if (drm_core_check_feature(dev, DRIVER_MODESET))
1036 drm_modeset_unregister_all(dev);
1037
1038 if (dev->driver->unload)
1039 dev->driver->unload(dev);
1040
1041 if (dev->agp)
1042 drm_pci_agp_destroy(dev);
1043
1044 drm_legacy_rmmaps(dev);
1045
1046 remove_compat_control_link(dev);
1047 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
1048 drm_minor_unregister(dev, DRM_MINOR_RENDER);
1049}
1050EXPORT_SYMBOL(drm_dev_unregister);
1051
1052
1053
1054
1055
1056
1057
1058
1059
1060
1061
1062
1063int drm_dev_set_unique(struct drm_device *dev, const char *name)
1064{
1065 kfree(dev->unique);
1066 dev->unique = kstrdup(name, GFP_KERNEL);
1067
1068 return dev->unique ? 0 : -ENOMEM;
1069}
1070EXPORT_SYMBOL(drm_dev_set_unique);
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092static int drm_stub_open(struct inode *inode, struct file *filp)
1093{
1094 const struct file_operations *new_fops;
1095 struct drm_minor *minor;
1096 int err;
1097
1098 DRM_DEBUG("\n");
1099
1100 mutex_lock(&drm_global_mutex);
1101 minor = drm_minor_acquire(iminor(inode));
1102 if (IS_ERR(minor)) {
1103 err = PTR_ERR(minor);
1104 goto out_unlock;
1105 }
1106
1107 new_fops = fops_get(minor->dev->driver->fops);
1108 if (!new_fops) {
1109 err = -ENODEV;
1110 goto out_release;
1111 }
1112
1113 replace_fops(filp, new_fops);
1114 if (filp->f_op->open)
1115 err = filp->f_op->open(inode, filp);
1116 else
1117 err = 0;
1118
1119out_release:
1120 drm_minor_release(minor);
1121out_unlock:
1122 mutex_unlock(&drm_global_mutex);
1123 return err;
1124}
1125
1126static const struct file_operations drm_stub_fops = {
1127 .owner = THIS_MODULE,
1128 .open = drm_stub_open,
1129 .llseek = noop_llseek,
1130};
1131
1132static void drm_core_exit(void)
1133{
1134 unregister_chrdev(DRM_MAJOR, "drm");
1135 debugfs_remove(drm_debugfs_root);
1136 drm_sysfs_destroy();
1137 idr_destroy(&drm_minors_idr);
1138 drm_connector_ida_destroy();
1139}
1140
1141static int __init drm_core_init(void)
1142{
1143 int ret;
1144
1145 drm_connector_ida_init();
1146 idr_init(&drm_minors_idr);
1147
1148 ret = drm_sysfs_init();
1149 if (ret < 0) {
1150 DRM_ERROR("Cannot create DRM class: %d\n", ret);
1151 goto error;
1152 }
1153
1154 drm_debugfs_root = debugfs_create_dir("dri", NULL);
1155
1156 ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);
1157 if (ret < 0)
1158 goto error;
1159
1160 drm_core_init_complete = true;
1161
1162 DRM_DEBUG("Initialized\n");
1163 return 0;
1164
1165error:
1166 drm_core_exit();
1167 return ret;
1168}
1169
1170module_init(drm_core_init);
1171module_exit(drm_core_exit);
1172