Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
tjh.dev
kernel
os
linux
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 */
32void 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}
52EXPORT_SYMBOL(drm_client_dev_unregister);
53
54static 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 */
86void 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}
103EXPORT_SYMBOL(drm_client_dev_hotplug);
104
105void 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
126static int drm_client_suspend(struct drm_client_dev *client)
127{
128 struct drm_device *dev = client->dev;
129 int ret = 0;
130
131 if (drm_WARN_ON_ONCE(dev, client->suspended))
132 return 0;
133
134 if (client->funcs && client->funcs->suspend)
135 ret = client->funcs->suspend(client);
136 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
137
138 client->suspended = true;
139
140 return ret;
141}
142
143void drm_client_dev_suspend(struct drm_device *dev)
144{
145 struct drm_client_dev *client;
146
147 mutex_lock(&dev->clientlist_mutex);
148 list_for_each_entry(client, &dev->clientlist, list) {
149 if (!client->suspended)
150 drm_client_suspend(client);
151 }
152 mutex_unlock(&dev->clientlist_mutex);
153}
154EXPORT_SYMBOL(drm_client_dev_suspend);
155
156static int drm_client_resume(struct drm_client_dev *client)
157{
158 struct drm_device *dev = client->dev;
159 int ret = 0;
160
161 if (drm_WARN_ON_ONCE(dev, !client->suspended))
162 return 0;
163
164 if (client->funcs && client->funcs->resume)
165 ret = client->funcs->resume(client);
166 drm_dbg_kms(dev, "%s: ret=%d\n", client->name, ret);
167
168 client->suspended = false;
169
170 if (client->hotplug_pending)
171 drm_client_hotplug(client);
172
173 return ret;
174}
175
176void drm_client_dev_resume(struct drm_device *dev)
177{
178 struct drm_client_dev *client;
179
180 mutex_lock(&dev->clientlist_mutex);
181 list_for_each_entry(client, &dev->clientlist, list) {
182 if (client->suspended)
183 drm_client_resume(client);
184 }
185 mutex_unlock(&dev->clientlist_mutex);
186}
187EXPORT_SYMBOL(drm_client_dev_resume);
188
189#ifdef CONFIG_DEBUG_FS
190static int drm_client_debugfs_internal_clients(struct seq_file *m, void *data)
191{
192 struct drm_debugfs_entry *entry = m->private;
193 struct drm_device *dev = entry->dev;
194 struct drm_printer p = drm_seq_file_printer(m);
195 struct drm_client_dev *client;
196
197 mutex_lock(&dev->clientlist_mutex);
198 list_for_each_entry(client, &dev->clientlist, list)
199 drm_printf(&p, "%s\n", client->name);
200 mutex_unlock(&dev->clientlist_mutex);
201
202 return 0;
203}
204
205static const struct drm_debugfs_info drm_client_debugfs_list[] = {
206 { "internal_clients", drm_client_debugfs_internal_clients, 0 },
207};
208
209void drm_client_debugfs_init(struct drm_device *dev)
210{
211 drm_debugfs_add_files(dev, drm_client_debugfs_list,
212 ARRAY_SIZE(drm_client_debugfs_list));
213}
214#endif