add dts config

hc

2023-12-06 08f87f769b595151be1afeff53e144f543faa614

 kernel/drivers/gpu/drm/udl/udl_drv.c
..
..
@@ -1,14 +1,20 @@
1
+// SPDX-License-Identifier: GPL-2.0-only
1
2
 /*
2
3
  * Copyright (C) 2012 Red Hat
3
- *
4
- * This file is subject to the terms and conditions of the GNU General Public
5
- * License v2. See the file COPYING in the main directory of this archive for
6
- * more details.
7
4
  */
8
5
 
9
6
 #include <linux/module.h>
10
-#include <drm/drmP.h>
7
+
11
8
 #include <drm/drm_crtc_helper.h>
9
+#include <drm/drm_drv.h>
10
+#include <drm/drm_fb_helper.h>
11
+#include <drm/drm_file.h>
12
+#include <drm/drm_gem_shmem_helper.h>
13
+#include <drm/drm_managed.h>
14
+#include <drm/drm_ioctl.h>
15
+#include <drm/drm_probe_helper.h>
16
+#include <drm/drm_print.h>
17
+
12
18
 #include "udl_drv.h"
13
19
 
14
20
 static int udl_usb_suspend(struct usb_interface *interface,
..
..
@@ -16,61 +22,43 @@
16
22
 {
17
23
 	struct drm_device *dev = usb_get_intfdata(interface);
18
24
 
19
-	drm_kms_helper_poll_disable(dev);
20
-	return 0;
25
+	return drm_mode_config_helper_suspend(dev);
21
26
 }
22
27
 
23
28
 static int udl_usb_resume(struct usb_interface *interface)
24
29
 {
25
30
 	struct drm_device *dev = usb_get_intfdata(interface);
26
31
 
27
-	drm_kms_helper_poll_enable(dev);
28
-	udl_modeset_restore(dev);
29
-	return 0;
32
+	return drm_mode_config_helper_resume(dev);
30
33
 }
31
34
 
32
-static const struct vm_operations_struct udl_gem_vm_ops = {
33
-	.fault = udl_gem_fault,
34
-	.open = drm_gem_vm_open,
35
-	.close = drm_gem_vm_close,
36
-};
37
-
38
-static const struct file_operations udl_driver_fops = {
39
-	.owner = THIS_MODULE,
40
-	.open = drm_open,
41
-	.mmap = udl_drm_gem_mmap,
42
-	.poll = drm_poll,
43
-	.read = drm_read,
44
-	.unlocked_ioctl	= drm_ioctl,
45
-	.release = drm_release,
46
-	.compat_ioctl = drm_compat_ioctl,
47
-	.llseek = noop_llseek,
48
-};
49
-
50
-static void udl_driver_release(struct drm_device *dev)
35
+/*
36
+ * FIXME: Dma-buf sharing requires DMA support by the importing device.
37
+ *        This function is a workaround to make USB devices work as well.
38
+ *        See todo.rst for how to fix the issue in the dma-buf framework.
39
+ */
40
+static struct drm_gem_object *udl_driver_gem_prime_import(struct drm_device *dev,
41
+							  struct dma_buf *dma_buf)
51
42
 {
52
-	udl_fini(dev);
53
-	udl_modeset_cleanup(dev);
54
-	drm_dev_fini(dev);
55
-	kfree(dev);
43
+	struct udl_device *udl = to_udl(dev);
44
+
45
+	if (!udl->dmadev)
46
+		return ERR_PTR(-ENODEV);
47
+
48
+	return drm_gem_prime_import_dev(dev, dma_buf, udl->dmadev);
56
49
 }
50
+
51
+DEFINE_DRM_GEM_FOPS(udl_driver_fops);
57
52
 
58
53
 static struct drm_driver driver = {
59
-	.driver_features = DRIVER_MODESET | DRIVER_GEM | DRIVER_PRIME,
60
-	.release = udl_driver_release,
54
+	.driver_features = DRIVER_ATOMIC | DRIVER_GEM | DRIVER_MODESET,
61
55
 
62
-	/* gem hooks */
63
-	.gem_free_object_unlocked = udl_gem_free_object,
64
-	.gem_vm_ops = &udl_gem_vm_ops,
56
+	/* GEM hooks */
57
+	.gem_create_object = drm_gem_shmem_create_object_cached,
65
58
 
66
-	.dumb_create = udl_dumb_create,
67
-	.dumb_map_offset = udl_gem_mmap,
68
59
 	.fops = &udl_driver_fops,
69
-
70
-	.prime_handle_to_fd = drm_gem_prime_handle_to_fd,
71
-	.prime_fd_to_handle = drm_gem_prime_fd_to_handle,
72
-	.gem_prime_export = udl_gem_prime_export,
73
-	.gem_prime_import = udl_gem_prime_import,
60
+	DRM_GEM_SHMEM_DRIVER_OPS,
61
+	.gem_prime_import = udl_driver_gem_prime_import,
74
62
 
75
63
 	.name = DRIVER_NAME,
76
64
 	.desc = DRIVER_DESC,
..
..
@@ -86,27 +74,19 @@
86
74
 	struct udl_device *udl;
87
75
 	int r;
88
76
 
89
-	udl = kzalloc(sizeof(*udl), GFP_KERNEL);
90
-	if (!udl)
91
-		return ERR_PTR(-ENOMEM);
92
-
93
-	r = drm_dev_init(&udl->drm, &driver, &interface->dev);
94
-	if (r) {
95
-		kfree(udl);
96
-		return ERR_PTR(r);
97
-	}
77
+	udl = devm_drm_dev_alloc(&interface->dev, &driver,
78
+				 struct udl_device, drm);
79
+	if (IS_ERR(udl))
80
+		return udl;
98
81
 
99
82
 	udl->udev = udev;
100
-	udl->drm.dev_private = udl;
101
83
 
102
84
 	r = udl_init(udl);
103
-	if (r) {
104
-		drm_dev_fini(&udl->drm);
105
-		kfree(udl);
85
+	if (r)
106
86
 		return ERR_PTR(r);
107
-	}
108
87
 
109
88
 	usb_set_intfdata(interface, udl);
89
+
110
90
 	return udl;
111
91
 }
112
92
 
..
..
@@ -122,23 +102,20 @@
122
102
 
123
103
 	r = drm_dev_register(&udl->drm, 0);
124
104
 	if (r)
125
-		goto err_free;
105
+		return r;
126
106
 
127
107
 	DRM_INFO("Initialized udl on minor %d\n", udl->drm.primary->index);
128
108
 
129
-	return 0;
109
+	drm_fbdev_generic_setup(&udl->drm, 0);
130
110
 
131
-err_free:
132
-	drm_dev_put(&udl->drm);
133
-	return r;
111
+	return 0;
134
112
 }
135
113
 
136
114
 static void udl_usb_disconnect(struct usb_interface *interface)
137
115
 {
138
116
 	struct drm_device *dev = usb_get_intfdata(interface);
139
117
 
140
-	drm_kms_helper_poll_disable(dev);
141
-	udl_fbdev_unplug(dev);
118
+	drm_kms_helper_poll_fini(dev);
142
119
 	udl_drop_usb(dev);
143
120
 	drm_dev_unplug(dev);
144
121
 }