projects/linux·blob master · refs

1824 lines · 60.1 KiB

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/debugfs.h>
25#include <linux/err.h>
26#include <linux/export.h>
27#include <linux/media-bus-format.h>
28#include <linux/module.h>
29#include <linux/mutex.h>
30#include <linux/srcu.h>
31
32#include <drm/drm_atomic_state_helper.h>
33#include <drm/drm_bridge.h>
34#include <drm/drm_debugfs.h>
35#include <drm/drm_edid.h>
36#include <drm/drm_encoder.h>
37#include <drm/drm_file.h>
38#include <drm/drm_of.h>
39#include <drm/drm_print.h>
40
41#include "drm_crtc_internal.h"
42
43/**
44 * DOC: overview
45 *
46 * &struct drm_bridge represents a device that hangs on to an encoder. These are
47 * handy when a regular &drm_encoder entity isn't enough to represent the entire
48 * encoder chain.
49 *
50 * A bridge is always attached to a single &drm_encoder at a time, but can be
51 * either connected to it directly, or through a chain of bridges::
52 *
53 * [ CRTC ---> ] Encoder ---> Bridge A ---> Bridge B
54 *
55 * Here, the output of the encoder feeds to bridge A, and that furthers feeds to
56 * bridge B. Bridge chains can be arbitrarily long, and shall be fully linear:
57 * Chaining multiple bridges to the output of a bridge, or the same bridge to
58 * the output of different bridges, is not supported.
59 *
60 * &drm_bridge, like &drm_panel, aren't &drm_mode_object entities like planes,
61 * CRTCs, encoders or connectors and hence are not visible to userspace. They
62 * just provide additional hooks to get the desired output at the end of the
63 * encoder chain.
64 */
65
66/**
67 * DOC: display driver integration
68 *
69 * Display drivers are responsible for linking encoders with the first bridge
70 * in the chains. This is done by acquiring the appropriate bridge with
71 * devm_drm_of_get_bridge(). Once acquired, the bridge shall be attached to the
72 * encoder with a call to drm_bridge_attach().
73 *
74 * Bridges are responsible for linking themselves with the next bridge in the
75 * chain, if any. This is done the same way as for encoders, with the call to
76 * drm_bridge_attach() occurring in the &drm_bridge_funcs.attach operation.
77 *
78 * Once these links are created, the bridges can participate along with encoder
79 * functions to perform mode validation and fixup (through
80 * drm_bridge_chain_mode_valid() and drm_atomic_bridge_chain_check()), mode
81 * setting (through drm_bridge_chain_mode_set()), enable (through
82 * drm_atomic_bridge_chain_pre_enable() and drm_atomic_bridge_chain_enable())
83 * and disable (through drm_atomic_bridge_chain_disable() and
84 * drm_atomic_bridge_chain_post_disable()). Those functions call the
85 * corresponding operations provided in &drm_bridge_funcs in sequence for all
86 * bridges in the chain.
87 *
88 * For display drivers that use the atomic helpers
89 * drm_atomic_helper_check_modeset(),
90 * drm_atomic_helper_commit_modeset_enables() and
91 * drm_atomic_helper_commit_modeset_disables() (either directly in hand-rolled
92 * commit check and commit tail handlers, or through the higher-level
93 * drm_atomic_helper_check() and drm_atomic_helper_commit_tail() or
94 * drm_atomic_helper_commit_tail_rpm() helpers), this is done transparently and
95 * requires no intervention from the driver. For other drivers, the relevant
96 * DRM bridge chain functions shall be called manually.
97 *
98 * Bridges also participate in implementing the &drm_connector at the end of
99 * the bridge chain. Display drivers may use the drm_bridge_connector_init()
100 * helper to create the &drm_connector, or implement it manually on top of the
101 * connector-related operations exposed by the bridge (see the overview
102 * documentation of bridge operations for more details).
103 */
104
105/**
106 * DOC: special care dsi
107 *
108 * The interaction between the bridges and other frameworks involved in
109 * the probing of the upstream driver and the bridge driver can be
110 * challenging. Indeed, there's multiple cases that needs to be
111 * considered:
112 *
113 * - The upstream driver doesn't use the component framework and isn't a
114 * MIPI-DSI host. In this case, the bridge driver will probe at some
115 * point and the upstream driver should try to probe again by returning
116 * EPROBE_DEFER as long as the bridge driver hasn't probed.
117 *
118 * - The upstream driver doesn't use the component framework, but is a
119 * MIPI-DSI host. The bridge device uses the MIPI-DCS commands to be
120 * controlled. In this case, the bridge device is a child of the
121 * display device and when it will probe it's assured that the display
122 * device (and MIPI-DSI host) is present. The upstream driver will be
123 * assured that the bridge driver is connected between the
124 * &mipi_dsi_host_ops.attach and &mipi_dsi_host_ops.detach operations.
125 * Therefore, it must run mipi_dsi_host_register() in its probe
126 * function, and then run drm_bridge_attach() in its
127 * &mipi_dsi_host_ops.attach hook.
128 *
129 * - The upstream driver uses the component framework and is a MIPI-DSI
130 * host. The bridge device uses the MIPI-DCS commands to be
131 * controlled. This is the same situation than above, and can run
132 * mipi_dsi_host_register() in either its probe or bind hooks.
133 *
134 * - The upstream driver uses the component framework and is a MIPI-DSI
135 * host. The bridge device uses a separate bus (such as I2C) to be
136 * controlled. In this case, there's no correlation between the probe
137 * of the bridge and upstream drivers, so care must be taken to avoid
138 * an endless EPROBE_DEFER loop, with each driver waiting for the
139 * other to probe.
140 *
141 * The ideal pattern to cover the last item (and all the others in the
142 * MIPI-DSI host driver case) is to split the operations like this:
143 *
144 * - The MIPI-DSI host driver must run mipi_dsi_host_register() in its
145 * probe hook. It will make sure that the MIPI-DSI host sticks around,
146 * and that the driver's bind can be called.
147 *
148 * - In its probe hook, the bridge driver must try to find its MIPI-DSI
149 * host, register as a MIPI-DSI device and attach the MIPI-DSI device
150 * to its host. The bridge driver is now functional.
151 *
152 * - In its &struct mipi_dsi_host_ops.attach hook, the MIPI-DSI host can
153 * now add its component. Its bind hook will now be called and since
154 * the bridge driver is attached and registered, we can now look for
155 * and attach it.
156 *
157 * At this point, we're now certain that both the upstream driver and
158 * the bridge driver are functional and we can't have a deadlock-like
159 * situation when probing.
160 */
161
162/**
163 * DOC: dsi bridge operations
164 *
165 * DSI host interfaces are expected to be implemented as bridges rather than
166 * encoders, however there are a few aspects of their operation that need to
167 * be defined in order to provide a consistent interface.
168 *
169 * A DSI host should keep the PHY powered down until the pre_enable operation is
170 * called. All lanes are in an undefined idle state up to this point, and it
171 * must not be assumed that it is LP-11.
172 * pre_enable should initialise the PHY, set the data lanes to LP-11, and the
173 * clock lane to either LP-11 or HS depending on the mode_flag
174 * %MIPI_DSI_CLOCK_NON_CONTINUOUS.
175 *
176 * Ordinarily the downstream bridge DSI peripheral pre_enable will have been
177 * called before the DSI host. If the DSI peripheral requires LP-11 and/or
178 * the clock lane to be in HS mode prior to pre_enable, then it can set the
179 * &pre_enable_prev_first flag to request the pre_enable (and
180 * post_disable) order to be altered to enable the DSI host first.
181 *
182 * Either the CRTC being enabled, or the DSI host enable operation should switch
183 * the host to actively transmitting video on the data lanes.
184 *
185 * The reverse also applies. The DSI host disable operation or stopping the CRTC
186 * should stop transmitting video, and the data lanes should return to the LP-11
187 * state. The DSI host &post_disable operation should disable the PHY.
188 * If the &pre_enable_prev_first flag is set, then the DSI peripheral's
189 * bridge &post_disable will be called before the DSI host's post_disable.
190 *
191 * Whilst it is valid to call &host_transfer prior to pre_enable or after
192 * post_disable, the exact state of the lanes is undefined at this point. The
193 * DSI host should initialise the interface, transmit the data, and then disable
194 * the interface again.
195 *
196 * Ultra Low Power State (ULPS) is not explicitly supported by DRM. If
197 * implemented, it therefore needs to be handled entirely within the DSI Host
198 * driver.
199 */
200
201/**
202 * DOC: bridge chain format selection
203 *
204 * A bridge chain, from display output processor to connector, may contain
205 * bridges capable of converting between bus formats on their inputs, and
206 * output formats on their outputs. For example, a bridge may be able to convert
207 * from RGB to YCbCr 4:4:4, and pass through YCbCr 4:2:0 as-is, but not convert
208 * from RGB to YCbCr 4:2:0. This means not all input formats map to all output
209 * formats.
210 *
211 * Further adding to this, a desired output color format, as specified with the
212 * "color format" DRM property, might not correspond 1:1 to what the display
213 * driver should set at its output. The bridge chain it feeds into may only be
214 * able to reach the desired output format, if a conversion from a different
215 * starting format is performed.
216 *
217 * To deal with this complexity, the recursive bridge chain bus format selection
218 * logic starts with the last bridge in the chain, usually the connector, and
219 * then recursively walks the chain of bridges backwards to the first bridge,
220 * trying to find a path.
221 *
222 * For a display driver to work in such a scenario, it should read the first
223 * bridge's bridge state to figure out which bus format the chain resolved to.
224 * If the first bridge's input format resolved to %MEDIA_BUS_FMT_FIXED, then its
225 * output format should be used.
226 *
227 * Special handling is done for HDMI as it relates to format selection. Instead
228 * of directly using the "color format" DRM property for bridge chains that end
229 * in HDMI bridges, the bridge chain format selection logic will trust the logic
230 * that set the HDMI output format. For the common HDMI state helper
231 * functionality, this means that %DRM_CONNECTOR_COLOR_FORMAT_AUTO will allow
232 * fallbacks to YCBCr 4:2:0 if the bandwidth requirements would otherwise be too
233 * high but the mode and connector allow it.
234 *
235 * For bridge chains that do not end in an HDMI bridge,
236 * %DRM_CONNECTOR_COLOR_FORMAT_AUTO will be satisfied with the first output
237 * format on the last bridge for which it can find a path back to the first
238 * bridge.
239 */
240
241/* Protect bridge_list and bridge_lingering_list */
242static DEFINE_MUTEX(bridge_lock);
243static LIST_HEAD(bridge_list);
244static LIST_HEAD(bridge_lingering_list);
245
246DEFINE_STATIC_SRCU(drm_bridge_unplug_srcu);
247
248/**
249 * drm_bridge_enter - Enter DRM bridge critical section
250 * @bridge: DRM bridge
251 * @idx: Pointer to index that will be passed to the matching drm_bridge_exit()
252 *
253 * This function marks and protects the beginning of a section that should not
254 * be entered after the bridge has been unplugged. The section end is marked
255 * with drm_bridge_exit(). Calls to this function can be nested.
256 *
257 * Returns:
258 * True if it is OK to enter the section, false otherwise.
259 */
260bool drm_bridge_enter(struct drm_bridge *bridge, int *idx)
261{
262 *idx = srcu_read_lock(&drm_bridge_unplug_srcu);
263
264 if (bridge->unplugged) {
265 srcu_read_unlock(&drm_bridge_unplug_srcu, *idx);
266 return false;
267 }
268
269 return true;
270}
271EXPORT_SYMBOL(drm_bridge_enter);
272
273/**
274 * drm_bridge_exit - Exit DRM bridge critical section
275 * @idx: index returned by drm_bridge_enter()
276 *
277 * This function marks the end of a section that should not be entered after
278 * the bridge has been unplugged.
279 */
280void drm_bridge_exit(int idx)
281{
282 srcu_read_unlock(&drm_bridge_unplug_srcu, idx);
283}
284EXPORT_SYMBOL(drm_bridge_exit);
285
286/**
287 * drm_bridge_unplug - declare a DRM bridge was unplugged and remove it
288 * @bridge: DRM bridge
289 *
290 * This tells the bridge has been physically unplugged and no operations on
291 * device resources must be done anymore. Entry-points can use
292 * drm_bridge_enter() and drm_bridge_exit() to protect device resources in
293 * a race free manner.
294 *
295 * Also unregisters the bridge.
296 */
297void drm_bridge_unplug(struct drm_bridge *bridge)
298{
299 bridge->unplugged = true;
300
301 synchronize_srcu(&drm_bridge_unplug_srcu);
302
303 drm_bridge_remove(bridge);
304}
305EXPORT_SYMBOL(drm_bridge_unplug);
306
307static void __drm_bridge_free(struct kref *kref)
308{
309 struct drm_bridge *bridge = container_of(kref, struct drm_bridge, refcount);
310
311 mutex_lock(&bridge_lock);
312 list_del(&bridge->list);
313 mutex_unlock(&bridge_lock);
314
315 if (bridge->funcs->destroy)
316 bridge->funcs->destroy(bridge);
317
318 drm_bridge_put(bridge->next_bridge);
319
320 kfree(bridge->container);
321}
322
323/**
324 * drm_bridge_get - Acquire a bridge reference
325 * @bridge: DRM bridge; if NULL this function does nothing
326 *
327 * This function increments the bridge's refcount.
328 *
329 * Returns:
330 * Pointer to @bridge.
331 */
332struct drm_bridge *drm_bridge_get(struct drm_bridge *bridge)
333{
334 if (bridge)
335 kref_get(&bridge->refcount);
336
337 return bridge;
338}
339EXPORT_SYMBOL(drm_bridge_get);
340
341/**
342 * drm_bridge_put - Release a bridge reference
343 * @bridge: DRM bridge; if NULL or an ERR_PTR this function does nothing
344 *
345 * This function decrements the bridge's reference count and frees the
346 * object if the reference count drops to zero.
347 *
348 * See also drm_bridge_clear_and_put() if you also need to set the pointer
349 * to NULL
350 */
351void drm_bridge_put(struct drm_bridge *bridge)
352{
353 if (!IS_ERR_OR_NULL(bridge))
354 kref_put(&bridge->refcount, __drm_bridge_free);
355}
356EXPORT_SYMBOL(drm_bridge_put);
357
358/**
359 * drm_bridge_clear_and_put - Given a bridge pointer, clear the pointer
360 * then put the bridge
361 * @bridge_pp: pointer to pointer to a struct drm_bridge; ``bridge_pp``
362 * must be non-NULL; if ``*bridge_pp`` is NULL this function
363 * does nothing
364 *
365 * Helper to put a DRM bridge, but only after setting its pointer to
366 * NULL. Useful when a struct drm_bridge reference must be dropped without
367 * leaving a use-after-free window where the pointed bridge might have been
368 * freed while still holding a pointer to it.
369 *
370 * For struct ``drm_bridge *some_bridge``, this code::
371 *
372 * drm_bridge_clear_and_put(&some_bridge);
373 *
374 * is equivalent to the more complex::
375 *
376 * struct drm_bridge *temp = some_bridge;
377 * some_bridge = NULL;
378 * drm_bridge_put(temp);
379 */
380void drm_bridge_clear_and_put(struct drm_bridge **bridge_pp)
381{
382 struct drm_bridge *bridge = *bridge_pp;
383
384 *bridge_pp = NULL;
385 drm_bridge_put(bridge);
386}
387EXPORT_SYMBOL(drm_bridge_clear_and_put);
388
389/**
390 * drm_bridge_put_void - wrapper to drm_bridge_put() taking a void pointer
391 *
392 * @data: pointer to @struct drm_bridge, cast to a void pointer
393 *
394 * Wrapper of drm_bridge_put() to be used when a function taking a void
395 * pointer is needed, for example as a devm action.
396 */
397static void drm_bridge_put_void(void *data)
398{
399 struct drm_bridge *bridge = (struct drm_bridge *)data;
400
401 drm_bridge_put(bridge);
402}
403
404void *__devm_drm_bridge_alloc(struct device *dev, size_t size, size_t offset,
405 const struct drm_bridge_funcs *funcs)
406{
407 void *container;
408 struct drm_bridge *bridge;
409 int err;
410
411 if (!funcs) {
412 dev_warn(dev, "Missing funcs pointer\n");
413 return ERR_PTR(-EINVAL);
414 }
415
416 container = kzalloc(size, GFP_KERNEL);
417 if (!container)
418 return ERR_PTR(-ENOMEM);
419
420 bridge = container + offset;
421 INIT_LIST_HEAD(&bridge->list);
422 bridge->container = container;
423 bridge->funcs = funcs;
424 kref_init(&bridge->refcount);
425
426 err = devm_add_action_or_reset(dev, drm_bridge_put_void, bridge);
427 if (err)
428 return ERR_PTR(err);
429
430 return container;
431}
432EXPORT_SYMBOL(__devm_drm_bridge_alloc);
433
434/**
435 * drm_bridge_add - register a bridge
436 *
437 * @bridge: bridge control structure
438 *
439 * Add the given bridge to the global list of bridges, where they can be
440 * found by users via of_drm_find_and_get_bridge().
441 *
442 * The bridge to be added must have been allocated by
443 * devm_drm_bridge_alloc().
444 */
445void drm_bridge_add(struct drm_bridge *bridge)
446{
447 if (!bridge->container)
448 DRM_WARN("DRM bridge corrupted or not allocated by devm_drm_bridge_alloc()\n");
449
450 drm_bridge_get(bridge);
451
452 /*
453 * If the bridge was previously added and then removed, it is now
454 * in bridge_lingering_list. Remove it or bridge_lingering_list will be
455 * corrupted when adding this bridge to bridge_list below.
456 */
457 mutex_lock(&bridge_lock);
458 if (!list_empty(&bridge->list))
459 list_del_init(&bridge->list);
460 mutex_unlock(&bridge_lock);
461
462 mutex_init(&bridge->hpd_state_mutex);
463 mutex_init(&bridge->hpd_mutex);
464
465 if (bridge->ops & DRM_BRIDGE_OP_HDMI)
466 bridge->ycbcr_420_allowed = !!(bridge->supported_formats &
467 BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR420));
468
469 mutex_lock(&bridge_lock);
470 list_add_tail(&bridge->list, &bridge_list);
471 mutex_unlock(&bridge_lock);
472}
473EXPORT_SYMBOL(drm_bridge_add);
474
475static void drm_bridge_remove_void(void *bridge)
476{
477 drm_bridge_remove(bridge);
478}
479
480/**
481 * devm_drm_bridge_add - devm managed version of drm_bridge_add()
482 *
483 * @dev: device to tie the bridge lifetime to
484 * @bridge: bridge control structure
485 *
486 * This is the managed version of drm_bridge_add() which automatically
487 * calls drm_bridge_remove() when @dev is unbound.
488 *
489 * Return: 0 if no error or negative error code.
490 */
491int devm_drm_bridge_add(struct device *dev, struct drm_bridge *bridge)
492{
493 drm_bridge_add(bridge);
494 return devm_add_action_or_reset(dev, drm_bridge_remove_void, bridge);
495}
496EXPORT_SYMBOL(devm_drm_bridge_add);
497
498/**
499 * drm_bridge_remove - unregister a bridge
500 *
501 * @bridge: bridge control structure
502 *
503 * Remove the given bridge from the global list of registered bridges, so
504 * it won't be found by users via of_drm_find_and_get_bridge(), and add it
505 * to the lingering bridge list, to keep track of it until its allocated
506 * memory is eventually freed.
507 */
508void drm_bridge_remove(struct drm_bridge *bridge)
509{
510 mutex_lock(&bridge_lock);
511 list_move_tail(&bridge->list, &bridge_lingering_list);
512 mutex_unlock(&bridge_lock);
513
514 mutex_destroy(&bridge->hpd_mutex);
515 mutex_destroy(&bridge->hpd_state_mutex);
516
517 drm_bridge_put(bridge);
518}
519EXPORT_SYMBOL(drm_bridge_remove);
520
521static struct drm_private_state *
522drm_bridge_atomic_duplicate_priv_state(struct drm_private_obj *obj)
523{
524 struct drm_bridge *bridge = drm_priv_to_bridge(obj);
525 struct drm_bridge_state *state;
526
527 state = bridge->funcs->atomic_duplicate_state(bridge);
528 return state ? &state->base : NULL;
529}
530
531static void
532drm_bridge_atomic_destroy_priv_state(struct drm_private_obj *obj,
533 struct drm_private_state *s)
534{
535 struct drm_bridge_state *state = drm_priv_to_bridge_state(s);
536 struct drm_bridge *bridge = drm_priv_to_bridge(obj);
537
538 bridge->funcs->atomic_destroy_state(bridge, state);
539}
540
541static struct drm_private_state *
542drm_bridge_atomic_create_priv_state(struct drm_private_obj *obj)
543{
544 struct drm_bridge *bridge = drm_priv_to_bridge(obj);
545 struct drm_bridge_state *state;
546
547 state = bridge->funcs->atomic_create_state(bridge);
548 if (IS_ERR(state))
549 return ERR_CAST(state);
550
551 return &state->base;
552}
553
554static const struct drm_private_state_funcs drm_bridge_priv_state_funcs = {
555 .atomic_create_state = drm_bridge_atomic_create_priv_state,
556 .atomic_duplicate_state = drm_bridge_atomic_duplicate_priv_state,
557 .atomic_destroy_state = drm_bridge_atomic_destroy_priv_state,
558};
559
560/**
561 * drm_bridge_attach - attach the bridge to an encoder's chain
562 *
563 * @encoder: DRM encoder
564 * @bridge: bridge to attach
565 * @previous: previous bridge in the chain (optional)
566 * @flags: DRM_BRIDGE_ATTACH_* flags
567 *
568 * Called by a kms driver to link the bridge to an encoder's chain. The previous
569 * argument specifies the previous bridge in the chain. If NULL, the bridge is
570 * linked directly at the encoder's output. Otherwise it is linked at the
571 * previous bridge's output.
572 *
573 * If non-NULL the previous bridge must be already attached by a call to this
574 * function.
575 *
576 * The bridge to be attached must have been previously added by
577 * drm_bridge_add().
578 *
579 * Note that bridges attached to encoders are auto-detached during encoder
580 * cleanup in drm_encoder_cleanup(), so drm_bridge_attach() should generally
581 * *not* be balanced with a drm_bridge_detach() in driver code.
582 *
583 * RETURNS:
584 * Zero on success, error code on failure
585 */
586int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge,
587 struct drm_bridge *previous,
588 enum drm_bridge_attach_flags flags)
589{
590 int ret;
591
592 if (!encoder || !bridge)
593 return -EINVAL;
594
595 if (!bridge->container)
596 DRM_WARN("DRM bridge corrupted or not allocated by devm_drm_bridge_alloc()\n");
597
598 scoped_guard(mutex, &bridge_lock) {
599 if (list_empty(&bridge->list))
600 DRM_WARN("Missing drm_bridge_add() before attach\n");
601 }
602
603 drm_bridge_get(bridge);
604
605 if (previous && (!previous->dev || previous->encoder != encoder)) {
606 ret = -EINVAL;
607 goto err_put_bridge;
608 }
609
610 if (bridge->dev) {
611 ret = -EBUSY;
612 goto err_put_bridge;
613 }
614
615 bridge->dev = encoder->dev;
616 bridge->encoder = encoder;
617
618 mutex_lock(&encoder->bridge_chain_mutex);
619 if (previous)
620 list_add(&bridge->chain_node, &previous->chain_node);
621 else
622 list_add(&bridge->chain_node, &encoder->bridge_chain);
623 mutex_unlock(&encoder->bridge_chain_mutex);
624
625 if (bridge->funcs->attach) {
626 ret = bridge->funcs->attach(bridge, encoder, flags);
627 if (ret < 0)
628 goto err_reset_bridge;
629 }
630
631 drm_atomic_private_obj_init(bridge->dev, &bridge->base,
632 &drm_bridge_priv_state_funcs);
633
634 return 0;
635
636err_reset_bridge:
637 bridge->dev = NULL;
638 bridge->encoder = NULL;
639 mutex_lock(&encoder->bridge_chain_mutex);
640 list_del(&bridge->chain_node);
641 mutex_unlock(&encoder->bridge_chain_mutex);
642
643 if (ret != -EPROBE_DEFER)
644 DRM_ERROR("failed to attach bridge %pOF to encoder %s: %d\n",
645 bridge->of_node, encoder->name, ret);
646 else
647 dev_err_probe(encoder->dev->dev, -EPROBE_DEFER,
648 "failed to attach bridge %pOF to encoder %s\n",
649 bridge->of_node, encoder->name);
650
651err_put_bridge:
652 drm_bridge_put(bridge);
653 return ret;
654}
655EXPORT_SYMBOL(drm_bridge_attach);
656
657void drm_bridge_detach(struct drm_bridge *bridge)
658{
659 if (WARN_ON(!bridge))
660 return;
661
662 if (WARN_ON(!bridge->dev))
663 return;
664
665 drm_atomic_private_obj_fini(&bridge->base);
666
667 if (bridge->funcs->detach)
668 bridge->funcs->detach(bridge);
669
670 list_del(&bridge->chain_node);
671 bridge->dev = NULL;
672 drm_bridge_put(bridge);
673}
674
675/**
676 * DOC: bridge operations
677 *
678 * Bridge drivers expose operations through the &drm_bridge_funcs structure.
679 * The DRM internals (atomic and CRTC helpers) use the helpers defined in
680 * drm_bridge.c to call bridge operations. Those operations are divided in
681 * three big categories to support different parts of the bridge usage.
682 *
683 * - The encoder-related operations support control of the bridges in the
684 * chain, and are roughly counterparts to the &drm_encoder_helper_funcs
685 * operations. They are used by the legacy CRTC and the atomic modeset
686 * helpers to perform mode validation, fixup and setting, and enable and
687 * disable the bridge automatically.
688 *
689 * The enable and disable operations are split in
690 * &drm_bridge_funcs.atomic_pre_enable, &drm_bridge_funcs.atomic_enable,
691 * &drm_bridge_funcs.atomic_disable and &drm_bridge_funcs.atomic_post_disable
692 * to provide finer-grained control.
693 *
694 * Bridge drivers may implement the legacy version of those operations, or
695 * the atomic version (prefixed with atomic\_), in which case they shall also
696 * implement the atomic state bookkeeping operations
697 * (&drm_bridge_funcs.atomic_duplicate_state,
698 * &drm_bridge_funcs.atomic_destroy_state and &drm_bridge_funcs.reset).
699 * Mixing atomic and non-atomic versions of the operations is not supported.
700 *
701 * - The bus format negotiation operations
702 * &drm_bridge_funcs.atomic_get_output_bus_fmts and
703 * &drm_bridge_funcs.atomic_get_input_bus_fmts allow bridge drivers to
704 * negotiate the formats transmitted between bridges in the chain when
705 * multiple formats are supported. Negotiation for formats is performed
706 * transparently for display drivers by the atomic modeset helpers. Only
707 * atomic versions of those operations exist, bridge drivers that need to
708 * implement them shall thus also implement the atomic version of the
709 * encoder-related operations. This feature is not supported by the legacy
710 * CRTC helpers.
711 *
712 * - The connector-related operations support implementing a &drm_connector
713 * based on a chain of bridges. DRM bridges traditionally create a
714 * &drm_connector for bridges meant to be used at the end of the chain. This
715 * puts additional burden on bridge drivers, especially for bridges that may
716 * be used in the middle of a chain or at the end of it. Furthermore, it
717 * requires all operations of the &drm_connector to be handled by a single
718 * bridge, which doesn't always match the hardware architecture.
719 *
720 * To simplify bridge drivers and make the connector implementation more
721 * flexible, a new model allows bridges to unconditionally skip creation of
722 * &drm_connector and instead expose &drm_bridge_funcs operations to support
723 * an externally-implemented &drm_connector. Those operations are
724 * &drm_bridge_funcs.detect, &drm_bridge_funcs.get_modes,
725 * &drm_bridge_funcs.get_edid, &drm_bridge_funcs.hpd_notify,
726 * &drm_bridge_funcs.hpd_enable and &drm_bridge_funcs.hpd_disable. When
727 * implemented, display drivers shall create a &drm_connector instance for
728 * each chain of bridges, and implement those connector instances based on
729 * the bridge connector operations.
730 *
731 * Bridge drivers shall implement the connector-related operations for all
732 * the features that the bridge hardware support. For instance, if a bridge
733 * supports reading EDID, the &drm_bridge_funcs.get_edid shall be
734 * implemented. This however doesn't mean that the DDC lines are wired to the
735 * bridge on a particular platform, as they could also be connected to an I2C
736 * controller of the SoC. Support for the connector-related operations on the
737 * running platform is reported through the &drm_bridge.ops flags. Bridge
738 * drivers shall detect which operations they can support on the platform
739 * (usually this information is provided by ACPI or DT), and set the
740 * &drm_bridge.ops flags for all supported operations. A flag shall only be
741 * set if the corresponding &drm_bridge_funcs operation is implemented, but
742 * an implemented operation doesn't necessarily imply that the corresponding
743 * flag will be set. Display drivers shall use the &drm_bridge.ops flags to
744 * decide which bridge to delegate a connector operation to. This mechanism
745 * allows providing a single static const &drm_bridge_funcs instance in
746 * bridge drivers, improving security by storing function pointers in
747 * read-only memory.
748 *
749 * In order to ease transition, bridge drivers may support both the old and
750 * new models by making connector creation optional and implementing the
751 * connected-related bridge operations. Connector creation is then controlled
752 * by the flags argument to the drm_bridge_attach() function. Display drivers
753 * that support the new model and create connectors themselves shall set the
754 * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag, and bridge drivers shall then skip
755 * connector creation. For intermediate bridges in the chain, the flag shall
756 * be passed to the drm_bridge_attach() call for the downstream bridge.
757 * Bridge drivers that implement the new model only shall return an error
758 * from their &drm_bridge_funcs.attach handler when the
759 * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag is not set. New display drivers
760 * should use the new model, and convert the bridge drivers they use if
761 * needed, in order to gradually transition to the new model.
762 */
763
764/**
765 * drm_bridge_chain_mode_valid - validate the mode against all bridges in the
766 * encoder chain.
767 * @first_bridge: bridge control structure
768 * @info: display info against which the mode shall be validated
769 * @mode: desired mode to be validated
770 *
771 * Calls &drm_bridge_funcs.mode_valid for all the bridges in the encoder
772 * chain, starting from the first bridge to the last. If at least one bridge
773 * does not accept the mode the function returns the error code.
774 *
775 * Note: the bridge passed should be the one closest to the encoder.
776 *
777 * RETURNS:
778 * MODE_OK on success, drm_mode_status Enum error code on failure
779 */
780enum drm_mode_status
781drm_bridge_chain_mode_valid(struct drm_bridge *first_bridge,
782 const struct drm_display_info *info,
783 const struct drm_display_mode *mode)
784{
785 if (!first_bridge)
786 return MODE_OK;
787
788 drm_for_each_bridge_in_chain_from(first_bridge, bridge) {
789 enum drm_mode_status ret;
790
791 if (!bridge->funcs->mode_valid)
792 continue;
793
794 ret = bridge->funcs->mode_valid(bridge, info, mode);
795 if (ret != MODE_OK)
796 return ret;
797 }
798
799 return MODE_OK;
800}
801EXPORT_SYMBOL(drm_bridge_chain_mode_valid);
802
803/**
804 * drm_bridge_chain_mode_set - set proposed mode for all bridges in the
805 * encoder chain
806 * @first_bridge: bridge control structure
807 * @mode: desired mode to be set for the encoder chain
808 * @adjusted_mode: updated mode that works for this encoder chain
809 *
810 * Calls &drm_bridge_funcs.mode_set op for all the bridges in the
811 * encoder chain, starting from the first bridge to the last.
812 *
813 * Note: the bridge passed should be the one closest to the encoder
814 */
815void drm_bridge_chain_mode_set(struct drm_bridge *first_bridge,
816 const struct drm_display_mode *mode,
817 const struct drm_display_mode *adjusted_mode)
818{
819 if (!first_bridge)
820 return;
821
822 drm_for_each_bridge_in_chain_from(first_bridge, bridge)
823 if (bridge->funcs->mode_set)
824 bridge->funcs->mode_set(bridge, mode, adjusted_mode);
825}
826EXPORT_SYMBOL(drm_bridge_chain_mode_set);
827
828/**
829 * drm_atomic_bridge_chain_disable - disables all bridges in the encoder chain
830 * @bridge: bridge control structure
831 * @state: atomic state being committed
832 *
833 * Calls &drm_bridge_funcs.atomic_disable op for all the bridges in the encoder
834 * chain, starting from the last bridge to the first. These are called before
835 * calling &drm_encoder_helper_funcs.atomic_disable
836 *
837 * Note: the bridge passed should be the one closest to the encoder
838 */
839void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,
840 struct drm_atomic_commit *state)
841{
842 struct drm_encoder *encoder;
843 struct drm_bridge *iter;
844
845 if (!bridge)
846 return;
847
848 encoder = bridge->encoder;
849 mutex_lock(&encoder->bridge_chain_mutex);
850 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {
851 if (iter->funcs->atomic_disable)
852 iter->funcs->atomic_disable(iter, state);
853
854 if (iter == bridge)
855 break;
856 }
857 mutex_unlock(&encoder->bridge_chain_mutex);
858}
859EXPORT_SYMBOL(drm_atomic_bridge_chain_disable);
860
861static void drm_atomic_bridge_call_post_disable(struct drm_bridge *bridge,
862 struct drm_atomic_commit *state)
863{
864 if (state && bridge->funcs->atomic_post_disable)
865 bridge->funcs->atomic_post_disable(bridge, state);
866}
867
868/**
869 * drm_atomic_bridge_chain_post_disable - cleans up after disabling all bridges
870 * in the encoder chain
871 * @bridge: bridge control structure
872 * @state: atomic state being committed
873 *
874 * Calls &drm_bridge_funcs.atomic_post_disable op for all the bridges in the
875 * encoder chain, starting from the first bridge to the last. These are called
876 * after completing &drm_encoder_helper_funcs.atomic_disable
877 *
878 * If a bridge sets @pre_enable_prev_first, then the @post_disable for that
879 * bridge will be called before the previous one to reverse the @pre_enable
880 * calling direction.
881 *
882 * Example:
883 * Bridge A ---> Bridge B ---> Bridge C ---> Bridge D ---> Bridge E
884 *
885 * With pre_enable_prev_first flag enable in Bridge B, D, E then the resulting
886 * @post_disable order would be,
887 * Bridge B, Bridge A, Bridge E, Bridge D, Bridge C.
888 *
889 * Note: the bridge passed should be the one closest to the encoder
890 */
891void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,
892 struct drm_atomic_commit *state)
893{
894 struct drm_encoder *encoder;
895 struct drm_bridge *next, *limit;
896
897 if (!bridge)
898 return;
899
900 encoder = bridge->encoder;
901
902 mutex_lock(&encoder->bridge_chain_mutex);
903 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {
904 limit = NULL;
905
906 if (!list_is_last(&bridge->chain_node, &encoder->bridge_chain)) {
907 next = list_next_entry(bridge, chain_node);
908
909 if (next->pre_enable_prev_first) {
910 /* next bridge had requested that prev
911 * was enabled first, so disabled last
912 */
913 limit = next;
914
915 /* Find the next bridge that has NOT requested
916 * prev to be enabled first / disabled last
917 */
918 list_for_each_entry_from(next, &encoder->bridge_chain,
919 chain_node) {
920 if (!next->pre_enable_prev_first) {
921 next = list_prev_entry(next, chain_node);
922 limit = next;
923 break;
924 }
925
926 if (list_is_last(&next->chain_node,
927 &encoder->bridge_chain)) {
928 limit = next;
929 break;
930 }
931 }
932
933 /* Call these bridges in reverse order */
934 list_for_each_entry_from_reverse(next, &encoder->bridge_chain,
935 chain_node) {
936 if (next == bridge)
937 break;
938
939 drm_atomic_bridge_call_post_disable(next,
940 state);
941 }
942 }
943 }
944
945 drm_atomic_bridge_call_post_disable(bridge, state);
946
947 if (limit)
948 /* Jump all bridges that we have already post_disabled */
949 bridge = limit;
950 }
951 mutex_unlock(&encoder->bridge_chain_mutex);
952}
953EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable);
954
955static void drm_atomic_bridge_call_pre_enable(struct drm_bridge *bridge,
956 struct drm_atomic_commit *state)
957{
958 if (state && bridge->funcs->atomic_pre_enable)
959 bridge->funcs->atomic_pre_enable(bridge, state);
960}
961
962/**
963 * drm_atomic_bridge_chain_pre_enable - prepares for enabling all bridges in
964 * the encoder chain
965 * @bridge: bridge control structure
966 * @state: atomic state being committed
967 *
968 * Calls &drm_bridge_funcs.atomic_pre_enable op for all the bridges in the
969 * encoder chain, starting from the last bridge to the first. These are called
970 * before calling &drm_encoder_helper_funcs.atomic_enable
971 *
972 * If a bridge sets @pre_enable_prev_first, then the pre_enable for the
973 * prev bridge will be called before pre_enable of this bridge.
974 *
975 * Example:
976 * Bridge A ---> Bridge B ---> Bridge C ---> Bridge D ---> Bridge E
977 *
978 * With pre_enable_prev_first flag enable in Bridge B, D, E then the resulting
979 * @pre_enable order would be,
980 * Bridge C, Bridge D, Bridge E, Bridge A, Bridge B.
981 *
982 * Note: the bridge passed should be the one closest to the encoder
983 */
984void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,
985 struct drm_atomic_commit *state)
986{
987 struct drm_encoder *encoder;
988 struct drm_bridge *iter, *next, *limit;
989
990 if (!bridge)
991 return;
992
993 encoder = bridge->encoder;
994
995 mutex_lock(&encoder->bridge_chain_mutex);
996 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {
997 if (iter->pre_enable_prev_first) {
998 next = iter;
999 limit = bridge;
1000 list_for_each_entry_from_reverse(next,
1001 &encoder->bridge_chain,
1002 chain_node) {
1003 if (next == bridge)
1004 break;
1005
1006 if (!next->pre_enable_prev_first) {
1007 /* Found first bridge that does NOT
1008 * request prev to be enabled first
1009 */
1010 limit = next;
1011 break;
1012 }
1013 }
1014
1015 list_for_each_entry_from(next, &encoder->bridge_chain, chain_node) {
1016 /* Call requested prev bridge pre_enable
1017 * in order.
1018 */
1019 if (next == iter)
1020 /* At the first bridge to request prev
1021 * bridges called first.
1022 */
1023 break;
1024
1025 drm_atomic_bridge_call_pre_enable(next, state);
1026 }
1027 }
1028
1029 drm_atomic_bridge_call_pre_enable(iter, state);
1030
1031 if (iter->pre_enable_prev_first)
1032 /* Jump all bridges that we have already pre_enabled */
1033 iter = limit;
1034
1035 if (iter == bridge)
1036 break;
1037 }
1038 mutex_unlock(&encoder->bridge_chain_mutex);
1039}
1040EXPORT_SYMBOL(drm_atomic_bridge_chain_pre_enable);
1041
1042/**
1043 * drm_atomic_bridge_chain_enable - enables all bridges in the encoder chain
1044 * @first_bridge: bridge control structure
1045 * @state: atomic state being committed
1046 *
1047 * Calls &drm_bridge_funcs.atomic_enable op for all the bridges in the encoder
1048 * chain, starting from the first bridge to the last. These are called after
1049 * completing &drm_encoder_helper_funcs.atomic_enable
1050 *
1051 * Note: the bridge passed should be the one closest to the encoder
1052 */
1053void drm_atomic_bridge_chain_enable(struct drm_bridge *first_bridge,
1054 struct drm_atomic_commit *state)
1055{
1056 if (!first_bridge)
1057 return;
1058
1059 drm_for_each_bridge_in_chain_from(first_bridge, bridge)
1060 if (bridge->funcs->atomic_enable)
1061 bridge->funcs->atomic_enable(bridge, state);
1062}
1063EXPORT_SYMBOL(drm_atomic_bridge_chain_enable);
1064
1065static int drm_atomic_bridge_check(struct drm_bridge *bridge,
1066 struct drm_crtc_state *crtc_state,
1067 struct drm_connector_state *conn_state)
1068{
1069 if (bridge->funcs->atomic_check) {
1070 struct drm_bridge_state *bridge_state;
1071 int ret;
1072
1073 bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
1074 bridge);
1075 if (WARN_ON(!bridge_state))
1076 return -EINVAL;
1077
1078 ret = bridge->funcs->atomic_check(bridge, bridge_state,
1079 crtc_state, conn_state);
1080 if (ret)
1081 return ret;
1082 } else if (bridge->funcs->mode_fixup) {
1083 if (!bridge->funcs->mode_fixup(bridge, &crtc_state->mode,
1084 &crtc_state->adjusted_mode))
1085 return -EINVAL;
1086 }
1087
1088 return 0;
1089}
1090
1091static int select_bus_fmt_recursive(struct drm_bridge *first_bridge,
1092 struct drm_bridge *cur_bridge,
1093 struct drm_crtc_state *crtc_state,
1094 struct drm_connector_state *conn_state,
1095 u32 out_bus_fmt)
1096{
1097 unsigned int i, num_in_bus_fmts = 0;
1098 struct drm_bridge_state *cur_state;
1099 struct drm_bridge *prev_bridge __free(drm_bridge_put) =
1100 drm_bridge_get_prev_bridge(cur_bridge);
1101 u32 *in_bus_fmts;
1102 int ret;
1103
1104 cur_state = drm_atomic_get_new_bridge_state(crtc_state->state,
1105 cur_bridge);
1106
1107 /*
1108 * If bus format negotiation is not supported by this bridge, let's
1109 * pass MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and
1110 * hope that it can handle this situation gracefully (by providing
1111 * appropriate default values).
1112 */
1113 if (!cur_bridge->funcs->atomic_get_input_bus_fmts) {
1114 if (cur_bridge != first_bridge) {
1115 ret = select_bus_fmt_recursive(first_bridge,
1116 prev_bridge, crtc_state,
1117 conn_state,
1118 MEDIA_BUS_FMT_FIXED);
1119 if (ret)
1120 return ret;
1121 }
1122
1123 /*
1124 * Driver does not implement the atomic state hooks, but that's
1125 * fine, as long as it does not access the bridge state.
1126 */
1127 if (cur_state) {
1128 cur_state->input_bus_cfg.format = MEDIA_BUS_FMT_FIXED;
1129 cur_state->output_bus_cfg.format = out_bus_fmt;
1130 }
1131
1132 return 0;
1133 }
1134
1135 /*
1136 * If the driver implements ->atomic_get_input_bus_fmts() it
1137 * should also implement the atomic state hooks.
1138 */
1139 if (WARN_ON(!cur_state))
1140 return -EINVAL;
1141
1142 in_bus_fmts = cur_bridge->funcs->atomic_get_input_bus_fmts(cur_bridge,
1143 cur_state,
1144 crtc_state,
1145 conn_state,
1146 out_bus_fmt,
1147 &num_in_bus_fmts);
1148 if (!num_in_bus_fmts)
1149 return -ENOTSUPP;
1150 else if (!in_bus_fmts)
1151 return -ENOMEM;
1152
1153 if (first_bridge == cur_bridge) {
1154 cur_state->input_bus_cfg.format = in_bus_fmts[0];
1155 cur_state->output_bus_cfg.format = out_bus_fmt;
1156 kfree(in_bus_fmts);
1157 return 0;
1158 }
1159
1160 for (i = 0; i < num_in_bus_fmts; i++) {
1161 ret = select_bus_fmt_recursive(first_bridge, prev_bridge,
1162 crtc_state, conn_state,
1163 in_bus_fmts[i]);
1164 if (ret != -ENOTSUPP)
1165 break;
1166 }
1167
1168 if (!ret) {
1169 cur_state->input_bus_cfg.format = in_bus_fmts[i];
1170 cur_state->output_bus_cfg.format = out_bus_fmt;
1171 }
1172
1173 kfree(in_bus_fmts);
1174 return ret;
1175}
1176
1177static bool __pure bus_format_is_color_fmt(u32 bus_fmt, enum drm_connector_color_format fmt)
1178{
1179 if (fmt == DRM_CONNECTOR_COLOR_FORMAT_AUTO)
1180 return true;
1181
1182 switch (bus_fmt) {
1183 case MEDIA_BUS_FMT_FIXED:
1184 return true;
1185 case MEDIA_BUS_FMT_RGB888_1X24:
1186 case MEDIA_BUS_FMT_RGB101010_1X30:
1187 case MEDIA_BUS_FMT_RGB121212_1X36:
1188 case MEDIA_BUS_FMT_RGB161616_1X48:
1189 return fmt == DRM_CONNECTOR_COLOR_FORMAT_RGB444;
1190 case MEDIA_BUS_FMT_YUV8_1X24:
1191 case MEDIA_BUS_FMT_YUV10_1X30:
1192 case MEDIA_BUS_FMT_YUV12_1X36:
1193 case MEDIA_BUS_FMT_YUV16_1X48:
1194 return fmt == DRM_CONNECTOR_COLOR_FORMAT_YCBCR444;
1195 case MEDIA_BUS_FMT_UYVY8_1X16:
1196 case MEDIA_BUS_FMT_VYUY8_1X16:
1197 case MEDIA_BUS_FMT_YUYV8_1X16:
1198 case MEDIA_BUS_FMT_YVYU8_1X16:
1199 case MEDIA_BUS_FMT_UYVY10_1X20:
1200 case MEDIA_BUS_FMT_YUYV10_1X20:
1201 case MEDIA_BUS_FMT_VYUY10_1X20:
1202 case MEDIA_BUS_FMT_YVYU10_1X20:
1203 case MEDIA_BUS_FMT_UYVY12_1X24:
1204 case MEDIA_BUS_FMT_VYUY12_1X24:
1205 case MEDIA_BUS_FMT_YUYV12_1X24:
1206 case MEDIA_BUS_FMT_YVYU12_1X24:
1207 return fmt == DRM_CONNECTOR_COLOR_FORMAT_YCBCR422;
1208 case MEDIA_BUS_FMT_UYYVYY8_0_5X24:
1209 case MEDIA_BUS_FMT_UYYVYY10_0_5X30:
1210 case MEDIA_BUS_FMT_UYYVYY12_0_5X36:
1211 case MEDIA_BUS_FMT_UYYVYY16_0_5X48:
1212 return fmt == DRM_CONNECTOR_COLOR_FORMAT_YCBCR420;
1213 default:
1214 return false;
1215 }
1216}
1217
1218/*
1219 * This function is called by &drm_atomic_bridge_chain_check() just before
1220 * calling &drm_bridge_funcs.atomic_check() on all elements of the chain.
1221 * It performs bus format negotiation between bridge elements. The negotiation
1222 * happens in reverse order, starting from the last element in the chain up to
1223 * @bridge.
1224 *
1225 * Negotiation starts by retrieving supported output bus formats on the last
1226 * bridge element and testing them one by one. The test is recursive, meaning
1227 * that for each tested output format, the whole chain will be walked backward,
1228 * and each element will have to choose an input bus format that can be
1229 * transcoded to the requested output format. When a bridge element does not
1230 * support transcoding into a specific output format -ENOTSUPP is returned and
1231 * the next bridge element will have to try a different format. If none of the
1232 * combinations worked, -ENOTSUPP is returned and the atomic modeset will fail.
1233 *
1234 * This implementation is relying on
1235 * &drm_bridge_funcs.atomic_get_output_bus_fmts() and
1236 * &drm_bridge_funcs.atomic_get_input_bus_fmts() to gather supported
1237 * input/output formats.
1238 *
1239 * When &drm_bridge_funcs.atomic_get_output_bus_fmts() is not implemented by
1240 * the last element of the chain, &drm_atomic_bridge_chain_select_bus_fmts()
1241 * tries a single format: &drm_connector.display_info.bus_formats[0] if
1242 * available, MEDIA_BUS_FMT_FIXED otherwise.
1243 *
1244 * When &drm_bridge_funcs.atomic_get_input_bus_fmts() is not implemented,
1245 * &drm_atomic_bridge_chain_select_bus_fmts() skips the negotiation on the
1246 * bridge element that lacks this hook and asks the previous element in the
1247 * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide what
1248 * to do in that case (fail if they want to enforce bus format negotiation, or
1249 * provide a reasonable default if they need to support pipelines where not
1250 * all elements support bus format negotiation).
1251 */
1252static int
1253drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge,
1254 struct drm_crtc_state *crtc_state,
1255 struct drm_connector_state *conn_state)
1256{
1257 struct drm_connector *conn = conn_state->connector;
1258 struct drm_encoder *encoder = bridge->encoder;
1259 struct drm_bridge_state *last_bridge_state;
1260 unsigned int i, num_out_bus_fmts = 0;
1261 enum drm_connector_color_format fmt;
1262 u32 *out_bus_fmts;
1263 int ret = 0;
1264
1265 struct drm_bridge *last_bridge __free(drm_bridge_put) =
1266 drm_bridge_get(list_last_entry(&encoder->bridge_chain,
1267 struct drm_bridge, chain_node));
1268 last_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,
1269 last_bridge);
1270
1271 if (last_bridge->funcs->atomic_get_output_bus_fmts) {
1272 const struct drm_bridge_funcs *funcs = last_bridge->funcs;
1273
1274 /*
1275 * If the driver implements ->atomic_get_output_bus_fmts() it
1276 * should also implement the atomic state hooks.
1277 */
1278 if (WARN_ON(!last_bridge_state))
1279 return -EINVAL;
1280
1281 out_bus_fmts = funcs->atomic_get_output_bus_fmts(last_bridge,
1282 last_bridge_state,
1283 crtc_state,
1284 conn_state,
1285 &num_out_bus_fmts);
1286 if (!num_out_bus_fmts)
1287 return -ENOTSUPP;
1288 else if (!out_bus_fmts)
1289 return -ENOMEM;
1290 } else {
1291 num_out_bus_fmts = 1;
1292 out_bus_fmts = kmalloc_obj(*out_bus_fmts);
1293 if (!out_bus_fmts)
1294 return -ENOMEM;
1295
1296 if (conn->display_info.num_bus_formats &&
1297 conn->display_info.bus_formats)
1298 out_bus_fmts[0] = conn->display_info.bus_formats[0];
1299 else
1300 out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;
1301 }
1302
1303 /*
1304 * Instead of directly accessing conn_state.color_format, call into a
1305 * connector function that allows connector implementations (e.g. for
1306 * bridge connectors including HDMI bridges, where the HDMI helpers will
1307 * have already chosen an appropriate output format) to override the
1308 * selected format.
1309 */
1310 fmt = drm_connector_get_color_format(conn_state);
1311
1312 for (i = 0; i < num_out_bus_fmts; i++) {
1313 if (!bus_format_is_color_fmt(out_bus_fmts[i], fmt)) {
1314 drm_dbg_kms(last_bridge->dev,
1315 "Skipping bus format 0x%04x as it doesn't match format %d\n",
1316 out_bus_fmts[i], fmt);
1317 ret = -ENOTSUPP;
1318 continue;
1319 }
1320 ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state,
1321 conn_state, out_bus_fmts[i]);
1322 if (ret != -ENOTSUPP) {
1323 drm_dbg_kms(last_bridge->dev,
1324 "Found bridge chain ending with bus format 0x%04x\n",
1325 out_bus_fmts[i]);
1326 break;
1327 }
1328 }
1329
1330 kfree(out_bus_fmts);
1331
1332 return ret;
1333}
1334
1335static void
1336drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge,
1337 struct drm_connector *conn,
1338 struct drm_atomic_commit *state)
1339{
1340 struct drm_bridge_state *bridge_state, *next_bridge_state;
1341 u32 output_flags = 0;
1342
1343 bridge_state = drm_atomic_get_new_bridge_state(state, bridge);
1344
1345 /* No bridge state attached to this bridge => nothing to propagate. */
1346 if (!bridge_state)
1347 return;
1348
1349 struct drm_bridge *next_bridge __free(drm_bridge_put) = drm_bridge_get_next_bridge(bridge);
1350
1351 /*
1352 * Let's try to apply the most common case here, that is, propagate
1353 * display_info flags for the last bridge, and propagate the input
1354 * flags of the next bridge element to the output end of the current
1355 * bridge when the bridge is not the last one.
1356 * There are exceptions to this rule, like when signal inversion is
1357 * happening at the board level, but that's something drivers can deal
1358 * with from their &drm_bridge_funcs.atomic_check() implementation by
1359 * simply overriding the flags value we've set here.
1360 */
1361 if (!next_bridge) {
1362 output_flags = conn->display_info.bus_flags;
1363 } else {
1364 next_bridge_state = drm_atomic_get_new_bridge_state(state,
1365 next_bridge);
1366 /*
1367 * No bridge state attached to the next bridge, just leave the
1368 * flags to 0.
1369 */
1370 if (next_bridge_state)
1371 output_flags = next_bridge_state->input_bus_cfg.flags;
1372 }
1373
1374 bridge_state->output_bus_cfg.flags = output_flags;
1375
1376 /*
1377 * Propagate the output flags to the input end of the bridge. Again, it's
1378 * not necessarily what all bridges want, but that's what most of them
1379 * do, and by doing that by default we avoid forcing drivers to
1380 * duplicate the "dummy propagation" logic.
1381 */
1382 bridge_state->input_bus_cfg.flags = output_flags;
1383}
1384
1385/**
1386 * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain
1387 * @bridge: bridge control structure
1388 * @crtc_state: new CRTC state
1389 * @conn_state: new connector state
1390 *
1391 * First trigger a bus format negotiation before calling
1392 * &drm_bridge_funcs.atomic_check() (falls back on
1393 * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder chain,
1394 * starting from the last bridge to the first. These are called before calling
1395 * &drm_encoder_helper_funcs.atomic_check()
1396 *
1397 * RETURNS:
1398 * 0 on success, a negative error code on failure
1399 */
1400int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,
1401 struct drm_crtc_state *crtc_state,
1402 struct drm_connector_state *conn_state)
1403{
1404 struct drm_connector *conn = conn_state->connector;
1405 struct drm_encoder *encoder;
1406 struct drm_bridge *iter;
1407 int ret;
1408
1409 if (!bridge)
1410 return 0;
1411
1412 ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state,
1413 conn_state);
1414 if (ret)
1415 return ret;
1416
1417 encoder = bridge->encoder;
1418 scoped_guard(mutex, &encoder->bridge_chain_mutex) {
1419 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {
1420 int ret;
1421
1422 /*
1423 * Bus flags are propagated by default. If a bridge needs to
1424 * tweak the input bus flags for any reason, it should happen
1425 * in its &drm_bridge_funcs.atomic_check() implementation such
1426 * that preceding bridges in the chain can propagate the new
1427 * bus flags.
1428 */
1429 drm_atomic_bridge_propagate_bus_flags(iter, conn,
1430 crtc_state->state);
1431
1432 ret = drm_atomic_bridge_check(iter, crtc_state, conn_state);
1433 if (ret)
1434 return ret;
1435
1436 if (iter == bridge)
1437 break;
1438 }
1439 }
1440
1441 return 0;
1442}
1443EXPORT_SYMBOL(drm_atomic_bridge_chain_check);
1444
1445/**
1446 * drm_bridge_detect - check if anything is attached to the bridge output
1447 * @bridge: bridge control structure
1448 * @connector: attached connector
1449 *
1450 * If the bridge supports output detection, as reported by the
1451 * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the
1452 * bridge and return the connection status. Otherwise return
1453 * connector_status_unknown.
1454 *
1455 * RETURNS:
1456 * The detection status on success, or connector_status_unknown if the bridge
1457 * doesn't support output detection.
1458 */
1459enum drm_connector_status
1460drm_bridge_detect(struct drm_bridge *bridge, struct drm_connector *connector)
1461{
1462 if (!(bridge->ops & DRM_BRIDGE_OP_DETECT))
1463 return connector_status_unknown;
1464
1465 return bridge->funcs->detect(bridge, connector);
1466}
1467EXPORT_SYMBOL_GPL(drm_bridge_detect);
1468
1469/**
1470 * drm_bridge_get_modes - fill all modes currently valid for the sink into the
1471 * @connector
1472 * @bridge: bridge control structure
1473 * @connector: the connector to fill with modes
1474 *
1475 * If the bridge supports output modes retrieval, as reported by the
1476 * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to
1477 * fill the connector with all valid modes and return the number of modes
1478 * added. Otherwise return 0.
1479 *
1480 * RETURNS:
1481 * The number of modes added to the connector.
1482 */
1483int drm_bridge_get_modes(struct drm_bridge *bridge,
1484 struct drm_connector *connector)
1485{
1486 if (!(bridge->ops & DRM_BRIDGE_OP_MODES))
1487 return 0;
1488
1489 return bridge->funcs->get_modes(bridge, connector);
1490}
1491EXPORT_SYMBOL_GPL(drm_bridge_get_modes);
1492
1493/**
1494 * drm_bridge_edid_read - read the EDID data of the connected display
1495 * @bridge: bridge control structure
1496 * @connector: the connector to read EDID for
1497 *
1498 * If the bridge supports output EDID retrieval, as reported by the
1499 * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.edid_read to get
1500 * the EDID and return it. Otherwise return NULL.
1501 *
1502 * RETURNS:
1503 * The retrieved EDID on success, or NULL otherwise.
1504 */
1505const struct drm_edid *drm_bridge_edid_read(struct drm_bridge *bridge,
1506 struct drm_connector *connector)
1507{
1508 if (!(bridge->ops & DRM_BRIDGE_OP_EDID))
1509 return NULL;
1510
1511 return bridge->funcs->edid_read(bridge, connector);
1512}
1513EXPORT_SYMBOL_GPL(drm_bridge_edid_read);
1514
1515/**
1516 * drm_bridge_hpd_enable - enable hot plug detection for the bridge
1517 * @bridge: bridge control structure
1518 * @cb: hot-plug detection callback
1519 * @data: data to be passed to the hot-plug detection callback
1520 *
1521 * Call &drm_bridge_funcs.hpd_enable if implemented and register the given @cb
1522 * and @data as hot plug notification callback. From now on the @cb will be
1523 * called with @data when an output status change is detected by the bridge,
1524 * until hot plug notification gets disabled with drm_bridge_hpd_disable().
1525 *
1526 * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in
1527 * bridge->ops. This function shall not be called when the flag is not set.
1528 *
1529 * Only one hot plug detection callback can be registered at a time, it is an
1530 * error to call this function when hot plug detection is already enabled for
1531 * the bridge.
1532 */
1533void drm_bridge_hpd_enable(struct drm_bridge *bridge,
1534 void (*cb)(void *data,
1535 enum drm_connector_status status),
1536 void *data)
1537{
1538 if (!(bridge->ops & DRM_BRIDGE_OP_HPD))
1539 return;
1540
1541 mutex_lock(&bridge->hpd_state_mutex);
1542
1543 mutex_lock(&bridge->hpd_mutex);
1544
1545 if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n")) {
1546 mutex_unlock(&bridge->hpd_mutex);
1547 goto unlock;
1548 }
1549
1550 bridge->hpd_cb = cb;
1551 bridge->hpd_data = data;
1552
1553 mutex_unlock(&bridge->hpd_mutex);
1554
1555 if (bridge->funcs->hpd_enable)
1556 bridge->funcs->hpd_enable(bridge);
1557
1558unlock:
1559 mutex_unlock(&bridge->hpd_state_mutex);
1560}
1561EXPORT_SYMBOL_GPL(drm_bridge_hpd_enable);
1562
1563/**
1564 * drm_bridge_hpd_disable - disable hot plug detection for the bridge
1565 * @bridge: bridge control structure
1566 *
1567 * Call &drm_bridge_funcs.hpd_disable if implemented and unregister the hot
1568 * plug detection callback previously registered with drm_bridge_hpd_enable().
1569 * Once this function returns the callback will not be called by the bridge
1570 * when an output status change occurs.
1571 *
1572 * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in
1573 * bridge->ops. This function shall not be called when the flag is not set.
1574 */
1575void drm_bridge_hpd_disable(struct drm_bridge *bridge)
1576{
1577 if (!(bridge->ops & DRM_BRIDGE_OP_HPD))
1578 return;
1579
1580 mutex_lock(&bridge->hpd_state_mutex);
1581 if (bridge->funcs->hpd_disable)
1582 bridge->funcs->hpd_disable(bridge);
1583
1584 mutex_lock(&bridge->hpd_mutex);
1585 bridge->hpd_cb = NULL;
1586 bridge->hpd_data = NULL;
1587 mutex_unlock(&bridge->hpd_mutex);
1588 mutex_unlock(&bridge->hpd_state_mutex);
1589}
1590EXPORT_SYMBOL_GPL(drm_bridge_hpd_disable);
1591
1592/**
1593 * drm_bridge_hpd_notify - notify hot plug detection events
1594 * @bridge: bridge control structure
1595 * @status: output connection status
1596 *
1597 * Bridge drivers shall call this function to report hot plug events when they
1598 * detect a change in the output status, when hot plug detection has been
1599 * enabled by drm_bridge_hpd_enable().
1600 *
1601 * This function shall be called in a context that can sleep.
1602 */
1603void drm_bridge_hpd_notify(struct drm_bridge *bridge,
1604 enum drm_connector_status status)
1605{
1606 mutex_lock(&bridge->hpd_mutex);
1607 if (bridge->hpd_cb)
1608 bridge->hpd_cb(bridge->hpd_data, status);
1609 mutex_unlock(&bridge->hpd_mutex);
1610}
1611EXPORT_SYMBOL_GPL(drm_bridge_hpd_notify);
1612
1613#ifdef CONFIG_OF
1614/**
1615 * of_drm_find_and_get_bridge - find the bridge corresponding to the device
1616 * node in the global bridge list
1617 * @np: device node
1618 *
1619 * The refcount of the returned bridge is incremented. Use drm_bridge_put()
1620 * when done with it.
1621 *
1622 * RETURNS:
1623 * drm_bridge control struct on success, NULL on failure
1624 */
1625struct drm_bridge *of_drm_find_and_get_bridge(struct device_node *np)
1626{
1627 struct drm_bridge *bridge;
1628
1629 scoped_guard(mutex, &bridge_lock) {
1630 list_for_each_entry(bridge, &bridge_list, list)
1631 if (bridge->of_node == np)
1632 return drm_bridge_get(bridge);
1633 }
1634
1635 return NULL;
1636}
1637EXPORT_SYMBOL(of_drm_find_and_get_bridge);
1638
1639/**
1640 * of_drm_find_bridge - find the bridge corresponding to the device node in
1641 * the global bridge list
1642 *
1643 * @np: device node
1644 *
1645 * This function is deprecated. Convert to of_drm_find_and_get_bridge()
1646 * instead for proper refcounting.
1647 *
1648 * The bridge returned by this function is not refcounted. This is
1649 * dangerous because the bridge might be deallocated even before the caller
1650 * has a chance to use it. To use this function you have to do one of:
1651 *
1652 * - get a reference with drm_bridge_get() as soon as possible to
1653 * minimize the race window, and then drm_bridge_put() when no longer
1654 * using the pointer
1655 *
1656 * - not call drm_bridge_get() or drm_bridge_put() at all, which used to
1657 * be the correct practice before dynamic bridge lifetime was introduced
1658 *
1659 * - again, convert to of_drm_find_and_get_bridge(), which is the only safe
1660 * thing to do
1661 *
1662 * RETURNS:
1663 * drm_bridge control struct on success, NULL on failure
1664 */
1665struct drm_bridge *of_drm_find_bridge(struct device_node *np)
1666{
1667 struct drm_bridge *bridge = of_drm_find_and_get_bridge(np);
1668
1669 /*
1670 * We need to emulate the original semantics of
1671 * of_drm_find_bridge(), which was not getting any bridge
1672 * reference. Being now based on of_drm_find_and_get_bridge() which
1673 * gets a reference, put it before returning.
1674 */
1675 drm_bridge_put(bridge);
1676
1677 return bridge;
1678}
1679EXPORT_SYMBOL(of_drm_find_bridge);
1680
1681/**
1682 * of_drm_get_bridge_by_endpoint - return DRM bridge connected to a port/endpoint
1683 * @np: device tree node containing output ports
1684 * @port: port in the device tree node, or -1 for the first port found
1685 * @endpoint: endpoint in the device tree node, or -1 for the first endpoint found
1686 *
1687 * Given a DT node's port and endpoint number, find the connected node and
1688 * return the associated drm_bridge device.
1689 *
1690 * The refcount of the returned bridge is incremented. Use drm_bridge_put()
1691 * when done with it.
1692 *
1693 * Returns a pointer to the connected drm_bridge, or a negative error on failure
1694 */
1695struct drm_bridge *of_drm_get_bridge_by_endpoint(const struct device_node *np,
1696 int port, int endpoint)
1697{
1698 struct drm_bridge *bridge;
1699
1700 /*
1701 * of_graph_get_remote_node() produces a noisy error message if port
1702 * node isn't found and the absence of the port is a legit case here,
1703 * so at first we silently check whether a graph is present in the
1704 * device-tree node.
1705 */
1706 if (!of_graph_is_present(np))
1707 return ERR_PTR(-ENODEV);
1708
1709 struct device_node *remote __free(device_node) =
1710 of_graph_get_remote_node(np, port, endpoint);
1711 if (!remote)
1712 return ERR_PTR(-ENODEV);
1713
1714 bridge = of_drm_find_and_get_bridge(remote);
1715 if (!bridge)
1716 return ERR_PTR(-EPROBE_DEFER);
1717
1718 return bridge;
1719}
1720EXPORT_SYMBOL_GPL(of_drm_get_bridge_by_endpoint);
1721#endif
1722
1723/**
1724 * devm_drm_put_bridge - Release a bridge reference obtained via devm
1725 * @dev: device that got the bridge via devm
1726 * @bridge: pointer to a struct drm_bridge obtained via devm
1727 *
1728 * Same as drm_bridge_put() for bridge pointers obtained via devm functions
1729 * such as devm_drm_bridge_alloc().
1730 *
1731 * This function is a temporary workaround and MUST NOT be used. Manual
1732 * handling of bridge lifetime is inherently unsafe.
1733 */
1734void devm_drm_put_bridge(struct device *dev, struct drm_bridge *bridge)
1735{
1736 devm_release_action(dev, drm_bridge_put_void, bridge);
1737}
1738EXPORT_SYMBOL(devm_drm_put_bridge);
1739
1740static void drm_bridge_debugfs_show_bridge(struct drm_printer *p,
1741 struct drm_bridge *bridge,
1742 unsigned int idx,
1743 bool lingering,
1744 bool scoped)
1745{
1746 unsigned int refcount = kref_read(&bridge->refcount);
1747
1748 if (scoped)
1749 refcount--;
1750
1751 drm_printf(p, "bridge[%u]: %ps\n", idx, bridge->funcs);
1752
1753 drm_printf_indent(p, 1, "refcount: %u%s\n", refcount,
1754 lingering ? " [lingering]" : "");
1755
1756 drm_printf_indent(p, 1, "type: [%d] %s\n", bridge->type,
1757 drm_get_connector_type_name(bridge->type));
1758
1759 /* The OF node could be freed after drm_bridge_remove() */
1760 if (bridge->of_node && !lingering)
1761 drm_printf_indent(p, 1, "OF: %pOFfc\n", bridge->of_node);
1762
1763 drm_printf_indent(p, 1, "ops: [0x%x]", bridge->ops);
1764 if (bridge->ops & DRM_BRIDGE_OP_DETECT)
1765 drm_puts(p, " detect");
1766 if (bridge->ops & DRM_BRIDGE_OP_EDID)
1767 drm_puts(p, " edid");
1768 if (bridge->ops & DRM_BRIDGE_OP_HPD)
1769 drm_puts(p, " hpd");
1770 if (bridge->ops & DRM_BRIDGE_OP_MODES)
1771 drm_puts(p, " modes");
1772 if (bridge->ops & DRM_BRIDGE_OP_HDMI)
1773 drm_puts(p, " hdmi");
1774 drm_puts(p, "\n");
1775}
1776
1777static int allbridges_show(struct seq_file *m, void *data)
1778{
1779 struct drm_printer p = drm_seq_file_printer(m);
1780 struct drm_bridge *bridge;
1781 unsigned int idx = 0;
1782
1783 mutex_lock(&bridge_lock);
1784
1785 list_for_each_entry(bridge, &bridge_list, list)
1786 drm_bridge_debugfs_show_bridge(&p, bridge, idx++, false, false);
1787
1788 list_for_each_entry(bridge, &bridge_lingering_list, list)
1789 drm_bridge_debugfs_show_bridge(&p, bridge, idx++, true, false);
1790
1791 mutex_unlock(&bridge_lock);
1792
1793 return 0;
1794}
1795DEFINE_SHOW_ATTRIBUTE(allbridges);
1796
1797static int encoder_bridges_show(struct seq_file *m, void *data)
1798{
1799 struct drm_encoder *encoder = m->private;
1800 struct drm_printer p = drm_seq_file_printer(m);
1801 unsigned int idx = 0;
1802
1803 drm_for_each_bridge_in_chain(encoder, bridge)
1804 drm_bridge_debugfs_show_bridge(&p, bridge, idx++, false, true);
1805
1806 return 0;
1807}
1808DEFINE_SHOW_ATTRIBUTE(encoder_bridges);
1809
1810void drm_bridge_debugfs_params(struct dentry *root)
1811{
1812 debugfs_create_file("bridges", 0444, root, NULL, &allbridges_fops);
1813}
1814
1815void drm_bridge_debugfs_encoder_params(struct dentry *root,
1816 struct drm_encoder *encoder)
1817{
1818 /* bridges list */
1819 debugfs_create_file("bridges", 0444, root, encoder, &encoder_bridges_fops);
1820}
1821
1822MODULE_AUTHOR("Ajay Kumar <[email protected]>");
1823MODULE_DESCRIPTION("DRM bridge infrastructure");
1824MODULE_LICENSE("GPL and additional rights");