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 */
58 struct 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
drm_bridge_connector_hpd_notify(struct drm_connector * connector,enum drm_connector_status status)135 static 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 struct drm_bridge *bridge;
141
142 /* Notify all bridges in the pipeline of hotplug events. */
143 drm_for_each_bridge_in_chain(bridge_connector->encoder, bridge) {
144 if (bridge->funcs->hpd_notify)
145 bridge->funcs->hpd_notify(bridge, status);
146 }
147 }
148
drm_bridge_connector_handle_hpd(struct drm_bridge_connector * drm_bridge_connector,enum drm_connector_status status)149 static void drm_bridge_connector_handle_hpd(struct drm_bridge_connector *drm_bridge_connector,
150 enum drm_connector_status status)
151 {
152 struct drm_connector *connector = &drm_bridge_connector->base;
153 struct drm_device *dev = connector->dev;
154
155 mutex_lock(&dev->mode_config.mutex);
156 connector->status = status;
157 mutex_unlock(&dev->mode_config.mutex);
158
159 drm_bridge_connector_hpd_notify(connector, status);
160
161 drm_kms_helper_connector_hotplug_event(connector);
162 }
163
drm_bridge_connector_hpd_cb(void * cb_data,enum drm_connector_status status)164 static void drm_bridge_connector_hpd_cb(void *cb_data,
165 enum drm_connector_status status)
166 {
167 drm_bridge_connector_handle_hpd(cb_data, status);
168 }
169
drm_bridge_connector_oob_hotplug_event(struct drm_connector * connector,enum drm_connector_status status)170 static void drm_bridge_connector_oob_hotplug_event(struct drm_connector *connector,
171 enum drm_connector_status status)
172 {
173 struct drm_bridge_connector *bridge_connector =
174 to_drm_bridge_connector(connector);
175
176 drm_bridge_connector_handle_hpd(bridge_connector, status);
177 }
178
drm_bridge_connector_enable_hpd(struct drm_connector * connector)179 static void drm_bridge_connector_enable_hpd(struct drm_connector *connector)
180 {
181 struct drm_bridge_connector *bridge_connector =
182 to_drm_bridge_connector(connector);
183 struct drm_bridge *hpd = bridge_connector->bridge_hpd;
184
185 if (hpd)
186 drm_bridge_hpd_enable(hpd, drm_bridge_connector_hpd_cb,
187 bridge_connector);
188 }
189
drm_bridge_connector_disable_hpd(struct drm_connector * connector)190 static void drm_bridge_connector_disable_hpd(struct drm_connector *connector)
191 {
192 struct drm_bridge_connector *bridge_connector =
193 to_drm_bridge_connector(connector);
194 struct drm_bridge *hpd = bridge_connector->bridge_hpd;
195
196 if (hpd)
197 drm_bridge_hpd_disable(hpd);
198 }
199
200 /* -----------------------------------------------------------------------------
201 * Bridge Connector Functions
202 */
203
204 static enum drm_connector_status
drm_bridge_connector_detect(struct drm_connector * connector,bool force)205 drm_bridge_connector_detect(struct drm_connector *connector, bool force)
206 {
207 struct drm_bridge_connector *bridge_connector =
208 to_drm_bridge_connector(connector);
209 struct drm_bridge *detect = bridge_connector->bridge_detect;
210 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi;
211 enum drm_connector_status status;
212
213 if (detect) {
214 status = detect->funcs->detect(detect, connector);
215
216 if (hdmi)
217 drm_atomic_helper_connector_hdmi_hotplug(connector, status);
218
219 drm_bridge_connector_hpd_notify(connector, status);
220 } else {
221 switch (connector->connector_type) {
222 case DRM_MODE_CONNECTOR_DPI:
223 case DRM_MODE_CONNECTOR_LVDS:
224 case DRM_MODE_CONNECTOR_DSI:
225 case DRM_MODE_CONNECTOR_eDP:
226 status = connector_status_connected;
227 break;
228 default:
229 status = connector_status_unknown;
230 break;
231 }
232 }
233
234 return status;
235 }
236
drm_bridge_connector_force(struct drm_connector * connector)237 static void drm_bridge_connector_force(struct drm_connector *connector)
238 {
239 struct drm_bridge_connector *bridge_connector =
240 to_drm_bridge_connector(connector);
241 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi;
242
243 if (hdmi)
244 drm_atomic_helper_connector_hdmi_force(connector);
245 }
246
drm_bridge_connector_debugfs_init(struct drm_connector * connector,struct dentry * root)247 static void drm_bridge_connector_debugfs_init(struct drm_connector *connector,
248 struct dentry *root)
249 {
250 struct drm_bridge_connector *bridge_connector =
251 to_drm_bridge_connector(connector);
252 struct drm_encoder *encoder = bridge_connector->encoder;
253 struct drm_bridge *bridge;
254
255 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) {
256 if (bridge->funcs->debugfs_init)
257 bridge->funcs->debugfs_init(bridge, root);
258 }
259 }
260
drm_bridge_connector_reset(struct drm_connector * connector)261 static void drm_bridge_connector_reset(struct drm_connector *connector)
262 {
263 struct drm_bridge_connector *bridge_connector =
264 to_drm_bridge_connector(connector);
265
266 drm_atomic_helper_connector_reset(connector);
267 if (bridge_connector->bridge_hdmi)
268 __drm_atomic_helper_connector_hdmi_reset(connector,
269 connector->state);
270 }
271
272 static const struct drm_connector_funcs drm_bridge_connector_funcs = {
273 .reset = drm_bridge_connector_reset,
274 .detect = drm_bridge_connector_detect,
275 .force = drm_bridge_connector_force,
276 .fill_modes = drm_helper_probe_single_connector_modes,
277 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
278 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
279 .debugfs_init = drm_bridge_connector_debugfs_init,
280 .oob_hotplug_event = drm_bridge_connector_oob_hotplug_event,
281 };
282
283 /* -----------------------------------------------------------------------------
284 * Bridge Connector Helper Functions
285 */
286
drm_bridge_connector_get_modes_edid(struct drm_connector * connector,struct drm_bridge * bridge)287 static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector,
288 struct drm_bridge *bridge)
289 {
290 enum drm_connector_status status;
291 const struct drm_edid *drm_edid;
292 int n;
293
294 status = drm_bridge_connector_detect(connector, false);
295 if (status != connector_status_connected)
296 goto no_edid;
297
298 drm_edid = drm_bridge_edid_read(bridge, connector);
299 if (!drm_edid_valid(drm_edid)) {
300 drm_edid_free(drm_edid);
301 goto no_edid;
302 }
303
304 drm_edid_connector_update(connector, drm_edid);
305 n = drm_edid_connector_add_modes(connector);
306
307 drm_edid_free(drm_edid);
308 return n;
309
310 no_edid:
311 drm_edid_connector_update(connector, NULL);
312 return 0;
313 }
314
drm_bridge_connector_get_modes(struct drm_connector * connector)315 static int drm_bridge_connector_get_modes(struct drm_connector *connector)
316 {
317 struct drm_bridge_connector *bridge_connector =
318 to_drm_bridge_connector(connector);
319 struct drm_bridge *bridge;
320
321 /*
322 * If there is a HDMI bridge, EDID has been updated as a part of
323 * the .detect(). Just update the modes here.
324 */
325 bridge = bridge_connector->bridge_hdmi;
326 if (bridge)
327 return drm_edid_connector_add_modes(connector);
328
329 /*
330 * If display exposes EDID, then we parse that in the normal way to
331 * build table of supported modes.
332 */
333 bridge = bridge_connector->bridge_edid;
334 if (bridge)
335 return drm_bridge_connector_get_modes_edid(connector, bridge);
336
337 /*
338 * Otherwise if the display pipeline reports modes (e.g. with a fixed
339 * resolution panel or an analog TV output), query it.
340 */
341 bridge = bridge_connector->bridge_modes;
342 if (bridge)
343 return bridge->funcs->get_modes(bridge, connector);
344
345 /*
346 * We can't retrieve modes, which can happen for instance for a DVI or
347 * VGA output with the DDC bus unconnected. The KMS core will add the
348 * default modes.
349 */
350 return 0;
351 }
352
353 static enum drm_mode_status
drm_bridge_connector_mode_valid(struct drm_connector * connector,const struct drm_display_mode * mode)354 drm_bridge_connector_mode_valid(struct drm_connector *connector,
355 const struct drm_display_mode *mode)
356 {
357 struct drm_bridge_connector *bridge_connector =
358 to_drm_bridge_connector(connector);
359
360 if (bridge_connector->bridge_hdmi)
361 return drm_hdmi_connector_mode_valid(connector, mode);
362
363 return MODE_OK;
364 }
365
drm_bridge_connector_atomic_check(struct drm_connector * connector,struct drm_atomic_state * state)366 static int drm_bridge_connector_atomic_check(struct drm_connector *connector,
367 struct drm_atomic_state *state)
368 {
369 struct drm_bridge_connector *bridge_connector =
370 to_drm_bridge_connector(connector);
371
372 if (bridge_connector->bridge_hdmi)
373 return drm_atomic_helper_connector_hdmi_check(connector, state);
374
375 return 0;
376 }
377
378 static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = {
379 .get_modes = drm_bridge_connector_get_modes,
380 .mode_valid = drm_bridge_connector_mode_valid,
381 .enable_hpd = drm_bridge_connector_enable_hpd,
382 .disable_hpd = drm_bridge_connector_disable_hpd,
383 .atomic_check = drm_bridge_connector_atomic_check,
384 };
385
386 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)387 drm_bridge_connector_tmds_char_rate_valid(const struct drm_connector *connector,
388 const struct drm_display_mode *mode,
389 unsigned long long tmds_rate)
390 {
391 struct drm_bridge_connector *bridge_connector =
392 to_drm_bridge_connector(connector);
393 struct drm_bridge *bridge;
394
395 bridge = bridge_connector->bridge_hdmi;
396 if (!bridge)
397 return MODE_ERROR;
398
399 if (bridge->funcs->hdmi_tmds_char_rate_valid)
400 return bridge->funcs->hdmi_tmds_char_rate_valid(bridge, mode, tmds_rate);
401 else
402 return MODE_OK;
403 }
404
drm_bridge_connector_clear_infoframe(struct drm_connector * connector,enum hdmi_infoframe_type type)405 static int drm_bridge_connector_clear_infoframe(struct drm_connector *connector,
406 enum hdmi_infoframe_type type)
407 {
408 struct drm_bridge_connector *bridge_connector =
409 to_drm_bridge_connector(connector);
410 struct drm_bridge *bridge;
411
412 bridge = bridge_connector->bridge_hdmi;
413 if (!bridge)
414 return -EINVAL;
415
416 return bridge->funcs->hdmi_clear_infoframe(bridge, type);
417 }
418
drm_bridge_connector_write_infoframe(struct drm_connector * connector,enum hdmi_infoframe_type type,const u8 * buffer,size_t len)419 static int drm_bridge_connector_write_infoframe(struct drm_connector *connector,
420 enum hdmi_infoframe_type type,
421 const u8 *buffer, size_t len)
422 {
423 struct drm_bridge_connector *bridge_connector =
424 to_drm_bridge_connector(connector);
425 struct drm_bridge *bridge;
426
427 bridge = bridge_connector->bridge_hdmi;
428 if (!bridge)
429 return -EINVAL;
430
431 return bridge->funcs->hdmi_write_infoframe(bridge, type, buffer, len);
432 }
433
434 static const struct drm_edid *
drm_bridge_connector_read_edid(struct drm_connector * connector)435 drm_bridge_connector_read_edid(struct drm_connector *connector)
436 {
437 struct drm_bridge_connector *bridge_connector =
438 to_drm_bridge_connector(connector);
439 struct drm_bridge *bridge;
440
441 bridge = bridge_connector->bridge_edid;
442 if (!bridge)
443 return NULL;
444
445 return drm_bridge_edid_read(bridge, connector);
446 }
447
448 static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = {
449 .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid,
450 .clear_infoframe = drm_bridge_connector_clear_infoframe,
451 .write_infoframe = drm_bridge_connector_write_infoframe,
452 .read_edid = drm_bridge_connector_read_edid,
453 };
454
drm_bridge_connector_audio_startup(struct drm_connector * connector)455 static int drm_bridge_connector_audio_startup(struct drm_connector *connector)
456 {
457 struct drm_bridge_connector *bridge_connector =
458 to_drm_bridge_connector(connector);
459 struct drm_bridge *bridge;
460
461 if (bridge_connector->bridge_hdmi_audio) {
462 bridge = bridge_connector->bridge_hdmi_audio;
463
464 if (!bridge->funcs->hdmi_audio_startup)
465 return 0;
466
467 return bridge->funcs->hdmi_audio_startup(bridge, connector);
468 }
469
470 if (bridge_connector->bridge_dp_audio) {
471 bridge = bridge_connector->bridge_dp_audio;
472
473 if (!bridge->funcs->dp_audio_startup)
474 return 0;
475
476 return bridge->funcs->dp_audio_startup(bridge, connector);
477 }
478
479 return -EINVAL;
480 }
481
drm_bridge_connector_audio_prepare(struct drm_connector * connector,struct hdmi_codec_daifmt * fmt,struct hdmi_codec_params * hparms)482 static int drm_bridge_connector_audio_prepare(struct drm_connector *connector,
483 struct hdmi_codec_daifmt *fmt,
484 struct hdmi_codec_params *hparms)
485 {
486 struct drm_bridge_connector *bridge_connector =
487 to_drm_bridge_connector(connector);
488 struct drm_bridge *bridge;
489
490 if (bridge_connector->bridge_hdmi_audio) {
491 bridge = bridge_connector->bridge_hdmi_audio;
492
493 return bridge->funcs->hdmi_audio_prepare(bridge, connector, fmt, hparms);
494 }
495
496 if (bridge_connector->bridge_dp_audio) {
497 bridge = bridge_connector->bridge_dp_audio;
498
499 return bridge->funcs->dp_audio_prepare(bridge, connector, fmt, hparms);
500 }
501
502 return -EINVAL;
503 }
504
drm_bridge_connector_audio_shutdown(struct drm_connector * connector)505 static void drm_bridge_connector_audio_shutdown(struct drm_connector *connector)
506 {
507 struct drm_bridge_connector *bridge_connector =
508 to_drm_bridge_connector(connector);
509 struct drm_bridge *bridge;
510
511 if (bridge_connector->bridge_hdmi_audio) {
512 bridge = bridge_connector->bridge_hdmi_audio;
513 bridge->funcs->hdmi_audio_shutdown(bridge, connector);
514 }
515
516 if (bridge_connector->bridge_dp_audio) {
517 bridge = bridge_connector->bridge_dp_audio;
518 bridge->funcs->dp_audio_shutdown(bridge, connector);
519 }
520 }
521
drm_bridge_connector_audio_mute_stream(struct drm_connector * connector,bool enable,int direction)522 static int drm_bridge_connector_audio_mute_stream(struct drm_connector *connector,
523 bool enable, int direction)
524 {
525 struct drm_bridge_connector *bridge_connector =
526 to_drm_bridge_connector(connector);
527 struct drm_bridge *bridge;
528
529 if (bridge_connector->bridge_hdmi_audio) {
530 bridge = bridge_connector->bridge_hdmi_audio;
531
532 if (!bridge->funcs->hdmi_audio_mute_stream)
533 return -ENOTSUPP;
534
535 return bridge->funcs->hdmi_audio_mute_stream(bridge, connector,
536 enable, direction);
537 }
538
539 if (bridge_connector->bridge_dp_audio) {
540 bridge = bridge_connector->bridge_dp_audio;
541
542 if (!bridge->funcs->dp_audio_mute_stream)
543 return -ENOTSUPP;
544
545 return bridge->funcs->dp_audio_mute_stream(bridge, connector,
546 enable, direction);
547 }
548
549 return -EINVAL;
550 }
551
552 static const struct drm_connector_hdmi_audio_funcs drm_bridge_connector_hdmi_audio_funcs = {
553 .startup = drm_bridge_connector_audio_startup,
554 .prepare = drm_bridge_connector_audio_prepare,
555 .shutdown = drm_bridge_connector_audio_shutdown,
556 .mute_stream = drm_bridge_connector_audio_mute_stream,
557 };
558
drm_bridge_connector_hdmi_cec_enable(struct drm_connector * connector,bool enable)559 static int drm_bridge_connector_hdmi_cec_enable(struct drm_connector *connector, bool enable)
560 {
561 struct drm_bridge_connector *bridge_connector =
562 to_drm_bridge_connector(connector);
563 struct drm_bridge *bridge;
564
565 bridge = bridge_connector->bridge_hdmi_cec;
566
567 return bridge->funcs->hdmi_cec_enable(bridge, enable);
568 }
569
drm_bridge_connector_hdmi_cec_log_addr(struct drm_connector * connector,u8 logical_addr)570 static int drm_bridge_connector_hdmi_cec_log_addr(struct drm_connector *connector, u8 logical_addr)
571 {
572 struct drm_bridge_connector *bridge_connector =
573 to_drm_bridge_connector(connector);
574 struct drm_bridge *bridge;
575
576 bridge = bridge_connector->bridge_hdmi_cec;
577
578 return bridge->funcs->hdmi_cec_log_addr(bridge, logical_addr);
579 }
580
drm_bridge_connector_hdmi_cec_transmit(struct drm_connector * connector,u8 attempts,u32 signal_free_time,struct cec_msg * msg)581 static int drm_bridge_connector_hdmi_cec_transmit(struct drm_connector *connector,
582 u8 attempts,
583 u32 signal_free_time,
584 struct cec_msg *msg)
585 {
586 struct drm_bridge_connector *bridge_connector =
587 to_drm_bridge_connector(connector);
588 struct drm_bridge *bridge;
589
590 bridge = bridge_connector->bridge_hdmi_cec;
591
592 return bridge->funcs->hdmi_cec_transmit(bridge, attempts,
593 signal_free_time,
594 msg);
595 }
596
drm_bridge_connector_hdmi_cec_init(struct drm_connector * connector)597 static int drm_bridge_connector_hdmi_cec_init(struct drm_connector *connector)
598 {
599 struct drm_bridge_connector *bridge_connector =
600 to_drm_bridge_connector(connector);
601 struct drm_bridge *bridge;
602
603 bridge = bridge_connector->bridge_hdmi_cec;
604
605 if (!bridge->funcs->hdmi_cec_init)
606 return 0;
607
608 return bridge->funcs->hdmi_cec_init(bridge, connector);
609 }
610
611 static const struct drm_connector_hdmi_cec_funcs drm_bridge_connector_hdmi_cec_funcs = {
612 .init = drm_bridge_connector_hdmi_cec_init,
613 .enable = drm_bridge_connector_hdmi_cec_enable,
614 .log_addr = drm_bridge_connector_hdmi_cec_log_addr,
615 .transmit = drm_bridge_connector_hdmi_cec_transmit,
616 };
617
618 /* -----------------------------------------------------------------------------
619 * Bridge Connector Initialisation
620 */
621
622 /**
623 * drm_bridge_connector_init - Initialise a connector for a chain of bridges
624 * @drm: the DRM device
625 * @encoder: the encoder where the bridge chain starts
626 *
627 * Allocate, initialise and register a &drm_bridge_connector with the @drm
628 * device. The connector is associated with a chain of bridges that starts at
629 * the @encoder. All bridges in the chain shall report bridge operation flags
630 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of
631 * them may create a DRM connector directly.
632 *
633 * Returns a pointer to the new connector on success, or a negative error
634 * pointer otherwise.
635 */
drm_bridge_connector_init(struct drm_device * drm,struct drm_encoder * encoder)636 struct drm_connector *drm_bridge_connector_init(struct drm_device *drm,
637 struct drm_encoder *encoder)
638 {
639 struct drm_bridge_connector *bridge_connector;
640 struct drm_connector *connector;
641 struct i2c_adapter *ddc = NULL;
642 struct drm_bridge *bridge, *panel_bridge = NULL;
643 unsigned int supported_formats = BIT(HDMI_COLORSPACE_RGB);
644 unsigned int max_bpc = 8;
645 bool support_hdcp = false;
646 int connector_type;
647 int ret;
648
649 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL);
650 if (!bridge_connector)
651 return ERR_PTR(-ENOMEM);
652
653 bridge_connector->encoder = encoder;
654
655 /*
656 * TODO: Handle doublescan_allowed and stereo_allowed.
657 */
658 connector = &bridge_connector->base;
659 connector->interlace_allowed = true;
660 connector->ycbcr_420_allowed = true;
661
662 /*
663 * Initialise connector status handling. First locate the furthest
664 * bridges in the pipeline that support HPD and output detection. Then
665 * initialise the connector polling mode, using HPD if available and
666 * falling back to polling if supported. If neither HPD nor output
667 * detection are available, we don't support hotplug detection at all.
668 */
669 connector_type = DRM_MODE_CONNECTOR_Unknown;
670 drm_for_each_bridge_in_chain(encoder, bridge) {
671 if (!bridge->interlace_allowed)
672 connector->interlace_allowed = false;
673 if (!bridge->ycbcr_420_allowed)
674 connector->ycbcr_420_allowed = false;
675
676 if (bridge->ops & DRM_BRIDGE_OP_EDID)
677 bridge_connector->bridge_edid = bridge;
678 if (bridge->ops & DRM_BRIDGE_OP_HPD)
679 bridge_connector->bridge_hpd = bridge;
680 if (bridge->ops & DRM_BRIDGE_OP_DETECT)
681 bridge_connector->bridge_detect = bridge;
682 if (bridge->ops & DRM_BRIDGE_OP_MODES)
683 bridge_connector->bridge_modes = bridge;
684 if (bridge->ops & DRM_BRIDGE_OP_HDMI) {
685 if (bridge_connector->bridge_hdmi)
686 return ERR_PTR(-EBUSY);
687 if (!bridge->funcs->hdmi_write_infoframe ||
688 !bridge->funcs->hdmi_clear_infoframe)
689 return ERR_PTR(-EINVAL);
690
691 bridge_connector->bridge_hdmi = bridge;
692
693 if (bridge->supported_formats)
694 supported_formats = bridge->supported_formats;
695 if (bridge->max_bpc)
696 max_bpc = bridge->max_bpc;
697 }
698
699 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO) {
700 if (bridge_connector->bridge_hdmi_audio)
701 return ERR_PTR(-EBUSY);
702
703 if (bridge_connector->bridge_dp_audio)
704 return ERR_PTR(-EBUSY);
705
706 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
707 !bridge->hdmi_audio_spdif_playback)
708 return ERR_PTR(-EINVAL);
709
710 if (!bridge->funcs->hdmi_audio_prepare ||
711 !bridge->funcs->hdmi_audio_shutdown)
712 return ERR_PTR(-EINVAL);
713
714 bridge_connector->bridge_hdmi_audio = bridge;
715 }
716
717 if (bridge->ops & DRM_BRIDGE_OP_DP_AUDIO) {
718 if (bridge_connector->bridge_dp_audio)
719 return ERR_PTR(-EBUSY);
720
721 if (bridge_connector->bridge_hdmi_audio)
722 return ERR_PTR(-EBUSY);
723
724 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
725 !bridge->hdmi_audio_spdif_playback)
726 return ERR_PTR(-EINVAL);
727
728 if (!bridge->funcs->dp_audio_prepare ||
729 !bridge->funcs->dp_audio_shutdown)
730 return ERR_PTR(-EINVAL);
731
732 bridge_connector->bridge_dp_audio = bridge;
733 }
734
735 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
736 if (bridge_connector->bridge_hdmi_cec)
737 return ERR_PTR(-EBUSY);
738
739 bridge_connector->bridge_hdmi_cec = bridge;
740 }
741
742 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
743 if (bridge_connector->bridge_hdmi_cec)
744 return ERR_PTR(-EBUSY);
745
746 bridge_connector->bridge_hdmi_cec = bridge;
747
748 if (!bridge->funcs->hdmi_cec_enable ||
749 !bridge->funcs->hdmi_cec_log_addr ||
750 !bridge->funcs->hdmi_cec_transmit)
751 return ERR_PTR(-EINVAL);
752 }
753
754 if (drm_bridge_is_last(bridge))
755 connector_type = bridge->type;
756
757 #ifdef CONFIG_OF
758 if (drm_bridge_is_last(bridge) && bridge->of_node)
759 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node));
760 #endif
761
762 if (bridge->ddc)
763 ddc = bridge->ddc;
764
765 if (drm_bridge_is_panel(bridge))
766 panel_bridge = bridge;
767
768 if (bridge->support_hdcp)
769 support_hdcp = true;
770 }
771
772 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
773 return ERR_PTR(-EINVAL);
774
775 if (bridge_connector->bridge_hdmi) {
776 if (!connector->ycbcr_420_allowed)
777 supported_formats &= ~BIT(HDMI_COLORSPACE_YUV420);
778
779 ret = drmm_connector_hdmi_init(drm, connector,
780 bridge_connector->bridge_hdmi->vendor,
781 bridge_connector->bridge_hdmi->product,
782 &drm_bridge_connector_funcs,
783 &drm_bridge_connector_hdmi_funcs,
784 connector_type, ddc,
785 supported_formats,
786 max_bpc);
787 if (ret)
788 return ERR_PTR(ret);
789 } else {
790 ret = drmm_connector_init(drm, connector,
791 &drm_bridge_connector_funcs,
792 connector_type, ddc);
793 if (ret)
794 return ERR_PTR(ret);
795 }
796
797 if (bridge_connector->bridge_hdmi_audio ||
798 bridge_connector->bridge_dp_audio) {
799 struct device *dev;
800 struct drm_bridge *bridge;
801
802 if (bridge_connector->bridge_hdmi_audio)
803 bridge = bridge_connector->bridge_hdmi_audio;
804 else
805 bridge = bridge_connector->bridge_dp_audio;
806
807 dev = bridge->hdmi_audio_dev;
808
809 ret = drm_connector_hdmi_audio_init(connector, dev,
810 &drm_bridge_connector_hdmi_audio_funcs,
811 bridge->hdmi_audio_max_i2s_playback_channels,
812 bridge->hdmi_audio_i2s_formats,
813 bridge->hdmi_audio_spdif_playback,
814 bridge->hdmi_audio_dai_port);
815 if (ret)
816 return ERR_PTR(ret);
817 }
818
819 if (bridge_connector->bridge_hdmi_cec &&
820 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
821 bridge = bridge_connector->bridge_hdmi_cec;
822
823 ret = drmm_connector_hdmi_cec_notifier_register(connector,
824 NULL,
825 bridge->hdmi_cec_dev);
826 if (ret)
827 return ERR_PTR(ret);
828 }
829
830 if (bridge_connector->bridge_hdmi_cec &&
831 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
832 bridge = bridge_connector->bridge_hdmi_cec;
833
834 ret = drmm_connector_hdmi_cec_register(connector,
835 &drm_bridge_connector_hdmi_cec_funcs,
836 bridge->hdmi_cec_adapter_name,
837 bridge->hdmi_cec_available_las,
838 bridge->hdmi_cec_dev);
839 if (ret)
840 return ERR_PTR(ret);
841 }
842
843 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs);
844
845 if (bridge_connector->bridge_hpd)
846 connector->polled = DRM_CONNECTOR_POLL_HPD;
847 else if (bridge_connector->bridge_detect)
848 connector->polled = DRM_CONNECTOR_POLL_CONNECT
849 | DRM_CONNECTOR_POLL_DISCONNECT;
850
851 if (panel_bridge)
852 drm_panel_bridge_set_orientation(connector, panel_bridge);
853
854 if (support_hdcp && IS_REACHABLE(CONFIG_DRM_DISPLAY_HELPER) &&
855 IS_ENABLED(CONFIG_DRM_DISPLAY_HDCP_HELPER))
856 drm_connector_attach_content_protection_property(connector, true);
857
858 return connector;
859 }
860 EXPORT_SYMBOL_GPL(drm_bridge_connector_init);
861