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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 * 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 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 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 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 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 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 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 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 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 */ 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