1/*
2 * Copyright (c) 2016 Intel Corporation
3 *
4 * Permission to use, copy, modify, distribute, and sell this software and its
5 * documentation for any purpose is hereby granted without fee, provided that
6 * the above copyright notice appear in all copies and that both that copyright
7 * notice and this permission notice appear in supporting documentation, and
8 * that the name of the copyright holders not be used in advertising or
9 * publicity pertaining to distribution of the software without specific,
10 * written prior permission. The copyright holders make no representations
11 * about the suitability of this software for any purpose. It is provided "as
12 * is" without express or implied warranty.
13 *
14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
20 * OF THIS SOFTWARE.
21 */
22
23#ifndef __DRM_BRIDGE_H__
24#define __DRM_BRIDGE_H__
25
26#include <linux/cleanup.h>
27#include <linux/ctype.h>
28#include <linux/list.h>
29#include <linux/mutex.h>
30
31#include <drm/drm_atomic.h>
32#include <drm/drm_encoder.h>
33#include <drm/drm_mode_object.h>
34#include <drm/drm_modes.h>
35
36struct cec_msg;
37struct device_node;
38
39struct drm_bridge;
40struct drm_bridge_timings;
41struct drm_connector;
42struct drm_display_info;
43struct drm_minor;
44struct drm_panel;
45struct edid;
46struct hdmi_codec_daifmt;
47struct hdmi_codec_params;
48struct i2c_adapter;
49
50/**
51 * enum drm_bridge_attach_flags - Flags for &drm_bridge_funcs.attach
52 */
53enum drm_bridge_attach_flags {
54 /**
55 * @DRM_BRIDGE_ATTACH_NO_CONNECTOR: When this flag is set the bridge
56 * shall not create a drm_connector.
57 */
58 DRM_BRIDGE_ATTACH_NO_CONNECTOR = BIT(0),
59};
60
61/**
62 * struct drm_bridge_funcs - drm_bridge control functions
63 */
64struct drm_bridge_funcs {
65 /**
66 * @attach:
67 *
68 * This callback is invoked whenever our bridge is being attached to a
69 * &drm_encoder. The flags argument tunes the behaviour of the attach
70 * operation (see DRM_BRIDGE_ATTACH_*).
71 *
72 * The @attach callback is optional.
73 *
74 * RETURNS:
75 *
76 * Zero on success, error code on failure.
77 */
78 int (*attach)(struct drm_bridge *bridge, struct drm_encoder *encoder,
79 enum drm_bridge_attach_flags flags);
80
81 /**
82 * @destroy:
83 *
84 * This callback is invoked when the bridge is about to be
85 * deallocated.
86 *
87 * The @destroy callback is optional.
88 */
89 void (*destroy)(struct drm_bridge *bridge);
90
91 /**
92 * @detach:
93 *
94 * This callback is invoked whenever our bridge is being detached from a
95 * &drm_encoder.
96 *
97 * The @detach callback is optional.
98 */
99 void (*detach)(struct drm_bridge *bridge);
100
101 /**
102 * @mode_valid:
103 *
104 * This callback is used to check if a specific mode is valid in this
105 * bridge. This should be implemented if the bridge has some sort of
106 * restriction in the modes it can display. For example, a given bridge
107 * may be responsible to set a clock value. If the clock can not
108 * produce all the values for the available modes then this callback
109 * can be used to restrict the number of modes to only the ones that
110 * can be displayed.
111 *
112 * This hook is used by the probe helpers to filter the mode list in
113 * drm_helper_probe_single_connector_modes(), and it is used by the
114 * atomic helpers to validate modes supplied by userspace in
115 * drm_atomic_helper_check_modeset().
116 *
117 * The @mode_valid callback is optional.
118 *
119 * NOTE:
120 *
121 * Since this function is both called from the check phase of an atomic
122 * commit, and the mode validation in the probe paths it is not allowed
123 * to look at anything else but the passed-in mode, and validate it
124 * against configuration-invariant hardware constraints. Any further
125 * limits which depend upon the configuration can only be checked in
126 * @mode_fixup.
127 *
128 * RETURNS:
129 *
130 * drm_mode_status Enum
131 */
132 enum drm_mode_status (*mode_valid)(struct drm_bridge *bridge,
133 const struct drm_display_info *info,
134 const struct drm_display_mode *mode);
135
136 /**
137 * @mode_fixup:
138 *
139 * This callback is used to validate and adjust a mode. The parameter
140 * mode is the display mode that should be fed to the next element in
141 * the display chain, either the final &drm_connector or the next
142 * &drm_bridge. The parameter adjusted_mode is the input mode the bridge
143 * requires. It can be modified by this callback and does not need to
144 * match mode. See also &drm_crtc_state.adjusted_mode for more details.
145 *
146 * This is the only hook that allows a bridge to reject a modeset. If
147 * this function passes all other callbacks must succeed for this
148 * configuration.
149 *
150 * The mode_fixup callback is optional. &drm_bridge_funcs.mode_fixup()
151 * is not called when &drm_bridge_funcs.atomic_check() is implemented,
152 * so only one of them should be provided.
153 *
154 * NOTE:
155 *
156 * This function is called in the check phase of atomic modesets, which
157 * can be aborted for any reason (including on userspace's request to
158 * just check whether a configuration would be possible). Drivers MUST
159 * NOT touch any persistent state (hardware or software) or data
160 * structures except the passed in @state parameter.
161 *
162 * Also beware that userspace can request its own custom modes, neither
163 * core nor helpers filter modes to the list of probe modes reported by
164 * the GETCONNECTOR IOCTL and stored in &drm_connector.modes. To ensure
165 * that modes are filtered consistently put any bridge constraints and
166 * limits checks into @mode_valid.
167 *
168 * RETURNS:
169 *
170 * True if an acceptable configuration is possible, false if the modeset
171 * operation should be rejected.
172 */
173 bool (*mode_fixup)(struct drm_bridge *bridge,
174 const struct drm_display_mode *mode,
175 struct drm_display_mode *adjusted_mode);
176 /**
177 * @disable:
178 *
179 * The @disable callback should disable the bridge.
180 *
181 * The bridge can assume that the display pipe (i.e. clocks and timing
182 * signals) feeding it is still running when this callback is called.
183 *
184 *
185 * If the preceding element is a &drm_bridge, then this is called before
186 * that bridge is disabled via one of:
187 *
188 * - &drm_bridge_funcs.disable
189 * - &drm_bridge_funcs.atomic_disable
190 *
191 * If the preceding element of the bridge is a display controller, then
192 * this callback is called before the encoder is disabled via one of:
193 *
194 * - &drm_encoder_helper_funcs.atomic_disable
195 * - &drm_encoder_helper_funcs.prepare
196 * - &drm_encoder_helper_funcs.disable
197 * - &drm_encoder_helper_funcs.dpms
198 *
199 * and the CRTC is disabled via one of:
200 *
201 * - &drm_crtc_helper_funcs.prepare
202 * - &drm_crtc_helper_funcs.atomic_disable
203 * - &drm_crtc_helper_funcs.disable
204 * - &drm_crtc_helper_funcs.dpms.
205 *
206 * The @disable callback is optional.
207 *
208 * NOTE:
209 *
210 * This is deprecated, do not use!
211 * New drivers shall use &drm_bridge_funcs.atomic_disable.
212 */
213 void (*disable)(struct drm_bridge *bridge);
214
215 /**
216 * @post_disable:
217 *
218 * The bridge must assume that the display pipe (i.e. clocks and timing
219 * signals) feeding this bridge is no longer running when the
220 * @post_disable is called.
221 *
222 * This callback should perform all the actions required by the hardware
223 * after it has stopped receiving signals from the preceding element.
224 *
225 * If the preceding element is a &drm_bridge, then this is called after
226 * that bridge is post-disabled (unless marked otherwise by the
227 * @pre_enable_prev_first flag) via one of:
228 *
229 * - &drm_bridge_funcs.post_disable
230 * - &drm_bridge_funcs.atomic_post_disable
231 *
232 * If the preceding element of the bridge is a display controller, then
233 * this callback is called after the encoder is disabled via one of:
234 *
235 * - &drm_encoder_helper_funcs.atomic_disable
236 * - &drm_encoder_helper_funcs.prepare
237 * - &drm_encoder_helper_funcs.disable
238 * - &drm_encoder_helper_funcs.dpms
239 *
240 * and the CRTC is disabled via one of:
241 *
242 * - &drm_crtc_helper_funcs.prepare
243 * - &drm_crtc_helper_funcs.atomic_disable
244 * - &drm_crtc_helper_funcs.disable
245 * - &drm_crtc_helper_funcs.dpms
246 *
247 * The @post_disable callback is optional.
248 *
249 * NOTE:
250 *
251 * This is deprecated, do not use!
252 * New drivers shall use &drm_bridge_funcs.atomic_post_disable.
253 */
254 void (*post_disable)(struct drm_bridge *bridge);
255
256 /**
257 * @mode_set:
258 *
259 * This callback should set the given mode on the bridge. It is called
260 * after the @mode_set callback for the preceding element in the display
261 * pipeline has been called already. If the bridge is the first element
262 * then this would be &drm_encoder_helper_funcs.mode_set. The display
263 * pipe (i.e. clocks and timing signals) is off when this function is
264 * called.
265 *
266 * The adjusted_mode parameter is the mode output by the CRTC for the
267 * first bridge in the chain. It can be different from the mode
268 * parameter that contains the desired mode for the connector at the end
269 * of the bridges chain, for instance when the first bridge in the chain
270 * performs scaling. The adjusted mode is mostly useful for the first
271 * bridge in the chain and is likely irrelevant for the other bridges.
272 *
273 * For atomic drivers the adjusted_mode is the mode stored in
274 * &drm_crtc_state.adjusted_mode.
275 *
276 * NOTE:
277 *
278 * This is deprecated, do not use!
279 * New drivers shall set their mode in the
280 * &drm_bridge_funcs.atomic_enable operation.
281 */
282 void (*mode_set)(struct drm_bridge *bridge,
283 const struct drm_display_mode *mode,
284 const struct drm_display_mode *adjusted_mode);
285 /**
286 * @pre_enable:
287 *
288 * The display pipe (i.e. clocks and timing signals) feeding this bridge
289 * will not yet be running when the @pre_enable is called.
290 *
291 * This callback should perform all the necessary actions to prepare the
292 * bridge to accept signals from the preceding element.
293 *
294 * If the preceding element is a &drm_bridge, then this is called before
295 * that bridge is pre-enabled (unless marked otherwise by
296 * @pre_enable_prev_first flag) via one of:
297 *
298 * - &drm_bridge_funcs.pre_enable
299 * - &drm_bridge_funcs.atomic_pre_enable
300 *
301 * If the preceding element of the bridge is a display controller, then
302 * this callback is called before the CRTC is enabled via one of:
303 *
304 * - &drm_crtc_helper_funcs.atomic_enable
305 * - &drm_crtc_helper_funcs.commit
306 *
307 * and the encoder is enabled via one of:
308 *
309 * - &drm_encoder_helper_funcs.atomic_enable
310 * - &drm_encoder_helper_funcs.enable
311 * - &drm_encoder_helper_funcs.commit
312 *
313 * The @pre_enable callback is optional.
314 *
315 * NOTE:
316 *
317 * This is deprecated, do not use!
318 * New drivers shall use &drm_bridge_funcs.atomic_pre_enable.
319 */
320 void (*pre_enable)(struct drm_bridge *bridge);
321
322 /**
323 * @enable:
324 *
325 * The @enable callback should enable the bridge.
326 *
327 * The bridge can assume that the display pipe (i.e. clocks and timing
328 * signals) feeding it is running when this callback is called. This
329 * callback must enable the display link feeding the next bridge in the
330 * chain if there is one.
331 *
332 * If the preceding element is a &drm_bridge, then this is called after
333 * that bridge is enabled via one of:
334 *
335 * - &drm_bridge_funcs.enable
336 * - &drm_bridge_funcs.atomic_enable
337 *
338 * If the preceding element of the bridge is a display controller, then
339 * this callback is called after the CRTC is enabled via one of:
340 *
341 * - &drm_crtc_helper_funcs.atomic_enable
342 * - &drm_crtc_helper_funcs.commit
343 *
344 * and the encoder is enabled via one of:
345 *
346 * - &drm_encoder_helper_funcs.atomic_enable
347 * - &drm_encoder_helper_funcs.enable
348 * - drm_encoder_helper_funcs.commit
349 *
350 * The @enable callback is optional.
351 *
352 * NOTE:
353 *
354 * This is deprecated, do not use!
355 * New drivers shall use &drm_bridge_funcs.atomic_enable.
356 */
357 void (*enable)(struct drm_bridge *bridge);
358
359 /**
360 * @atomic_pre_enable:
361 *
362 * The display pipe (i.e. clocks and timing signals) feeding this bridge
363 * will not yet be running when the @atomic_pre_enable is called.
364 *
365 * This callback should perform all the necessary actions to prepare the
366 * bridge to accept signals from the preceding element.
367 *
368 * If the preceding element is a &drm_bridge, then this is called before
369 * that bridge is pre-enabled (unless marked otherwise by
370 * @pre_enable_prev_first flag) via one of:
371 *
372 * - &drm_bridge_funcs.pre_enable
373 * - &drm_bridge_funcs.atomic_pre_enable
374 *
375 * If the preceding element of the bridge is a display controller, then
376 * this callback is called before the CRTC is enabled via one of:
377 *
378 * - &drm_crtc_helper_funcs.atomic_enable
379 * - &drm_crtc_helper_funcs.commit
380 *
381 * and the encoder is enabled via one of:
382 *
383 * - &drm_encoder_helper_funcs.atomic_enable
384 * - &drm_encoder_helper_funcs.enable
385 * - &drm_encoder_helper_funcs.commit
386 *
387 * The @atomic_pre_enable callback is optional.
388 */
389 void (*atomic_pre_enable)(struct drm_bridge *bridge,
390 struct drm_atomic_state *state);
391
392 /**
393 * @atomic_enable:
394 *
395 * The @atomic_enable callback should enable the bridge.
396 *
397 * The bridge can assume that the display pipe (i.e. clocks and timing
398 * signals) feeding it is running when this callback is called. This
399 * callback must enable the display link feeding the next bridge in the
400 * chain if there is one.
401 *
402 * If the preceding element is a &drm_bridge, then this is called after
403 * that bridge is enabled via one of:
404 *
405 * - &drm_bridge_funcs.enable
406 * - &drm_bridge_funcs.atomic_enable
407 *
408 * If the preceding element of the bridge is a display controller, then
409 * this callback is called after the CRTC is enabled via one of:
410 *
411 * - &drm_crtc_helper_funcs.atomic_enable
412 * - &drm_crtc_helper_funcs.commit
413 *
414 * and the encoder is enabled via one of:
415 *
416 * - &drm_encoder_helper_funcs.atomic_enable
417 * - &drm_encoder_helper_funcs.enable
418 * - drm_encoder_helper_funcs.commit
419 *
420 * The @atomic_enable callback is optional.
421 */
422 void (*atomic_enable)(struct drm_bridge *bridge,
423 struct drm_atomic_state *state);
424 /**
425 * @atomic_disable:
426 *
427 * The @atomic_disable callback should disable the bridge.
428 *
429 * The bridge can assume that the display pipe (i.e. clocks and timing
430 * signals) feeding it is still running when this callback is called.
431 *
432 * If the preceding element is a &drm_bridge, then this is called before
433 * that bridge is disabled via one of:
434 *
435 * - &drm_bridge_funcs.disable
436 * - &drm_bridge_funcs.atomic_disable
437 *
438 * If the preceding element of the bridge is a display controller, then
439 * this callback is called before the encoder is disabled via one of:
440 *
441 * - &drm_encoder_helper_funcs.atomic_disable
442 * - &drm_encoder_helper_funcs.prepare
443 * - &drm_encoder_helper_funcs.disable
444 * - &drm_encoder_helper_funcs.dpms
445 *
446 * and the CRTC is disabled via one of:
447 *
448 * - &drm_crtc_helper_funcs.prepare
449 * - &drm_crtc_helper_funcs.atomic_disable
450 * - &drm_crtc_helper_funcs.disable
451 * - &drm_crtc_helper_funcs.dpms.
452 *
453 * The @atomic_disable callback is optional.
454 */
455 void (*atomic_disable)(struct drm_bridge *bridge,
456 struct drm_atomic_state *state);
457
458 /**
459 * @atomic_post_disable:
460 *
461 * The bridge must assume that the display pipe (i.e. clocks and timing
462 * signals) feeding this bridge is no longer running when the
463 * @atomic_post_disable is called.
464 *
465 * This callback should perform all the actions required by the hardware
466 * after it has stopped receiving signals from the preceding element.
467 *
468 * If the preceding element is a &drm_bridge, then this is called after
469 * that bridge is post-disabled (unless marked otherwise by the
470 * @pre_enable_prev_first flag) via one of:
471 *
472 * - &drm_bridge_funcs.post_disable
473 * - &drm_bridge_funcs.atomic_post_disable
474 *
475 * If the preceding element of the bridge is a display controller, then
476 * this callback is called after the encoder is disabled via one of:
477 *
478 * - &drm_encoder_helper_funcs.atomic_disable
479 * - &drm_encoder_helper_funcs.prepare
480 * - &drm_encoder_helper_funcs.disable
481 * - &drm_encoder_helper_funcs.dpms
482 *
483 * and the CRTC is disabled via one of:
484 *
485 * - &drm_crtc_helper_funcs.prepare
486 * - &drm_crtc_helper_funcs.atomic_disable
487 * - &drm_crtc_helper_funcs.disable
488 * - &drm_crtc_helper_funcs.dpms
489 *
490 * The @atomic_post_disable callback is optional.
491 */
492 void (*atomic_post_disable)(struct drm_bridge *bridge,
493 struct drm_atomic_state *state);
494
495 /**
496 * @atomic_duplicate_state:
497 *
498 * Duplicate the current bridge state object (which is guaranteed to be
499 * non-NULL).
500 *
501 * The atomic_duplicate_state hook is mandatory if the bridge
502 * implements any of the atomic hooks, and should be left unassigned
503 * otherwise. For bridges that don't subclass &drm_bridge_state, the
504 * drm_atomic_helper_bridge_duplicate_state() helper function shall be
505 * used to implement this hook.
506 *
507 * RETURNS:
508 * A valid drm_bridge_state object or NULL if the allocation fails.
509 */
510 struct drm_bridge_state *(*atomic_duplicate_state)(struct drm_bridge *bridge);
511
512 /**
513 * @atomic_destroy_state:
514 *
515 * Destroy a bridge state object previously allocated by
516 * &drm_bridge_funcs.atomic_duplicate_state().
517 *
518 * The atomic_destroy_state hook is mandatory if the bridge implements
519 * any of the atomic hooks, and should be left unassigned otherwise.
520 * For bridges that don't subclass &drm_bridge_state, the
521 * drm_atomic_helper_bridge_destroy_state() helper function shall be
522 * used to implement this hook.
523 */
524 void (*atomic_destroy_state)(struct drm_bridge *bridge,
525 struct drm_bridge_state *state);
526
527 /**
528 * @atomic_get_output_bus_fmts:
529 *
530 * Return the supported bus formats on the output end of a bridge.
531 * The returned array must be allocated with kmalloc() and will be
532 * freed by the caller. If the allocation fails, NULL should be
533 * returned. num_output_fmts must be set to the returned array size.
534 * Formats listed in the returned array should be listed in decreasing
535 * preference order (the core will try all formats until it finds one
536 * that works).
537 *
538 * This method is only called on the last element of the bridge chain
539 * as part of the bus format negotiation process that happens in
540 * &drm_atomic_bridge_chain_select_bus_fmts().
541 * This method is optional. When not implemented, the core will
542 * fall back to &drm_connector.display_info.bus_formats[0] if
543 * &drm_connector.display_info.num_bus_formats > 0,
544 * or to MEDIA_BUS_FMT_FIXED otherwise.
545 */
546 u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge,
547 struct drm_bridge_state *bridge_state,
548 struct drm_crtc_state *crtc_state,
549 struct drm_connector_state *conn_state,
550 unsigned int *num_output_fmts);
551
552 /**
553 * @atomic_get_input_bus_fmts:
554 *
555 * Return the supported bus formats on the input end of a bridge for
556 * a specific output bus format.
557 *
558 * The returned array must be allocated with kmalloc() and will be
559 * freed by the caller. If the allocation fails, NULL should be
560 * returned. num_input_fmts must be set to the returned array size.
561 * Formats listed in the returned array should be listed in decreasing
562 * preference order (the core will try all formats until it finds one
563 * that works). When the format is not supported NULL should be
564 * returned and num_input_fmts should be set to 0.
565 *
566 * This method is called on all elements of the bridge chain as part of
567 * the bus format negotiation process that happens in
568 * drm_atomic_bridge_chain_select_bus_fmts().
569 * This method is optional. When not implemented, the core will bypass
570 * bus format negotiation on this element of the bridge without
571 * failing, and the previous element in the chain will be passed
572 * MEDIA_BUS_FMT_FIXED as its output bus format.
573 *
574 * Bridge drivers that need to support being linked to bridges that are
575 * not supporting bus format negotiation should handle the
576 * output_fmt == MEDIA_BUS_FMT_FIXED case appropriately, by selecting a
577 * sensible default value or extracting this information from somewhere
578 * else (FW property, &drm_display_mode, &drm_display_info, ...)
579 *
580 * Note: Even if input format selection on the first bridge has no
581 * impact on the negotiation process (bus format negotiation stops once
582 * we reach the first element of the chain), drivers are expected to
583 * return accurate input formats as the input format may be used to
584 * configure the CRTC output appropriately.
585 */
586 u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge,
587 struct drm_bridge_state *bridge_state,
588 struct drm_crtc_state *crtc_state,
589 struct drm_connector_state *conn_state,
590 u32 output_fmt,
591 unsigned int *num_input_fmts);
592
593 /**
594 * @atomic_check:
595 *
596 * This method is responsible for checking bridge state correctness.
597 * It can also check the state of the surrounding components in chain
598 * to make sure the whole pipeline can work properly.
599 *
600 * &drm_bridge_funcs.atomic_check() hooks are called in reverse
601 * order (from the last to the first bridge).
602 *
603 * This method is optional. &drm_bridge_funcs.mode_fixup() is not
604 * called when &drm_bridge_funcs.atomic_check() is implemented, so only
605 * one of them should be provided.
606 *
607 * If drivers need to tweak &drm_bridge_state.input_bus_cfg.flags or
608 * &drm_bridge_state.output_bus_cfg.flags it should happen in
609 * this function. By default the &drm_bridge_state.output_bus_cfg.flags
610 * field is set to the next bridge
611 * &drm_bridge_state.input_bus_cfg.flags value or
612 * &drm_connector.display_info.bus_flags if the bridge is the last
613 * element in the chain.
614 *
615 * RETURNS:
616 * zero if the check passed, a negative error code otherwise.
617 */
618 int (*atomic_check)(struct drm_bridge *bridge,
619 struct drm_bridge_state *bridge_state,
620 struct drm_crtc_state *crtc_state,
621 struct drm_connector_state *conn_state);
622
623 /**
624 * @atomic_reset:
625 *
626 * Reset the bridge to a predefined state (or retrieve its current
627 * state) and return a &drm_bridge_state object matching this state.
628 * This function is called at attach time.
629 *
630 * The atomic_reset hook is mandatory if the bridge implements any of
631 * the atomic hooks, and should be left unassigned otherwise. For
632 * bridges that don't subclass &drm_bridge_state, the
633 * drm_atomic_helper_bridge_reset() helper function shall be used to
634 * implement this hook.
635 *
636 * Note that the atomic_reset() semantics is not exactly matching the
637 * reset() semantics found on other components (connector, plane, ...).
638 *
639 * 1. The reset operation happens when the bridge is attached, not when
640 * drm_mode_config_reset() is called
641 * 2. It's meant to be used exclusively on bridges that have been
642 * converted to the ATOMIC API
643 *
644 * RETURNS:
645 * A valid drm_bridge_state object in case of success, an ERR_PTR()
646 * giving the reason of the failure otherwise.
647 */
648 struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge);
649
650 /**
651 * @detect:
652 *
653 * Check if anything is attached to the bridge output.
654 *
655 * This callback is optional, if not implemented the bridge will be
656 * considered as always having a component attached to its output.
657 * Bridges that implement this callback shall set the
658 * DRM_BRIDGE_OP_DETECT flag in their &drm_bridge->ops.
659 *
660 * RETURNS:
661 *
662 * drm_connector_status indicating the bridge output status.
663 */
664 enum drm_connector_status (*detect)(struct drm_bridge *bridge,
665 struct drm_connector *connector);
666
667 /**
668 * @get_modes:
669 *
670 * Fill all modes currently valid for the sink into the &drm_connector
671 * with drm_mode_probed_add().
672 *
673 * The @get_modes callback is mostly intended to support non-probeable
674 * displays such as many fixed panels. Bridges that support reading
675 * EDID shall leave @get_modes unimplemented and implement the
676 * &drm_bridge_funcs->edid_read callback instead.
677 *
678 * This callback is optional. Bridges that implement it shall set the
679 * DRM_BRIDGE_OP_MODES flag in their &drm_bridge->ops.
680 *
681 * The connector parameter shall be used for the sole purpose of
682 * filling modes, and shall not be stored internally by bridge drivers
683 * for future usage.
684 *
685 * RETURNS:
686 *
687 * The number of modes added by calling drm_mode_probed_add().
688 */
689 int (*get_modes)(struct drm_bridge *bridge,
690 struct drm_connector *connector);
691
692 /**
693 * @edid_read:
694 *
695 * Read the EDID data of the connected display.
696 *
697 * The @edid_read callback is the preferred way of reporting mode
698 * information for a display connected to the bridge output. Bridges
699 * that support reading EDID shall implement this callback and leave
700 * the @get_modes callback unimplemented.
701 *
702 * The caller of this operation shall first verify the output
703 * connection status and refrain from reading EDID from a disconnected
704 * output.
705 *
706 * This callback is optional. Bridges that implement it shall set the
707 * DRM_BRIDGE_OP_EDID flag in their &drm_bridge->ops.
708 *
709 * The connector parameter shall be used for the sole purpose of EDID
710 * retrieval, and shall not be stored internally by bridge drivers for
711 * future usage.
712 *
713 * RETURNS:
714 *
715 * An edid structure newly allocated with drm_edid_alloc() or returned
716 * from drm_edid_read() family of functions on success, or NULL
717 * otherwise. The caller is responsible for freeing the returned edid
718 * structure with drm_edid_free().
719 */
720 const struct drm_edid *(*edid_read)(struct drm_bridge *bridge,
721 struct drm_connector *connector);
722
723 /**
724 * @hpd_notify:
725 *
726 * Notify the bridge of hot plug detection.
727 *
728 * This callback is optional, it may be implemented by bridges that
729 * need to be notified of display connection or disconnection for
730 * internal reasons. One use case is to reset the internal state of CEC
731 * controllers for HDMI bridges.
732 */
733 void (*hpd_notify)(struct drm_bridge *bridge,
734 enum drm_connector_status status);
735
736 /**
737 * @hpd_enable:
738 *
739 * Enable hot plug detection. From now on the bridge shall call
740 * drm_bridge_hpd_notify() each time a change is detected in the output
741 * connection status, until hot plug detection gets disabled with
742 * @hpd_disable.
743 *
744 * This callback is optional and shall only be implemented by bridges
745 * that support hot-plug notification without polling. Bridges that
746 * implement it shall also implement the @hpd_disable callback and set
747 * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops.
748 */
749 void (*hpd_enable)(struct drm_bridge *bridge);
750
751 /**
752 * @hpd_disable:
753 *
754 * Disable hot plug detection. Once this function returns the bridge
755 * shall not call drm_bridge_hpd_notify() when a change in the output
756 * connection status occurs.
757 *
758 * This callback is optional and shall only be implemented by bridges
759 * that support hot-plug notification without polling. Bridges that
760 * implement it shall also implement the @hpd_enable callback and set
761 * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops.
762 */
763 void (*hpd_disable)(struct drm_bridge *bridge);
764
765 /**
766 * @hdmi_tmds_char_rate_valid:
767 *
768 * Check whether a particular TMDS character rate is supported by the
769 * driver.
770 *
771 * This callback is optional and should only be implemented by the
772 * bridges that take part in the HDMI connector implementation. Bridges
773 * that implement it shall set the DRM_BRIDGE_OP_HDMI flag in their
774 * &drm_bridge->ops.
775 *
776 * Returns:
777 *
778 * Either &drm_mode_status.MODE_OK or one of the failure reasons
779 * in &enum drm_mode_status.
780 */
781 enum drm_mode_status
782 (*hdmi_tmds_char_rate_valid)(const struct drm_bridge *bridge,
783 const struct drm_display_mode *mode,
784 unsigned long long tmds_rate);
785
786 /**
787 * @hdmi_clear_infoframe:
788 *
789 * This callback clears the infoframes in the hardware during commit.
790 * It will be called multiple times, once for every disabled infoframe
791 * type.
792 *
793 * This callback is optional but it must be implemented by bridges that
794 * set the DRM_BRIDGE_OP_HDMI flag in their &drm_bridge->ops.
795 */
796 int (*hdmi_clear_infoframe)(struct drm_bridge *bridge,
797 enum hdmi_infoframe_type type);
798 /**
799 * @hdmi_write_infoframe:
800 *
801 * Program the infoframe into the hardware. It will be called multiple
802 * times, once for every updated infoframe type.
803 *
804 * This callback is optional but it must be implemented by bridges that
805 * set the DRM_BRIDGE_OP_HDMI flag in their &drm_bridge->ops.
806 */
807 int (*hdmi_write_infoframe)(struct drm_bridge *bridge,
808 enum hdmi_infoframe_type type,
809 const u8 *buffer, size_t len);
810
811 /**
812 * @hdmi_audio_startup:
813 *
814 * Called when ASoC starts an audio stream setup.
815 *
816 * This callback is optional, it can be implemented by bridges that
817 * set the @DRM_BRIDGE_OP_HDMI_AUDIO flag in their &drm_bridge->ops.
818 *
819 * Returns:
820 * 0 on success, a negative error code otherwise
821 */
822 int (*hdmi_audio_startup)(struct drm_bridge *bridge,
823 struct drm_connector *connector);
824
825 /**
826 * @hdmi_audio_prepare:
827 * Configures HDMI-encoder for audio stream. Can be called multiple
828 * times for each setup.
829 *
830 * This callback is optional but it must be implemented by bridges that
831 * set the @DRM_BRIDGE_OP_HDMI_AUDIO flag in their &drm_bridge->ops.
832 *
833 * Returns:
834 * 0 on success, a negative error code otherwise
835 */
836 int (*hdmi_audio_prepare)(struct drm_bridge *bridge,
837 struct drm_connector *connector,
838 struct hdmi_codec_daifmt *fmt,
839 struct hdmi_codec_params *hparms);
840
841 /**
842 * @hdmi_audio_shutdown:
843 *
844 * Shut down the audio stream.
845 *
846 * This callback is optional but it must be implemented by bridges that
847 * set the @DRM_BRIDGE_OP_HDMI_AUDIO flag in their &drm_bridge->ops.
848 *
849 * Returns:
850 * 0 on success, a negative error code otherwise
851 */
852 void (*hdmi_audio_shutdown)(struct drm_bridge *bridge,
853 struct drm_connector *connector);
854
855 /**
856 * @hdmi_audio_mute_stream:
857 *
858 * Mute/unmute HDMI audio stream.
859 *
860 * This callback is optional, it can be implemented by bridges that
861 * set the @DRM_BRIDGE_OP_HDMI_AUDIO flag in their &drm_bridge->ops.
862 *
863 * Returns:
864 * 0 on success, a negative error code otherwise
865 */
866 int (*hdmi_audio_mute_stream)(struct drm_bridge *bridge,
867 struct drm_connector *connector,
868 bool enable, int direction);
869
870 /**
871 * @hdmi_cec_init:
872 *
873 * Initialize CEC part of the bridge.
874 *
875 * This callback is optional, it can be implemented by bridges that
876 * set the @DRM_BRIDGE_OP_HDMI_CEC_ADAPTER flag in their
877 * &drm_bridge->ops.
878 *
879 * Returns:
880 * 0 on success, a negative error code otherwise
881 */
882 int (*hdmi_cec_init)(struct drm_bridge *bridge,
883 struct drm_connector *connector);
884
885 /**
886 * @hdmi_cec_enable:
887 *
888 * Enable or disable the CEC adapter inside the bridge.
889 *
890 * This callback is optional, it can be implemented by bridges that
891 * set the @DRM_BRIDGE_OP_HDMI_CEC_ADAPTER flag in their
892 * &drm_bridge->ops.
893 *
894 * Returns:
895 * 0 on success, a negative error code otherwise
896 */
897 int (*hdmi_cec_enable)(struct drm_bridge *bridge, bool enable);
898
899 /**
900 * @hdmi_cec_log_addr:
901 *
902 * Set the logical address of the CEC adapter inside the bridge.
903 *
904 * This callback is optional, it can be implemented by bridges that
905 * set the @DRM_BRIDGE_OP_HDMI_CEC_ADAPTER flag in their
906 * &drm_bridge->ops.
907 *
908 * Returns:
909 * 0 on success, a negative error code otherwise
910 */
911 int (*hdmi_cec_log_addr)(struct drm_bridge *bridge, u8 logical_addr);
912
913 /**
914 * @hdmi_cec_transmit:
915 *
916 * Transmit the message using the CEC adapter inside the bridge.
917 *
918 * This callback is optional, it can be implemented by bridges that
919 * set the @DRM_BRIDGE_OP_HDMI_CEC_ADAPTER flag in their
920 * &drm_bridge->ops.
921 *
922 * Returns:
923 * 0 on success, a negative error code otherwise
924 */
925 int (*hdmi_cec_transmit)(struct drm_bridge *bridge, u8 attempts,
926 u32 signal_free_time, struct cec_msg *msg);
927
928 /**
929 * @dp_audio_startup:
930 *
931 * Called when ASoC starts a DisplayPort audio stream setup.
932 *
933 * This callback is optional, it can be implemented by bridges that
934 * set the @DRM_BRIDGE_OP_DP_AUDIO flag in their &drm_bridge->ops.
935 *
936 * Returns:
937 * 0 on success, a negative error code otherwise
938 */
939 int (*dp_audio_startup)(struct drm_bridge *bridge,
940 struct drm_connector *connector);
941
942 /**
943 * @dp_audio_prepare:
944 * Configures DisplayPort audio stream. Can be called multiple
945 * times for each setup.
946 *
947 * This callback is optional but it must be implemented by bridges that
948 * set the @DRM_BRIDGE_OP_DP_AUDIO flag in their &drm_bridge->ops.
949 *
950 * Returns:
951 * 0 on success, a negative error code otherwise
952 */
953 int (*dp_audio_prepare)(struct drm_bridge *bridge,
954 struct drm_connector *connector,
955 struct hdmi_codec_daifmt *fmt,
956 struct hdmi_codec_params *hparms);
957
958 /**
959 * @dp_audio_shutdown:
960 *
961 * Shut down the DisplayPort audio stream.
962 *
963 * This callback is optional but it must be implemented by bridges that
964 * set the @DRM_BRIDGE_OP_DP_AUDIO flag in their &drm_bridge->ops.
965 *
966 * Returns:
967 * 0 on success, a negative error code otherwise
968 */
969 void (*dp_audio_shutdown)(struct drm_bridge *bridge,
970 struct drm_connector *connector);
971
972 /**
973 * @dp_audio_mute_stream:
974 *
975 * Mute/unmute DisplayPort audio stream.
976 *
977 * This callback is optional, it can be implemented by bridges that
978 * set the @DRM_BRIDGE_OP_DP_AUDIO flag in their &drm_bridge->ops.
979 *
980 * Returns:
981 * 0 on success, a negative error code otherwise
982 */
983 int (*dp_audio_mute_stream)(struct drm_bridge *bridge,
984 struct drm_connector *connector,
985 bool enable, int direction);
986
987 /**
988 * @debugfs_init:
989 *
990 * Allows bridges to create bridge-specific debugfs files.
991 */
992 void (*debugfs_init)(struct drm_bridge *bridge, struct dentry *root);
993};
994
995/**
996 * struct drm_bridge_timings - timing information for the bridge
997 */
998struct drm_bridge_timings {
999 /**
1000 * @input_bus_flags:
1001 *
1002 * Tells what additional settings for the pixel data on the bus
1003 * this bridge requires (like pixel signal polarity). See also
1004 * &drm_display_info->bus_flags.
1005 */
1006 u32 input_bus_flags;
1007 /**
1008 * @setup_time_ps:
1009 *
1010 * Defines the time in picoseconds the input data lines must be
1011 * stable before the clock edge.
1012 */
1013 u32 setup_time_ps;
1014 /**
1015 * @hold_time_ps:
1016 *
1017 * Defines the time in picoseconds taken for the bridge to sample the
1018 * input signal after the clock edge.
1019 */
1020 u32 hold_time_ps;
1021 /**
1022 * @dual_link:
1023 *
1024 * True if the bus operates in dual-link mode. The exact meaning is
1025 * dependent on the bus type. For LVDS buses, this indicates that even-
1026 * and odd-numbered pixels are received on separate links.
1027 */
1028 bool dual_link;
1029};
1030
1031/**
1032 * enum drm_bridge_ops - Bitmask of operations supported by the bridge
1033 */
1034enum drm_bridge_ops {
1035 /**
1036 * @DRM_BRIDGE_OP_DETECT: The bridge can detect displays connected to
1037 * its output. Bridges that set this flag shall implement the
1038 * &drm_bridge_funcs->detect callback.
1039 */
1040 DRM_BRIDGE_OP_DETECT = BIT(0),
1041 /**
1042 * @DRM_BRIDGE_OP_EDID: The bridge can retrieve the EDID of the display
1043 * connected to its output. Bridges that set this flag shall implement
1044 * the &drm_bridge_funcs->edid_read callback.
1045 */
1046 DRM_BRIDGE_OP_EDID = BIT(1),
1047 /**
1048 * @DRM_BRIDGE_OP_HPD: The bridge can detect hot-plug and hot-unplug
1049 * without requiring polling. Bridges that set this flag shall
1050 * implement the &drm_bridge_funcs->hpd_enable and
1051 * &drm_bridge_funcs->hpd_disable callbacks if they support enabling
1052 * and disabling hot-plug detection dynamically.
1053 */
1054 DRM_BRIDGE_OP_HPD = BIT(2),
1055 /**
1056 * @DRM_BRIDGE_OP_MODES: The bridge can retrieve the modes supported
1057 * by the display at its output. This does not include reading EDID
1058 * which is separately covered by @DRM_BRIDGE_OP_EDID. Bridges that set
1059 * this flag shall implement the &drm_bridge_funcs->get_modes callback.
1060 */
1061 DRM_BRIDGE_OP_MODES = BIT(3),
1062 /**
1063 * @DRM_BRIDGE_OP_HDMI: The bridge provides HDMI connector operations,
1064 * including infoframes support. Bridges that set this flag must
1065 * implement the &drm_bridge_funcs->write_infoframe callback.
1066 *
1067 * Note: currently there can be at most one bridge in a chain that sets
1068 * this bit. This is to simplify corresponding glue code in connector
1069 * drivers.
1070 */
1071 DRM_BRIDGE_OP_HDMI = BIT(4),
1072 /**
1073 * @DRM_BRIDGE_OP_HDMI_AUDIO: The bridge provides HDMI audio operations.
1074 * Bridges that set this flag must implement the
1075 * &drm_bridge_funcs->hdmi_audio_prepare and
1076 * &drm_bridge_funcs->hdmi_audio_shutdown callbacks.
1077 *
1078 * Note: currently there can be at most one bridge in a chain that sets
1079 * this bit. This is to simplify corresponding glue code in connector
1080 * drivers. Also it is not possible to have a bridge in the chain that
1081 * sets @DRM_BRIDGE_OP_DP_AUDIO if there is a bridge that sets this
1082 * flag.
1083 */
1084 DRM_BRIDGE_OP_HDMI_AUDIO = BIT(5),
1085 /**
1086 * @DRM_BRIDGE_OP_DP_AUDIO: The bridge provides DisplayPort audio operations.
1087 * Bridges that set this flag must implement the
1088 * &drm_bridge_funcs->dp_audio_prepare and
1089 * &drm_bridge_funcs->dp_audio_shutdown callbacks.
1090 *
1091 * Note: currently there can be at most one bridge in a chain that sets
1092 * this bit. This is to simplify corresponding glue code in connector
1093 * drivers. Also it is not possible to have a bridge in the chain that
1094 * sets @DRM_BRIDGE_OP_HDMI_AUDIO if there is a bridge that sets this
1095 * flag.
1096 */
1097 DRM_BRIDGE_OP_DP_AUDIO = BIT(6),
1098 /**
1099 * @DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER: The bridge requires CEC notifier
1100 * to be present.
1101 */
1102 DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER = BIT(7),
1103 /**
1104 * @DRM_BRIDGE_OP_HDMI_CEC_ADAPTER: The bridge requires CEC adapter
1105 * to be present.
1106 */
1107 DRM_BRIDGE_OP_HDMI_CEC_ADAPTER = BIT(8),
1108};
1109
1110/**
1111 * struct drm_bridge - central DRM bridge control structure
1112 */
1113struct drm_bridge {
1114 /** @base: inherit from &drm_private_object */
1115 struct drm_private_obj base;
1116 /** @dev: DRM device this bridge belongs to */
1117 struct drm_device *dev;
1118 /** @encoder: encoder to which this bridge is connected */
1119 struct drm_encoder *encoder;
1120 /** @chain_node: used to form a bridge chain */
1121 struct list_head chain_node;
1122 /** @of_node: device node pointer to the bridge */
1123 struct device_node *of_node;
1124 /** @list: to keep track of all added bridges */
1125 struct list_head list;
1126 /**
1127 * @timings:
1128 *
1129 * the timing specification for the bridge, if any (may be NULL)
1130 */
1131 const struct drm_bridge_timings *timings;
1132 /** @funcs: control functions */
1133 const struct drm_bridge_funcs *funcs;
1134
1135 /**
1136 * @container: Pointer to the private driver struct embedding this
1137 * @struct drm_bridge.
1138 */
1139 void *container;
1140
1141 /**
1142 * @refcount: reference count of users referencing this bridge.
1143 */
1144 struct kref refcount;
1145
1146 /** @driver_private: pointer to the bridge driver's internal context */
1147 void *driver_private;
1148 /** @ops: bitmask of operations supported by the bridge */
1149 enum drm_bridge_ops ops;
1150 /**
1151 * @type: Type of the connection at the bridge output
1152 * (DRM_MODE_CONNECTOR_*). For bridges at the end of this chain this
1153 * identifies the type of connected display.
1154 */
1155 int type;
1156 /**
1157 * @interlace_allowed: Indicate that the bridge can handle interlaced
1158 * modes.
1159 */
1160 bool interlace_allowed;
1161 /**
1162 * @ycbcr_420_allowed: Indicate that the bridge can handle YCbCr 420
1163 * output.
1164 */
1165 bool ycbcr_420_allowed;
1166 /**
1167 * @pre_enable_prev_first: The bridge requires that the prev
1168 * bridge @pre_enable function is called before its @pre_enable,
1169 * and conversely for post_disable. This is most frequently a
1170 * requirement for DSI devices which need the host to be initialised
1171 * before the peripheral.
1172 */
1173 bool pre_enable_prev_first;
1174 /**
1175 * @support_hdcp: Indicate that the bridge supports HDCP.
1176 */
1177 bool support_hdcp;
1178 /**
1179 * @ddc: Associated I2C adapter for DDC access, if any.
1180 */
1181 struct i2c_adapter *ddc;
1182
1183 /**
1184 * @vendor: Vendor of the product to be used for the SPD InfoFrame
1185 * generation. This is required if @DRM_BRIDGE_OP_HDMI is set.
1186 */
1187 const char *vendor;
1188
1189 /**
1190 * @product: Name of the product to be used for the SPD InfoFrame
1191 * generation. This is required if @DRM_BRIDGE_OP_HDMI is set.
1192 */
1193 const char *product;
1194
1195 /**
1196 * @supported_formats: Bitmask of @hdmi_colorspace listing supported
1197 * output formats. This is only relevant if @DRM_BRIDGE_OP_HDMI is set.
1198 */
1199 unsigned int supported_formats;
1200
1201 /**
1202 * @max_bpc: Maximum bits per char the HDMI bridge supports. Allowed
1203 * values are 8, 10 and 12. This is only relevant if
1204 * @DRM_BRIDGE_OP_HDMI is set.
1205 */
1206 unsigned int max_bpc;
1207
1208 /**
1209 * @hdmi_cec_dev: device to be used as a containing device for CEC
1210 * functions.
1211 */
1212 struct device *hdmi_cec_dev;
1213
1214 /**
1215 * @hdmi_audio_dev: device to be used as a parent for the HDMI Codec if
1216 * either of @DRM_BRIDGE_OP_HDMI_AUDIO or @DRM_BRIDGE_OP_DP_AUDIO is set.
1217 */
1218 struct device *hdmi_audio_dev;
1219
1220 /**
1221 * @hdmi_audio_max_i2s_playback_channels: maximum number of playback
1222 * I2S channels for the @DRM_BRIDGE_OP_HDMI_AUDIO or
1223 * @DRM_BRIDGE_OP_DP_AUDIO.
1224 */
1225 int hdmi_audio_max_i2s_playback_channels;
1226
1227 /**
1228 * @hdmi_audio_i2s_formats: supported I2S formats, optional. The
1229 * default is to allow all formats supported by the corresponding I2S
1230 * bus driver. This is only used for bridges setting
1231 * @DRM_BRIDGE_OP_HDMI_AUDIO or @DRM_BRIDGE_OP_DP_AUDIO.
1232 */
1233 u64 hdmi_audio_i2s_formats;
1234
1235 /**
1236 * @hdmi_audio_spdif_playback: set if this bridge has S/PDIF playback
1237 * port for @DRM_BRIDGE_OP_HDMI_AUDIO or @DRM_BRIDGE_OP_DP_AUDIO.
1238 */
1239 unsigned int hdmi_audio_spdif_playback : 1;
1240
1241 /**
1242 * @hdmi_audio_dai_port: sound DAI port for either of
1243 * @DRM_BRIDGE_OP_HDMI_AUDIO and @DRM_BRIDGE_OP_DP_AUDIO, -1 if it is
1244 * not used.
1245 */
1246 int hdmi_audio_dai_port;
1247
1248 /**
1249 * @hdmi_cec_adapter_name: the name of the adapter to register
1250 */
1251 const char *hdmi_cec_adapter_name;
1252
1253 /**
1254 * @hdmi_cec_available_las: number of logical addresses, CEC_MAX_LOG_ADDRS if unset
1255 */
1256 u8 hdmi_cec_available_las;
1257
1258 /** private: */
1259 /**
1260 * @hpd_mutex: Protects the @hpd_cb and @hpd_data fields.
1261 */
1262 struct mutex hpd_mutex;
1263 /**
1264 * @hpd_cb: Hot plug detection callback, registered with
1265 * drm_bridge_hpd_enable().
1266 */
1267 void (*hpd_cb)(void *data, enum drm_connector_status status);
1268 /**
1269 * @hpd_data: Private data passed to the Hot plug detection callback
1270 * @hpd_cb.
1271 */
1272 void *hpd_data;
1273};
1274
1275static inline struct drm_bridge *
1276drm_priv_to_bridge(struct drm_private_obj *priv)
1277{
1278 return container_of(priv, struct drm_bridge, base);
1279}
1280
1281struct drm_bridge *drm_bridge_get(struct drm_bridge *bridge);
1282void drm_bridge_put(struct drm_bridge *bridge);
1283
1284/* Cleanup action for use with __free() */
1285DEFINE_FREE(drm_bridge_put, struct drm_bridge *, if (_T) drm_bridge_put(_T))
1286
1287void *__devm_drm_bridge_alloc(struct device *dev, size_t size, size_t offset,
1288 const struct drm_bridge_funcs *funcs);
1289
1290/**
1291 * devm_drm_bridge_alloc - Allocate and initialize a bridge
1292 * @dev: struct device of the bridge device
1293 * @type: the type of the struct which contains struct &drm_bridge
1294 * @member: the name of the &drm_bridge within @type
1295 * @funcs: callbacks for this bridge
1296 *
1297 * The reference count of the returned bridge is initialized to 1. This
1298 * reference will be automatically dropped via devm (by calling
1299 * drm_bridge_put()) when @dev is removed.
1300 *
1301 * Returns:
1302 * Pointer to new bridge, or ERR_PTR on failure.
1303 */
1304#define devm_drm_bridge_alloc(dev, type, member, funcs) \
1305 ((type *)__devm_drm_bridge_alloc(dev, sizeof(type), \
1306 offsetof(type, member), funcs))
1307
1308void drm_bridge_add(struct drm_bridge *bridge);
1309int devm_drm_bridge_add(struct device *dev, struct drm_bridge *bridge);
1310void drm_bridge_remove(struct drm_bridge *bridge);
1311int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge,
1312 struct drm_bridge *previous,
1313 enum drm_bridge_attach_flags flags);
1314
1315#ifdef CONFIG_OF
1316struct drm_bridge *of_drm_find_bridge(struct device_node *np);
1317#else
1318static inline struct drm_bridge *of_drm_find_bridge(struct device_node *np)
1319{
1320 return NULL;
1321}
1322#endif
1323
1324static inline bool drm_bridge_is_last(struct drm_bridge *bridge)
1325{
1326 return list_is_last(list: &bridge->chain_node, head: &bridge->encoder->bridge_chain);
1327}
1328
1329/**
1330 * drm_bridge_get_current_state() - Get the current bridge state
1331 * @bridge: bridge object
1332 *
1333 * This function must be called with the modeset lock held.
1334 *
1335 * RETURNS:
1336 *
1337 * The current bridge state, or NULL if there is none.
1338 */
1339static inline struct drm_bridge_state *
1340drm_bridge_get_current_state(struct drm_bridge *bridge)
1341{
1342 if (!bridge)
1343 return NULL;
1344
1345 /*
1346 * Only atomic bridges will have bridge->base initialized by
1347 * drm_atomic_private_obj_init(), so we need to make sure we're
1348 * working with one before we try to use the lock.
1349 */
1350 if (!bridge->funcs || !bridge->funcs->atomic_reset)
1351 return NULL;
1352
1353 drm_modeset_lock_assert_held(lock: &bridge->base.lock);
1354
1355 if (!bridge->base.state)
1356 return NULL;
1357
1358 return drm_priv_to_bridge_state(priv: bridge->base.state);
1359}
1360
1361/**
1362 * drm_bridge_get_next_bridge() - Get the next bridge in the chain
1363 * @bridge: bridge object
1364 *
1365 * RETURNS:
1366 * the next bridge in the chain after @bridge, or NULL if @bridge is the last.
1367 */
1368static inline struct drm_bridge *
1369drm_bridge_get_next_bridge(struct drm_bridge *bridge)
1370{
1371 if (list_is_last(list: &bridge->chain_node, head: &bridge->encoder->bridge_chain))
1372 return NULL;
1373
1374 return list_next_entry(bridge, chain_node);
1375}
1376
1377/**
1378 * drm_bridge_get_prev_bridge() - Get the previous bridge in the chain
1379 * @bridge: bridge object
1380 *
1381 * The caller is responsible of having a reference to @bridge via
1382 * drm_bridge_get() or equivalent. This function leaves the refcount of
1383 * @bridge unmodified.
1384 *
1385 * The refcount of the returned bridge is incremented. Use drm_bridge_put()
1386 * when done with it.
1387 *
1388 * RETURNS:
1389 * the previous bridge in the chain, or NULL if @bridge is the first.
1390 */
1391static inline struct drm_bridge *
1392drm_bridge_get_prev_bridge(struct drm_bridge *bridge)
1393{
1394 if (list_is_first(list: &bridge->chain_node, head: &bridge->encoder->bridge_chain))
1395 return NULL;
1396
1397 return drm_bridge_get(list_prev_entry(bridge, chain_node));
1398}
1399
1400/**
1401 * drm_bridge_chain_get_first_bridge() - Get the first bridge in the chain
1402 * @encoder: encoder object
1403 *
1404 * The refcount of the returned bridge is incremented. Use drm_bridge_put()
1405 * when done with it.
1406 *
1407 * RETURNS:
1408 * the first bridge in the chain, or NULL if @encoder has no bridge attached
1409 * to it.
1410 */
1411static inline struct drm_bridge *
1412drm_bridge_chain_get_first_bridge(struct drm_encoder *encoder)
1413{
1414 return drm_bridge_get(list_first_entry_or_null(&encoder->bridge_chain,
1415 struct drm_bridge, chain_node));
1416}
1417
1418/**
1419 * drm_bridge_chain_get_last_bridge() - Get the last bridge in the chain
1420 * @encoder: encoder object
1421 *
1422 * The refcount of the returned bridge is incremented. Use drm_bridge_put()
1423 * when done with it.
1424 *
1425 * RETURNS:
1426 * the last bridge in the chain, or NULL if @encoder has no bridge attached
1427 * to it.
1428 */
1429static inline struct drm_bridge *
1430drm_bridge_chain_get_last_bridge(struct drm_encoder *encoder)
1431{
1432 return drm_bridge_get(list_last_entry_or_null(&encoder->bridge_chain,
1433 struct drm_bridge, chain_node));
1434}
1435
1436/**
1437 * drm_for_each_bridge_in_chain() - Iterate over all bridges present in a chain
1438 * @encoder: the encoder to iterate bridges on
1439 * @bridge: a bridge pointer updated to point to the current bridge at each
1440 * iteration
1441 *
1442 * Iterate over all bridges present in the bridge chain attached to @encoder.
1443 */
1444#define drm_for_each_bridge_in_chain(encoder, bridge) \
1445 list_for_each_entry(bridge, &(encoder)->bridge_chain, chain_node)
1446
1447enum drm_mode_status
1448drm_bridge_chain_mode_valid(struct drm_bridge *bridge,
1449 const struct drm_display_info *info,
1450 const struct drm_display_mode *mode);
1451void drm_bridge_chain_mode_set(struct drm_bridge *bridge,
1452 const struct drm_display_mode *mode,
1453 const struct drm_display_mode *adjusted_mode);
1454
1455int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,
1456 struct drm_crtc_state *crtc_state,
1457 struct drm_connector_state *conn_state);
1458void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,
1459 struct drm_atomic_state *state);
1460void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,
1461 struct drm_atomic_state *state);
1462void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,
1463 struct drm_atomic_state *state);
1464void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,
1465 struct drm_atomic_state *state);
1466
1467u32 *
1468drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge,
1469 struct drm_bridge_state *bridge_state,
1470 struct drm_crtc_state *crtc_state,
1471 struct drm_connector_state *conn_state,
1472 u32 output_fmt,
1473 unsigned int *num_input_fmts);
1474
1475enum drm_connector_status
1476drm_bridge_detect(struct drm_bridge *bridge, struct drm_connector *connector);
1477int drm_bridge_get_modes(struct drm_bridge *bridge,
1478 struct drm_connector *connector);
1479const struct drm_edid *drm_bridge_edid_read(struct drm_bridge *bridge,
1480 struct drm_connector *connector);
1481void drm_bridge_hpd_enable(struct drm_bridge *bridge,
1482 void (*cb)(void *data,
1483 enum drm_connector_status status),
1484 void *data);
1485void drm_bridge_hpd_disable(struct drm_bridge *bridge);
1486void drm_bridge_hpd_notify(struct drm_bridge *bridge,
1487 enum drm_connector_status status);
1488
1489#ifdef CONFIG_DRM_PANEL_BRIDGE
1490bool drm_bridge_is_panel(const struct drm_bridge *bridge);
1491struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel);
1492struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel,
1493 u32 connector_type);
1494void drm_panel_bridge_remove(struct drm_bridge *bridge);
1495int drm_panel_bridge_set_orientation(struct drm_connector *connector,
1496 struct drm_bridge *bridge);
1497struct drm_bridge *devm_drm_panel_bridge_add(struct device *dev,
1498 struct drm_panel *panel);
1499struct drm_bridge *devm_drm_panel_bridge_add_typed(struct device *dev,
1500 struct drm_panel *panel,
1501 u32 connector_type);
1502struct drm_bridge *drmm_panel_bridge_add(struct drm_device *drm,
1503 struct drm_panel *panel);
1504struct drm_connector *drm_panel_bridge_connector(struct drm_bridge *bridge);
1505#else
1506static inline bool drm_bridge_is_panel(const struct drm_bridge *bridge)
1507{
1508 return false;
1509}
1510
1511static inline int drm_panel_bridge_set_orientation(struct drm_connector *connector,
1512 struct drm_bridge *bridge)
1513{
1514 return -EINVAL;
1515}
1516#endif
1517
1518#if defined(CONFIG_OF) && defined(CONFIG_DRM_PANEL_BRIDGE)
1519struct drm_bridge *devm_drm_of_get_bridge(struct device *dev, struct device_node *node,
1520 u32 port, u32 endpoint);
1521struct drm_bridge *drmm_of_get_bridge(struct drm_device *drm, struct device_node *node,
1522 u32 port, u32 endpoint);
1523#else
1524static inline struct drm_bridge *devm_drm_of_get_bridge(struct device *dev,
1525 struct device_node *node,
1526 u32 port,
1527 u32 endpoint)
1528{
1529 return ERR_PTR(error: -ENODEV);
1530}
1531
1532static inline struct drm_bridge *drmm_of_get_bridge(struct drm_device *drm,
1533 struct device_node *node,
1534 u32 port,
1535 u32 endpoint)
1536{
1537 return ERR_PTR(error: -ENODEV);
1538}
1539#endif
1540
1541void devm_drm_put_bridge(struct device *dev, struct drm_bridge *bridge);
1542
1543void drm_bridge_debugfs_params(struct dentry *root);
1544void drm_bridge_debugfs_encoder_params(struct dentry *root, struct drm_encoder *encoder);
1545
1546#endif
1547