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_hdmi_audio_helper.h> 24 #include <drm/display/drm_hdmi_cec_helper.h> 25 #include <drm/display/drm_hdmi_helper.h> 26 #include <drm/display/drm_hdmi_state_helper.h> 27 28 /** 29 * DOC: overview 30 * 31 * The DRM bridge connector helper object provides a DRM connector 32 * implementation that wraps a chain of &struct drm_bridge. The connector 33 * operations are fully implemented based on the operations of the bridges in 34 * the chain, and don't require any intervention from the display controller 35 * driver at runtime. 36 * 37 * To use the helper, display controller drivers create a bridge connector with 38 * a call to drm_bridge_connector_init(). This associates the newly created 39 * connector with the chain of bridges passed to the function and registers it 40 * with the DRM device. At that point the connector becomes fully usable, no 41 * further operation is needed. 42 * 43 * The DRM bridge connector operations are implemented based on the operations 44 * provided by the bridges in the chain. Each connector operation is delegated 45 * to the bridge closest to the connector (at the end of the chain) that 46 * provides the relevant functionality. 47 * 48 * To make use of this helper, all bridges in the chain shall report bridge 49 * operation flags (&drm_bridge->ops) and bridge output type 50 * (&drm_bridge->type), as well as the DRM_BRIDGE_ATTACH_NO_CONNECTOR attach 51 * flag (none of the bridges shall create a DRM connector directly). 52 */ 53 54 /** 55 * struct drm_bridge_connector - A connector backed by a chain of bridges 56 */ 57 struct drm_bridge_connector { 58 /** 59 * @base: The base DRM connector 60 */ 61 struct drm_connector base; 62 /** 63 * @encoder: 64 * 65 * The encoder at the start of the bridges chain. 66 */ 67 struct drm_encoder *encoder; 68 /** 69 * @bridge_edid: 70 * 71 * The last bridge in the chain (closest to the connector) that provides 72 * EDID read support, if any (see &DRM_BRIDGE_OP_EDID). 73 */ 74 struct drm_bridge *bridge_edid; 75 /** 76 * @bridge_hpd: 77 * 78 * The last bridge in the chain (closest to the connector) that provides 79 * hot-plug detection notification, if any (see &DRM_BRIDGE_OP_HPD). 80 */ 81 struct drm_bridge *bridge_hpd; 82 /** 83 * @bridge_detect: 84 * 85 * The last bridge in the chain (closest to the connector) that provides 86 * connector detection, if any (see &DRM_BRIDGE_OP_DETECT). 87 */ 88 struct drm_bridge *bridge_detect; 89 /** 90 * @bridge_modes: 91 * 92 * The last bridge in the chain (closest to the connector) that provides 93 * connector modes detection, if any (see &DRM_BRIDGE_OP_MODES). 94 */ 95 struct drm_bridge *bridge_modes; 96 /** 97 * @bridge_hdmi: 98 * 99 * The bridge in the chain that implements necessary support for the 100 * HDMI connector infrastructure, if any (see &DRM_BRIDGE_OP_HDMI). 101 */ 102 struct drm_bridge *bridge_hdmi; 103 /** 104 * @bridge_hdmi_audio: 105 * 106 * The bridge in the chain that implements necessary support for the 107 * HDMI Audio infrastructure, if any (see &DRM_BRIDGE_OP_HDMI_AUDIO). 108 */ 109 struct drm_bridge *bridge_hdmi_audio; 110 /** 111 * @bridge_dp_audio: 112 * 113 * The bridge in the chain that implements necessary support for the 114 * DisplayPort Audio infrastructure, if any (see 115 * &DRM_BRIDGE_OP_DP_AUDIO). 116 */ 117 struct drm_bridge *bridge_dp_audio; 118 /** 119 * @bridge_hdmi_cec: 120 * 121 * The bridge in the chain that implements CEC support, if any (see 122 * DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER). 123 */ 124 struct drm_bridge *bridge_hdmi_cec; 125 }; 126 127 #define to_drm_bridge_connector(x) \ 128 container_of(x, struct drm_bridge_connector, base) 129 130 /* ----------------------------------------------------------------------------- 131 * Bridge Connector Hot-Plug Handling 132 */ 133 134 static void drm_bridge_connector_hpd_notify(struct drm_connector *connector, 135 enum drm_connector_status status) 136 { 137 struct drm_bridge_connector *bridge_connector = 138 to_drm_bridge_connector(connector); 139 struct drm_bridge *bridge; 140 141 /* Notify all bridges in the pipeline of hotplug events. */ 142 drm_for_each_bridge_in_chain(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 *bridge, *panel_bridge = NULL; 642 unsigned int supported_formats = BIT(HDMI_COLORSPACE_RGB); 643 unsigned int max_bpc = 8; 644 int connector_type; 645 int ret; 646 647 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL); 648 if (!bridge_connector) 649 return ERR_PTR(-ENOMEM); 650 651 bridge_connector->encoder = encoder; 652 653 /* 654 * TODO: Handle doublescan_allowed and stereo_allowed. 655 */ 656 connector = &bridge_connector->base; 657 connector->interlace_allowed = true; 658 connector->ycbcr_420_allowed = true; 659 660 /* 661 * Initialise connector status handling. First locate the furthest 662 * bridges in the pipeline that support HPD and output detection. Then 663 * initialise the connector polling mode, using HPD if available and 664 * falling back to polling if supported. If neither HPD nor output 665 * detection are available, we don't support hotplug detection at all. 666 */ 667 connector_type = DRM_MODE_CONNECTOR_Unknown; 668 drm_for_each_bridge_in_chain(encoder, bridge) { 669 if (!bridge->interlace_allowed) 670 connector->interlace_allowed = false; 671 if (!bridge->ycbcr_420_allowed) 672 connector->ycbcr_420_allowed = false; 673 674 if (bridge->ops & DRM_BRIDGE_OP_EDID) 675 bridge_connector->bridge_edid = bridge; 676 if (bridge->ops & DRM_BRIDGE_OP_HPD) 677 bridge_connector->bridge_hpd = bridge; 678 if (bridge->ops & DRM_BRIDGE_OP_DETECT) 679 bridge_connector->bridge_detect = bridge; 680 if (bridge->ops & DRM_BRIDGE_OP_MODES) 681 bridge_connector->bridge_modes = bridge; 682 if (bridge->ops & DRM_BRIDGE_OP_HDMI) { 683 if (bridge_connector->bridge_hdmi) 684 return ERR_PTR(-EBUSY); 685 if (!bridge->funcs->hdmi_write_infoframe || 686 !bridge->funcs->hdmi_clear_infoframe) 687 return ERR_PTR(-EINVAL); 688 689 bridge_connector->bridge_hdmi = bridge; 690 691 if (bridge->supported_formats) 692 supported_formats = bridge->supported_formats; 693 if (bridge->max_bpc) 694 max_bpc = bridge->max_bpc; 695 } 696 697 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO) { 698 if (bridge_connector->bridge_hdmi_audio) 699 return ERR_PTR(-EBUSY); 700 701 if (bridge_connector->bridge_dp_audio) 702 return ERR_PTR(-EBUSY); 703 704 if (!bridge->hdmi_audio_max_i2s_playback_channels && 705 !bridge->hdmi_audio_spdif_playback) 706 return ERR_PTR(-EINVAL); 707 708 if (!bridge->funcs->hdmi_audio_prepare || 709 !bridge->funcs->hdmi_audio_shutdown) 710 return ERR_PTR(-EINVAL); 711 712 bridge_connector->bridge_hdmi_audio = bridge; 713 } 714 715 if (bridge->ops & DRM_BRIDGE_OP_DP_AUDIO) { 716 if (bridge_connector->bridge_dp_audio) 717 return ERR_PTR(-EBUSY); 718 719 if (bridge_connector->bridge_hdmi_audio) 720 return ERR_PTR(-EBUSY); 721 722 if (!bridge->hdmi_audio_max_i2s_playback_channels && 723 !bridge->hdmi_audio_spdif_playback) 724 return ERR_PTR(-EINVAL); 725 726 if (!bridge->funcs->dp_audio_prepare || 727 !bridge->funcs->dp_audio_shutdown) 728 return ERR_PTR(-EINVAL); 729 730 bridge_connector->bridge_dp_audio = bridge; 731 } 732 733 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) { 734 if (bridge_connector->bridge_hdmi_cec) 735 return ERR_PTR(-EBUSY); 736 737 bridge_connector->bridge_hdmi_cec = bridge; 738 } 739 740 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) { 741 if (bridge_connector->bridge_hdmi_cec) 742 return ERR_PTR(-EBUSY); 743 744 bridge_connector->bridge_hdmi_cec = bridge; 745 746 if (!bridge->funcs->hdmi_cec_enable || 747 !bridge->funcs->hdmi_cec_log_addr || 748 !bridge->funcs->hdmi_cec_transmit) 749 return ERR_PTR(-EINVAL); 750 } 751 752 if (!drm_bridge_get_next_bridge(bridge)) 753 connector_type = bridge->type; 754 755 #ifdef CONFIG_OF 756 if (!drm_bridge_get_next_bridge(bridge) && 757 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 768 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 769 return ERR_PTR(-EINVAL); 770 771 if (bridge_connector->bridge_hdmi) { 772 if (!connector->ycbcr_420_allowed) 773 supported_formats &= ~BIT(HDMI_COLORSPACE_YUV420); 774 775 bridge = bridge_connector->bridge_hdmi; 776 777 ret = drmm_connector_hdmi_init(drm, connector, 778 bridge_connector->bridge_hdmi->vendor, 779 bridge_connector->bridge_hdmi->product, 780 &drm_bridge_connector_funcs, 781 &drm_bridge_connector_hdmi_funcs, 782 connector_type, ddc, 783 supported_formats, 784 max_bpc); 785 if (ret) 786 return ERR_PTR(ret); 787 } else { 788 ret = drmm_connector_init(drm, connector, 789 &drm_bridge_connector_funcs, 790 connector_type, ddc); 791 if (ret) 792 return ERR_PTR(ret); 793 } 794 795 if (bridge_connector->bridge_hdmi_audio || 796 bridge_connector->bridge_dp_audio) { 797 struct device *dev; 798 struct drm_bridge *bridge; 799 800 if (bridge_connector->bridge_hdmi_audio) 801 bridge = bridge_connector->bridge_hdmi_audio; 802 else 803 bridge = bridge_connector->bridge_dp_audio; 804 805 dev = bridge->hdmi_audio_dev; 806 807 ret = drm_connector_hdmi_audio_init(connector, dev, 808 &drm_bridge_connector_hdmi_audio_funcs, 809 bridge->hdmi_audio_max_i2s_playback_channels, 810 bridge->hdmi_audio_i2s_formats, 811 bridge->hdmi_audio_spdif_playback, 812 bridge->hdmi_audio_dai_port); 813 if (ret) 814 return ERR_PTR(ret); 815 } 816 817 if (bridge_connector->bridge_hdmi_cec && 818 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) { 819 ret = drmm_connector_hdmi_cec_notifier_register(connector, 820 NULL, 821 bridge->hdmi_cec_dev); 822 if (ret) 823 return ERR_PTR(ret); 824 } 825 826 if (bridge_connector->bridge_hdmi_cec && 827 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) { 828 ret = drmm_connector_hdmi_cec_register(connector, 829 &drm_bridge_connector_hdmi_cec_funcs, 830 bridge->hdmi_cec_adapter_name, 831 bridge->hdmi_cec_available_las, 832 bridge->hdmi_cec_dev); 833 if (ret) 834 return ERR_PTR(ret); 835 } 836 837 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs); 838 839 if (bridge_connector->bridge_hpd) 840 connector->polled = DRM_CONNECTOR_POLL_HPD; 841 else if (bridge_connector->bridge_detect) 842 connector->polled = DRM_CONNECTOR_POLL_CONNECT 843 | DRM_CONNECTOR_POLL_DISCONNECT; 844 845 if (panel_bridge) 846 drm_panel_bridge_set_orientation(connector, panel_bridge); 847 848 return connector; 849 } 850 EXPORT_SYMBOL_GPL(drm_bridge_connector_init); 851