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_hdmi_audio_helper.h>
24 #include <drm/display/drm_hdmi_cec_helper.h>
25 #include <drm/display/drm_hdmi_helper.h>
26 #include <drm/display/drm_hdmi_state_helper.h>
27
28 /**
29 * DOC: overview
30 *
31 * The DRM bridge connector helper object provides a DRM connector
32 * implementation that wraps a chain of &struct drm_bridge. The connector
33 * operations are fully implemented based on the operations of the bridges in
34 * the chain, and don't require any intervention from the display controller
35 * driver at runtime.
36 *
37 * To use the helper, display controller drivers create a bridge connector with
38 * a call to drm_bridge_connector_init(). This associates the newly created
39 * connector with the chain of bridges passed to the function and registers it
40 * with the DRM device. At that point the connector becomes fully usable, no
41 * further operation is needed.
42 *
43 * The DRM bridge connector operations are implemented based on the operations
44 * provided by the bridges in the chain. Each connector operation is delegated
45 * to the bridge closest to the connector (at the end of the chain) that
46 * provides the relevant functionality.
47 *
48 * To make use of this helper, all bridges in the chain shall report bridge
49 * operation flags (&drm_bridge->ops) and bridge output type
50 * (&drm_bridge->type), as well as the DRM_BRIDGE_ATTACH_NO_CONNECTOR attach
51 * flag (none of the bridges shall create a DRM connector directly).
52 */
53
54 /**
55 * struct drm_bridge_connector - A connector backed by a chain of bridges
56 */
57 struct drm_bridge_connector {
58 /**
59 * @base: The base DRM connector
60 */
61 struct drm_connector base;
62 /**
63 * @encoder:
64 *
65 * The encoder at the start of the bridges chain.
66 */
67 struct drm_encoder *encoder;
68 /**
69 * @bridge_edid:
70 *
71 * The last bridge in the chain (closest to the connector) that provides
72 * EDID read support, if any (see &DRM_BRIDGE_OP_EDID).
73 */
74 struct drm_bridge *bridge_edid;
75 /**
76 * @bridge_hpd:
77 *
78 * The last bridge in the chain (closest to the connector) that provides
79 * hot-plug detection notification, if any (see &DRM_BRIDGE_OP_HPD).
80 */
81 struct drm_bridge *bridge_hpd;
82 /**
83 * @bridge_detect:
84 *
85 * The last bridge in the chain (closest to the connector) that provides
86 * connector detection, if any (see &DRM_BRIDGE_OP_DETECT).
87 */
88 struct drm_bridge *bridge_detect;
89 /**
90 * @bridge_modes:
91 *
92 * The last bridge in the chain (closest to the connector) that provides
93 * connector modes detection, if any (see &DRM_BRIDGE_OP_MODES).
94 */
95 struct drm_bridge *bridge_modes;
96 /**
97 * @bridge_hdmi:
98 *
99 * The bridge in the chain that implements necessary support for the
100 * HDMI connector infrastructure, if any (see &DRM_BRIDGE_OP_HDMI).
101 */
102 struct drm_bridge *bridge_hdmi;
103 /**
104 * @bridge_hdmi_audio:
105 *
106 * The bridge in the chain that implements necessary support for the
107 * HDMI Audio infrastructure, if any (see &DRM_BRIDGE_OP_HDMI_AUDIO).
108 */
109 struct drm_bridge *bridge_hdmi_audio;
110 /**
111 * @bridge_dp_audio:
112 *
113 * The bridge in the chain that implements necessary support for the
114 * DisplayPort Audio infrastructure, if any (see
115 * &DRM_BRIDGE_OP_DP_AUDIO).
116 */
117 struct drm_bridge *bridge_dp_audio;
118 /**
119 * @bridge_hdmi_cec:
120 *
121 * The bridge in the chain that implements CEC support, if any (see
122 * DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER).
123 */
124 struct drm_bridge *bridge_hdmi_cec;
125 };
126
127 #define to_drm_bridge_connector(x) \
128 container_of(x, struct drm_bridge_connector, base)
129
130 /* -----------------------------------------------------------------------------
131 * Bridge Connector Hot-Plug Handling
132 */
133
drm_bridge_connector_hpd_notify(struct drm_connector * connector,enum drm_connector_status status)134 static void drm_bridge_connector_hpd_notify(struct drm_connector *connector,
135 enum drm_connector_status status)
136 {
137 struct drm_bridge_connector *bridge_connector =
138 to_drm_bridge_connector(connector);
139 struct drm_bridge *bridge;
140
141 /* Notify all bridges in the pipeline of hotplug events. */
142 drm_for_each_bridge_in_chain(bridge_connector->encoder, bridge) {
143 if (bridge->funcs->hpd_notify)
144 bridge->funcs->hpd_notify(bridge, status);
145 }
146 }
147
drm_bridge_connector_handle_hpd(struct drm_bridge_connector * drm_bridge_connector,enum drm_connector_status status)148 static 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(&dev->mode_config.mutex);
157
158 drm_bridge_connector_hpd_notify(connector, status);
159
160 drm_kms_helper_connector_hotplug_event(connector);
161 }
162
drm_bridge_connector_hpd_cb(void * cb_data,enum drm_connector_status status)163 static void drm_bridge_connector_hpd_cb(void *cb_data,
164 enum drm_connector_status status)
165 {
166 drm_bridge_connector_handle_hpd(cb_data, status);
167 }
168
drm_bridge_connector_oob_hotplug_event(struct drm_connector * connector,enum drm_connector_status status)169 static 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(bridge_connector, status);
176 }
177
drm_bridge_connector_enable_hpd(struct drm_connector * connector)178 static 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(hpd, drm_bridge_connector_hpd_cb,
186 bridge_connector);
187 }
188
drm_bridge_connector_disable_hpd(struct drm_connector * connector)189 static 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(hpd);
197 }
198
199 /* -----------------------------------------------------------------------------
200 * Bridge Connector Functions
201 */
202
203 static enum drm_connector_status
drm_bridge_connector_detect(struct drm_connector * connector,bool force)204 drm_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
drm_bridge_connector_force(struct drm_connector * connector)236 static 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
drm_bridge_connector_debugfs_init(struct drm_connector * connector,struct dentry * root)246 static 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
drm_bridge_connector_reset(struct drm_connector * connector)260 static 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 connector->state);
269 }
270
271 static 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
drm_bridge_connector_get_modes_edid(struct drm_connector * connector,struct drm_bridge * bridge)286 static 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, 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, drm_edid);
304 n = drm_edid_connector_add_modes(connector);
305
306 drm_edid_free(drm_edid);
307 return n;
308
309 no_edid:
310 drm_edid_connector_update(connector, NULL);
311 return 0;
312 }
313
drm_bridge_connector_get_modes(struct drm_connector * connector)314 static 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
352 static enum drm_mode_status
drm_bridge_connector_mode_valid(struct drm_connector * connector,const struct drm_display_mode * mode)353 drm_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
drm_bridge_connector_atomic_check(struct drm_connector * connector,struct drm_atomic_state * state)365 static 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
377 static 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
385 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)386 drm_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
drm_bridge_connector_clear_infoframe(struct drm_connector * connector,enum hdmi_infoframe_type type)404 static 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
drm_bridge_connector_write_infoframe(struct drm_connector * connector,enum hdmi_infoframe_type type,const u8 * buffer,size_t len)418 static 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
433 static const struct drm_edid *
drm_bridge_connector_read_edid(struct drm_connector * connector)434 drm_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
447 static 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
drm_bridge_connector_audio_startup(struct drm_connector * connector)454 static 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
drm_bridge_connector_audio_prepare(struct drm_connector * connector,struct hdmi_codec_daifmt * fmt,struct hdmi_codec_params * hparms)481 static 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
drm_bridge_connector_audio_shutdown(struct drm_connector * connector)504 static 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
drm_bridge_connector_audio_mute_stream(struct drm_connector * connector,bool enable,int direction)521 static 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
551 static 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
drm_bridge_connector_hdmi_cec_enable(struct drm_connector * connector,bool enable)558 static 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
drm_bridge_connector_hdmi_cec_log_addr(struct drm_connector * connector,u8 logical_addr)569 static 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
drm_bridge_connector_hdmi_cec_transmit(struct drm_connector * connector,u8 attempts,u32 signal_free_time,struct cec_msg * msg)580 static 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
drm_bridge_connector_hdmi_cec_init(struct drm_connector * connector)596 static 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
610 static 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
621 /**
622 * drm_bridge_connector_init - Initialise a connector for a chain of bridges
623 * @drm: the DRM device
624 * @encoder: the encoder where the bridge chain starts
625 *
626 * Allocate, initialise and register a &drm_bridge_connector with the @drm
627 * device. The connector is associated with a chain of bridges that starts at
628 * the @encoder. All bridges in the chain shall report bridge operation flags
629 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of
630 * them may create a DRM connector directly.
631 *
632 * Returns a pointer to the new connector on success, or a negative error
633 * pointer otherwise.
634 */
drm_bridge_connector_init(struct drm_device * drm,struct drm_encoder * encoder)635 struct drm_connector *drm_bridge_connector_init(struct drm_device *drm,
636 struct drm_encoder *encoder)
637 {
638 struct drm_bridge_connector *bridge_connector;
639 struct drm_connector *connector;
640 struct i2c_adapter *ddc = NULL;
641 struct drm_bridge *bridge, *panel_bridge = NULL;
642 unsigned int supported_formats = BIT(HDMI_COLORSPACE_RGB);
643 unsigned int max_bpc = 8;
644 int connector_type;
645 int ret;
646
647 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL);
648 if (!bridge_connector)
649 return ERR_PTR(-ENOMEM);
650
651 bridge_connector->encoder = encoder;
652
653 /*
654 * TODO: Handle doublescan_allowed and stereo_allowed.
655 */
656 connector = &bridge_connector->base;
657 connector->interlace_allowed = true;
658 connector->ycbcr_420_allowed = true;
659
660 /*
661 * Initialise connector status handling. First locate the furthest
662 * bridges in the pipeline that support HPD and output detection. Then
663 * initialise the connector polling mode, using HPD if available and
664 * falling back to polling if supported. If neither HPD nor output
665 * detection are available, we don't support hotplug detection at all.
666 */
667 connector_type = DRM_MODE_CONNECTOR_Unknown;
668 drm_for_each_bridge_in_chain(encoder, bridge) {
669 if (!bridge->interlace_allowed)
670 connector->interlace_allowed = false;
671 if (!bridge->ycbcr_420_allowed)
672 connector->ycbcr_420_allowed = false;
673
674 if (bridge->ops & DRM_BRIDGE_OP_EDID)
675 bridge_connector->bridge_edid = bridge;
676 if (bridge->ops & DRM_BRIDGE_OP_HPD)
677 bridge_connector->bridge_hpd = bridge;
678 if (bridge->ops & DRM_BRIDGE_OP_DETECT)
679 bridge_connector->bridge_detect = bridge;
680 if (bridge->ops & DRM_BRIDGE_OP_MODES)
681 bridge_connector->bridge_modes = bridge;
682 if (bridge->ops & DRM_BRIDGE_OP_HDMI) {
683 if (bridge_connector->bridge_hdmi)
684 return ERR_PTR(-EBUSY);
685 if (!bridge->funcs->hdmi_write_infoframe ||
686 !bridge->funcs->hdmi_clear_infoframe)
687 return ERR_PTR(-EINVAL);
688
689 bridge_connector->bridge_hdmi = bridge;
690
691 if (bridge->supported_formats)
692 supported_formats = bridge->supported_formats;
693 if (bridge->max_bpc)
694 max_bpc = bridge->max_bpc;
695 }
696
697 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO) {
698 if (bridge_connector->bridge_hdmi_audio)
699 return ERR_PTR(-EBUSY);
700
701 if (bridge_connector->bridge_dp_audio)
702 return ERR_PTR(-EBUSY);
703
704 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
705 !bridge->hdmi_audio_spdif_playback)
706 return ERR_PTR(-EINVAL);
707
708 if (!bridge->funcs->hdmi_audio_prepare ||
709 !bridge->funcs->hdmi_audio_shutdown)
710 return ERR_PTR(-EINVAL);
711
712 bridge_connector->bridge_hdmi_audio = bridge;
713 }
714
715 if (bridge->ops & DRM_BRIDGE_OP_DP_AUDIO) {
716 if (bridge_connector->bridge_dp_audio)
717 return ERR_PTR(-EBUSY);
718
719 if (bridge_connector->bridge_hdmi_audio)
720 return ERR_PTR(-EBUSY);
721
722 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
723 !bridge->hdmi_audio_spdif_playback)
724 return ERR_PTR(-EINVAL);
725
726 if (!bridge->funcs->dp_audio_prepare ||
727 !bridge->funcs->dp_audio_shutdown)
728 return ERR_PTR(-EINVAL);
729
730 bridge_connector->bridge_dp_audio = bridge;
731 }
732
733 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
734 if (bridge_connector->bridge_hdmi_cec)
735 return ERR_PTR(-EBUSY);
736
737 bridge_connector->bridge_hdmi_cec = bridge;
738 }
739
740 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
741 if (bridge_connector->bridge_hdmi_cec)
742 return ERR_PTR(-EBUSY);
743
744 bridge_connector->bridge_hdmi_cec = bridge;
745
746 if (!bridge->funcs->hdmi_cec_enable ||
747 !bridge->funcs->hdmi_cec_log_addr ||
748 !bridge->funcs->hdmi_cec_transmit)
749 return ERR_PTR(-EINVAL);
750 }
751
752 if (!drm_bridge_get_next_bridge(bridge))
753 connector_type = bridge->type;
754
755 #ifdef CONFIG_OF
756 if (!drm_bridge_get_next_bridge(bridge) &&
757 bridge->of_node)
758 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node));
759 #endif
760
761 if (bridge->ddc)
762 ddc = bridge->ddc;
763
764 if (drm_bridge_is_panel(bridge))
765 panel_bridge = bridge;
766 }
767
768 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
769 return ERR_PTR(-EINVAL);
770
771 if (bridge_connector->bridge_hdmi) {
772 if (!connector->ycbcr_420_allowed)
773 supported_formats &= ~BIT(HDMI_COLORSPACE_YUV420);
774
775 bridge = bridge_connector->bridge_hdmi;
776
777 ret = drmm_connector_hdmi_init(drm, connector,
778 bridge_connector->bridge_hdmi->vendor,
779 bridge_connector->bridge_hdmi->product,
780 &drm_bridge_connector_funcs,
781 &drm_bridge_connector_hdmi_funcs,
782 connector_type, ddc,
783 supported_formats,
784 max_bpc);
785 if (ret)
786 return ERR_PTR(ret);
787 } else {
788 ret = drmm_connector_init(drm, connector,
789 &drm_bridge_connector_funcs,
790 connector_type, ddc);
791 if (ret)
792 return ERR_PTR(ret);
793 }
794
795 if (bridge_connector->bridge_hdmi_audio ||
796 bridge_connector->bridge_dp_audio) {
797 struct device *dev;
798 struct drm_bridge *bridge;
799
800 if (bridge_connector->bridge_hdmi_audio)
801 bridge = bridge_connector->bridge_hdmi_audio;
802 else
803 bridge = bridge_connector->bridge_dp_audio;
804
805 dev = bridge->hdmi_audio_dev;
806
807 ret = drm_connector_hdmi_audio_init(connector, dev,
808 &drm_bridge_connector_hdmi_audio_funcs,
809 bridge->hdmi_audio_max_i2s_playback_channels,
810 bridge->hdmi_audio_i2s_formats,
811 bridge->hdmi_audio_spdif_playback,
812 bridge->hdmi_audio_dai_port);
813 if (ret)
814 return ERR_PTR(ret);
815 }
816
817 if (bridge_connector->bridge_hdmi_cec &&
818 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
819 ret = drmm_connector_hdmi_cec_notifier_register(connector,
820 NULL,
821 bridge->hdmi_cec_dev);
822 if (ret)
823 return ERR_PTR(ret);
824 }
825
826 if (bridge_connector->bridge_hdmi_cec &&
827 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
828 ret = drmm_connector_hdmi_cec_register(connector,
829 &drm_bridge_connector_hdmi_cec_funcs,
830 bridge->hdmi_cec_adapter_name,
831 bridge->hdmi_cec_available_las,
832 bridge->hdmi_cec_dev);
833 if (ret)
834 return ERR_PTR(ret);
835 }
836
837 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs);
838
839 if (bridge_connector->bridge_hpd)
840 connector->polled = DRM_CONNECTOR_POLL_HPD;
841 else if (bridge_connector->bridge_detect)
842 connector->polled = DRM_CONNECTOR_POLL_CONNECT
843 | DRM_CONNECTOR_POLL_DISCONNECT;
844
845 if (panel_bridge)
846 drm_panel_bridge_set_orientation(connector, panel_bridge);
847
848 return connector;
849 }
850 EXPORT_SYMBOL_GPL(drm_bridge_connector_init);
851