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