xref: /linux/drivers/gpu/drm/drm_client_event.c (revision cb8fef4b07f71da01843457b66e579ad248a625e)
1 // SPDX-License-Identifier: GPL-2.0 or MIT
2 /*
3  * Copyright 2018 Noralf Trønnes
4  */
5 
6 #include <linux/export.h>
7 #include <linux/list.h>
8 #include <linux/mutex.h>
9 #include <linux/seq_file.h>
10 
11 #include <drm/drm_client.h>
12 #include <drm/drm_client_event.h>
13 #include <drm/drm_debugfs.h>
14 #include <drm/drm_device.h>
15 #include <drm/drm_drv.h>
16 #include <drm/drm_print.h>
17 
18 #include "drm_internal.h"
19 
20 /**
21  * drm_client_dev_unregister - Unregister clients
22  * @dev: DRM device
23  *
24  * This function releases all clients by calling each client's
25  * &drm_client_funcs.unregister callback. The callback function
26  * is responsibe for releaseing all resources including the client
27  * itself.
28  *
29  * The helper drm_dev_unregister() calls this function. Drivers
30  * that use it don't need to call this function themselves.
31  */
32 void drm_client_dev_unregister(struct drm_device *dev)
33 {
34 	struct drm_client_dev *client, *tmp;
35 
36 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
37 		return;
38 
39 	mutex_lock(&dev->clientlist_mutex);
40 	list_for_each_entry_safe(client, tmp, &dev->clientlist, list) {
41 		list_del(&client->list);
42 		/*
43 		 * Unregistering consumes and frees the client.
44 		 */
45 		if (client->funcs && client->funcs->unregister)
46 			client->funcs->unregister(client);
47 		else
48 			drm_client_release(client);
49 	}
50 	mutex_unlock(&dev->clientlist_mutex);
51 }
52 EXPORT_SYMBOL(drm_client_dev_unregister);
53 
54 static void drm_client_hotplug(struct drm_client_dev *client)
55 {
56 	struct drm_device *dev = client->dev;
57 	int ret;
58 
59 	if (!client->funcs || !client->funcs->hotplug)
60 		return;
61 
62 	if (client->hotplug_failed)
63 		return;
64 
65 	if (client->suspended) {
66 		client->hotplug_pending = true;
67 		return;
68 	}
69 
70 	client->hotplug_pending = false;
71 	ret = client->funcs->hotplug(client);
72 	drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
73 	if (ret)
74 		client->hotplug_failed = true;
75 }
76 
77 /**
78  * drm_client_dev_hotplug - Send hotplug event to clients
79  * @dev: DRM device
80  *
81  * This function calls the &drm_client_funcs.hotplug callback on the attached clients.
82  *
83  * drm_kms_helper_hotplug_event() calls this function, so drivers that use it
84  * don't need to call this function themselves.
85  */
86 void drm_client_dev_hotplug(struct drm_device *dev)
87 {
88 	struct drm_client_dev *client;
89 
90 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
91 		return;
92 
93 	if (!dev->mode_config.num_connector) {
94 		drm_dbg_kms(dev, "No connectors found, will not send hotplug events!\n");
95 		return;
96 	}
97 
98 	mutex_lock(&dev->clientlist_mutex);
99 	list_for_each_entry(client, &dev->clientlist, list)
100 		drm_client_hotplug(client);
101 	mutex_unlock(&dev->clientlist_mutex);
102 }
103 EXPORT_SYMBOL(drm_client_dev_hotplug);
104 
105 void drm_client_dev_restore(struct drm_device *dev, bool force)
106 {
107 	struct drm_client_dev *client;
108 	int ret;
109 
110 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
111 		return;
112 
113 	mutex_lock(&dev->clientlist_mutex);
114 	list_for_each_entry(client, &dev->clientlist, list) {
115 		if (!client->funcs || !client->funcs->restore)
116 			continue;
117 
118 		ret = client->funcs->restore(client, force);
119 		drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
120 		if (!ret) /* The first one to return zero gets the privilege to restore */
121 			break;
122 	}
123 	mutex_unlock(&dev->clientlist_mutex);
124 }
125 
126 void drm_client_dev_acquire_outputs(struct drm_device *dev)
127 {
128 	struct drm_client_dev *client;
129 
130 	if (!drm_core_check_feature(dev, DRIVER_MODESET))
131 		return;
132 
133 	mutex_lock(&dev->clientlist_mutex);
134 	list_for_each_entry(client, &dev->clientlist, list) {
135 		if (!client->funcs || !client->funcs->acquire_outputs)
136 			continue;
137 
138 		client->funcs->acquire_outputs(client);
139 	}
140 	mutex_unlock(&dev->clientlist_mutex);
141 }
142 EXPORT_SYMBOL(drm_client_dev_acquire_outputs);
143 
144 static int drm_client_suspend(struct drm_client_dev *client)
145 {
146 	struct drm_device *dev = client->dev;
147 	int ret = 0;
148 
149 	if (drm_WARN_ON_ONCE(dev, client->suspended))
150 		return 0;
151 
152 	if (client->funcs && client->funcs->suspend)
153 		ret = client->funcs->suspend(client);
154 	drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
155 
156 	client->suspended = true;
157 
158 	return ret;
159 }
160 
161 void drm_client_dev_suspend(struct drm_device *dev)
162 {
163 	struct drm_client_dev *client;
164 
165 	mutex_lock(&dev->clientlist_mutex);
166 	list_for_each_entry(client, &dev->clientlist, list) {
167 		if (!client->suspended)
168 			drm_client_suspend(client);
169 	}
170 	mutex_unlock(&dev->clientlist_mutex);
171 }
172 EXPORT_SYMBOL(drm_client_dev_suspend);
173 
174 static int drm_client_resume(struct drm_client_dev *client)
175 {
176 	struct drm_device *dev = client->dev;
177 	int ret = 0;
178 
179 	if (drm_WARN_ON_ONCE(dev, !client->suspended))
180 		return 0;
181 
182 	if (client->funcs && client->funcs->resume)
183 		ret = client->funcs->resume(client);
184 	drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
185 
186 	client->suspended = false;
187 
188 	if (client->hotplug_pending)
189 		drm_client_hotplug(client);
190 
191 	return ret;
192 }
193 
194 void drm_client_dev_resume(struct drm_device *dev)
195 {
196 	struct drm_client_dev *client;
197 
198 	mutex_lock(&dev->clientlist_mutex);
199 	list_for_each_entry(client, &dev->clientlist, list) {
200 		if  (client->suspended)
201 			drm_client_resume(client);
202 	}
203 	mutex_unlock(&dev->clientlist_mutex);
204 }
205 EXPORT_SYMBOL(drm_client_dev_resume);
206 
207 #ifdef CONFIG_DEBUG_FS
208 static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data)
209 {
210 	struct drm_debugfs_entry *entry = m->private;
211 	struct drm_device *dev = entry->dev;
212 	struct drm_printer p = drm_seq_file_printer(m);
213 	struct drm_client_dev *client;
214 
215 	mutex_lock(&dev->clientlist_mutex);
216 	list_for_each_entry(client, &dev->clientlist, list)
217 		drm_printf(&p, "%s\n", client->name);
218 	mutex_unlock(&dev->clientlist_mutex);
219 
220 	return 0;
221 }
222 
223 static const struct drm_debugfs_info drm_client_debugfs_list[] = {
224 	{ "internal_clients", drm_client_debugfs_internal_clients, 0 },
225 };
226 
227 void drm_client_debugfs_init(struct drm_device *dev)
228 {
229 	drm_debugfs_add_files(dev, drm_client_debugfs_list,
230 			      ARRAY_SIZE(drm_client_debugfs_list));
231 }
232 #endif
233