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_probe_helper.h> 21 #include <drm/display/drm_hdmi_helper.h> 22 #include <drm/display/drm_hdmi_state_helper.h> 23 24 /** 25 * DOC: overview 26 * 27 * The DRM bridge connector helper object provides a DRM connector 28 * implementation that wraps a chain of &struct drm_bridge. The connector 29 * operations are fully implemented based on the operations of the bridges in 30 * the chain, and don't require any intervention from the display controller 31 * driver at runtime. 32 * 33 * To use the helper, display controller drivers create a bridge connector with 34 * a call to drm_bridge_connector_init(). This associates the newly created 35 * connector with the chain of bridges passed to the function and registers it 36 * with the DRM device. At that point the connector becomes fully usable, no 37 * further operation is needed. 38 * 39 * The DRM bridge connector operations are implemented based on the operations 40 * provided by the bridges in the chain. Each connector operation is delegated 41 * to the bridge closest to the connector (at the end of the chain) that 42 * provides the relevant functionality. 43 * 44 * To make use of this helper, all bridges in the chain shall report bridge 45 * operation flags (&drm_bridge->ops) and bridge output type 46 * (&drm_bridge->type), as well as the DRM_BRIDGE_ATTACH_NO_CONNECTOR attach 47 * flag (none of the bridges shall create a DRM connector directly). 48 */ 49 50 /** 51 * struct drm_bridge_connector - A connector backed by a chain of bridges 52 */ 53 struct drm_bridge_connector { 54 /** 55 * @base: The base DRM connector 56 */ 57 struct drm_connector base; 58 /** 59 * @encoder: 60 * 61 * The encoder at the start of the bridges chain. 62 */ 63 struct drm_encoder *encoder; 64 /** 65 * @bridge_edid: 66 * 67 * The last bridge in the chain (closest to the connector) that provides 68 * EDID read support, if any (see &DRM_BRIDGE_OP_EDID). 69 */ 70 struct drm_bridge *bridge_edid; 71 /** 72 * @bridge_hpd: 73 * 74 * The last bridge in the chain (closest to the connector) that provides 75 * hot-plug detection notification, if any (see &DRM_BRIDGE_OP_HPD). 76 */ 77 struct drm_bridge *bridge_hpd; 78 /** 79 * @bridge_detect: 80 * 81 * The last bridge in the chain (closest to the connector) that provides 82 * connector detection, if any (see &DRM_BRIDGE_OP_DETECT). 83 */ 84 struct drm_bridge *bridge_detect; 85 /** 86 * @bridge_modes: 87 * 88 * The last bridge in the chain (closest to the connector) that provides 89 * connector modes detection, if any (see &DRM_BRIDGE_OP_MODES). 90 */ 91 struct drm_bridge *bridge_modes; 92 /** 93 * @bridge_hdmi: 94 * 95 * The bridge in the chain that implements necessary support for the 96 * HDMI connector infrastructure, if any (see &DRM_BRIDGE_OP_HDMI). 97 */ 98 struct drm_bridge *bridge_hdmi; 99 }; 100 101 #define to_drm_bridge_connector(x) \ 102 container_of(x, struct drm_bridge_connector, base) 103 104 /* ----------------------------------------------------------------------------- 105 * Bridge Connector Hot-Plug Handling 106 */ 107 108 static void drm_bridge_connector_hpd_notify(struct drm_connector *connector, 109 enum drm_connector_status status) 110 { 111 struct drm_bridge_connector *bridge_connector = 112 to_drm_bridge_connector(connector); 113 struct drm_bridge *bridge; 114 115 /* Notify all bridges in the pipeline of hotplug events. */ 116 drm_for_each_bridge_in_chain(bridge_connector->encoder, bridge) { 117 if (bridge->funcs->hpd_notify) 118 bridge->funcs->hpd_notify(bridge, status); 119 } 120 } 121 122 static void drm_bridge_connector_handle_hpd(struct drm_bridge_connector *drm_bridge_connector, 123 enum drm_connector_status status) 124 { 125 struct drm_connector *connector = &drm_bridge_connector->base; 126 struct drm_device *dev = connector->dev; 127 128 mutex_lock(&dev->mode_config.mutex); 129 connector->status = status; 130 mutex_unlock(&dev->mode_config.mutex); 131 132 drm_bridge_connector_hpd_notify(connector, status); 133 134 drm_kms_helper_connector_hotplug_event(connector); 135 } 136 137 static void drm_bridge_connector_hpd_cb(void *cb_data, 138 enum drm_connector_status status) 139 { 140 drm_bridge_connector_handle_hpd(cb_data, status); 141 } 142 143 static void drm_bridge_connector_oob_hotplug_event(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 drm_bridge_connector_handle_hpd(bridge_connector, status); 150 } 151 152 static void drm_bridge_connector_enable_hpd(struct drm_connector *connector) 153 { 154 struct drm_bridge_connector *bridge_connector = 155 to_drm_bridge_connector(connector); 156 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 157 158 if (hpd) 159 drm_bridge_hpd_enable(hpd, drm_bridge_connector_hpd_cb, 160 bridge_connector); 161 } 162 163 static void drm_bridge_connector_disable_hpd(struct drm_connector *connector) 164 { 165 struct drm_bridge_connector *bridge_connector = 166 to_drm_bridge_connector(connector); 167 struct drm_bridge *hpd = bridge_connector->bridge_hpd; 168 169 if (hpd) 170 drm_bridge_hpd_disable(hpd); 171 } 172 173 /* ----------------------------------------------------------------------------- 174 * Bridge Connector Functions 175 */ 176 177 static enum drm_connector_status 178 drm_bridge_connector_detect(struct drm_connector *connector, bool force) 179 { 180 struct drm_bridge_connector *bridge_connector = 181 to_drm_bridge_connector(connector); 182 struct drm_bridge *detect = bridge_connector->bridge_detect; 183 enum drm_connector_status status; 184 185 if (detect) { 186 status = detect->funcs->detect(detect); 187 188 drm_bridge_connector_hpd_notify(connector, status); 189 } else { 190 switch (connector->connector_type) { 191 case DRM_MODE_CONNECTOR_DPI: 192 case DRM_MODE_CONNECTOR_LVDS: 193 case DRM_MODE_CONNECTOR_DSI: 194 case DRM_MODE_CONNECTOR_eDP: 195 status = connector_status_connected; 196 break; 197 default: 198 status = connector_status_unknown; 199 break; 200 } 201 } 202 203 return status; 204 } 205 206 static void drm_bridge_connector_debugfs_init(struct drm_connector *connector, 207 struct dentry *root) 208 { 209 struct drm_bridge_connector *bridge_connector = 210 to_drm_bridge_connector(connector); 211 struct drm_encoder *encoder = bridge_connector->encoder; 212 struct drm_bridge *bridge; 213 214 list_for_each_entry(bridge, &encoder->bridge_chain, chain_node) { 215 if (bridge->funcs->debugfs_init) 216 bridge->funcs->debugfs_init(bridge, root); 217 } 218 } 219 220 static void drm_bridge_connector_reset(struct drm_connector *connector) 221 { 222 struct drm_bridge_connector *bridge_connector = 223 to_drm_bridge_connector(connector); 224 225 drm_atomic_helper_connector_reset(connector); 226 if (bridge_connector->bridge_hdmi) 227 __drm_atomic_helper_connector_hdmi_reset(connector, 228 connector->state); 229 } 230 231 static const struct drm_connector_funcs drm_bridge_connector_funcs = { 232 .reset = drm_bridge_connector_reset, 233 .detect = drm_bridge_connector_detect, 234 .fill_modes = drm_helper_probe_single_connector_modes, 235 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 236 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 237 .debugfs_init = drm_bridge_connector_debugfs_init, 238 .oob_hotplug_event = drm_bridge_connector_oob_hotplug_event, 239 }; 240 241 /* ----------------------------------------------------------------------------- 242 * Bridge Connector Helper Functions 243 */ 244 245 static int drm_bridge_connector_get_modes_edid(struct drm_connector *connector, 246 struct drm_bridge *bridge) 247 { 248 enum drm_connector_status status; 249 const struct drm_edid *drm_edid; 250 int n; 251 252 status = drm_bridge_connector_detect(connector, false); 253 if (status != connector_status_connected) 254 goto no_edid; 255 256 drm_edid = drm_bridge_edid_read(bridge, connector); 257 if (!drm_edid_valid(drm_edid)) { 258 drm_edid_free(drm_edid); 259 goto no_edid; 260 } 261 262 drm_edid_connector_update(connector, drm_edid); 263 n = drm_edid_connector_add_modes(connector); 264 265 drm_edid_free(drm_edid); 266 return n; 267 268 no_edid: 269 drm_edid_connector_update(connector, NULL); 270 return 0; 271 } 272 273 static int drm_bridge_connector_get_modes(struct drm_connector *connector) 274 { 275 struct drm_bridge_connector *bridge_connector = 276 to_drm_bridge_connector(connector); 277 struct drm_bridge *bridge; 278 279 /* 280 * If display exposes EDID, then we parse that in the normal way to 281 * build table of supported modes. 282 */ 283 bridge = bridge_connector->bridge_edid; 284 if (bridge) 285 return drm_bridge_connector_get_modes_edid(connector, bridge); 286 287 /* 288 * Otherwise if the display pipeline reports modes (e.g. with a fixed 289 * resolution panel or an analog TV output), query it. 290 */ 291 bridge = bridge_connector->bridge_modes; 292 if (bridge) 293 return bridge->funcs->get_modes(bridge, connector); 294 295 /* 296 * We can't retrieve modes, which can happen for instance for a DVI or 297 * VGA output with the DDC bus unconnected. The KMS core will add the 298 * default modes. 299 */ 300 return 0; 301 } 302 303 static enum drm_mode_status 304 drm_bridge_connector_mode_valid(struct drm_connector *connector, 305 struct drm_display_mode *mode) 306 { 307 struct drm_bridge_connector *bridge_connector = 308 to_drm_bridge_connector(connector); 309 310 if (bridge_connector->bridge_hdmi) 311 return drm_hdmi_connector_mode_valid(connector, mode); 312 313 return MODE_OK; 314 } 315 316 static const struct drm_connector_helper_funcs drm_bridge_connector_helper_funcs = { 317 .get_modes = drm_bridge_connector_get_modes, 318 .mode_valid = drm_bridge_connector_mode_valid, 319 .enable_hpd = drm_bridge_connector_enable_hpd, 320 .disable_hpd = drm_bridge_connector_disable_hpd, 321 }; 322 323 static enum drm_mode_status 324 drm_bridge_connector_tmds_char_rate_valid(const struct drm_connector *connector, 325 const struct drm_display_mode *mode, 326 unsigned long long tmds_rate) 327 { 328 struct drm_bridge_connector *bridge_connector = 329 to_drm_bridge_connector(connector); 330 struct drm_bridge *bridge; 331 332 bridge = bridge_connector->bridge_hdmi; 333 if (!bridge) 334 return MODE_ERROR; 335 336 if (bridge->funcs->hdmi_tmds_char_rate_valid) 337 return bridge->funcs->hdmi_tmds_char_rate_valid(bridge, mode, tmds_rate); 338 else 339 return MODE_OK; 340 } 341 342 static int drm_bridge_connector_clear_infoframe(struct drm_connector *connector, 343 enum hdmi_infoframe_type type) 344 { 345 struct drm_bridge_connector *bridge_connector = 346 to_drm_bridge_connector(connector); 347 struct drm_bridge *bridge; 348 349 bridge = bridge_connector->bridge_hdmi; 350 if (!bridge) 351 return -EINVAL; 352 353 return bridge->funcs->hdmi_clear_infoframe(bridge, type); 354 } 355 356 static int drm_bridge_connector_write_infoframe(struct drm_connector *connector, 357 enum hdmi_infoframe_type type, 358 const u8 *buffer, size_t len) 359 { 360 struct drm_bridge_connector *bridge_connector = 361 to_drm_bridge_connector(connector); 362 struct drm_bridge *bridge; 363 364 bridge = bridge_connector->bridge_hdmi; 365 if (!bridge) 366 return -EINVAL; 367 368 return bridge->funcs->hdmi_write_infoframe(bridge, type, buffer, len); 369 } 370 371 static const struct drm_connector_hdmi_funcs drm_bridge_connector_hdmi_funcs = { 372 .tmds_char_rate_valid = drm_bridge_connector_tmds_char_rate_valid, 373 .clear_infoframe = drm_bridge_connector_clear_infoframe, 374 .write_infoframe = drm_bridge_connector_write_infoframe, 375 }; 376 377 /* ----------------------------------------------------------------------------- 378 * Bridge Connector Initialisation 379 */ 380 381 /** 382 * drm_bridge_connector_init - Initialise a connector for a chain of bridges 383 * @drm: the DRM device 384 * @encoder: the encoder where the bridge chain starts 385 * 386 * Allocate, initialise and register a &drm_bridge_connector with the @drm 387 * device. The connector is associated with a chain of bridges that starts at 388 * the @encoder. All bridges in the chain shall report bridge operation flags 389 * (&drm_bridge->ops) and bridge output type (&drm_bridge->type), and none of 390 * them may create a DRM connector directly. 391 * 392 * Returns a pointer to the new connector on success, or a negative error 393 * pointer otherwise. 394 */ 395 struct drm_connector *drm_bridge_connector_init(struct drm_device *drm, 396 struct drm_encoder *encoder) 397 { 398 struct drm_bridge_connector *bridge_connector; 399 struct drm_connector *connector; 400 struct i2c_adapter *ddc = NULL; 401 struct drm_bridge *bridge, *panel_bridge = NULL; 402 unsigned int supported_formats = BIT(HDMI_COLORSPACE_RGB); 403 unsigned int max_bpc = 8; 404 int connector_type; 405 int ret; 406 407 bridge_connector = drmm_kzalloc(drm, sizeof(*bridge_connector), GFP_KERNEL); 408 if (!bridge_connector) 409 return ERR_PTR(-ENOMEM); 410 411 bridge_connector->encoder = encoder; 412 413 /* 414 * TODO: Handle doublescan_allowed and stereo_allowed. 415 */ 416 connector = &bridge_connector->base; 417 connector->interlace_allowed = true; 418 connector->ycbcr_420_allowed = true; 419 420 /* 421 * Initialise connector status handling. First locate the furthest 422 * bridges in the pipeline that support HPD and output detection. Then 423 * initialise the connector polling mode, using HPD if available and 424 * falling back to polling if supported. If neither HPD nor output 425 * detection are available, we don't support hotplug detection at all. 426 */ 427 connector_type = DRM_MODE_CONNECTOR_Unknown; 428 drm_for_each_bridge_in_chain(encoder, bridge) { 429 if (!bridge->interlace_allowed) 430 connector->interlace_allowed = false; 431 if (!bridge->ycbcr_420_allowed) 432 connector->ycbcr_420_allowed = false; 433 434 if (bridge->ops & DRM_BRIDGE_OP_EDID) 435 bridge_connector->bridge_edid = bridge; 436 if (bridge->ops & DRM_BRIDGE_OP_HPD) 437 bridge_connector->bridge_hpd = bridge; 438 if (bridge->ops & DRM_BRIDGE_OP_DETECT) 439 bridge_connector->bridge_detect = bridge; 440 if (bridge->ops & DRM_BRIDGE_OP_MODES) 441 bridge_connector->bridge_modes = bridge; 442 if (bridge->ops & DRM_BRIDGE_OP_HDMI) { 443 if (bridge_connector->bridge_hdmi) 444 return ERR_PTR(-EBUSY); 445 if (!bridge->funcs->hdmi_write_infoframe || 446 !bridge->funcs->hdmi_clear_infoframe) 447 return ERR_PTR(-EINVAL); 448 449 bridge_connector->bridge_hdmi = bridge; 450 451 if (bridge->supported_formats) 452 supported_formats = bridge->supported_formats; 453 if (bridge->max_bpc) 454 max_bpc = bridge->max_bpc; 455 } 456 457 if (!drm_bridge_get_next_bridge(bridge)) 458 connector_type = bridge->type; 459 460 #ifdef CONFIG_OF 461 if (!drm_bridge_get_next_bridge(bridge) && 462 bridge->of_node) 463 connector->fwnode = fwnode_handle_get(of_fwnode_handle(bridge->of_node)); 464 #endif 465 466 if (bridge->ddc) 467 ddc = bridge->ddc; 468 469 if (drm_bridge_is_panel(bridge)) 470 panel_bridge = bridge; 471 } 472 473 if (connector_type == DRM_MODE_CONNECTOR_Unknown) 474 return ERR_PTR(-EINVAL); 475 476 if (bridge_connector->bridge_hdmi) 477 ret = drmm_connector_hdmi_init(drm, connector, 478 bridge_connector->bridge_hdmi->vendor, 479 bridge_connector->bridge_hdmi->product, 480 &drm_bridge_connector_funcs, 481 &drm_bridge_connector_hdmi_funcs, 482 connector_type, ddc, 483 supported_formats, 484 max_bpc); 485 else 486 ret = drmm_connector_init(drm, connector, 487 &drm_bridge_connector_funcs, 488 connector_type, ddc); 489 if (ret) 490 return ERR_PTR(ret); 491 492 drm_connector_helper_add(connector, &drm_bridge_connector_helper_funcs); 493 494 if (bridge_connector->bridge_hpd) 495 connector->polled = DRM_CONNECTOR_POLL_HPD; 496 else if (bridge_connector->bridge_detect) 497 connector->polled = DRM_CONNECTOR_POLL_CONNECT 498 | DRM_CONNECTOR_POLL_DISCONNECT; 499 500 if (panel_bridge) 501 drm_panel_bridge_set_orientation(connector, panel_bridge); 502 503 return connector; 504 } 505 EXPORT_SYMBOL_GPL(drm_bridge_connector_init); 506