Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
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 * @hdmi_funcs:
129 *
130 * The particular &drm_connector_hdmi_funcs implementation for this
131 * bridge connector.
132 */
133 struct drm_connector_hdmi_funcs hdmi_funcs;
134};
135
136#define to_drm_bridge_connector(x) \
137 container_of(x, struct drm_bridge_connector, base)
138
139/* -----------------------------------------------------------------------------
140 * Bridge Connector Hot-Plug Handling
141 */
142
143static void drm_bridge_connector_hpd_notify(struct drm_connector *connector,
144 enum drm_connector_status status)
145{
146 struct drm_bridge_connector *bridge_connector =
147 to_drm_bridge_connector(connector);
148
149 /* Notify all bridges in the pipeline of hotplug events. */
150 drm_for_each_bridge_in_chain_scoped(bridge_connector->encoder, bridge) {
151 if (bridge->funcs->hpd_notify)
152 bridge->funcs->hpd_notify(bridge, connector, status);
153 }
154}
155
156static void drm_bridge_connector_handle_hpd(struct drm_bridge_connector *drm_bridge_connector,
157 enum drm_connector_status status)
158{
159 struct drm_connector *connector = &drm_bridge_connector->base;
160 struct drm_device *dev = connector->dev;
161
162 mutex_lock(&dev->mode_config.mutex);
163 connector->status = status;
164 mutex_unlock(&dev->mode_config.mutex);
165
166 drm_bridge_connector_hpd_notify(connector, status);
167
168 drm_kms_helper_connector_hotplug_event(connector);
169}
170
171static void drm_bridge_connector_hpd_cb(void *cb_data,
172 enum drm_connector_status status)
173{
174 drm_bridge_connector_handle_hpd(cb_data, status);
175}
176
177static void drm_bridge_connector_oob_hotplug_event(struct drm_connector *connector,
178 enum drm_connector_status status)
179{
180 struct drm_bridge_connector *bridge_connector =
181 to_drm_bridge_connector(connector);
182
183 drm_bridge_connector_handle_hpd(bridge_connector, status);
184}
185
186static void drm_bridge_connector_enable_hpd(struct drm_connector *connector)
187{
188 struct drm_bridge_connector *bridge_connector =
189 to_drm_bridge_connector(connector);
190 struct drm_bridge *hpd = bridge_connector->bridge_hpd;
191
192 if (hpd)
193 drm_bridge_hpd_enable(hpd, drm_bridge_connector_hpd_cb,
194 bridge_connector);
195}
196
197static void drm_bridge_connector_disable_hpd(struct drm_connector *connector)
198{
199 struct drm_bridge_connector *bridge_connector =
200 to_drm_bridge_connector(connector);
201 struct drm_bridge *hpd = bridge_connector->bridge_hpd;
202
203 if (hpd)
204 drm_bridge_hpd_disable(hpd);
205}
206
207/* -----------------------------------------------------------------------------
208 * Bridge Connector Functions
209 */
210
211static enum drm_connector_status
212drm_bridge_connector_detect(struct drm_connector *connector, bool force)
213{
214 struct drm_bridge_connector *bridge_connector =
215 to_drm_bridge_connector(connector);
216 struct drm_bridge *detect = bridge_connector->bridge_detect;
217 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi;
218 enum drm_connector_status status;
219
220 if (detect) {
221 status = detect->funcs->detect(detect, connector);
222
223 if (hdmi)
224 drm_atomic_helper_connector_hdmi_hotplug(connector, status);
225
226 drm_bridge_connector_hpd_notify(connector, status);
227 } else {
228 switch (connector->connector_type) {
229 case DRM_MODE_CONNECTOR_DPI:
230 case DRM_MODE_CONNECTOR_LVDS:
231 case DRM_MODE_CONNECTOR_DSI:
232 case DRM_MODE_CONNECTOR_eDP:
233 status = connector_status_connected;
234 break;
235 default:
236 status = connector_status_unknown;
237 break;
238 }
239 }
240
241 return status;
242}
243
244static void drm_bridge_connector_force(struct drm_connector *connector)
245{
246 struct drm_bridge_connector *bridge_connector =
247 to_drm_bridge_connector(connector);
248 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi;
249
250 if (hdmi)
251 drm_atomic_helper_connector_hdmi_force(connector);
252}
253
254static void drm_bridge_connector_debugfs_init(struct drm_connector *connector,
255 struct dentry *root)
256{
257 struct drm_bridge_connector *bridge_connector =
258 to_drm_bridge_connector(connector);
259 struct drm_encoder *encoder = bridge_connector->encoder;
260 struct drm_bridge *bridge;
261
262 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) {
263 if (bridge->funcs->debugfs_init)
264 bridge->funcs->debugfs_init(bridge, root);
265 }
266}
267
268static void drm_bridge_connector_reset(struct drm_connector *connector)
269{
270 struct drm_bridge_connector *bridge_connector =
271 to_drm_bridge_connector(connector);
272
273 drm_atomic_helper_connector_reset(connector);
274 if (bridge_connector->bridge_hdmi)
275 __drm_atomic_helper_connector_hdmi_reset(connector,
276 connector->state);
277}
278
279static const struct drm_connector_funcs drm_bridge_connector_funcs = {
280 .reset = drm_bridge_connector_reset,
281 .detect = drm_bridge_connector_detect,
282 .force = drm_bridge_connector_force,
283 .fill_modes = drm_helper_probe_single_connector_modes,
284 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state,
285 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state,
286 .debugfs_init = drm_bridge_connector_debugfs_init,
287 .oob_hotplug_event = drm_bridge_connector_oob_hotplug_event,
288};
289
290/* -----------------------------------------------------------------------------
291 * Bridge Connector Helper Functions
292 */
293
294static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector,
295 struct drm_bridge *bridge)
296{
297 enum drm_connector_status status;
298 const struct drm_edid *drm_edid;
299 int n;
300
301 status = drm_bridge_connector_detect(connector, false);
302 if (status != connector_status_connected)
303 goto no_edid;
304
305 drm_edid = drm_bridge_edid_read(bridge, connector);
306 if (!drm_edid_valid(drm_edid)) {
307 drm_edid_free(drm_edid);
308 goto no_edid;
309 }
310
311 drm_edid_connector_update(connector, drm_edid);
312 n = drm_edid_connector_add_modes(connector);
313
314 drm_edid_free(drm_edid);
315 return n;
316
317no_edid:
318 drm_edid_connector_update(connector, NULL);
319 return 0;
320}
321
322static int drm_bridge_connector_get_modes(struct drm_connector *connector)
323{
324 struct drm_bridge_connector *bridge_connector =
325 to_drm_bridge_connector(connector);
326 struct drm_bridge *bridge;
327
328 /*
329 * If there is a HDMI bridge, EDID has been updated as a part of
330 * the .detect(). Just update the modes here.
331 */
332 bridge = bridge_connector->bridge_hdmi;
333 if (bridge)
334 return drm_edid_connector_add_modes(connector);
335
336 /*
337 * If display exposes EDID, then we parse that in the normal way to
338 * build table of supported modes.
339 */
340 bridge = bridge_connector->bridge_edid;
341 if (bridge)
342 return drm_bridge_connector_get_modes_edid(connector, bridge);
343
344 /*
345 * Otherwise if the display pipeline reports modes (e.g. with a fixed
346 * resolution panel or an analog TV output), query it.
347 */
348 bridge = bridge_connector->bridge_modes;
349 if (bridge)
350 return bridge->funcs->get_modes(bridge, connector);
351
352 /*
353 * We can't retrieve modes, which can happen for instance for a DVI or
354 * VGA output with the DDC bus unconnected. The KMS core will add the
355 * default modes.
356 */
357 return 0;
358}
359
360static enum drm_mode_status
361drm_bridge_connector_mode_valid(struct drm_connector *connector,
362 const struct drm_display_mode *mode)
363{
364 struct drm_bridge_connector *bridge_connector =
365 to_drm_bridge_connector(connector);
366
367 if (bridge_connector->bridge_hdmi)
368 return drm_hdmi_connector_mode_valid(connector, mode);
369
370 return MODE_OK;
371}
372
373static int drm_bridge_connector_atomic_check(struct drm_connector *connector,
374 struct drm_atomic_state *state)
375{
376 struct drm_bridge_connector *bridge_connector =
377 to_drm_bridge_connector(connector);
378
379 if (bridge_connector->bridge_hdmi)
380 return drm_atomic_helper_connector_hdmi_check(connector, state);
381
382 return 0;
383}
384
385static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = {
386 .get_modes = drm_bridge_connector_get_modes,
387 .mode_valid = drm_bridge_connector_mode_valid,
388 .enable_hpd = drm_bridge_connector_enable_hpd,
389 .disable_hpd = drm_bridge_connector_disable_hpd,
390 .atomic_check = drm_bridge_connector_atomic_check,
391};
392
393static enum drm_mode_status
394drm_bridge_connector_tmds_char_rate_valid(const struct drm_connector *connector,
395 const struct drm_display_mode *mode,
396 unsigned long long tmds_rate)
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 MODE_ERROR;
405
406 if (bridge->funcs->hdmi_tmds_char_rate_valid)
407 return bridge->funcs->hdmi_tmds_char_rate_valid(bridge, mode, tmds_rate);
408 else
409 return MODE_OK;
410}
411
412static int drm_bridge_connector_clear_avi_infoframe(struct drm_connector *connector)
413{
414 struct drm_bridge_connector *bridge_connector =
415 to_drm_bridge_connector(connector);
416 struct drm_bridge *bridge;
417
418 bridge = bridge_connector->bridge_hdmi;
419 if (!bridge)
420 return -EINVAL;
421
422 return bridge->funcs->hdmi_clear_avi_infoframe(bridge);
423}
424
425static int drm_bridge_connector_write_avi_infoframe(struct drm_connector *connector,
426 const u8 *buffer, size_t len)
427{
428 struct drm_bridge_connector *bridge_connector =
429 to_drm_bridge_connector(connector);
430 struct drm_bridge *bridge;
431
432 bridge = bridge_connector->bridge_hdmi;
433 if (!bridge)
434 return -EINVAL;
435
436 return bridge->funcs->hdmi_write_avi_infoframe(bridge, buffer, len);
437}
438
439static int drm_bridge_connector_clear_hdmi_infoframe(struct drm_connector *connector)
440{
441 struct drm_bridge_connector *bridge_connector =
442 to_drm_bridge_connector(connector);
443 struct drm_bridge *bridge;
444
445 bridge = bridge_connector->bridge_hdmi;
446 if (!bridge)
447 return -EINVAL;
448
449 return bridge->funcs->hdmi_clear_hdmi_infoframe(bridge);
450}
451
452static int drm_bridge_connector_write_hdmi_infoframe(struct drm_connector *connector,
453 const u8 *buffer, size_t len)
454{
455 struct drm_bridge_connector *bridge_connector =
456 to_drm_bridge_connector(connector);
457 struct drm_bridge *bridge;
458
459 bridge = bridge_connector->bridge_hdmi;
460 if (!bridge)
461 return -EINVAL;
462
463 return bridge->funcs->hdmi_write_hdmi_infoframe(bridge, buffer, len);
464}
465
466static int drm_bridge_connector_clear_audio_infoframe(struct drm_connector *connector)
467{
468 struct drm_bridge_connector *bridge_connector =
469 to_drm_bridge_connector(connector);
470 struct drm_bridge *bridge;
471
472 bridge = bridge_connector->bridge_hdmi;
473 if (!bridge)
474 return -EINVAL;
475
476 return bridge->funcs->hdmi_clear_audio_infoframe(bridge);
477}
478
479static int drm_bridge_connector_write_audio_infoframe(struct drm_connector *connector,
480 const u8 *buffer, size_t len)
481{
482 struct drm_bridge_connector *bridge_connector =
483 to_drm_bridge_connector(connector);
484 struct drm_bridge *bridge;
485
486 bridge = bridge_connector->bridge_hdmi;
487 if (!bridge)
488 return -EINVAL;
489
490 return bridge->funcs->hdmi_write_audio_infoframe(bridge, buffer, len);
491}
492
493static int drm_bridge_connector_clear_hdr_drm_infoframe(struct drm_connector *connector)
494{
495 struct drm_bridge_connector *bridge_connector =
496 to_drm_bridge_connector(connector);
497 struct drm_bridge *bridge;
498
499 bridge = bridge_connector->bridge_hdmi;
500 if (!bridge)
501 return -EINVAL;
502
503 return bridge->funcs->hdmi_clear_hdr_drm_infoframe(bridge);
504}
505
506static int drm_bridge_connector_write_hdr_drm_infoframe(struct drm_connector *connector,
507 const u8 *buffer, size_t len)
508{
509 struct drm_bridge_connector *bridge_connector =
510 to_drm_bridge_connector(connector);
511 struct drm_bridge *bridge;
512
513 bridge = bridge_connector->bridge_hdmi;
514 if (!bridge)
515 return -EINVAL;
516
517 return bridge->funcs->hdmi_write_hdr_drm_infoframe(bridge, buffer, len);
518}
519
520static int drm_bridge_connector_clear_spd_infoframe(struct drm_connector *connector)
521{
522 struct drm_bridge_connector *bridge_connector =
523 to_drm_bridge_connector(connector);
524 struct drm_bridge *bridge;
525
526 bridge = bridge_connector->bridge_hdmi;
527 if (!bridge)
528 return -EINVAL;
529
530 return bridge->funcs->hdmi_clear_spd_infoframe(bridge);
531}
532
533static int drm_bridge_connector_write_spd_infoframe(struct drm_connector *connector,
534 const u8 *buffer, size_t len)
535{
536 struct drm_bridge_connector *bridge_connector =
537 to_drm_bridge_connector(connector);
538 struct drm_bridge *bridge;
539
540 bridge = bridge_connector->bridge_hdmi;
541 if (!bridge)
542 return -EINVAL;
543
544 return bridge->funcs->hdmi_write_spd_infoframe(bridge, buffer, len);
545}
546
547static const struct drm_edid *
548drm_bridge_connector_read_edid(struct drm_connector *connector)
549{
550 struct drm_bridge_connector *bridge_connector =
551 to_drm_bridge_connector(connector);
552 struct drm_bridge *bridge;
553
554 bridge = bridge_connector->bridge_edid;
555 if (!bridge)
556 return NULL;
557
558 return drm_bridge_edid_read(bridge, connector);
559}
560
561static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = {
562 .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid,
563 .read_edid = drm_bridge_connector_read_edid,
564 .avi = {
565 .clear_infoframe = drm_bridge_connector_clear_avi_infoframe,
566 .write_infoframe = drm_bridge_connector_write_avi_infoframe,
567 },
568 .hdmi = {
569 .clear_infoframe = drm_bridge_connector_clear_hdmi_infoframe,
570 .write_infoframe = drm_bridge_connector_write_hdmi_infoframe,
571 },
572 /* audio, hdr_drm and spd are set dynamically during init */
573};
574
575static const struct drm_connector_infoframe_funcs drm_bridge_connector_hdmi_audio_infoframe = {
576 .clear_infoframe = drm_bridge_connector_clear_audio_infoframe,
577 .write_infoframe = drm_bridge_connector_write_audio_infoframe,
578};
579
580static const struct drm_connector_infoframe_funcs drm_bridge_connector_hdmi_hdr_drm_infoframe = {
581 .clear_infoframe = drm_bridge_connector_clear_hdr_drm_infoframe,
582 .write_infoframe = drm_bridge_connector_write_hdr_drm_infoframe,
583};
584
585static const struct drm_connector_infoframe_funcs drm_bridge_connector_hdmi_spd_infoframe = {
586 .clear_infoframe = drm_bridge_connector_clear_spd_infoframe,
587 .write_infoframe = drm_bridge_connector_write_spd_infoframe,
588};
589
590static int drm_bridge_connector_audio_startup(struct drm_connector *connector)
591{
592 struct drm_bridge_connector *bridge_connector =
593 to_drm_bridge_connector(connector);
594 struct drm_bridge *bridge;
595
596 if (bridge_connector->bridge_hdmi_audio) {
597 bridge = bridge_connector->bridge_hdmi_audio;
598
599 if (!bridge->funcs->hdmi_audio_startup)
600 return 0;
601
602 return bridge->funcs->hdmi_audio_startup(bridge, connector);
603 }
604
605 if (bridge_connector->bridge_dp_audio) {
606 bridge = bridge_connector->bridge_dp_audio;
607
608 if (!bridge->funcs->dp_audio_startup)
609 return 0;
610
611 return bridge->funcs->dp_audio_startup(bridge, connector);
612 }
613
614 return -EINVAL;
615}
616
617static int drm_bridge_connector_audio_prepare(struct drm_connector *connector,
618 struct hdmi_codec_daifmt *fmt,
619 struct hdmi_codec_params *hparms)
620{
621 struct drm_bridge_connector *bridge_connector =
622 to_drm_bridge_connector(connector);
623 struct drm_bridge *bridge;
624
625 if (bridge_connector->bridge_hdmi_audio) {
626 bridge = bridge_connector->bridge_hdmi_audio;
627
628 return bridge->funcs->hdmi_audio_prepare(bridge, connector, fmt, hparms);
629 }
630
631 if (bridge_connector->bridge_dp_audio) {
632 bridge = bridge_connector->bridge_dp_audio;
633
634 return bridge->funcs->dp_audio_prepare(bridge, connector, fmt, hparms);
635 }
636
637 return -EINVAL;
638}
639
640static void drm_bridge_connector_audio_shutdown(struct drm_connector *connector)
641{
642 struct drm_bridge_connector *bridge_connector =
643 to_drm_bridge_connector(connector);
644 struct drm_bridge *bridge;
645
646 if (bridge_connector->bridge_hdmi_audio) {
647 bridge = bridge_connector->bridge_hdmi_audio;
648 bridge->funcs->hdmi_audio_shutdown(bridge, connector);
649 }
650
651 if (bridge_connector->bridge_dp_audio) {
652 bridge = bridge_connector->bridge_dp_audio;
653 bridge->funcs->dp_audio_shutdown(bridge, connector);
654 }
655}
656
657static int drm_bridge_connector_audio_mute_stream(struct drm_connector *connector,
658 bool enable, int direction)
659{
660 struct drm_bridge_connector *bridge_connector =
661 to_drm_bridge_connector(connector);
662 struct drm_bridge *bridge;
663
664 if (bridge_connector->bridge_hdmi_audio) {
665 bridge = bridge_connector->bridge_hdmi_audio;
666
667 if (!bridge->funcs->hdmi_audio_mute_stream)
668 return -ENOTSUPP;
669
670 return bridge->funcs->hdmi_audio_mute_stream(bridge, connector,
671 enable, direction);
672 }
673
674 if (bridge_connector->bridge_dp_audio) {
675 bridge = bridge_connector->bridge_dp_audio;
676
677 if (!bridge->funcs->dp_audio_mute_stream)
678 return -ENOTSUPP;
679
680 return bridge->funcs->dp_audio_mute_stream(bridge, connector,
681 enable, direction);
682 }
683
684 return -EINVAL;
685}
686
687static const struct drm_connector_hdmi_audio_funcs drm_bridge_connector_hdmi_audio_funcs = {
688 .startup = drm_bridge_connector_audio_startup,
689 .prepare = drm_bridge_connector_audio_prepare,
690 .shutdown = drm_bridge_connector_audio_shutdown,
691 .mute_stream = drm_bridge_connector_audio_mute_stream,
692};
693
694static int drm_bridge_connector_hdmi_cec_enable(struct drm_connector *connector, bool enable)
695{
696 struct drm_bridge_connector *bridge_connector =
697 to_drm_bridge_connector(connector);
698 struct drm_bridge *bridge;
699
700 bridge = bridge_connector->bridge_hdmi_cec;
701
702 return bridge->funcs->hdmi_cec_enable(bridge, enable);
703}
704
705static int drm_bridge_connector_hdmi_cec_log_addr(struct drm_connector *connector, u8 logical_addr)
706{
707 struct drm_bridge_connector *bridge_connector =
708 to_drm_bridge_connector(connector);
709 struct drm_bridge *bridge;
710
711 bridge = bridge_connector->bridge_hdmi_cec;
712
713 return bridge->funcs->hdmi_cec_log_addr(bridge, logical_addr);
714}
715
716static int drm_bridge_connector_hdmi_cec_transmit(struct drm_connector *connector,
717 u8 attempts,
718 u32 signal_free_time,
719 struct cec_msg *msg)
720{
721 struct drm_bridge_connector *bridge_connector =
722 to_drm_bridge_connector(connector);
723 struct drm_bridge *bridge;
724
725 bridge = bridge_connector->bridge_hdmi_cec;
726
727 return bridge->funcs->hdmi_cec_transmit(bridge, attempts,
728 signal_free_time,
729 msg);
730}
731
732static int drm_bridge_connector_hdmi_cec_init(struct drm_connector *connector)
733{
734 struct drm_bridge_connector *bridge_connector =
735 to_drm_bridge_connector(connector);
736 struct drm_bridge *bridge;
737
738 bridge = bridge_connector->bridge_hdmi_cec;
739
740 if (!bridge->funcs->hdmi_cec_init)
741 return 0;
742
743 return bridge->funcs->hdmi_cec_init(bridge, connector);
744}
745
746static const struct drm_connector_hdmi_cec_funcs drm_bridge_connector_hdmi_cec_funcs = {
747 .init = drm_bridge_connector_hdmi_cec_init,
748 .enable = drm_bridge_connector_hdmi_cec_enable,
749 .log_addr = drm_bridge_connector_hdmi_cec_log_addr,
750 .transmit = drm_bridge_connector_hdmi_cec_transmit,
751};
752
753/* -----------------------------------------------------------------------------
754 * Bridge Connector Initialisation
755 */
756
757static void drm_bridge_connector_put_bridges(struct drm_device *dev, void *data)
758{
759 struct drm_bridge_connector *bridge_connector = (struct drm_bridge_connector *)data;
760
761 drm_bridge_put(bridge_connector->bridge_edid);
762 drm_bridge_put(bridge_connector->bridge_hpd);
763 drm_bridge_put(bridge_connector->bridge_detect);
764 drm_bridge_put(bridge_connector->bridge_modes);
765 drm_bridge_put(bridge_connector->bridge_hdmi);
766 drm_bridge_put(bridge_connector->bridge_hdmi_audio);
767 drm_bridge_put(bridge_connector->bridge_dp_audio);
768 drm_bridge_put(bridge_connector->bridge_hdmi_cec);
769}
770
771/**
772 * drm_bridge_connector_init - Initialise a connector for a chain of bridges
773 * @drm: the DRM device
774 * @encoder: the encoder where the bridge chain starts
775 *
776 * Allocate, initialise and register a &drm_bridge_connector with the @drm
777 * device. The connector is associated with a chain of bridges that starts at
778 * the @encoder. All bridges in the chain shall report bridge operation flags
779 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of
780 * them may create a DRM connector directly.
781 *
782 * Returns a pointer to the new connector on success, or a negative error
783 * pointer otherwise.
784 */
785struct drm_connector *drm_bridge_connector_init(struct drm_device *drm,
786 struct drm_encoder *encoder)
787{
788 struct drm_bridge_connector *bridge_connector;
789 struct drm_connector *connector;
790 struct i2c_adapter *ddc = NULL;
791 struct drm_bridge *panel_bridge __free(drm_bridge_put) = NULL;
792 unsigned int supported_formats = BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444);
793 unsigned int max_bpc = 8;
794 bool support_hdcp = false;
795 int connector_type;
796 int ret;
797
798 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL);
799 if (!bridge_connector)
800 return ERR_PTR(-ENOMEM);
801
802 ret = drmm_add_action(drm, drm_bridge_connector_put_bridges, bridge_connector);
803 if (ret)
804 return ERR_PTR(ret);
805
806 bridge_connector->encoder = encoder;
807
808 /*
809 * TODO: Handle doublescan_allowed and stereo_allowed.
810 */
811 connector = &bridge_connector->base;
812 connector->interlace_allowed = true;
813 connector->ycbcr_420_allowed = true;
814
815 /*
816 * Initialise connector status handling. First locate the furthest
817 * bridges in the pipeline that support HPD and output detection. Then
818 * initialise the connector polling mode, using HPD if available and
819 * falling back to polling if supported. If neither HPD nor output
820 * detection are available, we don't support hotplug detection at all.
821 */
822 connector_type = DRM_MODE_CONNECTOR_Unknown;
823 drm_for_each_bridge_in_chain_scoped(encoder, bridge) {
824 if (!bridge->interlace_allowed)
825 connector->interlace_allowed = false;
826 if (!bridge->ycbcr_420_allowed)
827 connector->ycbcr_420_allowed = false;
828
829 /*
830 * Ensure the last bridge declares OP_EDID or OP_MODES or both.
831 */
832 if (bridge->ops & DRM_BRIDGE_OP_EDID || bridge->ops & DRM_BRIDGE_OP_MODES) {
833 drm_bridge_put(bridge_connector->bridge_edid);
834 bridge_connector->bridge_edid = NULL;
835 drm_bridge_put(bridge_connector->bridge_modes);
836 bridge_connector->bridge_modes = NULL;
837
838 if (bridge->ops & DRM_BRIDGE_OP_EDID)
839 bridge_connector->bridge_edid = drm_bridge_get(bridge);
840 if (bridge->ops & DRM_BRIDGE_OP_MODES)
841 bridge_connector->bridge_modes = drm_bridge_get(bridge);
842 }
843 if (bridge->ops & DRM_BRIDGE_OP_HPD) {
844 drm_bridge_put(bridge_connector->bridge_hpd);
845 bridge_connector->bridge_hpd = drm_bridge_get(bridge);
846 }
847 if (bridge->ops & DRM_BRIDGE_OP_DETECT) {
848 drm_bridge_put(bridge_connector->bridge_detect);
849 bridge_connector->bridge_detect = drm_bridge_get(bridge);
850 }
851 if (bridge->ops & DRM_BRIDGE_OP_HDMI) {
852 if (bridge_connector->bridge_hdmi)
853 return ERR_PTR(-EBUSY);
854 if (!bridge->funcs->hdmi_write_avi_infoframe ||
855 !bridge->funcs->hdmi_clear_avi_infoframe ||
856 !bridge->funcs->hdmi_write_hdmi_infoframe ||
857 !bridge->funcs->hdmi_clear_hdmi_infoframe)
858 return ERR_PTR(-EINVAL);
859
860 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO &&
861 (!bridge->funcs->hdmi_write_audio_infoframe ||
862 !bridge->funcs->hdmi_clear_audio_infoframe))
863 return ERR_PTR(-EINVAL);
864
865 if (bridge->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME &&
866 (!bridge->funcs->hdmi_write_hdr_drm_infoframe ||
867 !bridge->funcs->hdmi_clear_hdr_drm_infoframe))
868 return ERR_PTR(-EINVAL);
869
870 if (bridge->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME &&
871 (!bridge->funcs->hdmi_write_spd_infoframe ||
872 !bridge->funcs->hdmi_clear_spd_infoframe))
873 return ERR_PTR(-EINVAL);
874
875 bridge_connector->bridge_hdmi = drm_bridge_get(bridge);
876
877 if (bridge->supported_formats)
878 supported_formats = bridge->supported_formats;
879 if (bridge->max_bpc)
880 max_bpc = bridge->max_bpc;
881 }
882
883 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO) {
884 if (bridge_connector->bridge_hdmi_audio)
885 return ERR_PTR(-EBUSY);
886
887 if (bridge_connector->bridge_dp_audio)
888 return ERR_PTR(-EBUSY);
889
890 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
891 !bridge->hdmi_audio_spdif_playback)
892 return ERR_PTR(-EINVAL);
893
894 if (!bridge->funcs->hdmi_audio_prepare ||
895 !bridge->funcs->hdmi_audio_shutdown)
896 return ERR_PTR(-EINVAL);
897
898 bridge_connector->bridge_hdmi_audio = drm_bridge_get(bridge);
899 }
900
901 if (bridge->ops & DRM_BRIDGE_OP_DP_AUDIO) {
902 if (bridge_connector->bridge_dp_audio)
903 return ERR_PTR(-EBUSY);
904
905 if (bridge_connector->bridge_hdmi_audio)
906 return ERR_PTR(-EBUSY);
907
908 if (!bridge->hdmi_audio_max_i2s_playback_channels &&
909 !bridge->hdmi_audio_spdif_playback)
910 return ERR_PTR(-EINVAL);
911
912 if (!bridge->funcs->dp_audio_prepare ||
913 !bridge->funcs->dp_audio_shutdown)
914 return ERR_PTR(-EINVAL);
915
916 bridge_connector->bridge_dp_audio = drm_bridge_get(bridge);
917 }
918
919 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
920 if (bridge_connector->bridge_hdmi_cec)
921 return ERR_PTR(-EBUSY);
922
923 bridge_connector->bridge_hdmi_cec = drm_bridge_get(bridge);
924 }
925
926 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
927 if (bridge_connector->bridge_hdmi_cec)
928 return ERR_PTR(-EBUSY);
929
930 bridge_connector->bridge_hdmi_cec = drm_bridge_get(bridge);
931
932 if (!bridge->funcs->hdmi_cec_enable ||
933 !bridge->funcs->hdmi_cec_log_addr ||
934 !bridge->funcs->hdmi_cec_transmit)
935 return ERR_PTR(-EINVAL);
936 }
937
938 if (drm_bridge_is_last(bridge))
939 connector_type = bridge->type;
940
941#ifdef CONFIG_OF
942 if (drm_bridge_is_last(bridge) && bridge->of_node)
943 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node));
944#endif
945
946 if (bridge->ddc)
947 ddc = bridge->ddc;
948
949 if (drm_bridge_is_panel(bridge)) {
950 drm_bridge_put(panel_bridge);
951 panel_bridge = drm_bridge_get(bridge);
952 }
953
954 if (bridge->support_hdcp)
955 support_hdcp = true;
956 }
957
958 if (connector_type == DRM_MODE_CONNECTOR_Unknown)
959 return ERR_PTR(-EINVAL);
960
961 if (bridge_connector->bridge_hdmi) {
962 if (!connector->ycbcr_420_allowed)
963 supported_formats &= ~BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR420);
964
965 bridge_connector->hdmi_funcs = drm_bridge_connector_hdmi_funcs;
966
967 if (bridge_connector->bridge_hdmi->ops & DRM_BRIDGE_OP_HDMI_AUDIO)
968 bridge_connector->hdmi_funcs.audio =
969 drm_bridge_connector_hdmi_audio_infoframe;
970
971 if (bridge_connector->bridge_hdmi->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME)
972 bridge_connector->hdmi_funcs.hdr_drm =
973 drm_bridge_connector_hdmi_hdr_drm_infoframe;
974
975 if (bridge_connector->bridge_hdmi->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME)
976 bridge_connector->hdmi_funcs.spd =
977 drm_bridge_connector_hdmi_spd_infoframe;
978
979 ret = drmm_connector_hdmi_init(drm, connector,
980 bridge_connector->bridge_hdmi->vendor,
981 bridge_connector->bridge_hdmi->product,
982 &drm_bridge_connector_funcs,
983 &bridge_connector->hdmi_funcs,
984 connector_type, ddc,
985 supported_formats,
986 max_bpc);
987 if (ret)
988 return ERR_PTR(ret);
989 } else {
990 ret = drmm_connector_init(drm, connector,
991 &drm_bridge_connector_funcs,
992 connector_type, ddc);
993 if (ret)
994 return ERR_PTR(ret);
995 }
996
997 if (bridge_connector->bridge_hdmi_audio ||
998 bridge_connector->bridge_dp_audio) {
999 struct device *dev;
1000 struct drm_bridge *bridge;
1001
1002 if (bridge_connector->bridge_hdmi_audio)
1003 bridge = bridge_connector->bridge_hdmi_audio;
1004 else
1005 bridge = bridge_connector->bridge_dp_audio;
1006
1007 dev = bridge->hdmi_audio_dev;
1008
1009 ret = drm_connector_hdmi_audio_init(connector, dev,
1010 &drm_bridge_connector_hdmi_audio_funcs,
1011 bridge->hdmi_audio_max_i2s_playback_channels,
1012 bridge->hdmi_audio_i2s_formats,
1013 bridge->hdmi_audio_spdif_playback,
1014 bridge->hdmi_audio_dai_port);
1015 if (ret)
1016 return ERR_PTR(ret);
1017 }
1018
1019 if (bridge_connector->bridge_hdmi_cec &&
1020 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) {
1021 struct drm_bridge *bridge = bridge_connector->bridge_hdmi_cec;
1022
1023 ret = drmm_connector_hdmi_cec_notifier_register(connector,
1024 NULL,
1025 bridge->hdmi_cec_dev);
1026 if (ret)
1027 return ERR_PTR(ret);
1028 }
1029
1030 if (bridge_connector->bridge_hdmi_cec &&
1031 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) {
1032 struct drm_bridge *bridge = bridge_connector->bridge_hdmi_cec;
1033
1034 ret = drmm_connector_hdmi_cec_register(connector,
1035 &drm_bridge_connector_hdmi_cec_funcs,
1036 bridge->hdmi_cec_adapter_name,
1037 bridge->hdmi_cec_available_las,
1038 bridge->hdmi_cec_dev);
1039 if (ret)
1040 return ERR_PTR(ret);
1041 }
1042
1043 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs);
1044
1045 if (bridge_connector->bridge_hpd)
1046 connector->polled = DRM_CONNECTOR_POLL_HPD;
1047 else if (bridge_connector->bridge_detect)
1048 connector->polled = DRM_CONNECTOR_POLL_CONNECT
1049 | DRM_CONNECTOR_POLL_DISCONNECT;
1050
1051 if (panel_bridge)
1052 drm_panel_bridge_set_orientation(connector, panel_bridge);
1053
1054 if (support_hdcp && IS_REACHABLE(CONFIG_DRM_DISPLAY_HELPER) &&
1055 IS_ENABLED(CONFIG_DRM_DISPLAY_HDCP_HELPER))
1056 drm_connector_attach_content_protection_property(connector, true);
1057
1058 return connector;
1059}
1060EXPORT_SYMBOL_GPL(drm_bridge_connector_init);