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