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