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 103 #define to_drm_bridge_connector(x) \ 104 container_of(x, struct drm_bridge_connector, base) 105 106 /* ----------------------------------------------------------------------------- 107 * Bridge Connector Hot-Plug Handling 108 */ 109 110 static void drm_bridge_connector_hpd_notify(struct drm_connector *connector, 111 enum drm_connector_status status) 112 { 113 struct drm_bridge_connector *bridge_connector = 114 to_drm_bridge_connector(connector); 115 struct drm_bridge *bridge; 116 117 /* Notify all bridges in the pipeline of hotplug events. */ 118 drm_for_each_bridge_in_chain(bridge_connector->encoder, bridge) { 119 if (bridge->funcs->hpd_notify) 120 bridge->funcs->hpd_notify(bridge, status); 121 } 122 } 123 124 static void drm_bridge_connector_handle_hpd(struct drm_bridge_connector *drm_bridge_connector, 125 enum drm_connector_status status) 126 { 127 struct drm_connector *connector = &drm_bridge_connector->base; 128 struct drm_device *dev = connector->dev; 129 130 mutex_lock(&dev->mode_config.mutex); 131 connector->status = status; 132 mutex_unlock(&dev->mode_config.mutex); 133 134 drm_bridge_connector_hpd_notify(connector, status); 135 136 drm_kms_helper_connector_hotplug_event(connector); 137 } 138 139 static void drm_bridge_connector_hpd_cb(void *cb_data, 140 enum drm_connector_status status) 141 { 142 drm_bridge_connector_handle_hpd(cb_data, status); 143 } 144 145 static void drm_bridge_connector_oob_hotplug_event(struct drm_connector *connector, 146 enum drm_connector_status status) 147 { 148 struct drm_bridge_connector *bridge_connector = 149 to_drm_bridge_connector(connector); 150 151 drm_bridge_connector_handle_hpd(bridge_connector, status); 152 } 153 154 static void drm_bridge_connector_enable_hpd(struct drm_connector *connector) 155 { 156 struct drm_bridge_connector *bridge_connector = 157 to_drm_bridge_connector(connector); 158 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 159 160 if (hpd) 161 drm_bridge_hpd_enable(hpd, drm_bridge_connector_hpd_cb, 162 bridge_connector); 163 } 164 165 static void drm_bridge_connector_disable_hpd(struct drm_connector *connector) 166 { 167 struct drm_bridge_connector *bridge_connector = 168 to_drm_bridge_connector(connector); 169 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 170 171 if (hpd) 172 drm_bridge_hpd_disable(hpd); 173 } 174 175 /* ----------------------------------------------------------------------------- 176 * Bridge Connector Functions 177 */ 178 179 static enum drm_connector_status 180 drm_bridge_connector_detect(struct drm_connector *connector, bool force) 181 { 182 struct drm_bridge_connector *bridge_connector = 183 to_drm_bridge_connector(connector); 184 struct drm_bridge *detect = bridge_connector->bridge_detect; 185 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi; 186 enum drm_connector_status status; 187 188 if (detect) { 189 status = detect->funcs->detect(detect); 190 191 if (hdmi) 192 drm_atomic_helper_connector_hdmi_hotplug(connector, status); 193 194 drm_bridge_connector_hpd_notify(connector, status); 195 } else { 196 switch (connector->connector_type) { 197 case DRM_MODE_CONNECTOR_DPI: 198 case DRM_MODE_CONNECTOR_LVDS: 199 case DRM_MODE_CONNECTOR_DSI: 200 case DRM_MODE_CONNECTOR_eDP: 201 status = connector_status_connected; 202 break; 203 default: 204 status = connector_status_unknown; 205 break; 206 } 207 } 208 209 return status; 210 } 211 212 static void drm_bridge_connector_force(struct drm_connector *connector) 213 { 214 struct drm_bridge_connector *bridge_connector = 215 to_drm_bridge_connector(connector); 216 struct drm_bridge *hdmi = bridge_connector->bridge_hdmi; 217 218 if (hdmi) 219 drm_atomic_helper_connector_hdmi_force(connector); 220 } 221 222 static void drm_bridge_connector_debugfs_init(struct drm_connector *connector, 223 struct dentry *root) 224 { 225 struct drm_bridge_connector *bridge_connector = 226 to_drm_bridge_connector(connector); 227 struct drm_encoder *encoder = bridge_connector->encoder; 228 struct drm_bridge *bridge; 229 230 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) { 231 if (bridge->funcs->debugfs_init) 232 bridge->funcs->debugfs_init(bridge, root); 233 } 234 } 235 236 static void drm_bridge_connector_reset(struct drm_connector *connector) 237 { 238 struct drm_bridge_connector *bridge_connector = 239 to_drm_bridge_connector(connector); 240 241 drm_atomic_helper_connector_reset(connector); 242 if (bridge_connector->bridge_hdmi) 243 __drm_atomic_helper_connector_hdmi_reset(connector, 244 connector->state); 245 } 246 247 static const struct drm_connector_funcs drm_bridge_connector_funcs = { 248 .reset = drm_bridge_connector_reset, 249 .detect = drm_bridge_connector_detect, 250 .force = drm_bridge_connector_force, 251 .fill_modes = drm_helper_probe_single_connector_modes, 252 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 253 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 254 .debugfs_init = drm_bridge_connector_debugfs_init, 255 .oob_hotplug_event = drm_bridge_connector_oob_hotplug_event, 256 }; 257 258 /* ----------------------------------------------------------------------------- 259 * Bridge Connector Helper Functions 260 */ 261 262 static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector, 263 struct drm_bridge *bridge) 264 { 265 enum drm_connector_status status; 266 const struct drm_edid *drm_edid; 267 int n; 268 269 status = drm_bridge_connector_detect(connector, false); 270 if (status != connector_status_connected) 271 goto no_edid; 272 273 drm_edid = drm_bridge_edid_read(bridge, connector); 274 if (!drm_edid_valid(drm_edid)) { 275 drm_edid_free(drm_edid); 276 goto no_edid; 277 } 278 279 drm_edid_connector_update(connector, drm_edid); 280 n = drm_edid_connector_add_modes(connector); 281 282 drm_edid_free(drm_edid); 283 return n; 284 285 no_edid: 286 drm_edid_connector_update(connector, NULL); 287 return 0; 288 } 289 290 static int drm_bridge_connector_get_modes(struct drm_connector *connector) 291 { 292 struct drm_bridge_connector *bridge_connector = 293 to_drm_bridge_connector(connector); 294 struct drm_bridge *bridge; 295 296 /* 297 * If there is a HDMI bridge, EDID has been updated as a part of 298 * the .detect(). Just update the modes here. 299 */ 300 bridge = bridge_connector->bridge_hdmi; 301 if (bridge) 302 return drm_edid_connector_add_modes(connector); 303 304 /* 305 * If display exposes EDID, then we parse that in the normal way to 306 * build table of supported modes. 307 */ 308 bridge = bridge_connector->bridge_edid; 309 if (bridge) 310 return drm_bridge_connector_get_modes_edid(connector, bridge); 311 312 /* 313 * Otherwise if the display pipeline reports modes (e.g. with a fixed 314 * resolution panel or an analog TV output), query it. 315 */ 316 bridge = bridge_connector->bridge_modes; 317 if (bridge) 318 return bridge->funcs->get_modes(bridge, connector); 319 320 /* 321 * We can't retrieve modes, which can happen for instance for a DVI or 322 * VGA output with the DDC bus unconnected. The KMS core will add the 323 * default modes. 324 */ 325 return 0; 326 } 327 328 static enum drm_mode_status 329 drm_bridge_connector_mode_valid(struct drm_connector *connector, 330 const struct drm_display_mode *mode) 331 { 332 struct drm_bridge_connector *bridge_connector = 333 to_drm_bridge_connector(connector); 334 335 if (bridge_connector->bridge_hdmi) 336 return drm_hdmi_connector_mode_valid(connector, mode); 337 338 return MODE_OK; 339 } 340 341 static int drm_bridge_connector_atomic_check(struct drm_connector *connector, 342 struct drm_atomic_state *state) 343 { 344 struct drm_bridge_connector *bridge_connector = 345 to_drm_bridge_connector(connector); 346 347 if (bridge_connector->bridge_hdmi) 348 return drm_atomic_helper_connector_hdmi_check(connector, state); 349 350 return 0; 351 } 352 353 static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = { 354 .get_modes = drm_bridge_connector_get_modes, 355 .mode_valid = drm_bridge_connector_mode_valid, 356 .enable_hpd = drm_bridge_connector_enable_hpd, 357 .disable_hpd = drm_bridge_connector_disable_hpd, 358 .atomic_check = drm_bridge_connector_atomic_check, 359 }; 360 361 static enum drm_mode_status 362 drm_bridge_connector_tmds_char_rate_valid(const struct drm_connector *connector, 363 const struct drm_display_mode *mode, 364 unsigned long long tmds_rate) 365 { 366 struct drm_bridge_connector *bridge_connector = 367 to_drm_bridge_connector(connector); 368 struct drm_bridge *bridge; 369 370 bridge = bridge_connector->bridge_hdmi; 371 if (!bridge) 372 return MODE_ERROR; 373 374 if (bridge->funcs->hdmi_tmds_char_rate_valid) 375 return bridge->funcs->hdmi_tmds_char_rate_valid(bridge, mode, tmds_rate); 376 else 377 return MODE_OK; 378 } 379 380 static int drm_bridge_connector_clear_infoframe(struct drm_connector *connector, 381 enum hdmi_infoframe_type type) 382 { 383 struct drm_bridge_connector *bridge_connector = 384 to_drm_bridge_connector(connector); 385 struct drm_bridge *bridge; 386 387 bridge = bridge_connector->bridge_hdmi; 388 if (!bridge) 389 return -EINVAL; 390 391 return bridge->funcs->hdmi_clear_infoframe(bridge, type); 392 } 393 394 static int drm_bridge_connector_write_infoframe(struct drm_connector *connector, 395 enum hdmi_infoframe_type type, 396 const u8 *buffer, size_t len) 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_write_infoframe(bridge, type, buffer, len); 407 } 408 409 static const struct drm_edid * 410 drm_bridge_connector_read_edid(struct drm_connector *connector) 411 { 412 struct drm_bridge_connector *bridge_connector = 413 to_drm_bridge_connector(connector); 414 struct drm_bridge *bridge; 415 416 bridge = bridge_connector->bridge_edid; 417 if (!bridge) 418 return NULL; 419 420 return drm_bridge_edid_read(bridge, connector); 421 } 422 423 static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = { 424 .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid, 425 .clear_infoframe = drm_bridge_connector_clear_infoframe, 426 .write_infoframe = drm_bridge_connector_write_infoframe, 427 .read_edid = drm_bridge_connector_read_edid, 428 }; 429 430 static int drm_bridge_connector_audio_startup(struct drm_connector *connector) 431 { 432 struct drm_bridge_connector *bridge_connector = 433 to_drm_bridge_connector(connector); 434 struct drm_bridge *bridge; 435 436 bridge = bridge_connector->bridge_hdmi; 437 if (!bridge) 438 return -EINVAL; 439 440 if (!bridge->funcs->hdmi_audio_startup) 441 return 0; 442 443 return bridge->funcs->hdmi_audio_startup(connector, bridge); 444 } 445 446 static int drm_bridge_connector_audio_prepare(struct drm_connector *connector, 447 struct hdmi_codec_daifmt *fmt, 448 struct hdmi_codec_params *hparms) 449 { 450 struct drm_bridge_connector *bridge_connector = 451 to_drm_bridge_connector(connector); 452 struct drm_bridge *bridge; 453 454 bridge = bridge_connector->bridge_hdmi; 455 if (!bridge) 456 return -EINVAL; 457 458 return bridge->funcs->hdmi_audio_prepare(connector, bridge, fmt, hparms); 459 } 460 461 static void drm_bridge_connector_audio_shutdown(struct drm_connector *connector) 462 { 463 struct drm_bridge_connector *bridge_connector = 464 to_drm_bridge_connector(connector); 465 struct drm_bridge *bridge; 466 467 bridge = bridge_connector->bridge_hdmi; 468 if (!bridge) 469 return; 470 471 bridge->funcs->hdmi_audio_shutdown(connector, bridge); 472 } 473 474 static int drm_bridge_connector_audio_mute_stream(struct drm_connector *connector, 475 bool enable, int direction) 476 { 477 struct drm_bridge_connector *bridge_connector = 478 to_drm_bridge_connector(connector); 479 struct drm_bridge *bridge; 480 481 bridge = bridge_connector->bridge_hdmi; 482 if (!bridge) 483 return -EINVAL; 484 485 if (bridge->funcs->hdmi_audio_mute_stream) 486 return bridge->funcs->hdmi_audio_mute_stream(connector, bridge, 487 enable, direction); 488 else 489 return -ENOTSUPP; 490 } 491 492 static const struct drm_connector_hdmi_audio_funcs drm_bridge_connector_hdmi_audio_funcs = { 493 .startup = drm_bridge_connector_audio_startup, 494 .prepare = drm_bridge_connector_audio_prepare, 495 .shutdown = drm_bridge_connector_audio_shutdown, 496 .mute_stream = drm_bridge_connector_audio_mute_stream, 497 }; 498 499 /* ----------------------------------------------------------------------------- 500 * Bridge Connector Initialisation 501 */ 502 503 /** 504 * drm_bridge_connector_init - Initialise a connector for a chain of bridges 505 * @drm: the DRM device 506 * @encoder: the encoder where the bridge chain starts 507 * 508 * Allocate, initialise and register a &drm_bridge_connector with the @drm 509 * device. The connector is associated with a chain of bridges that starts at 510 * the @encoder. All bridges in the chain shall report bridge operation flags 511 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of 512 * them may create a DRM connector directly. 513 * 514 * Returns a pointer to the new connector on success, or a negative error 515 * pointer otherwise. 516 */ 517 struct drm_connector *drm_bridge_connector_init(struct drm_device *drm, 518 struct drm_encoder *encoder) 519 { 520 struct drm_bridge_connector *bridge_connector; 521 struct drm_connector *connector; 522 struct i2c_adapter *ddc = NULL; 523 struct drm_bridge *bridge, *panel_bridge = NULL; 524 unsigned int supported_formats = BIT(HDMI_COLORSPACE_RGB); 525 unsigned int max_bpc = 8; 526 int connector_type; 527 int ret; 528 529 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL); 530 if (!bridge_connector) 531 return ERR_PTR(-ENOMEM); 532 533 bridge_connector->encoder = encoder; 534 535 /* 536 * TODO: Handle doublescan_allowed and stereo_allowed. 537 */ 538 connector = &bridge_connector->base; 539 connector->interlace_allowed = true; 540 connector->ycbcr_420_allowed = true; 541 542 /* 543 * Initialise connector status handling. First locate the furthest 544 * bridges in the pipeline that support HPD and output detection. Then 545 * initialise the connector polling mode, using HPD if available and 546 * falling back to polling if supported. If neither HPD nor output 547 * detection are available, we don't support hotplug detection at all. 548 */ 549 connector_type = DRM_MODE_CONNECTOR_Unknown; 550 drm_for_each_bridge_in_chain(encoder, bridge) { 551 if (!bridge->interlace_allowed) 552 connector->interlace_allowed = false; 553 if (!bridge->ycbcr_420_allowed) 554 connector->ycbcr_420_allowed = false; 555 556 if (bridge->ops & DRM_BRIDGE_OP_EDID) 557 bridge_connector->bridge_edid = bridge; 558 if (bridge->ops & DRM_BRIDGE_OP_HPD) 559 bridge_connector->bridge_hpd = bridge; 560 if (bridge->ops & DRM_BRIDGE_OP_DETECT) 561 bridge_connector->bridge_detect = bridge; 562 if (bridge->ops & DRM_BRIDGE_OP_MODES) 563 bridge_connector->bridge_modes = bridge; 564 if (bridge->ops & DRM_BRIDGE_OP_HDMI) { 565 if (bridge_connector->bridge_hdmi) 566 return ERR_PTR(-EBUSY); 567 if (!bridge->funcs->hdmi_write_infoframe || 568 !bridge->funcs->hdmi_clear_infoframe) 569 return ERR_PTR(-EINVAL); 570 571 bridge_connector->bridge_hdmi = bridge; 572 573 if (bridge->supported_formats) 574 supported_formats = bridge->supported_formats; 575 if (bridge->max_bpc) 576 max_bpc = bridge->max_bpc; 577 } 578 579 if (!drm_bridge_get_next_bridge(bridge)) 580 connector_type = bridge->type; 581 582 #ifdef CONFIG_OF 583 if (!drm_bridge_get_next_bridge(bridge) && 584 bridge->of_node) 585 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node)); 586 #endif 587 588 if (bridge->ddc) 589 ddc = bridge->ddc; 590 591 if (drm_bridge_is_panel(bridge)) 592 panel_bridge = bridge; 593 } 594 595 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 596 return ERR_PTR(-EINVAL); 597 598 if (bridge_connector->bridge_hdmi) { 599 if (!connector->ycbcr_420_allowed) 600 supported_formats &= ~BIT(HDMI_COLORSPACE_YUV420); 601 602 bridge = bridge_connector->bridge_hdmi; 603 604 ret = drmm_connector_hdmi_init(drm, connector, 605 bridge_connector->bridge_hdmi->vendor, 606 bridge_connector->bridge_hdmi->product, 607 &drm_bridge_connector_funcs, 608 &drm_bridge_connector_hdmi_funcs, 609 connector_type, ddc, 610 supported_formats, 611 max_bpc); 612 if (ret) 613 return ERR_PTR(ret); 614 615 if (bridge->hdmi_audio_max_i2s_playback_channels || 616 bridge->hdmi_audio_spdif_playback) { 617 if (!bridge->funcs->hdmi_audio_prepare || 618 !bridge->funcs->hdmi_audio_shutdown) 619 return ERR_PTR(-EINVAL); 620 621 ret = drm_connector_hdmi_audio_init(connector, 622 bridge->hdmi_audio_dev, 623 &drm_bridge_connector_hdmi_audio_funcs, 624 bridge->hdmi_audio_max_i2s_playback_channels, 625 bridge->hdmi_audio_spdif_playback, 626 bridge->hdmi_audio_dai_port); 627 if (ret) 628 return ERR_PTR(ret); 629 } 630 } else { 631 ret = drmm_connector_init(drm, connector, 632 &drm_bridge_connector_funcs, 633 connector_type, ddc); 634 if (ret) 635 return ERR_PTR(ret); 636 } 637 638 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs); 639 640 if (bridge_connector->bridge_hpd) 641 connector->polled = DRM_CONNECTOR_POLL_HPD; 642 else if (bridge_connector->bridge_detect) 643 connector->polled = DRM_CONNECTOR_POLL_CONNECT 644 | DRM_CONNECTOR_POLL_DISCONNECT; 645 646 if (panel_bridge) 647 drm_panel_bridge_set_orientation(connector, panel_bridge); 648 649 return connector; 650 } 651 EXPORT_SYMBOL_GPL(drm_bridge_connector_init); 652