1// SPDX-License-Identifier: GPL-2.0+
2/*
3 * Copyright (C) 2019 Laurent Pinchart <laurent.pinchart@ideasonboard.com>
4 */
5
6#include <linux/export.h>
7#include <linux/kernel.h>
8#include <linux/module.h>
9#include <linux/of.h>
10#include <linux/property.h>
11#include <linux/slab.h>
12
13#include <drm/drm_atomic_state_helper.h>
14#include <drm/drm_bridge.h>
15#include <drm/drm_bridge_connector.h>
16#include <drm/drm_connector.h>
17#include <drm/drm_device.h>
18#include <drm/drm_edid.h>
19#include <drm/drm_managed.h>
20#include <drm/drm_modeset_helper_vtables.h>
21#include <drm/drm_print.h>
22#include <drm/drm_probe_helper.h>
23#include <drm/display/drm_hdcp_helper.h>
24#include <drm/display/drm_hdmi_audio_helper.h>
25#include <drm/display/drm_hdmi_cec_helper.h>
26#include <drm/display/drm_hdmi_helper.h>
27#include <drm/display/drm_hdmi_state_helper.h>
28
29/**
30 * DOC: overview
31 *
32 * The DRM bridge connector helper object provides a DRM connector
33 * implementation that wraps a chain of &struct drm_bridge. The connector
34 * operations are fully implemented based on the operations of the bridges in
35 * the chain, and don't require any intervention from the display controller
36 * driver at runtime.
37 *
38 * To use the helper, display controller drivers create a bridge connector with
39 * a call to drm_bridge_connector_init(). This associates the newly created
40 * connector with the chain of bridges passed to the function and registers it
41 * with the DRM device. At that point the connector becomes fully usable, no
42 * further operation is needed.
43 *
44 * The DRM bridge connector operations are implemented based on the operations
45 * provided by the bridges in the chain. Each connector operation is delegated
46 * to the bridge closest to the connector (at the end of the chain) that
47 * provides the relevant functionality.
48 *
49 * To make use of this helper, all bridges in the chain shall report bridge
50 * operation flags (&drm_bridge->ops) and bridge output type
51 * (&drm_bridge->type), as well as the DRM_BRIDGE_ATTACH_NO_CONNECTOR attach
52 * flag (none of the bridges shall create a DRM connector directly).
53 */
54
55/**
56 * struct drm_bridge_connector - A connector backed by a chain of bridges
57 */
58struct drm_bridge_connector {
59 /**
60 * @base: The base DRM connector
61 */
62 struct drm_connector base;
63 /**
64 * @encoder:
65 *
66 * The encoder at the start of the bridges chain.
67 */
68 struct drm_encoder *encoder;
69 /**
70 * @bridge_edid:
71 *
72 * The last bridge in the chain (closest to the connector) that provides
73 * EDID read support, if any (see &DRM_BRIDGE_OP_EDID).
74 */
75 struct drm_bridge *bridge_edid;
76 /**
77 * @bridge_hpd:
78 *
79 * The last bridge in the chain (closest to the connector) that provides
80 * hot-plug detection notification, if any (see &DRM_BRIDGE_OP_HPD).
81 */
82 struct drm_bridge *bridge_hpd;
83 /**
84 * @bridge_detect:
85 *
86 * The last bridge in the chain (closest to the connector) that provides
87 * connector detection, if any (see &DRM_BRIDGE_OP_DETECT).
88 */
89 struct drm_bridge *bridge_detect;
90 /**
91 * @bridge_modes:
92 *
93 * The last bridge in the chain (closest to the connector) that provides
94 * connector modes detection, if any (see &DRM_BRIDGE_OP_MODES).
95 */
96 struct drm_bridge *bridge_modes;
97 /**
98 * @bridge_hdmi:
99 *
100 * The bridge in the chain that implements necessary support for the
101 * HDMI connector infrastructure, if any (see &DRM_BRIDGE_OP_HDMI).
102 */
103 struct drm_bridge *bridge_hdmi;
104 /**
105 * @bridge_hdmi_audio:
106 *
107 * The bridge in the chain that implements necessary support for the
108 * HDMI Audio infrastructure, if any (see &DRM_BRIDGE_OP_HDMI_AUDIO).
109 */
110 struct drm_bridge *bridge_hdmi_audio;
111 /**
112 * @bridge_dp_audio:
113 *
114 * The bridge in the chain that implements necessary support for the
115 * DisplayPort Audio infrastructure, if any (see
116 * &DRM_BRIDGE_OP_DP_AUDIO).
117 */
118 struct drm_bridge *bridge_dp_audio;
119 /**
120 * @bridge_hdmi_cec:
121 *
122 * The bridge in the chain that implements CEC support, if any (see
123 * DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER).
124 */
125 struct drm_bridge *bridge_hdmi_cec;
126};
127
128#define to_drm_bridge_connector(x) \
129 container_of(x, struct drm_bridge_connector, base)
130
131/* -----------------------------------------------------------------------------
132 * Bridge Connector Hot-Plug Handling
133 */
134
135static void drm_bridge_connector_hpd_notify(struct drm_connector *connector,
136 enum drm_connector_status status)
137{
138 struct drm_bridge_connector *bridge_connector =
139 to_drm_bridge_connector(connector);
140
141 /* Notify all bridges in the pipeline of hotplug events. */
142 drm_for_each_bridge_in_chain_scoped(bridge_connector->encoder, bridge) {
143 if (bridge->funcs->hpd_notify)
144 bridge->funcs->hpd_notify(bridge, status);
145 }
146}
147
148static void drm_bridge_connector_handle_hpd(struct drm_bridge_connector *drm_bridge_connector,
149 enum drm_connector_status status)
150{
151 struct drm_connector *connector = &drm_bridge_connector->base;
152 struct drm_device *dev = connector->dev;
153
154 mutex_lock(&dev->mode_config.mutex);
155 connector->status = status;
156 mutex_unlock(lock: &dev->mode_config.mutex);
157
158 drm_bridge_connector_hpd_notify(connector, status);
159
160 drm_kms_helper_connector_hotplug_event(connector);
161}
162
163static void drm_bridge_connector_hpd_cb(void *cb_data,
164 enum drm_connector_status status)
165{
166 drm_bridge_connector_handle_hpd(drm_bridge_connector: cb_data, status);
167}
168
169static void drm_bridge_connector_oob_hotplug_event(struct drm_connector *connector,
170 enum drm_connector_status status)
171{
172 struct drm_bridge_connector *bridge_connector =
173 to_drm_bridge_connector(connector);
174
175 drm_bridge_connector_handle_hpd(drm_bridge_connector: bridge_connector, status);
176}
177
178static void drm_bridge_connector_enable_hpd(struct drm_connector *connector)
179{
180 struct drm_bridge_connector *bridge_connector =
181 to_drm_bridge_connector(connector);
182 struct drm_bridge *hpd = bridge_connector->bridge_hpd;
183
184 if (hpd)
185 drm_bridge_hpd_enable(bridge: hpd, cb: drm_bridge_connector_hpd_cb,
186 data: bridge_connector);
187}
188
189static void drm_bridge_connector_disable_hpd(struct drm_connector *connector)
190{
191 struct drm_bridge_connector *bridge_connector =
192 to_drm_bridge_connector(connector);
193 struct drm_bridge *hpd = bridge_connector->bridge_hpd;
194
195 if (hpd)
196 drm_bridge_hpd_disable(bridge: hpd);
197}
198
199/* -----------------------------------------------------------------------------
200 * Bridge Connector Functions
201 */
202
203static enum drm_connector_status
204drm_bridge_connector_detect(struct drm_connector *connector, bool force)
205{
206 struct drm_bridge_connector *bridge_connector =
207 to_drm_bridge_connector(connector);
208 struct drm_bridge *detect = bridge_connector->bridge_detect;
209 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi;
210 enum drm_connector_status status;
211
212 if (detect) {
213 status = detect->funcs->detect(detect, connector);
214
215 if (hdmi)
216 drm_atomic_helper_connector_hdmi_hotplug(connector, status);
217
218 drm_bridge_connector_hpd_notify(connector, status);
219 } else {
220 switch (connector->connector_type) {
221 case DRM_MODE_CONNECTOR_DPI:
222 case DRM_MODE_CONNECTOR_LVDS:
223 case DRM_MODE_CONNECTOR_DSI:
224 case DRM_MODE_CONNECTOR_eDP:
225 status = connector_status_connected;
226 break;
227 default:
228 status = connector_status_unknown;
229 break;
230 }
231 }
232
233 return status;
234}
235
236static void drm_bridge_connector_force(struct drm_connector *connector)
237{
238 struct drm_bridge_connector *bridge_connector =
239 to_drm_bridge_connector(connector);
240 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi;
241
242 if (hdmi)
243 drm_atomic_helper_connector_hdmi_force(connector);
244}
245
246static void drm_bridge_connector_debugfs_init(struct drm_connector *connector,
247 struct dentry *root)
248{
249 struct drm_bridge_connector *bridge_connector =
250 to_drm_bridge_connector(connector);
251 struct drm_encoder *encoder = bridge_connector->encoder;
252 struct drm_bridge *bridge;
253
254 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) {
255 if (bridge->funcs->debugfs_init)
256 bridge->funcs->debugfs_init(bridge, root);
257 }
258}
259
260static void drm_bridge_connector_reset(struct drm_connector *connector)
261{
262 struct drm_bridge_connector *bridge_connector =
263 to_drm_bridge_connector(connector);
264
265 drm_atomic_helper_connector_reset(connector);
266 if (bridge_connector->bridge_hdmi)
267 __drm_atomic_helper_connector_hdmi_reset(connector,
268 new_conn_state: connector->state);
269}
270
271static const struct drm_connector_funcs drm_bridge_connector_funcs = {
272 .reset = drm_bridge_connector_reset,
273 .detect = drm_bridge_connector_detect,
274 .force = drm_bridge_connector_force,
275 .fill_modes = drm_helper_probe_single_connector_modes,
276 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
277 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
278 .debugfs_init = drm_bridge_connector_debugfs_init,
279 .oob_hotplug_event = drm_bridge_connector_oob_hotplug_event,
280};
281
282/* -----------------------------------------------------------------------------
283 * Bridge Connector Helper Functions
284 */
285
286static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector,
287 struct drm_bridge *bridge)
288{
289 enum drm_connector_status status;
290 const struct drm_edid *drm_edid;
291 int n;
292
293 status = drm_bridge_connector_detect(connector, force: false);
294 if (status != connector_status_connected)
295 goto no_edid;
296
297 drm_edid = drm_bridge_edid_read(bridge, connector);
298 if (!drm_edid_valid(drm_edid)) {
299 drm_edid_free(drm_edid);
300 goto no_edid;
301 }
302
303 drm_edid_connector_update(connector, edid: drm_edid);
304 n = drm_edid_connector_add_modes(connector);
305
306 drm_edid_free(drm_edid);
307 return n;
308
309no_edid:
310 drm_edid_connector_update(connector, NULL);
311 return 0;
312}
313
314static int drm_bridge_connector_get_modes(struct drm_connector *connector)
315{
316 struct drm_bridge_connector *bridge_connector =
317 to_drm_bridge_connector(connector);
318 struct drm_bridge *bridge;
319
320 /*
321 * If there is a HDMI bridge, EDID has been updated as a part of
322 * the .detect(). Just update the modes here.
323 */
324 bridge = bridge_connector->bridge_hdmi;
325 if (bridge)
326 return drm_edid_connector_add_modes(connector);
327
328 /*
329 * If display exposes EDID, then we parse that in the normal way to
330 * build table of supported modes.
331 */
332 bridge = bridge_connector->bridge_edid;
333 if (bridge)
334 return drm_bridge_connector_get_modes_edid(connector, bridge);
335
336 /*
337 * Otherwise if the display pipeline reports modes (e.g. with a fixed
338 * resolution panel or an analog TV output), query it.
339 */
340 bridge = bridge_connector->bridge_modes;
341 if (bridge)
342 return bridge->funcs->get_modes(bridge, connector);
343
344 /*
345 * We can't retrieve modes, which can happen for instance for a DVI or
346 * VGA output with the DDC bus unconnected. The KMS core will add the
347 * default modes.
348 */
349 return 0;
350}
351
352static enum drm_mode_status
353drm_bridge_connector_mode_valid(struct drm_connector *connector,
354 const struct drm_display_mode *mode)
355{
356 struct drm_bridge_connector *bridge_connector =
357 to_drm_bridge_connector(connector);
358
359 if (bridge_connector->bridge_hdmi)
360 return drm_hdmi_connector_mode_valid(connector, mode);
361
362 return MODE_OK;
363}
364
365static int drm_bridge_connector_atomic_check(struct drm_connector *connector,
366 struct drm_atomic_state *state)
367{
368 struct drm_bridge_connector *bridge_connector =
369 to_drm_bridge_connector(connector);
370
371 if (bridge_connector->bridge_hdmi)
372 return drm_atomic_helper_connector_hdmi_check(connector, state);
373
374 return 0;
375}
376
377static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = {
378 .get_modes = drm_bridge_connector_get_modes,
379 .mode_valid = drm_bridge_connector_mode_valid,
380 .enable_hpd = drm_bridge_connector_enable_hpd,
381 .disable_hpd = drm_bridge_connector_disable_hpd,
382 .atomic_check = drm_bridge_connector_atomic_check,
383};
384
385static enum drm_mode_status
386drm_bridge_connector_tmds_char_rate_valid(const struct drm_connector *connector,
387 const struct drm_display_mode *mode,
388 unsigned long long tmds_rate)
389{
390 struct drm_bridge_connector *bridge_connector =
391 to_drm_bridge_connector(connector);
392 struct drm_bridge *bridge;
393
394 bridge = bridge_connector->bridge_hdmi;
395 if (!bridge)
396 return MODE_ERROR;
397
398 if (bridge->funcs->hdmi_tmds_char_rate_valid)
399 return bridge->funcs->hdmi_tmds_char_rate_valid(bridge, mode, tmds_rate);
400 else
401 return MODE_OK;
402}
403
404static int drm_bridge_connector_clear_infoframe(struct drm_connector *connector,
405 enum hdmi_infoframe_type type)
406{
407 struct drm_bridge_connector *bridge_connector =
408 to_drm_bridge_connector(connector);
409 struct drm_bridge *bridge;
410
411 bridge = bridge_connector->bridge_hdmi;
412 if (!bridge)
413 return -EINVAL;
414
415 return bridge->funcs->hdmi_clear_infoframe(bridge, type);
416}
417
418static int drm_bridge_connector_write_infoframe(struct drm_connector *connector,
419 enum hdmi_infoframe_type type,
420 const u8 *buffer, size_t len)
421{
422 struct drm_bridge_connector *bridge_connector =
423 to_drm_bridge_connector(connector);
424 struct drm_bridge *bridge;
425
426 bridge = bridge_connector->bridge_hdmi;
427 if (!bridge)
428 return -EINVAL;
429
430 return bridge->funcs->hdmi_write_infoframe(bridge, type, buffer, len);
431}
432
433static const struct drm_edid *
434drm_bridge_connector_read_edid(struct drm_connector *connector)
435{
436 struct drm_bridge_connector *bridge_connector =
437 to_drm_bridge_connector(connector);
438 struct drm_bridge *bridge;
439
440 bridge = bridge_connector->bridge_edid;
441 if (!bridge)
442 return NULL;
443
444 return drm_bridge_edid_read(bridge, connector);
445}
446
447static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = {
448 .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid,
449 .clear_infoframe = drm_bridge_connector_clear_infoframe,
450 .write_infoframe = drm_bridge_connector_write_infoframe,
451 .read_edid = drm_bridge_connector_read_edid,
452};
453
454static int drm_bridge_connector_audio_startup(struct drm_connector *connector)
455{
456 struct drm_bridge_connector *bridge_connector =
457 to_drm_bridge_connector(connector);
458 struct drm_bridge *bridge;
459
460 if (bridge_connector->bridge_hdmi_audio) {
461 bridge = bridge_connector->bridge_hdmi_audio;
462
463 if (!bridge->funcs->hdmi_audio_startup)
464 return 0;
465
466 return bridge->funcs->hdmi_audio_startup(bridge, connector);
467 }
468
469 if (bridge_connector->bridge_dp_audio) {
470 bridge = bridge_connector->bridge_dp_audio;
471
472 if (!bridge->funcs->dp_audio_startup)
473 return 0;
474
475 return bridge->funcs->dp_audio_startup(bridge, connector);
476 }
477
478 return -EINVAL;
479}
480
481static int drm_bridge_connector_audio_prepare(struct drm_connector *connector,
482 struct hdmi_codec_daifmt *fmt,
483 struct hdmi_codec_params *hparms)
484{
485 struct drm_bridge_connector *bridge_connector =
486 to_drm_bridge_connector(connector);
487 struct drm_bridge *bridge;
488
489 if (bridge_connector->bridge_hdmi_audio) {
490 bridge = bridge_connector->bridge_hdmi_audio;
491
492 return bridge->funcs->hdmi_audio_prepare(bridge, connector, fmt, hparms);
493 }
494
495 if (bridge_connector->bridge_dp_audio) {
496 bridge = bridge_connector->bridge_dp_audio;
497
498 return bridge->funcs->dp_audio_prepare(bridge, connector, fmt, hparms);
499 }
500
501 return -EINVAL;
502}
503
504static void drm_bridge_connector_audio_shutdown(struct drm_connector *connector)
505{
506 struct drm_bridge_connector *bridge_connector =
507 to_drm_bridge_connector(connector);
508 struct drm_bridge *bridge;
509
510 if (bridge_connector->bridge_hdmi_audio) {
511 bridge = bridge_connector->bridge_hdmi_audio;
512 bridge->funcs->hdmi_audio_shutdown(bridge, connector);
513 }
514
515 if (bridge_connector->bridge_dp_audio) {
516 bridge = bridge_connector->bridge_dp_audio;
517 bridge->funcs->dp_audio_shutdown(bridge, connector);
518 }
519}
520
521static int drm_bridge_connector_audio_mute_stream(struct drm_connector *connector,
522 bool enable, int direction)
523{
524 struct drm_bridge_connector *bridge_connector =
525 to_drm_bridge_connector(connector);
526 struct drm_bridge *bridge;
527
528 if (bridge_connector->bridge_hdmi_audio) {
529 bridge = bridge_connector->bridge_hdmi_audio;
530
531 if (!bridge->funcs->hdmi_audio_mute_stream)
532 return -ENOTSUPP;
533
534 return bridge->funcs->hdmi_audio_mute_stream(bridge, connector,
535 enable, direction);
536 }
537
538 if (bridge_connector->bridge_dp_audio) {
539 bridge = bridge_connector->bridge_dp_audio;
540
541 if (!bridge->funcs->dp_audio_mute_stream)
542 return -ENOTSUPP;
543
544 return bridge->funcs->dp_audio_mute_stream(bridge, connector,
545 enable, direction);
546 }
547
548 return -EINVAL;
549}
550
551static const struct drm_connector_hdmi_audio_funcs drm_bridge_connector_hdmi_audio_funcs = {
552 .startup = drm_bridge_connector_audio_startup,
553 .prepare = drm_bridge_connector_audio_prepare,
554 .shutdown = drm_bridge_connector_audio_shutdown,
555 .mute_stream = drm_bridge_connector_audio_mute_stream,
556};
557
558static int drm_bridge_connector_hdmi_cec_enable(struct drm_connector *connector, bool enable)
559{
560 struct drm_bridge_connector *bridge_connector =
561 to_drm_bridge_connector(connector);
562 struct drm_bridge *bridge;
563
564 bridge = bridge_connector->bridge_hdmi_cec;
565
566 return bridge->funcs->hdmi_cec_enable(bridge, enable);
567}
568
569static int drm_bridge_connector_hdmi_cec_log_addr(struct drm_connector *connector, u8 logical_addr)
570{
571 struct drm_bridge_connector *bridge_connector =
572 to_drm_bridge_connector(connector);
573 struct drm_bridge *bridge;
574
575 bridge = bridge_connector->bridge_hdmi_cec;
576
577 return bridge->funcs->hdmi_cec_log_addr(bridge, logical_addr);
578}
579
580static int drm_bridge_connector_hdmi_cec_transmit(struct drm_connector *connector,
581 u8 attempts,
582 u32 signal_free_time,
583 struct cec_msg *msg)
584{
585 struct drm_bridge_connector *bridge_connector =
586 to_drm_bridge_connector(connector);
587 struct drm_bridge *bridge;
588
589 bridge = bridge_connector->bridge_hdmi_cec;
590
591 return bridge->funcs->hdmi_cec_transmit(bridge, attempts,
592 signal_free_time,
593 msg);
594}
595
596static int drm_bridge_connector_hdmi_cec_init(struct drm_connector *connector)
597{
598 struct drm_bridge_connector *bridge_connector =
599 to_drm_bridge_connector(connector);
600 struct drm_bridge *bridge;
601
602 bridge = bridge_connector->bridge_hdmi_cec;
603
604 if (!bridge->funcs->hdmi_cec_init)
605 return 0;
606
607 return bridge->funcs->hdmi_cec_init(bridge, connector);
608}
609
610static const struct drm_connector_hdmi_cec_funcs drm_bridge_connector_hdmi_cec_funcs = {
611 .init = drm_bridge_connector_hdmi_cec_init,
612 .enable = drm_bridge_connector_hdmi_cec_enable,
613 .log_addr = drm_bridge_connector_hdmi_cec_log_addr,
614 .transmit = drm_bridge_connector_hdmi_cec_transmit,
615};
616
617/* -----------------------------------------------------------------------------
618 * Bridge Connector Initialisation
619 */
620
621static void drm_bridge_connector_put_bridges(struct drm_device *dev, void *data)
622{
623 struct drm_bridge_connector *bridge_connector = (struct drm_bridge_connector *)data;
624
625 drm_bridge_put(bridge: bridge_connector->bridge_edid);
626 drm_bridge_put(bridge: bridge_connector->bridge_hpd);
627 drm_bridge_put(bridge: bridge_connector->bridge_detect);
628 drm_bridge_put(bridge: bridge_connector->bridge_modes);
629 drm_bridge_put(bridge: bridge_connector->bridge_hdmi);
630 drm_bridge_put(bridge: bridge_connector->bridge_hdmi_audio);
631 drm_bridge_put(bridge: bridge_connector->bridge_dp_audio);
632 drm_bridge_put(bridge: bridge_connector->bridge_hdmi_cec);
633}
634
635/**
636 * drm_bridge_connector_init - Initialise a connector for a chain of bridges
637 * @drm: the DRM device
638 * @encoder: the encoder where the bridge chain starts
639 *
640 * Allocate, initialise and register a &drm_bridge_connector with the @drm
641 * device. The connector is associated with a chain of bridges that starts at
642 * the @encoder. All bridges in the chain shall report bridge operation flags
643 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of
644 * them may create a DRM connector directly.
645 *
646 * Returns a pointer to the new connector on success, or a negative error
647 * pointer otherwise.
648 */
649struct drm_connector *drm_bridge_connector_init(struct drm_device *drm,
650 struct drm_encoder *encoder)
651{
652 struct drm_bridge_connector *bridge_connector;
653 struct drm_connector *connector;
654 struct i2c_adapter *ddc = NULL;
655 struct drm_bridge *panel_bridge __free(drm_bridge_put) = NULL;
656 unsigned int supported_formats = BIT(HDMI_COLORSPACE_RGB);
657 unsigned int max_bpc = 8;
658 bool support_hdcp = false;
659 int connector_type;
660 int ret;
661
662 bridge_connector = drmm_kzalloc(dev: drm, size: sizeof(*bridge_connector), GFP_KERNEL);
663 if (!bridge_connector)
664 return ERR_PTR(error: -ENOMEM);
665
666 ret = drmm_add_action(drm, drm_bridge_connector_put_bridges, bridge_connector);
667 if (ret)
668 return ERR_PTR(error: ret);
669
670 bridge_connector->encoder = encoder;
671
672 /*
673 * TODO: Handle doublescan_allowed and stereo_allowed.
674 */
675 connector = &bridge_connector->base;
676 connector->interlace_allowed = true;
677 connector->ycbcr_420_allowed = true;
678
679 /*
680 * Initialise connector status handling. First locate the furthest
681 * bridges in the pipeline that support HPD and output detection. Then
682 * initialise the connector polling mode, using HPD if available and
683 * falling back to polling if supported. If neither HPD nor output
684 * detection are available, we don't support hotplug detection at all.
685 */
686 connector_type = DRM_MODE_CONNECTOR_Unknown;
687 drm_for_each_bridge_in_chain_scoped(encoder, bridge) {
688 if (!bridge->interlace_allowed)
689 connector->interlace_allowed = false;
690 if (!bridge->ycbcr_420_allowed)
691 connector->ycbcr_420_allowed = false;
692
693 if (bridge->ops & DRM_BRIDGE_OP_EDID) {
694 drm_bridge_put(bridge: bridge_connector->bridge_edid);
695 bridge_connector->bridge_edid = drm_bridge_get(bridge);
696 }
697 if (bridge->ops & DRM_BRIDGE_OP_HPD) {
698 drm_bridge_put(bridge: bridge_connector->bridge_hpd);
699 bridge_connector->bridge_hpd = drm_bridge_get(bridge);
700 }
701 if (bridge->ops & DRM_BRIDGE_OP_DETECT) {
702 drm_bridge_put(bridge: bridge_connector->bridge_detect);
703 bridge_connector->bridge_detect = drm_bridge_get(bridge);
704 }
705 if (bridge->ops & DRM_BRIDGE_OP_MODES) {
706 drm_bridge_put(bridge: bridge_connector->bridge_modes);
707 bridge_connector->bridge_modes = drm_bridge_get(bridge);
708 }
709 if (bridge->ops & DRM_BRIDGE_OP_HDMI) {
710 if (bridge_connector->bridge_hdmi)
711 return ERR_PTR(error: -EBUSY);
712 if (!bridge->funcs->hdmi_write_infoframe ||
713 !bridge->funcs->hdmi_clear_infoframe)
714 return ERR_PTR(error: -EINVAL);
715
716 bridge_connector->bridge_hdmi = drm_bridge_get(bridge);
717
718 if (bridge->supported_formats)
719 supported_formats = bridge->supported_formats;
720 if (bridge->max_bpc)
721 max_bpc = bridge->max_bpc;
722 }
723
724 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO) {
725 if (bridge_connector->bridge_hdmi_audio)
726 return ERR_PTR(error: -EBUSY);
727
728 if (bridge_connector->bridge_dp_audio)
729 return ERR_PTR(error: -EBUSY);
730
731 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
732 !bridge->hdmi_audio_spdif_playback)
733 return ERR_PTR(error: -EINVAL);
734
735 if (!bridge->funcs->hdmi_audio_prepare ||
736 !bridge->funcs->hdmi_audio_shutdown)
737 return ERR_PTR(error: -EINVAL);
738
739 bridge_connector->bridge_hdmi_audio = drm_bridge_get(bridge);
740 }
741
742 if (bridge->ops & DRM_BRIDGE_OP_DP_AUDIO) {
743 if (bridge_connector->bridge_dp_audio)
744 return ERR_PTR(error: -EBUSY);
745
746 if (bridge_connector->bridge_hdmi_audio)
747 return ERR_PTR(error: -EBUSY);
748
749 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
750 !bridge->hdmi_audio_spdif_playback)
751 return ERR_PTR(error: -EINVAL);
752
753 if (!bridge->funcs->dp_audio_prepare ||
754 !bridge->funcs->dp_audio_shutdown)
755 return ERR_PTR(error: -EINVAL);
756
757 bridge_connector->bridge_dp_audio = drm_bridge_get(bridge);
758 }
759
760 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
761 if (bridge_connector->bridge_hdmi_cec)
762 return ERR_PTR(error: -EBUSY);
763
764 bridge_connector->bridge_hdmi_cec = drm_bridge_get(bridge);
765 }
766
767 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
768 if (bridge_connector->bridge_hdmi_cec)
769 return ERR_PTR(error: -EBUSY);
770
771 bridge_connector->bridge_hdmi_cec = drm_bridge_get(bridge);
772
773 if (!bridge->funcs->hdmi_cec_enable ||
774 !bridge->funcs->hdmi_cec_log_addr ||
775 !bridge->funcs->hdmi_cec_transmit)
776 return ERR_PTR(error: -EINVAL);
777 }
778
779 if (drm_bridge_is_last(bridge))
780 connector_type = bridge->type;
781
782#ifdef CONFIG_OF
783 if (drm_bridge_is_last(bridge) && bridge->of_node)
784 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node));
785#endif
786
787 if (bridge->ddc)
788 ddc = bridge->ddc;
789
790 if (drm_bridge_is_panel(bridge)) {
791 drm_bridge_put(bridge: panel_bridge);
792 panel_bridge = drm_bridge_get(bridge);
793 }
794
795 if (bridge->support_hdcp)
796 support_hdcp = true;
797 }
798
799 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
800 return ERR_PTR(error: -EINVAL);
801
802 if (bridge_connector->bridge_hdmi) {
803 if (!connector->ycbcr_420_allowed)
804 supported_formats &= ~BIT(HDMI_COLORSPACE_YUV420);
805
806 ret = drmm_connector_hdmi_init(dev: drm, connector,
807 vendor: bridge_connector->bridge_hdmi->vendor,
808 product: bridge_connector->bridge_hdmi->product,
809 funcs: &drm_bridge_connector_funcs,
810 hdmi_funcs: &drm_bridge_connector_hdmi_funcs,
811 connector_type, ddc,
812 supported_formats,
813 max_bpc);
814 if (ret)
815 return ERR_PTR(error: ret);
816 } else {
817 ret = drmm_connector_init(dev: drm, connector,
818 funcs: &drm_bridge_connector_funcs,
819 connector_type, ddc);
820 if (ret)
821 return ERR_PTR(error: ret);
822 }
823
824 if (bridge_connector->bridge_hdmi_audio ||
825 bridge_connector->bridge_dp_audio) {
826 struct device *dev;
827 struct drm_bridge *bridge;
828
829 if (bridge_connector->bridge_hdmi_audio)
830 bridge = bridge_connector->bridge_hdmi_audio;
831 else
832 bridge = bridge_connector->bridge_dp_audio;
833
834 dev = bridge->hdmi_audio_dev;
835
836 ret = drm_connector_hdmi_audio_init(connector, hdmi_codec_dev: dev,
837 funcs: &drm_bridge_connector_hdmi_audio_funcs,
838 max_i2s_playback_channels: bridge->hdmi_audio_max_i2s_playback_channels,
839 i2s_formats: bridge->hdmi_audio_i2s_formats,
840 spdif_playback: bridge->hdmi_audio_spdif_playback,
841 sound_dai_port: bridge->hdmi_audio_dai_port);
842 if (ret)
843 return ERR_PTR(error: ret);
844 }
845
846 if (bridge_connector->bridge_hdmi_cec &&
847 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
848 struct drm_bridge *bridge = bridge_connector->bridge_hdmi_cec;
849
850 ret = drmm_connector_hdmi_cec_notifier_register(connector,
851 NULL,
852 dev: bridge->hdmi_cec_dev);
853 if (ret)
854 return ERR_PTR(error: ret);
855 }
856
857 if (bridge_connector->bridge_hdmi_cec &&
858 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
859 struct drm_bridge *bridge = bridge_connector->bridge_hdmi_cec;
860
861 ret = drmm_connector_hdmi_cec_register(connector,
862 funcs: &drm_bridge_connector_hdmi_cec_funcs,
863 name: bridge->hdmi_cec_adapter_name,
864 available_las: bridge->hdmi_cec_available_las,
865 dev: bridge->hdmi_cec_dev);
866 if (ret)
867 return ERR_PTR(error: ret);
868 }
869
870 drm_connector_helper_add(connector, funcs: &drm_bridge_connector_helper_funcs);
871
872 if (bridge_connector->bridge_hpd)
873 connector->polled = DRM_CONNECTOR_POLL_HPD;
874 else if (bridge_connector->bridge_detect)
875 connector->polled = DRM_CONNECTOR_POLL_CONNECT
876 | DRM_CONNECTOR_POLL_DISCONNECT;
877
878 if (panel_bridge)
879 drm_panel_bridge_set_orientation(connector, bridge: panel_bridge);
880
881 if (support_hdcp && IS_REACHABLE(CONFIG_DRM_DISPLAY_HELPER) &&
882 IS_ENABLED(CONFIG_DRM_DISPLAY_HDCP_HELPER))
883 drm_connector_attach_content_protection_property(connector, hdcp_content_type: true);
884
885 return connector;
886}
887EXPORT_SYMBOL_GPL(drm_bridge_connector_init);
888

source code of linux/drivers/gpu/drm/display/drm_bridge_connector.c