Commit | Line | Data |
---|---|---|
3d3f8b1f AK |
1 | /* |
2 | * Copyright (c) 2014 Samsung Electronics Co., Ltd | |
3 | * | |
4 | * Permission is hereby granted, free of charge, to any person obtaining a | |
5 | * copy of this software and associated documentation files (the "Software"), | |
6 | * to deal in the Software without restriction, including without limitation | |
7 | * the rights to use, copy, modify, merge, publish, distribute, sub license, | |
8 | * and/or sell copies of the Software, and to permit persons to whom the | |
9 | * Software is furnished to do so, subject to the following conditions: | |
10 | * | |
11 | * The above copyright notice and this permission notice (including the | |
12 | * next paragraph) shall be included in all copies or substantial portions | |
13 | * of the Software. | |
14 | * | |
15 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
16 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
17 | * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL | |
18 | * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
19 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING | |
20 | * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER | |
21 | * DEALINGS IN THE SOFTWARE. | |
22 | */ | |
23 | ||
24 | #include <linux/err.h> | |
25 | #include <linux/module.h> | |
199e4e96 | 26 | #include <linux/mutex.h> |
3d3f8b1f | 27 | |
75146591 | 28 | #include <drm/drm_atomic_state_helper.h> |
199e4e96 | 29 | #include <drm/drm_bridge.h> |
3bb80f24 | 30 | #include <drm/drm_encoder.h> |
3d3f8b1f | 31 | |
4a878c03 LP |
32 | #include "drm_crtc_internal.h" |
33 | ||
2331b4e4 AT |
34 | /** |
35 | * DOC: overview | |
36 | * | |
ea0dd85a | 37 | * &struct drm_bridge represents a device that hangs on to an encoder. These are |
da024fe5 | 38 | * handy when a regular &drm_encoder entity isn't enough to represent the entire |
2331b4e4 AT |
39 | * encoder chain. |
40 | * | |
da024fe5 | 41 | * A bridge is always attached to a single &drm_encoder at a time, but can be |
0451369b | 42 | * either connected to it directly, or through a chain of bridges:: |
2331b4e4 | 43 | * |
0451369b | 44 | * [ CRTC ---> ] Encoder ---> Bridge A ---> Bridge B |
2331b4e4 | 45 | * |
0451369b LP |
46 | * Here, the output of the encoder feeds to bridge A, and that furthers feeds to |
47 | * bridge B. Bridge chains can be arbitrarily long, and shall be fully linear: | |
48 | * Chaining multiple bridges to the output of a bridge, or the same bridge to | |
49 | * the output of different bridges, is not supported. | |
2331b4e4 | 50 | * |
0451369b LP |
51 | * Display drivers are responsible for linking encoders with the first bridge |
52 | * in the chains. This is done by acquiring the appropriate bridge with | |
53 | * of_drm_find_bridge() or drm_of_find_panel_or_bridge(), or creating it for a | |
54 | * panel with drm_panel_bridge_add_typed() (or the managed version | |
55 | * devm_drm_panel_bridge_add_typed()). Once acquired, the bridge shall be | |
56 | * attached to the encoder with a call to drm_bridge_attach(). | |
2331b4e4 | 57 | * |
0451369b LP |
58 | * Bridges are responsible for linking themselves with the next bridge in the |
59 | * chain, if any. This is done the same way as for encoders, with the call to | |
60 | * drm_bridge_attach() occurring in the &drm_bridge_funcs.attach operation. | |
61 | * | |
62 | * Once these links are created, the bridges can participate along with encoder | |
63 | * functions to perform mode validation and fixup (through | |
64 | * drm_bridge_chain_mode_valid() and drm_atomic_bridge_chain_check()), mode | |
65 | * setting (through drm_bridge_chain_mode_set()), enable (through | |
66 | * drm_atomic_bridge_chain_pre_enable() and drm_atomic_bridge_chain_enable()) | |
67 | * and disable (through drm_atomic_bridge_chain_disable() and | |
68 | * drm_atomic_bridge_chain_post_disable()). Those functions call the | |
69 | * corresponding operations provided in &drm_bridge_funcs in sequence for all | |
70 | * bridges in the chain. | |
71 | * | |
72 | * For display drivers that use the atomic helpers | |
73 | * drm_atomic_helper_check_modeset(), | |
74 | * drm_atomic_helper_commit_modeset_enables() and | |
75 | * drm_atomic_helper_commit_modeset_disables() (either directly in hand-rolled | |
76 | * commit check and commit tail handlers, or through the higher-level | |
77 | * drm_atomic_helper_check() and drm_atomic_helper_commit_tail() or | |
78 | * drm_atomic_helper_commit_tail_rpm() helpers), this is done transparently and | |
79 | * requires no intervention from the driver. For other drivers, the relevant | |
80 | * DRM bridge chain functions shall be called manually. | |
81 | * | |
5e20bdf3 LP |
82 | * Bridges also participate in implementing the &drm_connector at the end of |
83 | * the bridge chain. Display drivers may use the drm_bridge_connector_init() | |
84 | * helper to create the &drm_connector, or implement it manually on top of the | |
85 | * connector-related operations exposed by the bridge (see the overview | |
86 | * documentation of bridge operations for more details). | |
87 | * | |
0451369b | 88 | * &drm_bridge, like &drm_panel, aren't &drm_mode_object entities like planes, |
da024fe5 DV |
89 | * CRTCs, encoders or connectors and hence are not visible to userspace. They |
90 | * just provide additional hooks to get the desired output at the end of the | |
91 | * encoder chain. | |
2331b4e4 AT |
92 | */ |
93 | ||
3d3f8b1f AK |
94 | static DEFINE_MUTEX(bridge_lock); |
95 | static LIST_HEAD(bridge_list); | |
96 | ||
2331b4e4 AT |
97 | /** |
98 | * drm_bridge_add - add the given bridge to the global bridge list | |
99 | * | |
100 | * @bridge: bridge control structure | |
2331b4e4 | 101 | */ |
99286884 | 102 | void drm_bridge_add(struct drm_bridge *bridge) |
3d3f8b1f | 103 | { |
11f6c4b1 LP |
104 | mutex_init(&bridge->hpd_mutex); |
105 | ||
3d3f8b1f AK |
106 | mutex_lock(&bridge_lock); |
107 | list_add_tail(&bridge->list, &bridge_list); | |
108 | mutex_unlock(&bridge_lock); | |
3d3f8b1f AK |
109 | } |
110 | EXPORT_SYMBOL(drm_bridge_add); | |
111 | ||
2331b4e4 AT |
112 | /** |
113 | * drm_bridge_remove - remove the given bridge from the global bridge list | |
114 | * | |
115 | * @bridge: bridge control structure | |
116 | */ | |
3d3f8b1f AK |
117 | void drm_bridge_remove(struct drm_bridge *bridge) |
118 | { | |
119 | mutex_lock(&bridge_lock); | |
120 | list_del_init(&bridge->list); | |
121 | mutex_unlock(&bridge_lock); | |
11f6c4b1 LP |
122 | |
123 | mutex_destroy(&bridge->hpd_mutex); | |
3d3f8b1f AK |
124 | } |
125 | EXPORT_SYMBOL(drm_bridge_remove); | |
126 | ||
75146591 BB |
127 | static struct drm_private_state * |
128 | drm_bridge_atomic_duplicate_priv_state(struct drm_private_obj *obj) | |
129 | { | |
130 | struct drm_bridge *bridge = drm_priv_to_bridge(obj); | |
131 | struct drm_bridge_state *state; | |
132 | ||
133 | state = bridge->funcs->atomic_duplicate_state(bridge); | |
134 | return state ? &state->base : NULL; | |
135 | } | |
136 | ||
137 | static void | |
138 | drm_bridge_atomic_destroy_priv_state(struct drm_private_obj *obj, | |
139 | struct drm_private_state *s) | |
140 | { | |
141 | struct drm_bridge_state *state = drm_priv_to_bridge_state(s); | |
142 | struct drm_bridge *bridge = drm_priv_to_bridge(obj); | |
143 | ||
144 | bridge->funcs->atomic_destroy_state(bridge, state); | |
145 | } | |
146 | ||
147 | static const struct drm_private_state_funcs drm_bridge_priv_state_funcs = { | |
148 | .atomic_duplicate_state = drm_bridge_atomic_duplicate_priv_state, | |
149 | .atomic_destroy_state = drm_bridge_atomic_destroy_priv_state, | |
150 | }; | |
151 | ||
2331b4e4 | 152 | /** |
3bb80f24 | 153 | * drm_bridge_attach - attach the bridge to an encoder's chain |
2331b4e4 | 154 | * |
3bb80f24 LP |
155 | * @encoder: DRM encoder |
156 | * @bridge: bridge to attach | |
157 | * @previous: previous bridge in the chain (optional) | |
a25b988f | 158 | * @flags: DRM_BRIDGE_ATTACH_* flags |
2331b4e4 | 159 | * |
3bb80f24 LP |
160 | * Called by a kms driver to link the bridge to an encoder's chain. The previous |
161 | * argument specifies the previous bridge in the chain. If NULL, the bridge is | |
162 | * linked directly at the encoder's output. Otherwise it is linked at the | |
163 | * previous bridge's output. | |
2331b4e4 | 164 | * |
3bb80f24 LP |
165 | * If non-NULL the previous bridge must be already attached by a call to this |
166 | * function. | |
2331b4e4 | 167 | * |
169cc4c7 PR |
168 | * Note that bridges attached to encoders are auto-detached during encoder |
169 | * cleanup in drm_encoder_cleanup(), so drm_bridge_attach() should generally | |
170 | * *not* be balanced with a drm_bridge_detach() in driver code. | |
171 | * | |
2331b4e4 AT |
172 | * RETURNS: |
173 | * Zero on success, error code on failure | |
174 | */ | |
3bb80f24 | 175 | int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, |
a25b988f LP |
176 | struct drm_bridge *previous, |
177 | enum drm_bridge_attach_flags flags) | |
3d3f8b1f | 178 | { |
3bb80f24 LP |
179 | int ret; |
180 | ||
181 | if (!encoder || !bridge) | |
182 | return -EINVAL; | |
183 | ||
184 | if (previous && (!previous->dev || previous->encoder != encoder)) | |
3d3f8b1f AK |
185 | return -EINVAL; |
186 | ||
187 | if (bridge->dev) | |
188 | return -EBUSY; | |
189 | ||
3bb80f24 LP |
190 | bridge->dev = encoder->dev; |
191 | bridge->encoder = encoder; | |
192 | ||
05193dc3 BB |
193 | if (previous) |
194 | list_add(&bridge->chain_node, &previous->chain_node); | |
195 | else | |
196 | list_add(&bridge->chain_node, &encoder->bridge_chain); | |
197 | ||
3bb80f24 | 198 | if (bridge->funcs->attach) { |
a25b988f | 199 | ret = bridge->funcs->attach(bridge, flags); |
75146591 BB |
200 | if (ret < 0) |
201 | goto err_reset_bridge; | |
202 | } | |
203 | ||
204 | if (bridge->funcs->atomic_reset) { | |
205 | struct drm_bridge_state *state; | |
206 | ||
207 | state = bridge->funcs->atomic_reset(bridge); | |
208 | if (IS_ERR(state)) { | |
209 | ret = PTR_ERR(state); | |
210 | goto err_detach_bridge; | |
09912635 | 211 | } |
75146591 BB |
212 | |
213 | drm_atomic_private_obj_init(bridge->dev, &bridge->base, | |
214 | &state->base, | |
215 | &drm_bridge_priv_state_funcs); | |
6ed7e962 BB |
216 | } |
217 | ||
3d3f8b1f | 218 | return 0; |
75146591 BB |
219 | |
220 | err_detach_bridge: | |
221 | if (bridge->funcs->detach) | |
222 | bridge->funcs->detach(bridge); | |
223 | ||
224 | err_reset_bridge: | |
225 | bridge->dev = NULL; | |
226 | bridge->encoder = NULL; | |
227 | list_del(&bridge->chain_node); | |
228 | return ret; | |
3d3f8b1f AK |
229 | } |
230 | EXPORT_SYMBOL(drm_bridge_attach); | |
231 | ||
cf3bef95 AM |
232 | void drm_bridge_detach(struct drm_bridge *bridge) |
233 | { | |
234 | if (WARN_ON(!bridge)) | |
235 | return; | |
236 | ||
237 | if (WARN_ON(!bridge->dev)) | |
238 | return; | |
239 | ||
75146591 BB |
240 | if (bridge->funcs->atomic_reset) |
241 | drm_atomic_private_obj_fini(&bridge->base); | |
242 | ||
cf3bef95 AM |
243 | if (bridge->funcs->detach) |
244 | bridge->funcs->detach(bridge); | |
245 | ||
05193dc3 | 246 | list_del(&bridge->chain_node); |
cf3bef95 AM |
247 | bridge->dev = NULL; |
248 | } | |
cf3bef95 | 249 | |
2331b4e4 | 250 | /** |
0451369b LP |
251 | * DOC: bridge operations |
252 | * | |
253 | * Bridge drivers expose operations through the &drm_bridge_funcs structure. | |
254 | * The DRM internals (atomic and CRTC helpers) use the helpers defined in | |
255 | * drm_bridge.c to call bridge operations. Those operations are divided in | |
11f6c4b1 | 256 | * three big categories to support different parts of the bridge usage. |
0451369b LP |
257 | * |
258 | * - The encoder-related operations support control of the bridges in the | |
259 | * chain, and are roughly counterparts to the &drm_encoder_helper_funcs | |
260 | * operations. They are used by the legacy CRTC and the atomic modeset | |
261 | * helpers to perform mode validation, fixup and setting, and enable and | |
262 | * disable the bridge automatically. | |
263 | * | |
264 | * The enable and disable operations are split in | |
265 | * &drm_bridge_funcs.pre_enable, &drm_bridge_funcs.enable, | |
266 | * &drm_bridge_funcs.disable and &drm_bridge_funcs.post_disable to provide | |
267 | * finer-grained control. | |
2331b4e4 | 268 | * |
0451369b LP |
269 | * Bridge drivers may implement the legacy version of those operations, or |
270 | * the atomic version (prefixed with atomic\_), in which case they shall also | |
271 | * implement the atomic state bookkeeping operations | |
272 | * (&drm_bridge_funcs.atomic_duplicate_state, | |
273 | * &drm_bridge_funcs.atomic_destroy_state and &drm_bridge_funcs.reset). | |
274 | * Mixing atomic and non-atomic versions of the operations is not supported. | |
2331b4e4 | 275 | * |
0451369b LP |
276 | * - The bus format negotiation operations |
277 | * &drm_bridge_funcs.atomic_get_output_bus_fmts and | |
278 | * &drm_bridge_funcs.atomic_get_input_bus_fmts allow bridge drivers to | |
279 | * negotiate the formats transmitted between bridges in the chain when | |
280 | * multiple formats are supported. Negotiation for formats is performed | |
281 | * transparently for display drivers by the atomic modeset helpers. Only | |
282 | * atomic versions of those operations exist, bridge drivers that need to | |
283 | * implement them shall thus also implement the atomic version of the | |
284 | * encoder-related operations. This feature is not supported by the legacy | |
285 | * CRTC helpers. | |
11f6c4b1 LP |
286 | * |
287 | * - The connector-related operations support implementing a &drm_connector | |
288 | * based on a chain of bridges. DRM bridges traditionally create a | |
289 | * &drm_connector for bridges meant to be used at the end of the chain. This | |
290 | * puts additional burden on bridge drivers, especially for bridges that may | |
291 | * be used in the middle of a chain or at the end of it. Furthermore, it | |
292 | * requires all operations of the &drm_connector to be handled by a single | |
293 | * bridge, which doesn't always match the hardware architecture. | |
294 | * | |
295 | * To simplify bridge drivers and make the connector implementation more | |
296 | * flexible, a new model allows bridges to unconditionally skip creation of | |
297 | * &drm_connector and instead expose &drm_bridge_funcs operations to support | |
298 | * an externally-implemented &drm_connector. Those operations are | |
299 | * &drm_bridge_funcs.detect, &drm_bridge_funcs.get_modes, | |
300 | * &drm_bridge_funcs.get_edid, &drm_bridge_funcs.hpd_notify, | |
301 | * &drm_bridge_funcs.hpd_enable and &drm_bridge_funcs.hpd_disable. When | |
302 | * implemented, display drivers shall create a &drm_connector instance for | |
303 | * each chain of bridges, and implement those connector instances based on | |
304 | * the bridge connector operations. | |
305 | * | |
306 | * Bridge drivers shall implement the connector-related operations for all | |
307 | * the features that the bridge hardware support. For instance, if a bridge | |
308 | * supports reading EDID, the &drm_bridge_funcs.get_edid shall be | |
309 | * implemented. This however doesn't mean that the DDC lines are wired to the | |
310 | * bridge on a particular platform, as they could also be connected to an I2C | |
311 | * controller of the SoC. Support for the connector-related operations on the | |
312 | * running platform is reported through the &drm_bridge.ops flags. Bridge | |
313 | * drivers shall detect which operations they can support on the platform | |
314 | * (usually this information is provided by ACPI or DT), and set the | |
315 | * &drm_bridge.ops flags for all supported operations. A flag shall only be | |
316 | * set if the corresponding &drm_bridge_funcs operation is implemented, but | |
317 | * an implemented operation doesn't necessarily imply that the corresponding | |
318 | * flag will be set. Display drivers shall use the &drm_bridge.ops flags to | |
319 | * decide which bridge to delegate a connector operation to. This mechanism | |
320 | * allows providing a single static const &drm_bridge_funcs instance in | |
321 | * bridge drivers, improving security by storing function pointers in | |
322 | * read-only memory. | |
a25b988f LP |
323 | * |
324 | * In order to ease transition, bridge drivers may support both the old and | |
325 | * new models by making connector creation optional and implementing the | |
326 | * connected-related bridge operations. Connector creation is then controlled | |
327 | * by the flags argument to the drm_bridge_attach() function. Display drivers | |
328 | * that support the new model and create connectors themselves shall set the | |
329 | * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag, and bridge drivers shall then skip | |
330 | * connector creation. For intermediate bridges in the chain, the flag shall | |
331 | * be passed to the drm_bridge_attach() call for the downstream bridge. | |
332 | * Bridge drivers that implement the new model only shall return an error | |
333 | * from their &drm_bridge_funcs.attach handler when the | |
334 | * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag is not set. New display drivers | |
335 | * should use the new model, and convert the bridge drivers they use if | |
336 | * needed, in order to gradually transition to the new model. | |
2331b4e4 AT |
337 | */ |
338 | ||
862e686c | 339 | /** |
ea099adf BB |
340 | * drm_bridge_chain_mode_fixup - fixup proposed mode for all bridges in the |
341 | * encoder chain | |
862e686c AT |
342 | * @bridge: bridge control structure |
343 | * @mode: desired mode to be set for the bridge | |
344 | * @adjusted_mode: updated mode that works for this bridge | |
345 | * | |
4541d31e | 346 | * Calls &drm_bridge_funcs.mode_fixup for all the bridges in the |
862e686c AT |
347 | * encoder chain, starting from the first bridge to the last. |
348 | * | |
349 | * Note: the bridge passed should be the one closest to the encoder | |
350 | * | |
351 | * RETURNS: | |
352 | * true on success, false on failure | |
353 | */ | |
ea099adf BB |
354 | bool drm_bridge_chain_mode_fixup(struct drm_bridge *bridge, |
355 | const struct drm_display_mode *mode, | |
356 | struct drm_display_mode *adjusted_mode) | |
862e686c | 357 | { |
05193dc3 | 358 | struct drm_encoder *encoder; |
862e686c AT |
359 | |
360 | if (!bridge) | |
361 | return true; | |
362 | ||
05193dc3 BB |
363 | encoder = bridge->encoder; |
364 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
365 | if (!bridge->funcs->mode_fixup) | |
366 | continue; | |
862e686c | 367 | |
05193dc3 BB |
368 | if (!bridge->funcs->mode_fixup(bridge, mode, adjusted_mode)) |
369 | return false; | |
370 | } | |
862e686c | 371 | |
05193dc3 | 372 | return true; |
862e686c | 373 | } |
ea099adf | 374 | EXPORT_SYMBOL(drm_bridge_chain_mode_fixup); |
862e686c | 375 | |
b1240f81 | 376 | /** |
ea099adf BB |
377 | * drm_bridge_chain_mode_valid - validate the mode against all bridges in the |
378 | * encoder chain. | |
b1240f81 | 379 | * @bridge: bridge control structure |
12c683e1 | 380 | * @info: display info against which the mode shall be validated |
b1240f81 JA |
381 | * @mode: desired mode to be validated |
382 | * | |
383 | * Calls &drm_bridge_funcs.mode_valid for all the bridges in the encoder | |
384 | * chain, starting from the first bridge to the last. If at least one bridge | |
385 | * does not accept the mode the function returns the error code. | |
386 | * | |
387 | * Note: the bridge passed should be the one closest to the encoder. | |
388 | * | |
389 | * RETURNS: | |
390 | * MODE_OK on success, drm_mode_status Enum error code on failure | |
391 | */ | |
ea099adf BB |
392 | enum drm_mode_status |
393 | drm_bridge_chain_mode_valid(struct drm_bridge *bridge, | |
12c683e1 | 394 | const struct drm_display_info *info, |
ea099adf | 395 | const struct drm_display_mode *mode) |
b1240f81 | 396 | { |
05193dc3 | 397 | struct drm_encoder *encoder; |
b1240f81 JA |
398 | |
399 | if (!bridge) | |
05193dc3 | 400 | return MODE_OK; |
b1240f81 | 401 | |
05193dc3 BB |
402 | encoder = bridge->encoder; |
403 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
404 | enum drm_mode_status ret; | |
405 | ||
406 | if (!bridge->funcs->mode_valid) | |
407 | continue; | |
b1240f81 | 408 | |
12c683e1 | 409 | ret = bridge->funcs->mode_valid(bridge, info, mode); |
05193dc3 BB |
410 | if (ret != MODE_OK) |
411 | return ret; | |
412 | } | |
b1240f81 | 413 | |
05193dc3 | 414 | return MODE_OK; |
b1240f81 | 415 | } |
ea099adf | 416 | EXPORT_SYMBOL(drm_bridge_chain_mode_valid); |
b1240f81 | 417 | |
862e686c | 418 | /** |
ea099adf | 419 | * drm_bridge_chain_disable - disables all bridges in the encoder chain |
862e686c AT |
420 | * @bridge: bridge control structure |
421 | * | |
4541d31e | 422 | * Calls &drm_bridge_funcs.disable op for all the bridges in the encoder |
862e686c AT |
423 | * chain, starting from the last bridge to the first. These are called before |
424 | * calling the encoder's prepare op. | |
425 | * | |
426 | * Note: the bridge passed should be the one closest to the encoder | |
427 | */ | |
ea099adf | 428 | void drm_bridge_chain_disable(struct drm_bridge *bridge) |
862e686c | 429 | { |
05193dc3 BB |
430 | struct drm_encoder *encoder; |
431 | struct drm_bridge *iter; | |
432 | ||
862e686c AT |
433 | if (!bridge) |
434 | return; | |
435 | ||
05193dc3 BB |
436 | encoder = bridge->encoder; |
437 | list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { | |
438 | if (iter->funcs->disable) | |
439 | iter->funcs->disable(iter); | |
862e686c | 440 | |
05193dc3 BB |
441 | if (iter == bridge) |
442 | break; | |
443 | } | |
862e686c | 444 | } |
ea099adf | 445 | EXPORT_SYMBOL(drm_bridge_chain_disable); |
862e686c AT |
446 | |
447 | /** | |
ea099adf BB |
448 | * drm_bridge_chain_post_disable - cleans up after disabling all bridges in the |
449 | * encoder chain | |
862e686c AT |
450 | * @bridge: bridge control structure |
451 | * | |
4541d31e | 452 | * Calls &drm_bridge_funcs.post_disable op for all the bridges in the |
862e686c AT |
453 | * encoder chain, starting from the first bridge to the last. These are called |
454 | * after completing the encoder's prepare op. | |
455 | * | |
456 | * Note: the bridge passed should be the one closest to the encoder | |
457 | */ | |
ea099adf | 458 | void drm_bridge_chain_post_disable(struct drm_bridge *bridge) |
862e686c | 459 | { |
05193dc3 BB |
460 | struct drm_encoder *encoder; |
461 | ||
862e686c AT |
462 | if (!bridge) |
463 | return; | |
464 | ||
05193dc3 BB |
465 | encoder = bridge->encoder; |
466 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
467 | if (bridge->funcs->post_disable) | |
468 | bridge->funcs->post_disable(bridge); | |
469 | } | |
862e686c | 470 | } |
ea099adf | 471 | EXPORT_SYMBOL(drm_bridge_chain_post_disable); |
862e686c AT |
472 | |
473 | /** | |
ea099adf BB |
474 | * drm_bridge_chain_mode_set - set proposed mode for all bridges in the |
475 | * encoder chain | |
862e686c | 476 | * @bridge: bridge control structure |
ea099adf BB |
477 | * @mode: desired mode to be set for the encoder chain |
478 | * @adjusted_mode: updated mode that works for this encoder chain | |
862e686c | 479 | * |
4541d31e | 480 | * Calls &drm_bridge_funcs.mode_set op for all the bridges in the |
862e686c AT |
481 | * encoder chain, starting from the first bridge to the last. |
482 | * | |
483 | * Note: the bridge passed should be the one closest to the encoder | |
484 | */ | |
ea099adf BB |
485 | void drm_bridge_chain_mode_set(struct drm_bridge *bridge, |
486 | const struct drm_display_mode *mode, | |
487 | const struct drm_display_mode *adjusted_mode) | |
862e686c | 488 | { |
05193dc3 BB |
489 | struct drm_encoder *encoder; |
490 | ||
862e686c AT |
491 | if (!bridge) |
492 | return; | |
493 | ||
05193dc3 BB |
494 | encoder = bridge->encoder; |
495 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
496 | if (bridge->funcs->mode_set) | |
497 | bridge->funcs->mode_set(bridge, mode, adjusted_mode); | |
498 | } | |
862e686c | 499 | } |
ea099adf | 500 | EXPORT_SYMBOL(drm_bridge_chain_mode_set); |
862e686c AT |
501 | |
502 | /** | |
ea099adf BB |
503 | * drm_bridge_chain_pre_enable - prepares for enabling all bridges in the |
504 | * encoder chain | |
862e686c AT |
505 | * @bridge: bridge control structure |
506 | * | |
4541d31e | 507 | * Calls &drm_bridge_funcs.pre_enable op for all the bridges in the encoder |
862e686c AT |
508 | * chain, starting from the last bridge to the first. These are called |
509 | * before calling the encoder's commit op. | |
510 | * | |
511 | * Note: the bridge passed should be the one closest to the encoder | |
512 | */ | |
ea099adf | 513 | void drm_bridge_chain_pre_enable(struct drm_bridge *bridge) |
862e686c | 514 | { |
05193dc3 BB |
515 | struct drm_encoder *encoder; |
516 | struct drm_bridge *iter; | |
517 | ||
862e686c AT |
518 | if (!bridge) |
519 | return; | |
520 | ||
05193dc3 BB |
521 | encoder = bridge->encoder; |
522 | list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { | |
523 | if (iter->funcs->pre_enable) | |
524 | iter->funcs->pre_enable(iter); | |
525 | } | |
862e686c | 526 | } |
ea099adf | 527 | EXPORT_SYMBOL(drm_bridge_chain_pre_enable); |
862e686c AT |
528 | |
529 | /** | |
ea099adf | 530 | * drm_bridge_chain_enable - enables all bridges in the encoder chain |
862e686c AT |
531 | * @bridge: bridge control structure |
532 | * | |
4541d31e | 533 | * Calls &drm_bridge_funcs.enable op for all the bridges in the encoder |
862e686c AT |
534 | * chain, starting from the first bridge to the last. These are called |
535 | * after completing the encoder's commit op. | |
536 | * | |
537 | * Note that the bridge passed should be the one closest to the encoder | |
538 | */ | |
ea099adf | 539 | void drm_bridge_chain_enable(struct drm_bridge *bridge) |
862e686c | 540 | { |
05193dc3 BB |
541 | struct drm_encoder *encoder; |
542 | ||
862e686c AT |
543 | if (!bridge) |
544 | return; | |
545 | ||
05193dc3 BB |
546 | encoder = bridge->encoder; |
547 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
548 | if (bridge->funcs->enable) | |
549 | bridge->funcs->enable(bridge); | |
550 | } | |
862e686c | 551 | } |
ea099adf | 552 | EXPORT_SYMBOL(drm_bridge_chain_enable); |
862e686c | 553 | |
5ade071b | 554 | /** |
ea099adf | 555 | * drm_atomic_bridge_chain_disable - disables all bridges in the encoder chain |
5ade071b | 556 | * @bridge: bridge control structure |
f3fdbc72 | 557 | * @old_state: old atomic state |
5ade071b SP |
558 | * |
559 | * Calls &drm_bridge_funcs.atomic_disable (falls back on | |
560 | * &drm_bridge_funcs.disable) op for all the bridges in the encoder chain, | |
561 | * starting from the last bridge to the first. These are called before calling | |
562 | * &drm_encoder_helper_funcs.atomic_disable | |
563 | * | |
564 | * Note: the bridge passed should be the one closest to the encoder | |
565 | */ | |
ea099adf | 566 | void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge, |
f3fdbc72 | 567 | struct drm_atomic_state *old_state) |
5ade071b | 568 | { |
05193dc3 BB |
569 | struct drm_encoder *encoder; |
570 | struct drm_bridge *iter; | |
571 | ||
5ade071b SP |
572 | if (!bridge) |
573 | return; | |
574 | ||
05193dc3 BB |
575 | encoder = bridge->encoder; |
576 | list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { | |
41cf5712 BB |
577 | if (iter->funcs->atomic_disable) { |
578 | struct drm_bridge_state *old_bridge_state; | |
579 | ||
580 | old_bridge_state = | |
581 | drm_atomic_get_old_bridge_state(old_state, | |
582 | iter); | |
583 | if (WARN_ON(!old_bridge_state)) | |
584 | return; | |
585 | ||
586 | iter->funcs->atomic_disable(iter, old_bridge_state); | |
587 | } else if (iter->funcs->disable) { | |
05193dc3 | 588 | iter->funcs->disable(iter); |
41cf5712 | 589 | } |
5ade071b | 590 | |
05193dc3 BB |
591 | if (iter == bridge) |
592 | break; | |
593 | } | |
5ade071b | 594 | } |
ea099adf | 595 | EXPORT_SYMBOL(drm_atomic_bridge_chain_disable); |
5ade071b SP |
596 | |
597 | /** | |
ea099adf BB |
598 | * drm_atomic_bridge_chain_post_disable - cleans up after disabling all bridges |
599 | * in the encoder chain | |
5ade071b | 600 | * @bridge: bridge control structure |
f3fdbc72 | 601 | * @old_state: old atomic state |
5ade071b SP |
602 | * |
603 | * Calls &drm_bridge_funcs.atomic_post_disable (falls back on | |
604 | * &drm_bridge_funcs.post_disable) op for all the bridges in the encoder chain, | |
605 | * starting from the first bridge to the last. These are called after completing | |
606 | * &drm_encoder_helper_funcs.atomic_disable | |
607 | * | |
608 | * Note: the bridge passed should be the one closest to the encoder | |
609 | */ | |
ea099adf | 610 | void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge, |
f3fdbc72 | 611 | struct drm_atomic_state *old_state) |
5ade071b | 612 | { |
05193dc3 BB |
613 | struct drm_encoder *encoder; |
614 | ||
5ade071b SP |
615 | if (!bridge) |
616 | return; | |
617 | ||
05193dc3 BB |
618 | encoder = bridge->encoder; |
619 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
41cf5712 BB |
620 | if (bridge->funcs->atomic_post_disable) { |
621 | struct drm_bridge_state *old_bridge_state; | |
622 | ||
623 | old_bridge_state = | |
624 | drm_atomic_get_old_bridge_state(old_state, | |
625 | bridge); | |
626 | if (WARN_ON(!old_bridge_state)) | |
627 | return; | |
628 | ||
629 | bridge->funcs->atomic_post_disable(bridge, | |
630 | old_bridge_state); | |
631 | } else if (bridge->funcs->post_disable) { | |
05193dc3 | 632 | bridge->funcs->post_disable(bridge); |
41cf5712 | 633 | } |
05193dc3 | 634 | } |
5ade071b | 635 | } |
ea099adf | 636 | EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable); |
5ade071b SP |
637 | |
638 | /** | |
ea099adf BB |
639 | * drm_atomic_bridge_chain_pre_enable - prepares for enabling all bridges in |
640 | * the encoder chain | |
5ade071b | 641 | * @bridge: bridge control structure |
f3fdbc72 | 642 | * @old_state: old atomic state |
5ade071b SP |
643 | * |
644 | * Calls &drm_bridge_funcs.atomic_pre_enable (falls back on | |
645 | * &drm_bridge_funcs.pre_enable) op for all the bridges in the encoder chain, | |
646 | * starting from the last bridge to the first. These are called before calling | |
647 | * &drm_encoder_helper_funcs.atomic_enable | |
648 | * | |
649 | * Note: the bridge passed should be the one closest to the encoder | |
650 | */ | |
ea099adf | 651 | void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge, |
f3fdbc72 | 652 | struct drm_atomic_state *old_state) |
5ade071b | 653 | { |
05193dc3 BB |
654 | struct drm_encoder *encoder; |
655 | struct drm_bridge *iter; | |
656 | ||
5ade071b SP |
657 | if (!bridge) |
658 | return; | |
659 | ||
05193dc3 BB |
660 | encoder = bridge->encoder; |
661 | list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { | |
41cf5712 BB |
662 | if (iter->funcs->atomic_pre_enable) { |
663 | struct drm_bridge_state *old_bridge_state; | |
664 | ||
665 | old_bridge_state = | |
666 | drm_atomic_get_old_bridge_state(old_state, | |
667 | iter); | |
668 | if (WARN_ON(!old_bridge_state)) | |
669 | return; | |
670 | ||
671 | iter->funcs->atomic_pre_enable(iter, old_bridge_state); | |
672 | } else if (iter->funcs->pre_enable) { | |
05193dc3 | 673 | iter->funcs->pre_enable(iter); |
41cf5712 | 674 | } |
5ade071b | 675 | |
05193dc3 BB |
676 | if (iter == bridge) |
677 | break; | |
678 | } | |
5ade071b | 679 | } |
ea099adf | 680 | EXPORT_SYMBOL(drm_atomic_bridge_chain_pre_enable); |
5ade071b SP |
681 | |
682 | /** | |
ea099adf | 683 | * drm_atomic_bridge_chain_enable - enables all bridges in the encoder chain |
5ade071b | 684 | * @bridge: bridge control structure |
f3fdbc72 | 685 | * @old_state: old atomic state |
5ade071b SP |
686 | * |
687 | * Calls &drm_bridge_funcs.atomic_enable (falls back on | |
688 | * &drm_bridge_funcs.enable) op for all the bridges in the encoder chain, | |
689 | * starting from the first bridge to the last. These are called after completing | |
690 | * &drm_encoder_helper_funcs.atomic_enable | |
691 | * | |
692 | * Note: the bridge passed should be the one closest to the encoder | |
693 | */ | |
ea099adf | 694 | void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, |
f3fdbc72 | 695 | struct drm_atomic_state *old_state) |
5ade071b | 696 | { |
05193dc3 BB |
697 | struct drm_encoder *encoder; |
698 | ||
5ade071b SP |
699 | if (!bridge) |
700 | return; | |
701 | ||
05193dc3 BB |
702 | encoder = bridge->encoder; |
703 | list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) { | |
41cf5712 BB |
704 | if (bridge->funcs->atomic_enable) { |
705 | struct drm_bridge_state *old_bridge_state; | |
706 | ||
707 | old_bridge_state = | |
708 | drm_atomic_get_old_bridge_state(old_state, | |
709 | bridge); | |
710 | if (WARN_ON(!old_bridge_state)) | |
711 | return; | |
712 | ||
713 | bridge->funcs->atomic_enable(bridge, old_bridge_state); | |
714 | } else if (bridge->funcs->enable) { | |
05193dc3 | 715 | bridge->funcs->enable(bridge); |
41cf5712 | 716 | } |
05193dc3 | 717 | } |
5ade071b | 718 | } |
ea099adf | 719 | EXPORT_SYMBOL(drm_atomic_bridge_chain_enable); |
5ade071b | 720 | |
5061b8a9 BB |
721 | static int drm_atomic_bridge_check(struct drm_bridge *bridge, |
722 | struct drm_crtc_state *crtc_state, | |
723 | struct drm_connector_state *conn_state) | |
724 | { | |
725 | if (bridge->funcs->atomic_check) { | |
726 | struct drm_bridge_state *bridge_state; | |
727 | int ret; | |
728 | ||
729 | bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, | |
730 | bridge); | |
731 | if (WARN_ON(!bridge_state)) | |
732 | return -EINVAL; | |
733 | ||
734 | ret = bridge->funcs->atomic_check(bridge, bridge_state, | |
735 | crtc_state, conn_state); | |
736 | if (ret) | |
737 | return ret; | |
738 | } else if (bridge->funcs->mode_fixup) { | |
739 | if (!bridge->funcs->mode_fixup(bridge, &crtc_state->mode, | |
740 | &crtc_state->adjusted_mode)) | |
741 | return -EINVAL; | |
742 | } | |
743 | ||
744 | return 0; | |
745 | } | |
746 | ||
f32df58a BB |
747 | static int select_bus_fmt_recursive(struct drm_bridge *first_bridge, |
748 | struct drm_bridge *cur_bridge, | |
749 | struct drm_crtc_state *crtc_state, | |
750 | struct drm_connector_state *conn_state, | |
751 | u32 out_bus_fmt) | |
752 | { | |
753 | struct drm_bridge_state *cur_state; | |
754 | unsigned int num_in_bus_fmts, i; | |
755 | struct drm_bridge *prev_bridge; | |
756 | u32 *in_bus_fmts; | |
757 | int ret; | |
758 | ||
759 | prev_bridge = drm_bridge_get_prev_bridge(cur_bridge); | |
760 | cur_state = drm_atomic_get_new_bridge_state(crtc_state->state, | |
761 | cur_bridge); | |
762 | ||
763 | /* | |
764 | * If bus format negotiation is not supported by this bridge, let's | |
765 | * pass MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and | |
766 | * hope that it can handle this situation gracefully (by providing | |
767 | * appropriate default values). | |
768 | */ | |
769 | if (!cur_bridge->funcs->atomic_get_input_bus_fmts) { | |
770 | if (cur_bridge != first_bridge) { | |
771 | ret = select_bus_fmt_recursive(first_bridge, | |
772 | prev_bridge, crtc_state, | |
773 | conn_state, | |
774 | MEDIA_BUS_FMT_FIXED); | |
775 | if (ret) | |
776 | return ret; | |
777 | } | |
778 | ||
779 | /* | |
780 | * Driver does not implement the atomic state hooks, but that's | |
781 | * fine, as long as it does not access the bridge state. | |
782 | */ | |
783 | if (cur_state) { | |
784 | cur_state->input_bus_cfg.format = MEDIA_BUS_FMT_FIXED; | |
785 | cur_state->output_bus_cfg.format = out_bus_fmt; | |
786 | } | |
787 | ||
788 | return 0; | |
789 | } | |
790 | ||
791 | /* | |
792 | * If the driver implements ->atomic_get_input_bus_fmts() it | |
793 | * should also implement the atomic state hooks. | |
794 | */ | |
795 | if (WARN_ON(!cur_state)) | |
796 | return -EINVAL; | |
797 | ||
798 | in_bus_fmts = cur_bridge->funcs->atomic_get_input_bus_fmts(cur_bridge, | |
799 | cur_state, | |
800 | crtc_state, | |
801 | conn_state, | |
802 | out_bus_fmt, | |
803 | &num_in_bus_fmts); | |
804 | if (!num_in_bus_fmts) | |
805 | return -ENOTSUPP; | |
806 | else if (!in_bus_fmts) | |
807 | return -ENOMEM; | |
808 | ||
809 | if (first_bridge == cur_bridge) { | |
810 | cur_state->input_bus_cfg.format = in_bus_fmts[0]; | |
811 | cur_state->output_bus_cfg.format = out_bus_fmt; | |
812 | kfree(in_bus_fmts); | |
813 | return 0; | |
814 | } | |
815 | ||
816 | for (i = 0; i < num_in_bus_fmts; i++) { | |
817 | ret = select_bus_fmt_recursive(first_bridge, prev_bridge, | |
818 | crtc_state, conn_state, | |
819 | in_bus_fmts[i]); | |
820 | if (ret != -ENOTSUPP) | |
821 | break; | |
822 | } | |
823 | ||
824 | if (!ret) { | |
825 | cur_state->input_bus_cfg.format = in_bus_fmts[i]; | |
826 | cur_state->output_bus_cfg.format = out_bus_fmt; | |
827 | } | |
828 | ||
829 | kfree(in_bus_fmts); | |
830 | return ret; | |
831 | } | |
832 | ||
833 | /* | |
834 | * This function is called by &drm_atomic_bridge_chain_check() just before | |
835 | * calling &drm_bridge_funcs.atomic_check() on all elements of the chain. | |
836 | * It performs bus format negotiation between bridge elements. The negotiation | |
837 | * happens in reverse order, starting from the last element in the chain up to | |
838 | * @bridge. | |
839 | * | |
840 | * Negotiation starts by retrieving supported output bus formats on the last | |
841 | * bridge element and testing them one by one. The test is recursive, meaning | |
842 | * that for each tested output format, the whole chain will be walked backward, | |
843 | * and each element will have to choose an input bus format that can be | |
844 | * transcoded to the requested output format. When a bridge element does not | |
845 | * support transcoding into a specific output format -ENOTSUPP is returned and | |
846 | * the next bridge element will have to try a different format. If none of the | |
847 | * combinations worked, -ENOTSUPP is returned and the atomic modeset will fail. | |
848 | * | |
849 | * This implementation is relying on | |
850 | * &drm_bridge_funcs.atomic_get_output_bus_fmts() and | |
851 | * &drm_bridge_funcs.atomic_get_input_bus_fmts() to gather supported | |
852 | * input/output formats. | |
853 | * | |
854 | * When &drm_bridge_funcs.atomic_get_output_bus_fmts() is not implemented by | |
855 | * the last element of the chain, &drm_atomic_bridge_chain_select_bus_fmts() | |
856 | * tries a single format: &drm_connector.display_info.bus_formats[0] if | |
857 | * available, MEDIA_BUS_FMT_FIXED otherwise. | |
858 | * | |
859 | * When &drm_bridge_funcs.atomic_get_input_bus_fmts() is not implemented, | |
860 | * &drm_atomic_bridge_chain_select_bus_fmts() skips the negotiation on the | |
861 | * bridge element that lacks this hook and asks the previous element in the | |
862 | * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide what | |
863 | * to do in that case (fail if they want to enforce bus format negotiation, or | |
864 | * provide a reasonable default if they need to support pipelines where not | |
865 | * all elements support bus format negotiation). | |
866 | */ | |
867 | static int | |
868 | drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge, | |
869 | struct drm_crtc_state *crtc_state, | |
870 | struct drm_connector_state *conn_state) | |
871 | { | |
872 | struct drm_connector *conn = conn_state->connector; | |
873 | struct drm_encoder *encoder = bridge->encoder; | |
874 | struct drm_bridge_state *last_bridge_state; | |
875 | unsigned int i, num_out_bus_fmts; | |
876 | struct drm_bridge *last_bridge; | |
877 | u32 *out_bus_fmts; | |
878 | int ret = 0; | |
879 | ||
880 | last_bridge = list_last_entry(&encoder->bridge_chain, | |
881 | struct drm_bridge, chain_node); | |
882 | last_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state, | |
883 | last_bridge); | |
884 | ||
885 | if (last_bridge->funcs->atomic_get_output_bus_fmts) { | |
886 | const struct drm_bridge_funcs *funcs = last_bridge->funcs; | |
887 | ||
888 | /* | |
889 | * If the driver implements ->atomic_get_output_bus_fmts() it | |
890 | * should also implement the atomic state hooks. | |
891 | */ | |
892 | if (WARN_ON(!last_bridge_state)) | |
893 | return -EINVAL; | |
894 | ||
895 | out_bus_fmts = funcs->atomic_get_output_bus_fmts(last_bridge, | |
896 | last_bridge_state, | |
897 | crtc_state, | |
898 | conn_state, | |
899 | &num_out_bus_fmts); | |
900 | if (!num_out_bus_fmts) | |
901 | return -ENOTSUPP; | |
902 | else if (!out_bus_fmts) | |
903 | return -ENOMEM; | |
904 | } else { | |
905 | num_out_bus_fmts = 1; | |
906 | out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL); | |
907 | if (!out_bus_fmts) | |
908 | return -ENOMEM; | |
909 | ||
910 | if (conn->display_info.num_bus_formats && | |
911 | conn->display_info.bus_formats) | |
912 | out_bus_fmts[0] = conn->display_info.bus_formats[0]; | |
913 | else | |
914 | out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED; | |
915 | } | |
916 | ||
917 | for (i = 0; i < num_out_bus_fmts; i++) { | |
918 | ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state, | |
919 | conn_state, out_bus_fmts[i]); | |
920 | if (ret != -ENOTSUPP) | |
921 | break; | |
922 | } | |
923 | ||
924 | kfree(out_bus_fmts); | |
925 | ||
926 | return ret; | |
927 | } | |
928 | ||
929 | static void | |
930 | drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge, | |
931 | struct drm_connector *conn, | |
932 | struct drm_atomic_state *state) | |
933 | { | |
934 | struct drm_bridge_state *bridge_state, *next_bridge_state; | |
935 | struct drm_bridge *next_bridge; | |
936 | u32 output_flags = 0; | |
937 | ||
938 | bridge_state = drm_atomic_get_new_bridge_state(state, bridge); | |
939 | ||
940 | /* No bridge state attached to this bridge => nothing to propagate. */ | |
941 | if (!bridge_state) | |
942 | return; | |
943 | ||
944 | next_bridge = drm_bridge_get_next_bridge(bridge); | |
945 | ||
946 | /* | |
947 | * Let's try to apply the most common case here, that is, propagate | |
948 | * display_info flags for the last bridge, and propagate the input | |
949 | * flags of the next bridge element to the output end of the current | |
950 | * bridge when the bridge is not the last one. | |
951 | * There are exceptions to this rule, like when signal inversion is | |
952 | * happening at the board level, but that's something drivers can deal | |
953 | * with from their &drm_bridge_funcs.atomic_check() implementation by | |
954 | * simply overriding the flags value we've set here. | |
955 | */ | |
956 | if (!next_bridge) { | |
957 | output_flags = conn->display_info.bus_flags; | |
958 | } else { | |
959 | next_bridge_state = drm_atomic_get_new_bridge_state(state, | |
960 | next_bridge); | |
961 | /* | |
962 | * No bridge state attached to the next bridge, just leave the | |
963 | * flags to 0. | |
964 | */ | |
965 | if (next_bridge_state) | |
966 | output_flags = next_bridge_state->input_bus_cfg.flags; | |
967 | } | |
968 | ||
969 | bridge_state->output_bus_cfg.flags = output_flags; | |
970 | ||
971 | /* | |
972 | * Propage the output flags to the input end of the bridge. Again, it's | |
973 | * not necessarily what all bridges want, but that's what most of them | |
974 | * do, and by doing that by default we avoid forcing drivers to | |
975 | * duplicate the "dummy propagation" logic. | |
976 | */ | |
977 | bridge_state->input_bus_cfg.flags = output_flags; | |
978 | } | |
979 | ||
5061b8a9 BB |
980 | /** |
981 | * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain | |
982 | * @bridge: bridge control structure | |
983 | * @crtc_state: new CRTC state | |
984 | * @conn_state: new connector state | |
985 | * | |
f32df58a BB |
986 | * First trigger a bus format negotiation before calling |
987 | * &drm_bridge_funcs.atomic_check() (falls back on | |
5061b8a9 BB |
988 | * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder chain, |
989 | * starting from the last bridge to the first. These are called before calling | |
990 | * &drm_encoder_helper_funcs.atomic_check() | |
991 | * | |
992 | * RETURNS: | |
993 | * 0 on success, a negative error code on failure | |
994 | */ | |
995 | int drm_atomic_bridge_chain_check(struct drm_bridge *bridge, | |
996 | struct drm_crtc_state *crtc_state, | |
997 | struct drm_connector_state *conn_state) | |
998 | { | |
f32df58a | 999 | struct drm_connector *conn = conn_state->connector; |
5061b8a9 BB |
1000 | struct drm_encoder *encoder; |
1001 | struct drm_bridge *iter; | |
f32df58a | 1002 | int ret; |
5061b8a9 BB |
1003 | |
1004 | if (!bridge) | |
1005 | return 0; | |
1006 | ||
f32df58a BB |
1007 | ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state, |
1008 | conn_state); | |
1009 | if (ret) | |
1010 | return ret; | |
1011 | ||
5061b8a9 BB |
1012 | encoder = bridge->encoder; |
1013 | list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) { | |
1014 | int ret; | |
1015 | ||
f32df58a BB |
1016 | /* |
1017 | * Bus flags are propagated by default. If a bridge needs to | |
1018 | * tweak the input bus flags for any reason, it should happen | |
1019 | * in its &drm_bridge_funcs.atomic_check() implementation such | |
1020 | * that preceding bridges in the chain can propagate the new | |
1021 | * bus flags. | |
1022 | */ | |
1023 | drm_atomic_bridge_propagate_bus_flags(iter, conn, | |
1024 | crtc_state->state); | |
1025 | ||
5061b8a9 BB |
1026 | ret = drm_atomic_bridge_check(iter, crtc_state, conn_state); |
1027 | if (ret) | |
1028 | return ret; | |
1029 | ||
1030 | if (iter == bridge) | |
1031 | break; | |
1032 | } | |
1033 | ||
1034 | return 0; | |
1035 | } | |
1036 | EXPORT_SYMBOL(drm_atomic_bridge_chain_check); | |
1037 | ||
11f6c4b1 LP |
1038 | /** |
1039 | * drm_bridge_detect - check if anything is attached to the bridge output | |
1040 | * @bridge: bridge control structure | |
1041 | * | |
1042 | * If the bridge supports output detection, as reported by the | |
1043 | * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the | |
1044 | * bridge and return the connection status. Otherwise return | |
1045 | * connector_status_unknown. | |
1046 | * | |
1047 | * RETURNS: | |
1048 | * The detection status on success, or connector_status_unknown if the bridge | |
1049 | * doesn't support output detection. | |
1050 | */ | |
1051 | enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge) | |
1052 | { | |
1053 | if (!(bridge->ops & DRM_BRIDGE_OP_DETECT)) | |
1054 | return connector_status_unknown; | |
1055 | ||
1056 | return bridge->funcs->detect(bridge); | |
1057 | } | |
1058 | EXPORT_SYMBOL_GPL(drm_bridge_detect); | |
1059 | ||
1060 | /** | |
1061 | * drm_bridge_get_modes - fill all modes currently valid for the sink into the | |
1062 | * @connector | |
1063 | * @bridge: bridge control structure | |
1064 | * @connector: the connector to fill with modes | |
1065 | * | |
1066 | * If the bridge supports output modes retrieval, as reported by the | |
1067 | * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to | |
1068 | * fill the connector with all valid modes and return the number of modes | |
1069 | * added. Otherwise return 0. | |
1070 | * | |
1071 | * RETURNS: | |
1072 | * The number of modes added to the connector. | |
1073 | */ | |
1074 | int drm_bridge_get_modes(struct drm_bridge *bridge, | |
1075 | struct drm_connector *connector) | |
1076 | { | |
1077 | if (!(bridge->ops & DRM_BRIDGE_OP_MODES)) | |
1078 | return 0; | |
1079 | ||
1080 | return bridge->funcs->get_modes(bridge, connector); | |
1081 | } | |
1082 | EXPORT_SYMBOL_GPL(drm_bridge_get_modes); | |
1083 | ||
1084 | /** | |
1085 | * drm_bridge_get_edid - get the EDID data of the connected display | |
1086 | * @bridge: bridge control structure | |
1087 | * @connector: the connector to read EDID for | |
1088 | * | |
1089 | * If the bridge supports output EDID retrieval, as reported by the | |
1090 | * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.get_edid to | |
11d3cf80 | 1091 | * get the EDID and return it. Otherwise return NULL. |
11f6c4b1 LP |
1092 | * |
1093 | * RETURNS: | |
11d3cf80 | 1094 | * The retrieved EDID on success, or NULL otherwise. |
11f6c4b1 LP |
1095 | */ |
1096 | struct edid *drm_bridge_get_edid(struct drm_bridge *bridge, | |
1097 | struct drm_connector *connector) | |
1098 | { | |
1099 | if (!(bridge->ops & DRM_BRIDGE_OP_EDID)) | |
11d3cf80 | 1100 | return NULL; |
11f6c4b1 LP |
1101 | |
1102 | return bridge->funcs->get_edid(bridge, connector); | |
1103 | } | |
1104 | EXPORT_SYMBOL_GPL(drm_bridge_get_edid); | |
1105 | ||
1106 | /** | |
1107 | * drm_bridge_hpd_enable - enable hot plug detection for the bridge | |
1108 | * @bridge: bridge control structure | |
1109 | * @cb: hot-plug detection callback | |
1110 | * @data: data to be passed to the hot-plug detection callback | |
1111 | * | |
1112 | * Call &drm_bridge_funcs.hpd_enable if implemented and register the given @cb | |
1113 | * and @data as hot plug notification callback. From now on the @cb will be | |
1114 | * called with @data when an output status change is detected by the bridge, | |
1115 | * until hot plug notification gets disabled with drm_bridge_hpd_disable(). | |
1116 | * | |
1117 | * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in | |
1118 | * bridge->ops. This function shall not be called when the flag is not set. | |
1119 | * | |
1120 | * Only one hot plug detection callback can be registered at a time, it is an | |
1121 | * error to call this function when hot plug detection is already enabled for | |
1122 | * the bridge. | |
1123 | */ | |
1124 | void drm_bridge_hpd_enable(struct drm_bridge *bridge, | |
1125 | void (*cb)(void *data, | |
1126 | enum drm_connector_status status), | |
1127 | void *data) | |
1128 | { | |
1129 | if (!(bridge->ops & DRM_BRIDGE_OP_HPD)) | |
1130 | return; | |
1131 | ||
1132 | mutex_lock(&bridge->hpd_mutex); | |
1133 | ||
1134 | if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n")) | |
1135 | goto unlock; | |
1136 | ||
1137 | bridge->hpd_cb = cb; | |
1138 | bridge->hpd_data = data; | |
1139 | ||
1140 | if (bridge->funcs->hpd_enable) | |
1141 | bridge->funcs->hpd_enable(bridge); | |
1142 | ||
1143 | unlock: | |
1144 | mutex_unlock(&bridge->hpd_mutex); | |
1145 | } | |
1146 | EXPORT_SYMBOL_GPL(drm_bridge_hpd_enable); | |
1147 | ||
1148 | /** | |
1149 | * drm_bridge_hpd_disable - disable hot plug detection for the bridge | |
1150 | * @bridge: bridge control structure | |
1151 | * | |
1152 | * Call &drm_bridge_funcs.hpd_disable if implemented and unregister the hot | |
1153 | * plug detection callback previously registered with drm_bridge_hpd_enable(). | |
1154 | * Once this function returns the callback will not be called by the bridge | |
1155 | * when an output status change occurs. | |
1156 | * | |
1157 | * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in | |
1158 | * bridge->ops. This function shall not be called when the flag is not set. | |
1159 | */ | |
1160 | void drm_bridge_hpd_disable(struct drm_bridge *bridge) | |
1161 | { | |
1162 | if (!(bridge->ops & DRM_BRIDGE_OP_HPD)) | |
1163 | return; | |
1164 | ||
1165 | mutex_lock(&bridge->hpd_mutex); | |
1166 | if (bridge->funcs->hpd_disable) | |
1167 | bridge->funcs->hpd_disable(bridge); | |
1168 | ||
1169 | bridge->hpd_cb = NULL; | |
1170 | bridge->hpd_data = NULL; | |
1171 | mutex_unlock(&bridge->hpd_mutex); | |
1172 | } | |
1173 | EXPORT_SYMBOL_GPL(drm_bridge_hpd_disable); | |
1174 | ||
1175 | /** | |
1176 | * drm_bridge_hpd_notify - notify hot plug detection events | |
1177 | * @bridge: bridge control structure | |
1178 | * @status: output connection status | |
1179 | * | |
1180 | * Bridge drivers shall call this function to report hot plug events when they | |
1181 | * detect a change in the output status, when hot plug detection has been | |
1182 | * enabled by drm_bridge_hpd_enable(). | |
1183 | * | |
1184 | * This function shall be called in a context that can sleep. | |
1185 | */ | |
1186 | void drm_bridge_hpd_notify(struct drm_bridge *bridge, | |
1187 | enum drm_connector_status status) | |
1188 | { | |
1189 | mutex_lock(&bridge->hpd_mutex); | |
1190 | if (bridge->hpd_cb) | |
1191 | bridge->hpd_cb(bridge->hpd_data, status); | |
1192 | mutex_unlock(&bridge->hpd_mutex); | |
1193 | } | |
1194 | EXPORT_SYMBOL_GPL(drm_bridge_hpd_notify); | |
1195 | ||
3d3f8b1f | 1196 | #ifdef CONFIG_OF |
2331b4e4 AT |
1197 | /** |
1198 | * of_drm_find_bridge - find the bridge corresponding to the device node in | |
1199 | * the global bridge list | |
1200 | * | |
1201 | * @np: device node | |
1202 | * | |
1203 | * RETURNS: | |
1204 | * drm_bridge control struct on success, NULL on failure | |
1205 | */ | |
3d3f8b1f AK |
1206 | struct drm_bridge *of_drm_find_bridge(struct device_node *np) |
1207 | { | |
1208 | struct drm_bridge *bridge; | |
1209 | ||
1210 | mutex_lock(&bridge_lock); | |
1211 | ||
1212 | list_for_each_entry(bridge, &bridge_list, list) { | |
1213 | if (bridge->of_node == np) { | |
1214 | mutex_unlock(&bridge_lock); | |
1215 | return bridge; | |
1216 | } | |
1217 | } | |
1218 | ||
1219 | mutex_unlock(&bridge_lock); | |
1220 | return NULL; | |
1221 | } | |
1222 | EXPORT_SYMBOL(of_drm_find_bridge); | |
1223 | #endif | |
1224 | ||
1225 | MODULE_AUTHOR("Ajay Kumar <ajaykumar.rs@samsung.com>"); | |
1226 | MODULE_DESCRIPTION("DRM bridge infrastructure"); | |
1227 | MODULE_LICENSE("GPL and additional rights"); |