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 * @hdmi_funcs: 129 * 130 * The particular &drm_connector_hdmi_funcs implementation for this 131 * bridge connector. 132 */ 133 struct drm_connector_hdmi_funcs hdmi_funcs; 134 }; 135 136 #define to_drm_bridge_connector(x) \ 137 container_of(x, struct drm_bridge_connector, base) 138 139 /* ----------------------------------------------------------------------------- 140 * Bridge Connector Hot-Plug Handling 141 */ 142 143 static void drm_bridge_connector_hpd_notify(struct drm_connector *connector, 144 enum drm_connector_status status) 145 { 146 struct drm_bridge_connector *bridge_connector = 147 to_drm_bridge_connector(connector); 148 149 /* Notify all bridges in the pipeline of hotplug events. */ 150 drm_for_each_bridge_in_chain_scoped(bridge_connector->encoder, bridge) { 151 if (bridge->funcs->hpd_notify) 152 bridge->funcs->hpd_notify(bridge, connector, status); 153 } 154 } 155 156 static void drm_bridge_connector_handle_hpd(struct drm_bridge_connector *drm_bridge_connector, 157 enum drm_connector_status status) 158 { 159 struct drm_connector *connector = &drm_bridge_connector->base; 160 struct drm_device *dev = connector->dev; 161 162 mutex_lock(&dev->mode_config.mutex); 163 connector->status = status; 164 mutex_unlock(&dev->mode_config.mutex); 165 166 drm_bridge_connector_hpd_notify(connector, status); 167 168 drm_kms_helper_connector_hotplug_event(connector); 169 } 170 171 static void drm_bridge_connector_hpd_cb(void *cb_data, 172 enum drm_connector_status status) 173 { 174 drm_bridge_connector_handle_hpd(cb_data, status); 175 } 176 177 static void drm_bridge_connector_oob_hotplug_event(struct drm_connector *connector, 178 enum drm_connector_status status) 179 { 180 struct drm_bridge_connector *bridge_connector = 181 to_drm_bridge_connector(connector); 182 183 drm_bridge_connector_handle_hpd(bridge_connector, status); 184 } 185 186 static void drm_bridge_connector_enable_hpd(struct drm_connector *connector) 187 { 188 struct drm_bridge_connector *bridge_connector = 189 to_drm_bridge_connector(connector); 190 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 191 192 if (hpd) 193 drm_bridge_hpd_enable(hpd, drm_bridge_connector_hpd_cb, 194 bridge_connector); 195 } 196 197 static void drm_bridge_connector_disable_hpd(struct drm_connector *connector) 198 { 199 struct drm_bridge_connector *bridge_connector = 200 to_drm_bridge_connector(connector); 201 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 202 203 if (hpd) 204 drm_bridge_hpd_disable(hpd); 205 } 206 207 /* ----------------------------------------------------------------------------- 208 * Bridge Connector Functions 209 */ 210 211 static enum drm_connector_status 212 drm_bridge_connector_detect(struct drm_connector *connector, bool force) 213 { 214 struct drm_bridge_connector *bridge_connector = 215 to_drm_bridge_connector(connector); 216 struct drm_bridge *detect = bridge_connector->bridge_detect; 217 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi; 218 enum drm_connector_status status; 219 220 if (detect) { 221 status = detect->funcs->detect(detect, connector); 222 223 if (hdmi) 224 drm_atomic_helper_connector_hdmi_hotplug(connector, status); 225 226 drm_bridge_connector_hpd_notify(connector, status); 227 } else { 228 switch (connector->connector_type) { 229 case DRM_MODE_CONNECTOR_DPI: 230 case DRM_MODE_CONNECTOR_LVDS: 231 case DRM_MODE_CONNECTOR_DSI: 232 case DRM_MODE_CONNECTOR_eDP: 233 status = connector_status_connected; 234 break; 235 default: 236 status = connector_status_unknown; 237 break; 238 } 239 } 240 241 return status; 242 } 243 244 static void drm_bridge_connector_force(struct drm_connector *connector) 245 { 246 struct drm_bridge_connector *bridge_connector = 247 to_drm_bridge_connector(connector); 248 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi; 249 250 if (hdmi) 251 drm_atomic_helper_connector_hdmi_force(connector); 252 } 253 254 static void drm_bridge_connector_debugfs_init(struct drm_connector *connector, 255 struct dentry *root) 256 { 257 struct drm_bridge_connector *bridge_connector = 258 to_drm_bridge_connector(connector); 259 struct drm_encoder *encoder = bridge_connector->encoder; 260 struct drm_bridge *bridge; 261 262 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) { 263 if (bridge->funcs->debugfs_init) 264 bridge->funcs->debugfs_init(bridge, root); 265 } 266 } 267 268 static void drm_bridge_connector_reset(struct drm_connector *connector) 269 { 270 struct drm_bridge_connector *bridge_connector = 271 to_drm_bridge_connector(connector); 272 273 drm_atomic_helper_connector_reset(connector); 274 if (bridge_connector->bridge_hdmi) 275 __drm_atomic_helper_connector_hdmi_reset(connector, 276 connector->state); 277 } 278 279 static const struct drm_connector_funcs drm_bridge_connector_funcs = { 280 .reset = drm_bridge_connector_reset, 281 .detect = drm_bridge_connector_detect, 282 .force = drm_bridge_connector_force, 283 .fill_modes = drm_helper_probe_single_connector_modes, 284 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 285 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 286 .debugfs_init = drm_bridge_connector_debugfs_init, 287 .oob_hotplug_event = drm_bridge_connector_oob_hotplug_event, 288 }; 289 290 /* ----------------------------------------------------------------------------- 291 * Bridge Connector Helper Functions 292 */ 293 294 static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector, 295 struct drm_bridge *bridge) 296 { 297 enum drm_connector_status status; 298 const struct drm_edid *drm_edid; 299 int n; 300 301 status = drm_bridge_connector_detect(connector, false); 302 if (status != connector_status_connected) 303 goto no_edid; 304 305 drm_edid = drm_bridge_edid_read(bridge, connector); 306 if (!drm_edid_valid(drm_edid)) { 307 drm_edid_free(drm_edid); 308 goto no_edid; 309 } 310 311 drm_edid_connector_update(connector, drm_edid); 312 n = drm_edid_connector_add_modes(connector); 313 314 drm_edid_free(drm_edid); 315 return n; 316 317 no_edid: 318 drm_edid_connector_update(connector, NULL); 319 return 0; 320 } 321 322 static int drm_bridge_connector_get_modes(struct drm_connector *connector) 323 { 324 struct drm_bridge_connector *bridge_connector = 325 to_drm_bridge_connector(connector); 326 struct drm_bridge *bridge; 327 328 /* 329 * If there is a HDMI bridge, EDID has been updated as a part of 330 * the .detect(). Just update the modes here. 331 */ 332 bridge = bridge_connector->bridge_hdmi; 333 if (bridge) 334 return drm_edid_connector_add_modes(connector); 335 336 /* 337 * If display exposes EDID, then we parse that in the normal way to 338 * build table of supported modes. 339 */ 340 bridge = bridge_connector->bridge_edid; 341 if (bridge) 342 return drm_bridge_connector_get_modes_edid(connector, bridge); 343 344 /* 345 * Otherwise if the display pipeline reports modes (e.g. with a fixed 346 * resolution panel or an analog TV output), query it. 347 */ 348 bridge = bridge_connector->bridge_modes; 349 if (bridge) 350 return bridge->funcs->get_modes(bridge, connector); 351 352 /* 353 * We can't retrieve modes, which can happen for instance for a DVI or 354 * VGA output with the DDC bus unconnected. The KMS core will add the 355 * default modes. 356 */ 357 return 0; 358 } 359 360 static enum drm_mode_status 361 drm_bridge_connector_mode_valid(struct drm_connector *connector, 362 const struct drm_display_mode *mode) 363 { 364 struct drm_bridge_connector *bridge_connector = 365 to_drm_bridge_connector(connector); 366 367 if (bridge_connector->bridge_hdmi) 368 return drm_hdmi_connector_mode_valid(connector, mode); 369 370 return MODE_OK; 371 } 372 373 static int drm_bridge_connector_atomic_check(struct drm_connector *connector, 374 struct drm_atomic_commit *state) 375 { 376 struct drm_bridge_connector *bridge_connector = 377 to_drm_bridge_connector(connector); 378 379 if (bridge_connector->bridge_hdmi) 380 return drm_atomic_helper_connector_hdmi_check(connector, state); 381 382 return 0; 383 } 384 385 static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = { 386 .get_modes = drm_bridge_connector_get_modes, 387 .mode_valid = drm_bridge_connector_mode_valid, 388 .enable_hpd = drm_bridge_connector_enable_hpd, 389 .disable_hpd = drm_bridge_connector_disable_hpd, 390 .atomic_check = drm_bridge_connector_atomic_check, 391 }; 392 393 static enum drm_mode_status 394 drm_bridge_connector_tmds_char_rate_valid(const struct drm_connector *connector, 395 const struct drm_display_mode *mode, 396 unsigned long long tmds_rate) 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 MODE_ERROR; 405 406 if (bridge->funcs->hdmi_tmds_char_rate_valid) 407 return bridge->funcs->hdmi_tmds_char_rate_valid(bridge, mode, tmds_rate); 408 else 409 return MODE_OK; 410 } 411 412 static int drm_bridge_connector_clear_avi_infoframe(struct drm_connector *connector) 413 { 414 struct drm_bridge_connector *bridge_connector = 415 to_drm_bridge_connector(connector); 416 struct drm_bridge *bridge; 417 418 bridge = bridge_connector->bridge_hdmi; 419 if (!bridge) 420 return -EINVAL; 421 422 return bridge->funcs->hdmi_clear_avi_infoframe(bridge); 423 } 424 425 static int drm_bridge_connector_write_avi_infoframe(struct drm_connector *connector, 426 const u8 *buffer, size_t len) 427 { 428 struct drm_bridge_connector *bridge_connector = 429 to_drm_bridge_connector(connector); 430 struct drm_bridge *bridge; 431 432 bridge = bridge_connector->bridge_hdmi; 433 if (!bridge) 434 return -EINVAL; 435 436 return bridge->funcs->hdmi_write_avi_infoframe(bridge, buffer, len); 437 } 438 439 static int drm_bridge_connector_clear_hdmi_infoframe(struct drm_connector *connector) 440 { 441 struct drm_bridge_connector *bridge_connector = 442 to_drm_bridge_connector(connector); 443 struct drm_bridge *bridge; 444 445 bridge = bridge_connector->bridge_hdmi; 446 if (!bridge) 447 return -EINVAL; 448 449 return bridge->funcs->hdmi_clear_hdmi_infoframe(bridge); 450 } 451 452 static int drm_bridge_connector_write_hdmi_infoframe(struct drm_connector *connector, 453 const u8 *buffer, size_t len) 454 { 455 struct drm_bridge_connector *bridge_connector = 456 to_drm_bridge_connector(connector); 457 struct drm_bridge *bridge; 458 459 bridge = bridge_connector->bridge_hdmi; 460 if (!bridge) 461 return -EINVAL; 462 463 return bridge->funcs->hdmi_write_hdmi_infoframe(bridge, buffer, len); 464 } 465 466 static int drm_bridge_connector_clear_audio_infoframe(struct drm_connector *connector) 467 { 468 struct drm_bridge_connector *bridge_connector = 469 to_drm_bridge_connector(connector); 470 struct drm_bridge *bridge; 471 472 bridge = bridge_connector->bridge_hdmi; 473 if (!bridge) 474 return -EINVAL; 475 476 return bridge->funcs->hdmi_clear_audio_infoframe(bridge); 477 } 478 479 static int drm_bridge_connector_write_audio_infoframe(struct drm_connector *connector, 480 const u8 *buffer, size_t len) 481 { 482 struct drm_bridge_connector *bridge_connector = 483 to_drm_bridge_connector(connector); 484 struct drm_bridge *bridge; 485 486 bridge = bridge_connector->bridge_hdmi; 487 if (!bridge) 488 return -EINVAL; 489 490 return bridge->funcs->hdmi_write_audio_infoframe(bridge, buffer, len); 491 } 492 493 static int drm_bridge_connector_clear_hdr_drm_infoframe(struct drm_connector *connector) 494 { 495 struct drm_bridge_connector *bridge_connector = 496 to_drm_bridge_connector(connector); 497 struct drm_bridge *bridge; 498 499 bridge = bridge_connector->bridge_hdmi; 500 if (!bridge) 501 return -EINVAL; 502 503 return bridge->funcs->hdmi_clear_hdr_drm_infoframe(bridge); 504 } 505 506 static int drm_bridge_connector_write_hdr_drm_infoframe(struct drm_connector *connector, 507 const u8 *buffer, size_t len) 508 { 509 struct drm_bridge_connector *bridge_connector = 510 to_drm_bridge_connector(connector); 511 struct drm_bridge *bridge; 512 513 bridge = bridge_connector->bridge_hdmi; 514 if (!bridge) 515 return -EINVAL; 516 517 return bridge->funcs->hdmi_write_hdr_drm_infoframe(bridge, buffer, len); 518 } 519 520 static int drm_bridge_connector_clear_spd_infoframe(struct drm_connector *connector) 521 { 522 struct drm_bridge_connector *bridge_connector = 523 to_drm_bridge_connector(connector); 524 struct drm_bridge *bridge; 525 526 bridge = bridge_connector->bridge_hdmi; 527 if (!bridge) 528 return -EINVAL; 529 530 return bridge->funcs->hdmi_clear_spd_infoframe(bridge); 531 } 532 533 static int drm_bridge_connector_write_spd_infoframe(struct drm_connector *connector, 534 const u8 *buffer, size_t len) 535 { 536 struct drm_bridge_connector *bridge_connector = 537 to_drm_bridge_connector(connector); 538 struct drm_bridge *bridge; 539 540 bridge = bridge_connector->bridge_hdmi; 541 if (!bridge) 542 return -EINVAL; 543 544 return bridge->funcs->hdmi_write_spd_infoframe(bridge, buffer, len); 545 } 546 547 static const struct drm_edid * 548 drm_bridge_connector_read_edid(struct drm_connector *connector) 549 { 550 struct drm_bridge_connector *bridge_connector = 551 to_drm_bridge_connector(connector); 552 struct drm_bridge *bridge; 553 554 bridge = bridge_connector->bridge_edid; 555 if (!bridge) 556 return NULL; 557 558 return drm_bridge_edid_read(bridge, connector); 559 } 560 561 static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = { 562 .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid, 563 .read_edid = drm_bridge_connector_read_edid, 564 .avi = { 565 .clear_infoframe = drm_bridge_connector_clear_avi_infoframe, 566 .write_infoframe = drm_bridge_connector_write_avi_infoframe, 567 }, 568 .hdmi = { 569 .clear_infoframe = drm_bridge_connector_clear_hdmi_infoframe, 570 .write_infoframe = drm_bridge_connector_write_hdmi_infoframe, 571 }, 572 /* audio, hdr_drm and spd are set dynamically during init */ 573 }; 574 575 static const struct drm_connector_infoframe_funcs drm_bridge_connector_hdmi_audio_infoframe = { 576 .clear_infoframe = drm_bridge_connector_clear_audio_infoframe, 577 .write_infoframe = drm_bridge_connector_write_audio_infoframe, 578 }; 579 580 static const struct drm_connector_infoframe_funcs drm_bridge_connector_hdmi_hdr_drm_infoframe = { 581 .clear_infoframe = drm_bridge_connector_clear_hdr_drm_infoframe, 582 .write_infoframe = drm_bridge_connector_write_hdr_drm_infoframe, 583 }; 584 585 static const struct drm_connector_infoframe_funcs drm_bridge_connector_hdmi_spd_infoframe = { 586 .clear_infoframe = drm_bridge_connector_clear_spd_infoframe, 587 .write_infoframe = drm_bridge_connector_write_spd_infoframe, 588 }; 589 590 static int drm_bridge_connector_audio_startup(struct drm_connector *connector) 591 { 592 struct drm_bridge_connector *bridge_connector = 593 to_drm_bridge_connector(connector); 594 struct drm_bridge *bridge; 595 596 if (bridge_connector->bridge_hdmi_audio) { 597 bridge = bridge_connector->bridge_hdmi_audio; 598 599 if (!bridge->funcs->hdmi_audio_startup) 600 return 0; 601 602 return bridge->funcs->hdmi_audio_startup(bridge, connector); 603 } 604 605 if (bridge_connector->bridge_dp_audio) { 606 bridge = bridge_connector->bridge_dp_audio; 607 608 if (!bridge->funcs->dp_audio_startup) 609 return 0; 610 611 return bridge->funcs->dp_audio_startup(bridge, connector); 612 } 613 614 return -EINVAL; 615 } 616 617 static int drm_bridge_connector_audio_prepare(struct drm_connector *connector, 618 struct hdmi_codec_daifmt *fmt, 619 struct hdmi_codec_params *hparms) 620 { 621 struct drm_bridge_connector *bridge_connector = 622 to_drm_bridge_connector(connector); 623 struct drm_bridge *bridge; 624 625 if (bridge_connector->bridge_hdmi_audio) { 626 bridge = bridge_connector->bridge_hdmi_audio; 627 628 return bridge->funcs->hdmi_audio_prepare(bridge, connector, fmt, hparms); 629 } 630 631 if (bridge_connector->bridge_dp_audio) { 632 bridge = bridge_connector->bridge_dp_audio; 633 634 return bridge->funcs->dp_audio_prepare(bridge, connector, fmt, hparms); 635 } 636 637 return -EINVAL; 638 } 639 640 static void drm_bridge_connector_audio_shutdown(struct drm_connector *connector) 641 { 642 struct drm_bridge_connector *bridge_connector = 643 to_drm_bridge_connector(connector); 644 struct drm_bridge *bridge; 645 646 if (bridge_connector->bridge_hdmi_audio) { 647 bridge = bridge_connector->bridge_hdmi_audio; 648 bridge->funcs->hdmi_audio_shutdown(bridge, connector); 649 } 650 651 if (bridge_connector->bridge_dp_audio) { 652 bridge = bridge_connector->bridge_dp_audio; 653 bridge->funcs->dp_audio_shutdown(bridge, connector); 654 } 655 } 656 657 static int drm_bridge_connector_audio_mute_stream(struct drm_connector *connector, 658 bool enable, int direction) 659 { 660 struct drm_bridge_connector *bridge_connector = 661 to_drm_bridge_connector(connector); 662 struct drm_bridge *bridge; 663 664 if (bridge_connector->bridge_hdmi_audio) { 665 bridge = bridge_connector->bridge_hdmi_audio; 666 667 if (!bridge->funcs->hdmi_audio_mute_stream) 668 return -ENOTSUPP; 669 670 return bridge->funcs->hdmi_audio_mute_stream(bridge, connector, 671 enable, direction); 672 } 673 674 if (bridge_connector->bridge_dp_audio) { 675 bridge = bridge_connector->bridge_dp_audio; 676 677 if (!bridge->funcs->dp_audio_mute_stream) 678 return -ENOTSUPP; 679 680 return bridge->funcs->dp_audio_mute_stream(bridge, connector, 681 enable, direction); 682 } 683 684 return -EINVAL; 685 } 686 687 static const struct drm_connector_hdmi_audio_funcs drm_bridge_connector_hdmi_audio_funcs = { 688 .startup = drm_bridge_connector_audio_startup, 689 .prepare = drm_bridge_connector_audio_prepare, 690 .shutdown = drm_bridge_connector_audio_shutdown, 691 .mute_stream = drm_bridge_connector_audio_mute_stream, 692 }; 693 694 static int drm_bridge_connector_hdmi_cec_enable(struct drm_connector *connector, bool enable) 695 { 696 struct drm_bridge_connector *bridge_connector = 697 to_drm_bridge_connector(connector); 698 struct drm_bridge *bridge; 699 700 bridge = bridge_connector->bridge_hdmi_cec; 701 702 return bridge->funcs->hdmi_cec_enable(bridge, enable); 703 } 704 705 static int drm_bridge_connector_hdmi_cec_log_addr(struct drm_connector *connector, u8 logical_addr) 706 { 707 struct drm_bridge_connector *bridge_connector = 708 to_drm_bridge_connector(connector); 709 struct drm_bridge *bridge; 710 711 bridge = bridge_connector->bridge_hdmi_cec; 712 713 return bridge->funcs->hdmi_cec_log_addr(bridge, logical_addr); 714 } 715 716 static int drm_bridge_connector_hdmi_cec_transmit(struct drm_connector *connector, 717 u8 attempts, 718 u32 signal_free_time, 719 struct cec_msg *msg) 720 { 721 struct drm_bridge_connector *bridge_connector = 722 to_drm_bridge_connector(connector); 723 struct drm_bridge *bridge; 724 725 bridge = bridge_connector->bridge_hdmi_cec; 726 727 return bridge->funcs->hdmi_cec_transmit(bridge, attempts, 728 signal_free_time, 729 msg); 730 } 731 732 static int drm_bridge_connector_hdmi_cec_init(struct drm_connector *connector) 733 { 734 struct drm_bridge_connector *bridge_connector = 735 to_drm_bridge_connector(connector); 736 struct drm_bridge *bridge; 737 738 bridge = bridge_connector->bridge_hdmi_cec; 739 740 if (!bridge->funcs->hdmi_cec_init) 741 return 0; 742 743 return bridge->funcs->hdmi_cec_init(bridge, connector); 744 } 745 746 static const struct drm_connector_hdmi_cec_funcs drm_bridge_connector_hdmi_cec_funcs = { 747 .init = drm_bridge_connector_hdmi_cec_init, 748 .enable = drm_bridge_connector_hdmi_cec_enable, 749 .log_addr = drm_bridge_connector_hdmi_cec_log_addr, 750 .transmit = drm_bridge_connector_hdmi_cec_transmit, 751 }; 752 753 /* ----------------------------------------------------------------------------- 754 * Bridge Connector Initialisation 755 */ 756 757 static void drm_bridge_connector_put_bridges(struct drm_device *dev, void *data) 758 { 759 struct drm_bridge_connector *bridge_connector = (struct drm_bridge_connector *)data; 760 761 drm_bridge_put(bridge_connector->bridge_edid); 762 drm_bridge_put(bridge_connector->bridge_hpd); 763 drm_bridge_put(bridge_connector->bridge_detect); 764 drm_bridge_put(bridge_connector->bridge_modes); 765 drm_bridge_put(bridge_connector->bridge_hdmi); 766 drm_bridge_put(bridge_connector->bridge_hdmi_audio); 767 drm_bridge_put(bridge_connector->bridge_dp_audio); 768 drm_bridge_put(bridge_connector->bridge_hdmi_cec); 769 } 770 771 /** 772 * drm_bridge_connector_init - Initialise a connector for a chain of bridges 773 * @drm: the DRM device 774 * @encoder: the encoder where the bridge chain starts 775 * 776 * Create a new &drm_bridge_connector for the @drm device. The connector is 777 * allocated, initialised, registered with the @drm device and attached to 778 * @encoder. 779 * 780 * The connector is associated with a chain of bridges that starts at 781 * the @encoder. All bridges in the chain shall report bridge operation flags 782 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of 783 * them may create a DRM connector directly. 784 * 785 * Returns a pointer to the new connector on success, or a negative error 786 * pointer otherwise. 787 */ 788 struct drm_connector *drm_bridge_connector_init(struct drm_device *drm, 789 struct drm_encoder *encoder) 790 { 791 struct drm_bridge_connector *bridge_connector; 792 struct drm_connector *connector; 793 struct i2c_adapter *ddc = NULL; 794 struct drm_bridge *panel_bridge __free(drm_bridge_put) = NULL; 795 unsigned int supported_formats = BIT(DRM_OUTPUT_COLOR_FORMAT_RGB444); 796 unsigned int max_bpc = 8; 797 bool support_hdcp = false; 798 int connector_type; 799 int ret; 800 801 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL); 802 if (!bridge_connector) 803 return ERR_PTR(-ENOMEM); 804 805 ret = drmm_add_action(drm, drm_bridge_connector_put_bridges, bridge_connector); 806 if (ret) 807 return ERR_PTR(ret); 808 809 bridge_connector->encoder = encoder; 810 811 /* 812 * TODO: Handle doublescan_allowed and stereo_allowed. 813 */ 814 connector = &bridge_connector->base; 815 connector->interlace_allowed = true; 816 connector->ycbcr_420_allowed = true; 817 818 /* 819 * Initialise connector status handling. First locate the furthest 820 * bridges in the pipeline that support HPD and output detection. Then 821 * initialise the connector polling mode, using HPD if available and 822 * falling back to polling if supported. If neither HPD nor output 823 * detection are available, we don't support hotplug detection at all. 824 */ 825 connector_type = DRM_MODE_CONNECTOR_Unknown; 826 drm_for_each_bridge_in_chain_scoped(encoder, bridge) { 827 if (!bridge->interlace_allowed) 828 connector->interlace_allowed = false; 829 if (!bridge->ycbcr_420_allowed) 830 connector->ycbcr_420_allowed = false; 831 832 /* 833 * Ensure the last bridge declares OP_EDID or OP_MODES or both. 834 */ 835 if (bridge->ops & DRM_BRIDGE_OP_EDID || bridge->ops & DRM_BRIDGE_OP_MODES) { 836 drm_bridge_put(bridge_connector->bridge_edid); 837 bridge_connector->bridge_edid = NULL; 838 drm_bridge_put(bridge_connector->bridge_modes); 839 bridge_connector->bridge_modes = NULL; 840 841 if (bridge->ops & DRM_BRIDGE_OP_EDID) 842 bridge_connector->bridge_edid = drm_bridge_get(bridge); 843 if (bridge->ops & DRM_BRIDGE_OP_MODES) 844 bridge_connector->bridge_modes = drm_bridge_get(bridge); 845 } 846 if (bridge->ops & DRM_BRIDGE_OP_HPD) { 847 drm_bridge_put(bridge_connector->bridge_hpd); 848 bridge_connector->bridge_hpd = drm_bridge_get(bridge); 849 } 850 if (bridge->ops & DRM_BRIDGE_OP_DETECT) { 851 drm_bridge_put(bridge_connector->bridge_detect); 852 bridge_connector->bridge_detect = drm_bridge_get(bridge); 853 } 854 if (bridge->ops & DRM_BRIDGE_OP_HDMI) { 855 if (bridge_connector->bridge_hdmi) 856 return ERR_PTR(-EBUSY); 857 if (!bridge->funcs->hdmi_write_avi_infoframe || 858 !bridge->funcs->hdmi_clear_avi_infoframe || 859 !bridge->funcs->hdmi_write_hdmi_infoframe || 860 !bridge->funcs->hdmi_clear_hdmi_infoframe) 861 return ERR_PTR(-EINVAL); 862 863 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO && 864 (!bridge->funcs->hdmi_write_audio_infoframe || 865 !bridge->funcs->hdmi_clear_audio_infoframe)) 866 return ERR_PTR(-EINVAL); 867 868 if (bridge->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME && 869 (!bridge->funcs->hdmi_write_hdr_drm_infoframe || 870 !bridge->funcs->hdmi_clear_hdr_drm_infoframe)) 871 return ERR_PTR(-EINVAL); 872 873 if (bridge->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME && 874 (!bridge->funcs->hdmi_write_spd_infoframe || 875 !bridge->funcs->hdmi_clear_spd_infoframe)) 876 return ERR_PTR(-EINVAL); 877 878 bridge_connector->bridge_hdmi = drm_bridge_get(bridge); 879 880 if (bridge->supported_formats) 881 supported_formats = bridge->supported_formats; 882 if (bridge->max_bpc) 883 max_bpc = bridge->max_bpc; 884 } 885 886 if (bridge->ops & DRM_BRIDGE_OP_HDMI_AUDIO) { 887 if (bridge_connector->bridge_hdmi_audio) 888 return ERR_PTR(-EBUSY); 889 890 if (bridge_connector->bridge_dp_audio) 891 return ERR_PTR(-EBUSY); 892 893 if (!bridge->hdmi_audio_max_i2s_playback_channels && 894 !bridge->hdmi_audio_spdif_playback) 895 return ERR_PTR(-EINVAL); 896 897 if (!bridge->funcs->hdmi_audio_prepare || 898 !bridge->funcs->hdmi_audio_shutdown) 899 return ERR_PTR(-EINVAL); 900 901 bridge_connector->bridge_hdmi_audio = drm_bridge_get(bridge); 902 } 903 904 if (bridge->ops & DRM_BRIDGE_OP_DP_AUDIO) { 905 if (bridge_connector->bridge_dp_audio) 906 return ERR_PTR(-EBUSY); 907 908 if (bridge_connector->bridge_hdmi_audio) 909 return ERR_PTR(-EBUSY); 910 911 if (!bridge->hdmi_audio_max_i2s_playback_channels && 912 !bridge->hdmi_audio_spdif_playback) 913 return ERR_PTR(-EINVAL); 914 915 if (!bridge->funcs->dp_audio_prepare || 916 !bridge->funcs->dp_audio_shutdown) 917 return ERR_PTR(-EINVAL); 918 919 bridge_connector->bridge_dp_audio = drm_bridge_get(bridge); 920 } 921 922 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) { 923 if (bridge_connector->bridge_hdmi_cec) 924 return ERR_PTR(-EBUSY); 925 926 bridge_connector->bridge_hdmi_cec = drm_bridge_get(bridge); 927 } 928 929 if (bridge->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) { 930 if (bridge_connector->bridge_hdmi_cec) 931 return ERR_PTR(-EBUSY); 932 933 bridge_connector->bridge_hdmi_cec = drm_bridge_get(bridge); 934 935 if (!bridge->funcs->hdmi_cec_enable || 936 !bridge->funcs->hdmi_cec_log_addr || 937 !bridge->funcs->hdmi_cec_transmit) 938 return ERR_PTR(-EINVAL); 939 } 940 941 if (drm_bridge_is_last(bridge)) 942 connector_type = bridge->type; 943 944 #ifdef CONFIG_OF 945 if (drm_bridge_is_last(bridge) && bridge->of_node) 946 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node)); 947 #endif 948 949 if (bridge->ddc) 950 ddc = bridge->ddc; 951 952 if (drm_bridge_is_panel(bridge)) { 953 drm_bridge_put(panel_bridge); 954 panel_bridge = drm_bridge_get(bridge); 955 } 956 957 if (bridge->support_hdcp) 958 support_hdcp = true; 959 } 960 961 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 962 return ERR_PTR(-EINVAL); 963 964 if (bridge_connector->bridge_hdmi) { 965 if (!connector->ycbcr_420_allowed) 966 supported_formats &= ~BIT(DRM_OUTPUT_COLOR_FORMAT_YCBCR420); 967 968 bridge_connector->hdmi_funcs = drm_bridge_connector_hdmi_funcs; 969 970 if (bridge_connector->bridge_hdmi->ops & DRM_BRIDGE_OP_HDMI_AUDIO) 971 bridge_connector->hdmi_funcs.audio = 972 drm_bridge_connector_hdmi_audio_infoframe; 973 974 if (bridge_connector->bridge_hdmi->ops & DRM_BRIDGE_OP_HDMI_HDR_DRM_INFOFRAME) 975 bridge_connector->hdmi_funcs.hdr_drm = 976 drm_bridge_connector_hdmi_hdr_drm_infoframe; 977 978 if (bridge_connector->bridge_hdmi->ops & DRM_BRIDGE_OP_HDMI_SPD_INFOFRAME) 979 bridge_connector->hdmi_funcs.spd = 980 drm_bridge_connector_hdmi_spd_infoframe; 981 982 ret = drmm_connector_hdmi_init(drm, connector, 983 bridge_connector->bridge_hdmi->vendor, 984 bridge_connector->bridge_hdmi->product, 985 &drm_bridge_connector_funcs, 986 &bridge_connector->hdmi_funcs, 987 connector_type, ddc, 988 supported_formats, 989 max_bpc); 990 if (ret) 991 return ERR_PTR(ret); 992 } else { 993 ret = drmm_connector_init(drm, connector, 994 &drm_bridge_connector_funcs, 995 connector_type, ddc); 996 if (ret) 997 return ERR_PTR(ret); 998 } 999 1000 if (bridge_connector->bridge_hdmi_audio || 1001 bridge_connector->bridge_dp_audio) { 1002 struct device *dev; 1003 struct drm_bridge *bridge; 1004 1005 if (bridge_connector->bridge_hdmi_audio) 1006 bridge = bridge_connector->bridge_hdmi_audio; 1007 else 1008 bridge = bridge_connector->bridge_dp_audio; 1009 1010 dev = bridge->hdmi_audio_dev; 1011 1012 ret = drm_connector_hdmi_audio_init(connector, dev, 1013 &drm_bridge_connector_hdmi_audio_funcs, 1014 bridge->hdmi_audio_max_i2s_playback_channels, 1015 bridge->hdmi_audio_i2s_formats, 1016 bridge->hdmi_audio_spdif_playback, 1017 bridge->hdmi_audio_dai_port); 1018 if (ret) 1019 return ERR_PTR(ret); 1020 } 1021 1022 if (bridge_connector->bridge_hdmi_cec && 1023 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_NOTIFIER) { 1024 struct drm_bridge *bridge = bridge_connector->bridge_hdmi_cec; 1025 1026 ret = drmm_connector_hdmi_cec_notifier_register(connector, 1027 NULL, 1028 bridge->hdmi_cec_dev); 1029 if (ret) 1030 return ERR_PTR(ret); 1031 } 1032 1033 if (bridge_connector->bridge_hdmi_cec && 1034 bridge_connector->bridge_hdmi_cec->ops & DRM_BRIDGE_OP_HDMI_CEC_ADAPTER) { 1035 struct drm_bridge *bridge = bridge_connector->bridge_hdmi_cec; 1036 1037 ret = drmm_connector_hdmi_cec_register(connector, 1038 &drm_bridge_connector_hdmi_cec_funcs, 1039 bridge->hdmi_cec_adapter_name, 1040 bridge->hdmi_cec_available_las, 1041 bridge->hdmi_cec_dev); 1042 if (ret) 1043 return ERR_PTR(ret); 1044 } 1045 1046 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs); 1047 1048 if (bridge_connector->bridge_hpd) 1049 connector->polled = DRM_CONNECTOR_POLL_HPD; 1050 else if (bridge_connector->bridge_detect) 1051 connector->polled = DRM_CONNECTOR_POLL_CONNECT 1052 | DRM_CONNECTOR_POLL_DISCONNECT; 1053 1054 if (panel_bridge) 1055 drm_panel_bridge_set_orientation(connector, panel_bridge); 1056 1057 if (support_hdcp && IS_REACHABLE(CONFIG_DRM_DISPLAY_HELPER) && 1058 IS_ENABLED(CONFIG_DRM_DISPLAY_HDCP_HELPER)) 1059 drm_connector_attach_content_protection_property(connector, true); 1060 1061 ret = drm_connector_attach_encoder(connector, encoder); 1062 if (ret) 1063 return ERR_PTR(ret); 1064 1065 return connector; 1066 } 1067 EXPORT_SYMBOL_GPL(drm_bridge_connector_init); 1068