1 // SPDX-License-Identifier: GPL-2.0-or-later 2 /* 3 * Copyright (C) 2016 Laurent Pinchart <laurent.pinchart@ideasonboard.com> 4 * Copyright (C) 2017 Broadcom 5 */ 6 7 #include <linux/debugfs.h> 8 9 #include <drm/drm_atomic_helper.h> 10 #include <drm/drm_bridge.h> 11 #include <drm/drm_connector.h> 12 #include <drm/drm_encoder.h> 13 #include <drm/drm_managed.h> 14 #include <drm/drm_modeset_helper_vtables.h> 15 #include <drm/drm_of.h> 16 #include <drm/drm_panel.h> 17 #include <drm/drm_print.h> 18 #include <drm/drm_probe_helper.h> 19 20 struct panel_bridge { 21 struct drm_bridge bridge; 22 struct drm_connector connector; 23 struct drm_panel *panel; 24 u32 connector_type; 25 }; 26 27 static inline struct panel_bridge * 28 drm_bridge_to_panel_bridge(struct drm_bridge *bridge) 29 { 30 return container_of(bridge, struct panel_bridge, bridge); 31 } 32 33 static inline struct panel_bridge * 34 drm_connector_to_panel_bridge(struct drm_connector *connector) 35 { 36 return container_of(connector, struct panel_bridge, connector); 37 } 38 39 static int panel_bridge_connector_get_modes(struct drm_connector *connector) 40 { 41 struct panel_bridge *panel_bridge = 42 drm_connector_to_panel_bridge(connector); 43 44 return drm_panel_get_modes(panel_bridge->panel, connector); 45 } 46 47 static const struct drm_connector_helper_funcs 48 panel_bridge_connector_helper_funcs = { 49 .get_modes = panel_bridge_connector_get_modes, 50 }; 51 52 static const struct drm_connector_funcs panel_bridge_connector_funcs = { 53 .reset = drm_atomic_helper_connector_reset, 54 .fill_modes = drm_helper_probe_single_connector_modes, 55 .destroy = drm_connector_cleanup, 56 .atomic_duplicate_state = drm_atomic_helper_connector_duplicate_state, 57 .atomic_destroy_state = drm_atomic_helper_connector_destroy_state, 58 }; 59 60 static int panel_bridge_attach(struct drm_bridge *bridge, 61 struct drm_encoder *encoder, 62 enum drm_bridge_attach_flags flags) 63 { 64 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 65 struct drm_connector *connector = &panel_bridge->connector; 66 int ret; 67 68 if (flags & DRM_BRIDGE_ATTACH_NO_CONNECTOR) 69 return 0; 70 71 drm_connector_helper_add(connector, 72 &panel_bridge_connector_helper_funcs); 73 74 ret = drm_connector_init(bridge->dev, connector, 75 &panel_bridge_connector_funcs, 76 panel_bridge->connector_type); 77 if (ret) { 78 DRM_ERROR("Failed to initialize connector\n"); 79 return ret; 80 } 81 82 drm_panel_bridge_set_orientation(connector, bridge); 83 84 drm_connector_attach_encoder(&panel_bridge->connector, 85 encoder); 86 87 if (bridge->dev->registered) { 88 if (connector->funcs->reset) 89 connector->funcs->reset(connector); 90 drm_connector_register(connector); 91 } 92 93 return 0; 94 } 95 96 static void panel_bridge_detach(struct drm_bridge *bridge) 97 { 98 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 99 struct drm_connector *connector = &panel_bridge->connector; 100 101 /* 102 * Cleanup the connector if we know it was initialized. 103 * 104 * FIXME: This wouldn't be needed if the panel_bridge structure was 105 * allocated with drmm_kzalloc(). This might be tricky since the 106 * drm_device pointer can only be retrieved when the bridge is attached. 107 */ 108 if (connector->dev) 109 drm_connector_cleanup(connector); 110 } 111 112 static void panel_bridge_atomic_pre_enable(struct drm_bridge *bridge, 113 struct drm_atomic_state *atomic_state) 114 { 115 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 116 struct drm_encoder *encoder = bridge->encoder; 117 struct drm_crtc *crtc; 118 struct drm_crtc_state *old_crtc_state; 119 120 crtc = drm_atomic_get_new_crtc_for_encoder(atomic_state, encoder); 121 if (!crtc) 122 return; 123 124 old_crtc_state = drm_atomic_get_old_crtc_state(atomic_state, crtc); 125 if (old_crtc_state && old_crtc_state->self_refresh_active) 126 return; 127 128 drm_panel_prepare(panel_bridge->panel); 129 } 130 131 static void panel_bridge_atomic_enable(struct drm_bridge *bridge, 132 struct drm_atomic_state *atomic_state) 133 { 134 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 135 struct drm_encoder *encoder = bridge->encoder; 136 struct drm_crtc *crtc; 137 struct drm_crtc_state *old_crtc_state; 138 139 crtc = drm_atomic_get_new_crtc_for_encoder(atomic_state, encoder); 140 if (!crtc) 141 return; 142 143 old_crtc_state = drm_atomic_get_old_crtc_state(atomic_state, crtc); 144 if (old_crtc_state && old_crtc_state->self_refresh_active) 145 return; 146 147 drm_panel_enable(panel_bridge->panel); 148 } 149 150 static void panel_bridge_atomic_disable(struct drm_bridge *bridge, 151 struct drm_atomic_state *atomic_state) 152 { 153 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 154 struct drm_encoder *encoder = bridge->encoder; 155 struct drm_crtc *crtc; 156 struct drm_crtc_state *new_crtc_state; 157 158 crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state, encoder); 159 if (!crtc) 160 return; 161 162 new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc); 163 if (new_crtc_state && new_crtc_state->self_refresh_active) 164 return; 165 166 drm_panel_disable(panel_bridge->panel); 167 } 168 169 static void panel_bridge_atomic_post_disable(struct drm_bridge *bridge, 170 struct drm_atomic_state *atomic_state) 171 { 172 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 173 struct drm_encoder *encoder = bridge->encoder; 174 struct drm_crtc *crtc; 175 struct drm_crtc_state *new_crtc_state; 176 177 crtc = drm_atomic_get_old_crtc_for_encoder(atomic_state, encoder); 178 if (!crtc) 179 return; 180 181 new_crtc_state = drm_atomic_get_new_crtc_state(atomic_state, crtc); 182 if (new_crtc_state && new_crtc_state->self_refresh_active) 183 return; 184 185 drm_panel_unprepare(panel_bridge->panel); 186 } 187 188 static int panel_bridge_get_modes(struct drm_bridge *bridge, 189 struct drm_connector *connector) 190 { 191 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 192 193 return drm_panel_get_modes(panel_bridge->panel, connector); 194 } 195 196 static void panel_bridge_debugfs_init(struct drm_bridge *bridge, 197 struct dentry *root) 198 { 199 struct panel_bridge *panel_bridge = drm_bridge_to_panel_bridge(bridge); 200 struct drm_panel *panel = panel_bridge->panel; 201 202 root = debugfs_create_dir("panel", root); 203 if (panel->funcs->debugfs_init) 204 panel->funcs->debugfs_init(panel, root); 205 } 206 207 static const struct drm_bridge_funcs panel_bridge_bridge_funcs = { 208 .attach = panel_bridge_attach, 209 .detach = panel_bridge_detach, 210 .atomic_pre_enable = panel_bridge_atomic_pre_enable, 211 .atomic_enable = panel_bridge_atomic_enable, 212 .atomic_disable = panel_bridge_atomic_disable, 213 .atomic_post_disable = panel_bridge_atomic_post_disable, 214 .get_modes = panel_bridge_get_modes, 215 .atomic_reset = drm_atomic_helper_bridge_reset, 216 .atomic_duplicate_state = drm_atomic_helper_bridge_duplicate_state, 217 .atomic_destroy_state = drm_atomic_helper_bridge_destroy_state, 218 .atomic_get_input_bus_fmts = drm_atomic_helper_bridge_propagate_bus_fmt, 219 .debugfs_init = panel_bridge_debugfs_init, 220 }; 221 222 /** 223 * drm_bridge_is_panel - Checks if a drm_bridge is a panel_bridge. 224 * 225 * @bridge: The drm_bridge to be checked. 226 * 227 * Returns true if the bridge is a panel bridge, or false otherwise. 228 */ 229 bool drm_bridge_is_panel(const struct drm_bridge *bridge) 230 { 231 return bridge->funcs == &panel_bridge_bridge_funcs; 232 } 233 EXPORT_SYMBOL(drm_bridge_is_panel); 234 235 /** 236 * drm_panel_bridge_add - Creates a &drm_bridge and &drm_connector that 237 * just calls the appropriate functions from &drm_panel. 238 * 239 * @panel: The drm_panel being wrapped. Must be non-NULL. 240 * 241 * For drivers converting from directly using drm_panel: The expected 242 * usage pattern is that during either encoder module probe or DSI 243 * host attach, a drm_panel will be looked up through 244 * drm_of_find_panel_or_bridge(). drm_panel_bridge_add() is used to 245 * wrap that panel in the new bridge, and the result can then be 246 * passed to drm_bridge_attach(). The drm_panel_prepare() and related 247 * functions can be dropped from the encoder driver (they're now 248 * called by the KMS helpers before calling into the encoder), along 249 * with connector creation. When done with the bridge (after 250 * drm_mode_config_cleanup() if the bridge has already been attached), then 251 * drm_panel_bridge_remove() to free it. 252 * 253 * The connector type is set to @panel->connector_type, which must be set to a 254 * known type. Calling this function with a panel whose connector type is 255 * DRM_MODE_CONNECTOR_Unknown will return ERR_PTR(-EINVAL). 256 * 257 * See devm_drm_panel_bridge_add() for an automatically managed version of this 258 * function. 259 */ 260 struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel) 261 { 262 if (WARN_ON(panel->connector_type == DRM_MODE_CONNECTOR_Unknown)) 263 return ERR_PTR(-EINVAL); 264 265 return drm_panel_bridge_add_typed(panel, panel->connector_type); 266 } 267 EXPORT_SYMBOL(drm_panel_bridge_add); 268 269 /** 270 * drm_panel_bridge_add_typed - Creates a &drm_bridge and &drm_connector with 271 * an explicit connector type. 272 * @panel: The drm_panel being wrapped. Must be non-NULL. 273 * @connector_type: The connector type (DRM_MODE_CONNECTOR_*) 274 * 275 * This is just like drm_panel_bridge_add(), but forces the connector type to 276 * @connector_type instead of infering it from the panel. 277 * 278 * This function is deprecated and should not be used in new drivers. Use 279 * drm_panel_bridge_add() instead, and fix panel drivers as necessary if they 280 * don't report a connector type. 281 */ 282 struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel, 283 u32 connector_type) 284 { 285 struct panel_bridge *panel_bridge; 286 287 if (!panel) 288 return ERR_PTR(-EINVAL); 289 290 panel_bridge = devm_kzalloc(panel->dev, sizeof(*panel_bridge), 291 GFP_KERNEL); 292 if (!panel_bridge) 293 return ERR_PTR(-ENOMEM); 294 295 panel_bridge->connector_type = connector_type; 296 panel_bridge->panel = panel; 297 298 panel_bridge->bridge.funcs = &panel_bridge_bridge_funcs; 299 panel_bridge->bridge.of_node = panel->dev->of_node; 300 panel_bridge->bridge.ops = DRM_BRIDGE_OP_MODES; 301 panel_bridge->bridge.type = connector_type; 302 panel_bridge->bridge.pre_enable_prev_first = panel->prepare_prev_first; 303 304 drm_bridge_add(&panel_bridge->bridge); 305 306 return &panel_bridge->bridge; 307 } 308 EXPORT_SYMBOL(drm_panel_bridge_add_typed); 309 310 /** 311 * drm_panel_bridge_remove - Unregisters and frees a drm_bridge 312 * created by drm_panel_bridge_add(). 313 * 314 * @bridge: The drm_bridge being freed. 315 */ 316 void drm_panel_bridge_remove(struct drm_bridge *bridge) 317 { 318 struct panel_bridge *panel_bridge; 319 320 if (!bridge) 321 return; 322 323 if (!drm_bridge_is_panel(bridge)) { 324 drm_warn(bridge->dev, "%s: called on non-panel bridge!\n", __func__); 325 return; 326 } 327 328 panel_bridge = drm_bridge_to_panel_bridge(bridge); 329 330 drm_bridge_remove(bridge); 331 devm_kfree(panel_bridge->panel->dev, bridge); 332 } 333 EXPORT_SYMBOL(drm_panel_bridge_remove); 334 335 /** 336 * drm_panel_bridge_set_orientation - Set the connector's panel orientation 337 * from the bridge that can be transformed to panel bridge. 338 * 339 * @connector: The connector to be set panel orientation. 340 * @bridge: The drm_bridge to be transformed to panel bridge. 341 * 342 * Returns 0 on success, negative errno on failure. 343 */ 344 int drm_panel_bridge_set_orientation(struct drm_connector *connector, 345 struct drm_bridge *bridge) 346 { 347 struct panel_bridge *panel_bridge; 348 349 panel_bridge = drm_bridge_to_panel_bridge(bridge); 350 351 return drm_connector_set_orientation_from_panel(connector, 352 panel_bridge->panel); 353 } 354 EXPORT_SYMBOL(drm_panel_bridge_set_orientation); 355 356 static void devm_drm_panel_bridge_release(struct device *dev, void *res) 357 { 358 struct drm_bridge *bridge = *(struct drm_bridge **)res; 359 360 if (!bridge) 361 return; 362 363 drm_bridge_remove(bridge); 364 } 365 366 /** 367 * devm_drm_panel_bridge_add - Creates a managed &drm_bridge and &drm_connector 368 * that just calls the appropriate functions from &drm_panel. 369 * @dev: device to tie the bridge lifetime to 370 * @panel: The drm_panel being wrapped. Must be non-NULL. 371 * 372 * This is the managed version of drm_panel_bridge_add() which automatically 373 * calls drm_panel_bridge_remove() when @dev is unbound. 374 */ 375 struct drm_bridge *devm_drm_panel_bridge_add(struct device *dev, 376 struct drm_panel *panel) 377 { 378 if (WARN_ON(panel->connector_type == DRM_MODE_CONNECTOR_Unknown)) 379 return ERR_PTR(-EINVAL); 380 381 return devm_drm_panel_bridge_add_typed(dev, panel, 382 panel->connector_type); 383 } 384 EXPORT_SYMBOL(devm_drm_panel_bridge_add); 385 386 /** 387 * devm_drm_panel_bridge_add_typed - Creates a managed &drm_bridge and 388 * &drm_connector with an explicit connector type. 389 * @dev: device to tie the bridge lifetime to 390 * @panel: The drm_panel being wrapped. Must be non-NULL. 391 * @connector_type: The connector type (DRM_MODE_CONNECTOR_*) 392 * 393 * This is just like devm_drm_panel_bridge_add(), but forces the connector type 394 * to @connector_type instead of infering it from the panel. 395 * 396 * This function is deprecated and should not be used in new drivers. Use 397 * devm_drm_panel_bridge_add() instead, and fix panel drivers as necessary if 398 * they don't report a connector type. 399 */ 400 struct drm_bridge *devm_drm_panel_bridge_add_typed(struct device *dev, 401 struct drm_panel *panel, 402 u32 connector_type) 403 { 404 struct drm_bridge **ptr, *bridge; 405 406 ptr = devres_alloc(devm_drm_panel_bridge_release, sizeof(*ptr), 407 GFP_KERNEL); 408 if (!ptr) 409 return ERR_PTR(-ENOMEM); 410 411 bridge = drm_panel_bridge_add_typed(panel, connector_type); 412 if (IS_ERR(bridge)) { 413 devres_free(ptr); 414 return bridge; 415 } 416 417 *ptr = bridge; 418 devres_add(dev, ptr); 419 420 return bridge; 421 } 422 EXPORT_SYMBOL(devm_drm_panel_bridge_add_typed); 423 424 static void drmm_drm_panel_bridge_release(struct drm_device *drm, void *ptr) 425 { 426 struct drm_bridge *bridge = ptr; 427 428 drm_panel_bridge_remove(bridge); 429 } 430 431 /** 432 * drmm_panel_bridge_add - Creates a DRM-managed &drm_bridge and 433 * &drm_connector that just calls the 434 * appropriate functions from &drm_panel. 435 * 436 * @drm: DRM device to tie the bridge lifetime to 437 * @panel: The drm_panel being wrapped. Must be non-NULL. 438 * 439 * This is the DRM-managed version of drm_panel_bridge_add() which 440 * automatically calls drm_panel_bridge_remove() when @dev is cleaned 441 * up. 442 */ 443 struct drm_bridge *drmm_panel_bridge_add(struct drm_device *drm, 444 struct drm_panel *panel) 445 { 446 struct drm_bridge *bridge; 447 int ret; 448 449 bridge = drm_panel_bridge_add_typed(panel, panel->connector_type); 450 if (IS_ERR(bridge)) 451 return bridge; 452 453 ret = drmm_add_action_or_reset(drm, drmm_drm_panel_bridge_release, 454 bridge); 455 if (ret) 456 return ERR_PTR(ret); 457 458 return bridge; 459 } 460 EXPORT_SYMBOL(drmm_panel_bridge_add); 461 462 /** 463 * drm_panel_bridge_connector - return the connector for the panel bridge 464 * @bridge: The drm_bridge. 465 * 466 * drm_panel_bridge creates the connector. 467 * This function gives external access to the connector. 468 * 469 * Returns: Pointer to drm_connector 470 */ 471 struct drm_connector *drm_panel_bridge_connector(struct drm_bridge *bridge) 472 { 473 struct panel_bridge *panel_bridge; 474 475 panel_bridge = drm_bridge_to_panel_bridge(bridge); 476 477 return &panel_bridge->connector; 478 } 479 EXPORT_SYMBOL(drm_panel_bridge_connector); 480 481 #ifdef CONFIG_OF 482 /** 483 * devm_drm_of_get_bridge - Return next bridge in the chain 484 * @dev: device to tie the bridge lifetime to 485 * @np: device tree node containing encoder output ports 486 * @port: port in the device tree node 487 * @endpoint: endpoint in the device tree node 488 * 489 * Given a DT node's port and endpoint number, finds the connected node 490 * and returns the associated bridge if any, or creates and returns a 491 * drm panel bridge instance if a panel is connected. 492 * 493 * Returns a pointer to the bridge if successful, or an error pointer 494 * otherwise. 495 */ 496 struct drm_bridge *devm_drm_of_get_bridge(struct device *dev, 497 struct device_node *np, 498 u32 port, u32 endpoint) 499 { 500 struct drm_bridge *bridge; 501 struct drm_panel *panel; 502 int ret; 503 504 ret = drm_of_find_panel_or_bridge(np, port, endpoint, 505 &panel, &bridge); 506 if (ret) 507 return ERR_PTR(ret); 508 509 if (panel) 510 bridge = devm_drm_panel_bridge_add(dev, panel); 511 512 return bridge; 513 } 514 EXPORT_SYMBOL(devm_drm_of_get_bridge); 515 516 /** 517 * drmm_of_get_bridge - Return next bridge in the chain 518 * @drm: device to tie the bridge lifetime to 519 * @np: device tree node containing encoder output ports 520 * @port: port in the device tree node 521 * @endpoint: endpoint in the device tree node 522 * 523 * Given a DT node's port and endpoint number, finds the connected node 524 * and returns the associated bridge if any, or creates and returns a 525 * drm panel bridge instance if a panel is connected. 526 * 527 * Returns a drmm managed pointer to the bridge if successful, or an error 528 * pointer otherwise. 529 */ 530 struct drm_bridge *drmm_of_get_bridge(struct drm_device *drm, 531 struct device_node *np, 532 u32 port, u32 endpoint) 533 { 534 struct drm_bridge *bridge; 535 struct drm_panel *panel; 536 int ret; 537 538 ret = drm_of_find_panel_or_bridge(np, port, endpoint, 539 &panel, &bridge); 540 if (ret) 541 return ERR_PTR(ret); 542 543 if (panel) 544 bridge = drmm_panel_bridge_add(drm, panel); 545 546 return bridge; 547 } 548 EXPORT_SYMBOL(drmm_of_get_bridge); 549 550 #endif 551