1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23#include <linux/export.h>
24
25#include <drm/drm_bridge.h>
26#include <drm/drm_device.h>
27#include <drm/drm_drv.h>
28#include <drm/drm_encoder.h>
29#include <drm/drm_managed.h>
30
31#include "drm_crtc_internal.h"
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58static const struct drm_prop_enum_list drm_encoder_enum_list[] = {
59 { DRM_MODE_ENCODER_NONE, "None" },
60 { DRM_MODE_ENCODER_DAC, "DAC" },
61 { DRM_MODE_ENCODER_TMDS, "TMDS" },
62 { DRM_MODE_ENCODER_LVDS, "LVDS" },
63 { DRM_MODE_ENCODER_TVDAC, "TV" },
64 { DRM_MODE_ENCODER_VIRTUAL, "Virtual" },
65 { DRM_MODE_ENCODER_DSI, "DSI" },
66 { DRM_MODE_ENCODER_DPMST, "DP MST" },
67 { DRM_MODE_ENCODER_DPI, "DPI" },
68};
69
70int drm_encoder_register_all(struct drm_device *dev)
71{
72 struct drm_encoder *encoder;
73 int ret = 0;
74
75 drm_for_each_encoder(encoder, dev) {
76 if (encoder->funcs && encoder->funcs->late_register)
77 ret = encoder->funcs->late_register(encoder);
78 if (ret)
79 return ret;
80 }
81
82 return 0;
83}
84
85void drm_encoder_unregister_all(struct drm_device *dev)
86{
87 struct drm_encoder *encoder;
88
89 drm_for_each_encoder(encoder, dev) {
90 if (encoder->funcs && encoder->funcs->early_unregister)
91 encoder->funcs->early_unregister(encoder);
92 }
93}
94
95__printf(5, 0)
96static int __drm_encoder_init(struct drm_device *dev,
97 struct drm_encoder *encoder,
98 const struct drm_encoder_funcs *funcs,
99 int encoder_type, const char *name, va_list ap)
100{
101 int ret;
102
103
104 if (WARN_ON(dev->mode_config.num_encoder >= 32))
105 return -EINVAL;
106
107 ret = drm_mode_object_add(dev, &encoder->base, DRM_MODE_OBJECT_ENCODER);
108 if (ret)
109 return ret;
110
111 encoder->dev = dev;
112 encoder->encoder_type = encoder_type;
113 encoder->funcs = funcs;
114 if (name) {
115 encoder->name = kvasprintf(GFP_KERNEL, name, ap);
116 } else {
117 encoder->name = kasprintf(GFP_KERNEL, "%s-%d",
118 drm_encoder_enum_list[encoder_type].name,
119 encoder->base.id);
120 }
121 if (!encoder->name) {
122 ret = -ENOMEM;
123 goto out_put;
124 }
125
126 INIT_LIST_HEAD(&encoder->bridge_chain);
127 list_add_tail(&encoder->head, &dev->mode_config.encoder_list);
128 encoder->index = dev->mode_config.num_encoder++;
129
130out_put:
131 if (ret)
132 drm_mode_object_unregister(dev, &encoder->base);
133
134 return ret;
135}
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158int drm_encoder_init(struct drm_device *dev,
159 struct drm_encoder *encoder,
160 const struct drm_encoder_funcs *funcs,
161 int encoder_type, const char *name, ...)
162{
163 va_list ap;
164 int ret;
165
166 WARN_ON(!funcs->destroy);
167
168 va_start(ap, name);
169 ret = __drm_encoder_init(dev, encoder, funcs, encoder_type, name, ap);
170 va_end(ap);
171
172 return ret;
173}
174EXPORT_SYMBOL(drm_encoder_init);
175
176
177
178
179
180
181
182void drm_encoder_cleanup(struct drm_encoder *encoder)
183{
184 struct drm_device *dev = encoder->dev;
185 struct drm_bridge *bridge, *next;
186
187
188
189
190
191
192 list_for_each_entry_safe(bridge, next, &encoder->bridge_chain,
193 chain_node)
194 drm_bridge_detach(bridge);
195
196 drm_mode_object_unregister(dev, &encoder->base);
197 kfree(encoder->name);
198 list_del(&encoder->head);
199 dev->mode_config.num_encoder--;
200
201 memset(encoder, 0, sizeof(*encoder));
202}
203EXPORT_SYMBOL(drm_encoder_cleanup);
204
205static void drmm_encoder_alloc_release(struct drm_device *dev, void *ptr)
206{
207 struct drm_encoder *encoder = ptr;
208
209 if (WARN_ON(!encoder->dev))
210 return;
211
212 drm_encoder_cleanup(encoder);
213}
214
215void *__drmm_encoder_alloc(struct drm_device *dev, size_t size, size_t offset,
216 const struct drm_encoder_funcs *funcs,
217 int encoder_type, const char *name, ...)
218{
219 void *container;
220 struct drm_encoder *encoder;
221 va_list ap;
222 int ret;
223
224 if (WARN_ON(funcs && funcs->destroy))
225 return ERR_PTR(-EINVAL);
226
227 container = drmm_kzalloc(dev, size, GFP_KERNEL);
228 if (!container)
229 return ERR_PTR(-EINVAL);
230
231 encoder = container + offset;
232
233 va_start(ap, name);
234 ret = __drm_encoder_init(dev, encoder, funcs, encoder_type, name, ap);
235 va_end(ap);
236 if (ret)
237 return ERR_PTR(ret);
238
239 ret = drmm_add_action_or_reset(dev, drmm_encoder_alloc_release, encoder);
240 if (ret)
241 return ERR_PTR(ret);
242
243 return container;
244}
245EXPORT_SYMBOL(__drmm_encoder_alloc);
246
247static struct drm_crtc *drm_encoder_get_crtc(struct drm_encoder *encoder)
248{
249 struct drm_connector *connector;
250 struct drm_device *dev = encoder->dev;
251 bool uses_atomic = false;
252 struct drm_connector_list_iter conn_iter;
253
254
255
256 drm_connector_list_iter_begin(dev, &conn_iter);
257 drm_for_each_connector_iter(connector, &conn_iter) {
258 if (!connector->state)
259 continue;
260
261 uses_atomic = true;
262
263 if (connector->state->best_encoder != encoder)
264 continue;
265
266 drm_connector_list_iter_end(&conn_iter);
267 return connector->state->crtc;
268 }
269 drm_connector_list_iter_end(&conn_iter);
270
271
272 if (uses_atomic)
273 return NULL;
274
275 return encoder->crtc;
276}
277
278int drm_mode_getencoder(struct drm_device *dev, void *data,
279 struct drm_file *file_priv)
280{
281 struct drm_mode_get_encoder *enc_resp = data;
282 struct drm_encoder *encoder;
283 struct drm_crtc *crtc;
284
285 if (!drm_core_check_feature(dev, DRIVER_MODESET))
286 return -EOPNOTSUPP;
287
288 encoder = drm_encoder_find(dev, file_priv, enc_resp->encoder_id);
289 if (!encoder)
290 return -ENOENT;
291
292 drm_modeset_lock(&dev->mode_config.connection_mutex, NULL);
293 crtc = drm_encoder_get_crtc(encoder);
294 if (crtc && drm_lease_held(file_priv, crtc->base.id))
295 enc_resp->crtc_id = crtc->base.id;
296 else
297 enc_resp->crtc_id = 0;
298 drm_modeset_unlock(&dev->mode_config.connection_mutex);
299
300 enc_resp->encoder_type = encoder->encoder_type;
301 enc_resp->encoder_id = encoder->base.id;
302 enc_resp->possible_crtcs = drm_lease_filter_crtcs(file_priv,
303 encoder->possible_crtcs);
304 enc_resp->possible_clones = encoder->possible_clones;
305
306 return 0;
307}
308