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 */
drm_client_dev_unregister(struct drm_device * dev)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 if (client->funcs && client->funcs->unregister) {
43 client->funcs->unregister(client);
44 } else {
45 drm_client_release(client);
46 kfree(client);
47 }
48 }
49 mutex_unlock(&dev->clientlist_mutex);
50 }
51 EXPORT_SYMBOL(drm_client_dev_unregister);
52
drm_client_hotplug(struct drm_client_dev * client)53 static void drm_client_hotplug(struct drm_client_dev *client)
54 {
55 struct drm_device *dev = client->dev;
56 int ret;
57
58 if (!client->funcs || !client->funcs->hotplug)
59 return;
60
61 if (client->hotplug_failed)
62 return;
63
64 if (client->suspended) {
65 client->hotplug_pending = true;
66 return;
67 }
68
69 client->hotplug_pending = false;
70 ret = client->funcs->hotplug(client);
71 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
72 if (ret)
73 client->hotplug_failed = true;
74 }
75
76 /**
77 * drm_client_dev_hotplug - Send hotplug event to clients
78 * @dev: DRM device
79 *
80 * This function calls the &drm_client_funcs.hotplug callback on the attached clients.
81 *
82 * drm_kms_helper_hotplug_event() calls this function, so drivers that use it
83 * don't need to call this function themselves.
84 */
drm_client_dev_hotplug(struct drm_device * dev)85 void drm_client_dev_hotplug(struct drm_device *dev)
86 {
87 struct drm_client_dev *client;
88
89 if (!drm_core_check_feature(dev, DRIVER_MODESET))
90 return;
91
92 if (!dev->mode_config.num_connector) {
93 drm_dbg_kms(dev, "No connectors found, will not send hotplug events!\n");
94 return;
95 }
96
97 mutex_lock(&dev->clientlist_mutex);
98 list_for_each_entry(client, &dev->clientlist, list)
99 drm_client_hotplug(client);
100 mutex_unlock(&dev->clientlist_mutex);
101 }
102 EXPORT_SYMBOL(drm_client_dev_hotplug);
103
drm_client_dev_restore(struct drm_device * dev)104 void drm_client_dev_restore(struct drm_device *dev)
105 {
106 struct drm_client_dev *client;
107 int ret;
108
109 if (!drm_core_check_feature(dev, DRIVER_MODESET))
110 return;
111
112 mutex_lock(&dev->clientlist_mutex);
113 list_for_each_entry(client, &dev->clientlist, list) {
114 if (!client->funcs || !client->funcs->restore)
115 continue;
116
117 ret = client->funcs->restore(client);
118 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
119 if (!ret) /* The first one to return zero gets the privilege to restore */
120 break;
121 }
122 mutex_unlock(&dev->clientlist_mutex);
123 }
124
drm_client_suspend(struct drm_client_dev * client,bool holds_console_lock)125 static int drm_client_suspend(struct drm_client_dev *client, bool holds_console_lock)
126 {
127 struct drm_device *dev = client->dev;
128 int ret = 0;
129
130 if (drm_WARN_ON_ONCE(dev, client->suspended))
131 return 0;
132
133 if (client->funcs && client->funcs->suspend)
134 ret = client->funcs->suspend(client, holds_console_lock);
135 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
136
137 client->suspended = true;
138
139 return ret;
140 }
141
drm_client_dev_suspend(struct drm_device * dev,bool holds_console_lock)142 void drm_client_dev_suspend(struct drm_device *dev, bool holds_console_lock)
143 {
144 struct drm_client_dev *client;
145
146 mutex_lock(&dev->clientlist_mutex);
147 list_for_each_entry(client, &dev->clientlist, list) {
148 if (!client->suspended)
149 drm_client_suspend(client, holds_console_lock);
150 }
151 mutex_unlock(&dev->clientlist_mutex);
152 }
153 EXPORT_SYMBOL(drm_client_dev_suspend);
154
drm_client_resume(struct drm_client_dev * client,bool holds_console_lock)155 static int drm_client_resume(struct drm_client_dev *client, bool holds_console_lock)
156 {
157 struct drm_device *dev = client->dev;
158 int ret = 0;
159
160 if (drm_WARN_ON_ONCE(dev, !client->suspended))
161 return 0;
162
163 if (client->funcs && client->funcs->resume)
164 ret = client->funcs->resume(client, holds_console_lock);
165 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
166
167 client->suspended = false;
168
169 if (client->hotplug_pending)
170 drm_client_hotplug(client);
171
172 return ret;
173 }
174
drm_client_dev_resume(struct drm_device * dev,bool holds_console_lock)175 void drm_client_dev_resume(struct drm_device *dev, bool holds_console_lock)
176 {
177 struct drm_client_dev *client;
178
179 mutex_lock(&dev->clientlist_mutex);
180 list_for_each_entry(client, &dev->clientlist, list) {
181 if (client->suspended)
182 drm_client_resume(client, holds_console_lock);
183 }
184 mutex_unlock(&dev->clientlist_mutex);
185 }
186 EXPORT_SYMBOL(drm_client_dev_resume);
187
188 #ifdef CONFIG_DEBUG_FS
drm_client_debugfs_internal_clients(struct seq_file * m,void * data)189 static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data)
190 {
191 struct drm_debugfs_entry *entry = m->private;
192 struct drm_device *dev = entry->dev;
193 struct drm_printer p = drm_seq_file_printer(m);
194 struct drm_client_dev *client;
195
196 mutex_lock(&dev->clientlist_mutex);
197 list_for_each_entry(client, &dev->clientlist, list)
198 drm_printf(&p, "%s\n", client->name);
199 mutex_unlock(&dev->clientlist_mutex);
200
201 return 0;
202 }
203
204 static const struct drm_debugfs_info drm_client_debugfs_list[] = {
205 { "internal_clients", drm_client_debugfs_internal_clients, 0 },
206 };
207
drm_client_debugfs_init(struct drm_device * dev)208 void drm_client_debugfs_init(struct drm_device *dev)
209 {
210 drm_debugfs_add_files(dev, drm_client_debugfs_list,
211 ARRAY_SIZE(drm_client_debugfs_list));
212 }
213 #endif
214