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