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