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_cache.h>
39#include <drm/drm_client.h>
40#include <drm/drm_color_mgmt.h>
41#include <drm/drm_drv.h>
42#include <drm/drm_file.h>
43#include <drm/drm_managed.h>
44#include <drm/drm_mode_object.h>
45#include <drm/drm_print.h>
46
47#include "drm_crtc_internal.h"
48#include "drm_internal.h"
49#include "drm_legacy.h"
50
51MODULE_AUTHOR("Gareth Hughes, Leif Delgass, José Fonseca, Jon Smirl");
52MODULE_DESCRIPTION("DRM shared core routines");
53MODULE_LICENSE("GPL and additional rights");
54
55static DEFINE_SPINLOCK(drm_minor_lock);
56static struct idr drm_minors_idr;
57
58
59
60
61
62
63
64
65static bool drm_core_init_complete;
66
67static struct dentry *drm_debugfs_root;
68
69DEFINE_STATIC_SRCU(drm_unplug_srcu);
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84static struct drm_minor **drm_minor_get_slot(struct drm_device *dev,
85 unsigned int type)
86{
87 switch (type) {
88 case DRM_MINOR_PRIMARY:
89 return &dev->primary;
90 case DRM_MINOR_RENDER:
91 return &dev->render;
92 default:
93 BUG();
94 }
95}
96
97static void drm_minor_alloc_release(struct drm_device *dev, void *data)
98{
99 struct drm_minor *minor = data;
100 unsigned long flags;
101
102 WARN_ON(dev != minor->dev);
103
104 put_device(minor->kdev);
105
106 spin_lock_irqsave(&drm_minor_lock, flags);
107 idr_remove(&drm_minors_idr, minor->index);
108 spin_unlock_irqrestore(&drm_minor_lock, flags);
109}
110
111static int drm_minor_alloc(struct drm_device *dev, unsigned int type)
112{
113 struct drm_minor *minor;
114 unsigned long flags;
115 int r;
116
117 minor = drmm_kzalloc(dev, sizeof(*minor), GFP_KERNEL);
118 if (!minor)
119 return -ENOMEM;
120
121 minor->type = type;
122 minor->dev = dev;
123
124 idr_preload(GFP_KERNEL);
125 spin_lock_irqsave(&drm_minor_lock, flags);
126 r = idr_alloc(&drm_minors_idr,
127 NULL,
128 64 * type,
129 64 * (type + 1),
130 GFP_NOWAIT);
131 spin_unlock_irqrestore(&drm_minor_lock, flags);
132 idr_preload_end();
133
134 if (r < 0)
135 return r;
136
137 minor->index = r;
138
139 r = drmm_add_action_or_reset(dev, drm_minor_alloc_release, minor);
140 if (r)
141 return r;
142
143 minor->kdev = drm_sysfs_minor_alloc(minor);
144 if (IS_ERR(minor->kdev))
145 return PTR_ERR(minor->kdev);
146
147 *drm_minor_get_slot(dev, type) = minor;
148 return 0;
149}
150
151static int drm_minor_register(struct drm_device *dev, unsigned int type)
152{
153 struct drm_minor *minor;
154 unsigned long flags;
155 int ret;
156
157 DRM_DEBUG("\n");
158
159 minor = *drm_minor_get_slot(dev, type);
160 if (!minor)
161 return 0;
162
163 ret = drm_debugfs_init(minor, minor->index, drm_debugfs_root);
164 if (ret) {
165 DRM_ERROR("DRM: Failed to initialize /sys/kernel/debug/dri.\n");
166 goto err_debugfs;
167 }
168
169 ret = device_add(minor->kdev);
170 if (ret)
171 goto err_debugfs;
172
173
174 spin_lock_irqsave(&drm_minor_lock, flags);
175 idr_replace(&drm_minors_idr, minor, minor->index);
176 spin_unlock_irqrestore(&drm_minor_lock, flags);
177
178 DRM_DEBUG("new minor registered %d\n", minor->index);
179 return 0;
180
181err_debugfs:
182 drm_debugfs_cleanup(minor);
183 return ret;
184}
185
186static void drm_minor_unregister(struct drm_device *dev, unsigned int type)
187{
188 struct drm_minor *minor;
189 unsigned long flags;
190
191 minor = *drm_minor_get_slot(dev, type);
192 if (!minor || !device_is_registered(minor->kdev))
193 return;
194
195
196 spin_lock_irqsave(&drm_minor_lock, flags);
197 idr_replace(&drm_minors_idr, NULL, minor->index);
198 spin_unlock_irqrestore(&drm_minor_lock, flags);
199
200 device_del(minor->kdev);
201 dev_set_drvdata(minor->kdev, NULL);
202 drm_debugfs_cleanup(minor);
203}
204
205
206
207
208
209
210
211
212
213
214struct drm_minor *drm_minor_acquire(unsigned int minor_id)
215{
216 struct drm_minor *minor;
217 unsigned long flags;
218
219 spin_lock_irqsave(&drm_minor_lock, flags);
220 minor = idr_find(&drm_minors_idr, minor_id);
221 if (minor)
222 drm_dev_get(minor->dev);
223 spin_unlock_irqrestore(&drm_minor_lock, flags);
224
225 if (!minor) {
226 return ERR_PTR(-ENODEV);
227 } else if (drm_dev_is_unplugged(minor->dev)) {
228 drm_dev_put(minor->dev);
229 return ERR_PTR(-ENODEV);
230 }
231
232 return minor;
233}
234
235void drm_minor_release(struct drm_minor *minor)
236{
237 drm_dev_put(minor->dev);
238}
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
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
399void drm_put_dev(struct drm_device *dev)
400{
401 DRM_DEBUG("\n");
402
403 if (!dev) {
404 DRM_ERROR("cleanup called no dev\n");
405 return;
406 }
407
408 drm_dev_unregister(dev);
409 drm_dev_put(dev);
410}
411EXPORT_SYMBOL(drm_put_dev);
412
413
414
415
416
417
418
419
420
421
422
423
424
425bool drm_dev_enter(struct drm_device *dev, int *idx)
426{
427 *idx = srcu_read_lock(&drm_unplug_srcu);
428
429 if (dev->unplugged) {
430 srcu_read_unlock(&drm_unplug_srcu, *idx);
431 return false;
432 }
433
434 return true;
435}
436EXPORT_SYMBOL(drm_dev_enter);
437
438
439
440
441
442
443
444
445void drm_dev_exit(int idx)
446{
447 srcu_read_unlock(&drm_unplug_srcu, idx);
448}
449EXPORT_SYMBOL(drm_dev_exit);
450
451
452
453
454
455
456
457
458
459
460
461void drm_dev_unplug(struct drm_device *dev)
462{
463
464
465
466
467
468
469 dev->unplugged = true;
470 synchronize_srcu(&drm_unplug_srcu);
471
472 drm_dev_unregister(dev);
473
474
475 unmap_mapping_range(dev->anon_inode->i_mapping, 0, 0, 1);
476}
477EXPORT_SYMBOL(drm_dev_unplug);
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497static int drm_fs_cnt;
498static struct vfsmount *drm_fs_mnt;
499
500static int drm_fs_init_fs_context(struct fs_context *fc)
501{
502 return init_pseudo(fc, 0x010203ff) ? 0 : -ENOMEM;
503}
504
505static struct file_system_type drm_fs_type = {
506 .name = "drm",
507 .owner = THIS_MODULE,
508 .init_fs_context = drm_fs_init_fs_context,
509 .kill_sb = kill_anon_super,
510};
511
512static struct inode *drm_fs_inode_new(void)
513{
514 struct inode *inode;
515 int r;
516
517 r = simple_pin_fs(&drm_fs_type, &drm_fs_mnt, &drm_fs_cnt);
518 if (r < 0) {
519 DRM_ERROR("Cannot mount pseudo fs: %d\n", r);
520 return ERR_PTR(r);
521 }
522
523 inode = alloc_anon_inode(drm_fs_mnt->mnt_sb);
524 if (IS_ERR(inode))
525 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
526
527 return inode;
528}
529
530static void drm_fs_inode_free(struct inode *inode)
531{
532 if (inode) {
533 iput(inode);
534 simple_release_fs(&drm_fs_mnt, &drm_fs_cnt);
535 }
536}
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563static void drm_dev_init_release(struct drm_device *dev, void *res)
564{
565 drm_legacy_ctxbitmap_cleanup(dev);
566 drm_legacy_remove_map_hash(dev);
567 drm_fs_inode_free(dev->anon_inode);
568
569 put_device(dev->dev);
570
571
572 dev->dev = NULL;
573 mutex_destroy(&dev->master_mutex);
574 mutex_destroy(&dev->clientlist_mutex);
575 mutex_destroy(&dev->filelist_mutex);
576 mutex_destroy(&dev->struct_mutex);
577 drm_legacy_destroy_members(dev);
578}
579
580static int drm_dev_init(struct drm_device *dev,
581 const struct drm_driver *driver,
582 struct device *parent)
583{
584 int ret;
585
586 if (!drm_core_init_complete) {
587 DRM_ERROR("DRM core is not initialized\n");
588 return -ENODEV;
589 }
590
591 if (WARN_ON(!parent))
592 return -EINVAL;
593
594 kref_init(&dev->ref);
595 dev->dev = get_device(parent);
596 dev->driver = driver;
597
598 INIT_LIST_HEAD(&dev->managed.resources);
599 spin_lock_init(&dev->managed.lock);
600
601
602 dev->driver_features = ~0u;
603
604 drm_legacy_init_members(dev);
605 INIT_LIST_HEAD(&dev->filelist);
606 INIT_LIST_HEAD(&dev->filelist_internal);
607 INIT_LIST_HEAD(&dev->clientlist);
608 INIT_LIST_HEAD(&dev->vblank_event_list);
609
610 spin_lock_init(&dev->event_lock);
611 mutex_init(&dev->struct_mutex);
612 mutex_init(&dev->filelist_mutex);
613 mutex_init(&dev->clientlist_mutex);
614 mutex_init(&dev->master_mutex);
615
616 ret = drmm_add_action(dev, drm_dev_init_release, NULL);
617 if (ret)
618 return ret;
619
620 dev->anon_inode = drm_fs_inode_new();
621 if (IS_ERR(dev->anon_inode)) {
622 ret = PTR_ERR(dev->anon_inode);
623 DRM_ERROR("Cannot allocate anonymous inode: %d\n", ret);
624 goto err;
625 }
626
627 if (drm_core_check_feature(dev, DRIVER_RENDER)) {
628 ret = drm_minor_alloc(dev, DRM_MINOR_RENDER);
629 if (ret)
630 goto err;
631 }
632
633 ret = drm_minor_alloc(dev, DRM_MINOR_PRIMARY);
634 if (ret)
635 goto err;
636
637 ret = drm_legacy_create_map_hash(dev);
638 if (ret)
639 goto err;
640
641 drm_legacy_ctxbitmap_init(dev);
642
643 if (drm_core_check_feature(dev, DRIVER_GEM)) {
644 ret = drm_gem_init(dev);
645 if (ret) {
646 DRM_ERROR("Cannot initialize graphics execution manager (GEM)\n");
647 goto err;
648 }
649 }
650
651 ret = drm_dev_set_unique(dev, dev_name(parent));
652 if (ret)
653 goto err;
654
655 return 0;
656
657err:
658 drm_managed_release(dev);
659
660 return ret;
661}
662
663static void devm_drm_dev_init_release(void *data)
664{
665 drm_dev_put(data);
666}
667
668static int devm_drm_dev_init(struct device *parent,
669 struct drm_device *dev,
670 const struct drm_driver *driver)
671{
672 int ret;
673
674 ret = drm_dev_init(dev, driver, parent);
675 if (ret)
676 return ret;
677
678 return devm_add_action_or_reset(parent,
679 devm_drm_dev_init_release, dev);
680}
681
682void *__devm_drm_dev_alloc(struct device *parent,
683 const struct drm_driver *driver,
684 size_t size, size_t offset)
685{
686 void *container;
687 struct drm_device *drm;
688 int ret;
689
690 container = kzalloc(size, GFP_KERNEL);
691 if (!container)
692 return ERR_PTR(-ENOMEM);
693
694 drm = container + offset;
695 ret = devm_drm_dev_init(parent, drm, driver);
696 if (ret) {
697 kfree(container);
698 return ERR_PTR(ret);
699 }
700 drmm_add_final_kfree(drm, container);
701
702 return container;
703}
704EXPORT_SYMBOL(__devm_drm_dev_alloc);
705
706
707
708
709
710
711
712
713
714
715
716
717
718struct drm_device *drm_dev_alloc(const struct drm_driver *driver,
719 struct device *parent)
720{
721 struct drm_device *dev;
722 int ret;
723
724 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
725 if (!dev)
726 return ERR_PTR(-ENOMEM);
727
728 ret = drm_dev_init(dev, driver, parent);
729 if (ret) {
730 kfree(dev);
731 return ERR_PTR(ret);
732 }
733
734 drmm_add_final_kfree(dev, dev);
735
736 return dev;
737}
738EXPORT_SYMBOL(drm_dev_alloc);
739
740static void drm_dev_release(struct kref *ref)
741{
742 struct drm_device *dev = container_of(ref, struct drm_device, ref);
743
744 if (dev->driver->release)
745 dev->driver->release(dev);
746
747 drm_managed_release(dev);
748
749 kfree(dev->managed.final_kfree);
750}
751
752
753
754
755
756
757
758
759
760
761
762
763
764void drm_dev_get(struct drm_device *dev)
765{
766 if (dev)
767 kref_get(&dev->ref);
768}
769EXPORT_SYMBOL(drm_dev_get);
770
771
772
773
774
775
776
777
778void drm_dev_put(struct drm_device *dev)
779{
780 if (dev)
781 kref_put(&dev->ref, drm_dev_release);
782}
783EXPORT_SYMBOL(drm_dev_put);
784
785static int create_compat_control_link(struct drm_device *dev)
786{
787 struct drm_minor *minor;
788 char *name;
789 int ret;
790
791 if (!drm_core_check_feature(dev, DRIVER_MODESET))
792 return 0;
793
794 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
795 if (!minor)
796 return 0;
797
798
799
800
801
802
803
804
805
806
807 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
808 if (!name)
809 return -ENOMEM;
810
811 ret = sysfs_create_link(minor->kdev->kobj.parent,
812 &minor->kdev->kobj,
813 name);
814
815 kfree(name);
816
817 return ret;
818}
819
820static void remove_compat_control_link(struct drm_device *dev)
821{
822 struct drm_minor *minor;
823 char *name;
824
825 if (!drm_core_check_feature(dev, DRIVER_MODESET))
826 return;
827
828 minor = *drm_minor_get_slot(dev, DRM_MINOR_PRIMARY);
829 if (!minor)
830 return;
831
832 name = kasprintf(GFP_KERNEL, "controlD%d", minor->index + 64);
833 if (!name)
834 return;
835
836 sysfs_remove_link(minor->kdev->kobj.parent, name);
837
838 kfree(name);
839}
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861int drm_dev_register(struct drm_device *dev, unsigned long flags)
862{
863 const struct drm_driver *driver = dev->driver;
864 int ret;
865
866 if (!driver->load)
867 drm_mode_config_validate(dev);
868
869 WARN_ON(!dev->managed.final_kfree);
870
871 if (drm_dev_needs_global_mutex(dev))
872 mutex_lock(&drm_global_mutex);
873
874 ret = drm_minor_register(dev, DRM_MINOR_RENDER);
875 if (ret)
876 goto err_minors;
877
878 ret = drm_minor_register(dev, DRM_MINOR_PRIMARY);
879 if (ret)
880 goto err_minors;
881
882 ret = create_compat_control_link(dev);
883 if (ret)
884 goto err_minors;
885
886 dev->registered = true;
887
888 if (dev->driver->load) {
889 ret = dev->driver->load(dev, flags);
890 if (ret)
891 goto err_minors;
892 }
893
894 if (drm_core_check_feature(dev, DRIVER_MODESET))
895 drm_modeset_register_all(dev);
896
897 DRM_INFO("Initialized %s %d.%d.%d %s for %s on minor %d\n",
898 driver->name, driver->major, driver->minor,
899 driver->patchlevel, driver->date,
900 dev->dev ? dev_name(dev->dev) : "virtual device",
901 dev->primary->index);
902
903 goto out_unlock;
904
905err_minors:
906 remove_compat_control_link(dev);
907 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
908 drm_minor_unregister(dev, DRM_MINOR_RENDER);
909out_unlock:
910 if (drm_dev_needs_global_mutex(dev))
911 mutex_unlock(&drm_global_mutex);
912 return ret;
913}
914EXPORT_SYMBOL(drm_dev_register);
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930void drm_dev_unregister(struct drm_device *dev)
931{
932 if (drm_core_check_feature(dev, DRIVER_LEGACY))
933 drm_lastclose(dev);
934
935 dev->registered = false;
936
937 drm_client_dev_unregister(dev);
938
939 if (drm_core_check_feature(dev, DRIVER_MODESET))
940 drm_modeset_unregister_all(dev);
941
942 if (dev->driver->unload)
943 dev->driver->unload(dev);
944
945 drm_legacy_pci_agp_destroy(dev);
946 drm_legacy_rmmaps(dev);
947
948 remove_compat_control_link(dev);
949 drm_minor_unregister(dev, DRM_MINOR_PRIMARY);
950 drm_minor_unregister(dev, DRM_MINOR_RENDER);
951}
952EXPORT_SYMBOL(drm_dev_unregister);
953
954
955
956
957
958
959
960
961
962
963
964
965int drm_dev_set_unique(struct drm_device *dev, const char *name)
966{
967 drmm_kfree(dev, dev->unique);
968 dev->unique = drmm_kstrdup(dev, name, GFP_KERNEL);
969
970 return dev->unique ? 0 : -ENOMEM;
971}
972EXPORT_SYMBOL(drm_dev_set_unique);
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994static int drm_stub_open(struct inode *inode, struct file *filp)
995{
996 const struct file_operations *new_fops;
997 struct drm_minor *minor;
998 int err;
999
1000 DRM_DEBUG("\n");
1001
1002 minor = drm_minor_acquire(iminor(inode));
1003 if (IS_ERR(minor))
1004 return PTR_ERR(minor);
1005
1006 new_fops = fops_get(minor->dev->driver->fops);
1007 if (!new_fops) {
1008 err = -ENODEV;
1009 goto out;
1010 }
1011
1012 replace_fops(filp, new_fops);
1013 if (filp->f_op->open)
1014 err = filp->f_op->open(inode, filp);
1015 else
1016 err = 0;
1017
1018out:
1019 drm_minor_release(minor);
1020
1021 return err;
1022}
1023
1024static const struct file_operations drm_stub_fops = {
1025 .owner = THIS_MODULE,
1026 .open = drm_stub_open,
1027 .llseek = noop_llseek,
1028};
1029
1030static void drm_core_exit(void)
1031{
1032 unregister_chrdev(DRM_MAJOR, "drm");
1033 debugfs_remove(drm_debugfs_root);
1034 drm_sysfs_destroy();
1035 idr_destroy(&drm_minors_idr);
1036 drm_connector_ida_destroy();
1037}
1038
1039static int __init drm_core_init(void)
1040{
1041 int ret;
1042
1043 drm_connector_ida_init();
1044 idr_init(&drm_minors_idr);
1045 drm_memcpy_init_early();
1046
1047 ret = drm_sysfs_init();
1048 if (ret < 0) {
1049 DRM_ERROR("Cannot create DRM class: %d\n", ret);
1050 goto error;
1051 }
1052
1053 drm_debugfs_root = debugfs_create_dir("dri", NULL);
1054
1055 ret = register_chrdev(DRM_MAJOR, "drm", &drm_stub_fops);
1056 if (ret < 0)
1057 goto error;
1058
1059 drm_core_init_complete = true;
1060
1061 DRM_DEBUG("Initialized\n");
1062 return 0;
1063
1064error:
1065 drm_core_exit();
1066 return ret;
1067}
1068
1069module_init(drm_core_init);
1070module_exit(drm_core_exit);
1071