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