1 /* 2 * Copyright (c) 2016 Intel Corporation 3 * 4 * Permission to use, copy, modify, distribute, and sell this software and its 5 * documentation for any purpose is hereby granted without fee, provided that 6 * the above copyright notice appear in all copies and that both that copyright 7 * notice and this permission notice appear in supporting documentation, and 8 * that the name of the copyright holders not be used in advertising or 9 * publicity pertaining to distribution of the software without specific, 10 * written prior permission. The copyright holders make no representations 11 * about the suitability of this software for any purpose. It is provided "as 12 * is" without express or implied warranty. 13 * 14 * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, 15 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO 16 * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR 17 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 18 * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER 19 * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE 20 * OF THIS SOFTWARE. 21 */ 22 23 #ifndef __DRM_BRIDGE_H__ 24 #define __DRM_BRIDGE_H__ 25 26 #include <linux/ctype.h> 27 #include <linux/list.h> 28 #include <linux/mutex.h> 29 30 #include <drm/drm_atomic.h> 31 #include <drm/drm_encoder.h> 32 #include <drm/drm_mode_object.h> 33 #include <drm/drm_modes.h> 34 35 struct drm_bridge; 36 struct drm_bridge_timings; 37 struct drm_connector; 38 struct drm_display_info; 39 struct drm_panel; 40 struct edid; 41 struct i2c_adapter; 42 43 /** 44 * enum drm_bridge_attach_flags - Flags for &drm_bridge_funcs.attach 45 */ 46 enum drm_bridge_attach_flags { 47 /** 48 * @DRM_BRIDGE_ATTACH_NO_CONNECTOR: When this flag is set the bridge 49 * shall not create a drm_connector. 50 */ 51 DRM_BRIDGE_ATTACH_NO_CONNECTOR = BIT(0), 52 }; 53 54 /** 55 * struct drm_bridge_funcs - drm_bridge control functions 56 */ 57 struct drm_bridge_funcs { 58 /** 59 * @attach: 60 * 61 * This callback is invoked whenever our bridge is being attached to a 62 * &drm_encoder. The flags argument tunes the behaviour of the attach 63 * operation (see DRM_BRIDGE_ATTACH_*). 64 * 65 * The @attach callback is optional. 66 * 67 * RETURNS: 68 * 69 * Zero on success, error code on failure. 70 */ 71 int (*attach)(struct drm_bridge *bridge, 72 enum drm_bridge_attach_flags flags); 73 74 /** 75 * @detach: 76 * 77 * This callback is invoked whenever our bridge is being detached from a 78 * &drm_encoder. 79 * 80 * The @detach callback is optional. 81 */ 82 void (*detach)(struct drm_bridge *bridge); 83 84 /** 85 * @mode_valid: 86 * 87 * This callback is used to check if a specific mode is valid in this 88 * bridge. This should be implemented if the bridge has some sort of 89 * restriction in the modes it can display. For example, a given bridge 90 * may be responsible to set a clock value. If the clock can not 91 * produce all the values for the available modes then this callback 92 * can be used to restrict the number of modes to only the ones that 93 * can be displayed. 94 * 95 * This hook is used by the probe helpers to filter the mode list in 96 * drm_helper_probe_single_connector_modes(), and it is used by the 97 * atomic helpers to validate modes supplied by userspace in 98 * drm_atomic_helper_check_modeset(). 99 * 100 * The @mode_valid callback is optional. 101 * 102 * NOTE: 103 * 104 * Since this function is both called from the check phase of an atomic 105 * commit, and the mode validation in the probe paths it is not allowed 106 * to look at anything else but the passed-in mode, and validate it 107 * against configuration-invariant hardward constraints. Any further 108 * limits which depend upon the configuration can only be checked in 109 * @mode_fixup. 110 * 111 * RETURNS: 112 * 113 * drm_mode_status Enum 114 */ 115 enum drm_mode_status (*mode_valid)(struct drm_bridge *bridge, 116 const struct drm_display_info *info, 117 const struct drm_display_mode *mode); 118 119 /** 120 * @mode_fixup: 121 * 122 * This callback is used to validate and adjust a mode. The parameter 123 * mode is the display mode that should be fed to the next element in 124 * the display chain, either the final &drm_connector or the next 125 * &drm_bridge. The parameter adjusted_mode is the input mode the bridge 126 * requires. It can be modified by this callback and does not need to 127 * match mode. See also &drm_crtc_state.adjusted_mode for more details. 128 * 129 * This is the only hook that allows a bridge to reject a modeset. If 130 * this function passes all other callbacks must succeed for this 131 * configuration. 132 * 133 * The mode_fixup callback is optional. &drm_bridge_funcs.mode_fixup() 134 * is not called when &drm_bridge_funcs.atomic_check() is implemented, 135 * so only one of them should be provided. 136 * 137 * NOTE: 138 * 139 * This function is called in the check phase of atomic modesets, which 140 * can be aborted for any reason (including on userspace's request to 141 * just check whether a configuration would be possible). Drivers MUST 142 * NOT touch any persistent state (hardware or software) or data 143 * structures except the passed in @state parameter. 144 * 145 * Also beware that userspace can request its own custom modes, neither 146 * core nor helpers filter modes to the list of probe modes reported by 147 * the GETCONNECTOR IOCTL and stored in &drm_connector.modes. To ensure 148 * that modes are filtered consistently put any bridge constraints and 149 * limits checks into @mode_valid. 150 * 151 * RETURNS: 152 * 153 * True if an acceptable configuration is possible, false if the modeset 154 * operation should be rejected. 155 */ 156 bool (*mode_fixup)(struct drm_bridge *bridge, 157 const struct drm_display_mode *mode, 158 struct drm_display_mode *adjusted_mode); 159 /** 160 * @disable: 161 * 162 * This callback should disable the bridge. It is called right before 163 * the preceding element in the display pipe is disabled. If the 164 * preceding element is a bridge this means it's called before that 165 * bridge's @disable vfunc. If the preceding element is a &drm_encoder 166 * it's called right before the &drm_encoder_helper_funcs.disable, 167 * &drm_encoder_helper_funcs.prepare or &drm_encoder_helper_funcs.dpms 168 * hook. 169 * 170 * The bridge can assume that the display pipe (i.e. clocks and timing 171 * signals) feeding it is still running when this callback is called. 172 * 173 * The @disable callback is optional. 174 * 175 * NOTE: 176 * 177 * This is deprecated, do not use! 178 * New drivers shall use &drm_bridge_funcs.atomic_disable. 179 */ 180 void (*disable)(struct drm_bridge *bridge); 181 182 /** 183 * @post_disable: 184 * 185 * This callback should disable the bridge. It is called right after the 186 * preceding element in the display pipe is disabled. If the preceding 187 * element is a bridge this means it's called after that bridge's 188 * @post_disable function. If the preceding element is a &drm_encoder 189 * it's called right after the encoder's 190 * &drm_encoder_helper_funcs.disable, &drm_encoder_helper_funcs.prepare 191 * or &drm_encoder_helper_funcs.dpms hook. 192 * 193 * The bridge must assume that the display pipe (i.e. clocks and timing 194 * singals) feeding it is no longer running when this callback is 195 * called. 196 * 197 * The @post_disable callback is optional. 198 * 199 * NOTE: 200 * 201 * This is deprecated, do not use! 202 * New drivers shall use &drm_bridge_funcs.atomic_post_disable. 203 */ 204 void (*post_disable)(struct drm_bridge *bridge); 205 206 /** 207 * @mode_set: 208 * 209 * This callback should set the given mode on the bridge. It is called 210 * after the @mode_set callback for the preceding element in the display 211 * pipeline has been called already. If the bridge is the first element 212 * then this would be &drm_encoder_helper_funcs.mode_set. The display 213 * pipe (i.e. clocks and timing signals) is off when this function is 214 * called. 215 * 216 * The adjusted_mode parameter is the mode output by the CRTC for the 217 * first bridge in the chain. It can be different from the mode 218 * parameter that contains the desired mode for the connector at the end 219 * of the bridges chain, for instance when the first bridge in the chain 220 * performs scaling. The adjusted mode is mostly useful for the first 221 * bridge in the chain and is likely irrelevant for the other bridges. 222 * 223 * For atomic drivers the adjusted_mode is the mode stored in 224 * &drm_crtc_state.adjusted_mode. 225 * 226 * NOTE: 227 * 228 * This is deprecated, do not use! 229 * New drivers shall set their mode in the 230 * &drm_bridge_funcs.atomic_enable operation. 231 */ 232 void (*mode_set)(struct drm_bridge *bridge, 233 const struct drm_display_mode *mode, 234 const struct drm_display_mode *adjusted_mode); 235 /** 236 * @pre_enable: 237 * 238 * This callback should enable the bridge. It is called right before 239 * the preceding element in the display pipe is enabled. If the 240 * preceding element is a bridge this means it's called before that 241 * bridge's @pre_enable function. If the preceding element is a 242 * &drm_encoder it's called right before the encoder's 243 * &drm_encoder_helper_funcs.enable, &drm_encoder_helper_funcs.commit or 244 * &drm_encoder_helper_funcs.dpms hook. 245 * 246 * The display pipe (i.e. clocks and timing signals) feeding this bridge 247 * will not yet be running when this callback is called. The bridge must 248 * not enable the display link feeding the next bridge in the chain (if 249 * there is one) when this callback is called. 250 * 251 * The @pre_enable callback is optional. 252 * 253 * NOTE: 254 * 255 * This is deprecated, do not use! 256 * New drivers shall use &drm_bridge_funcs.atomic_pre_enable. 257 */ 258 void (*pre_enable)(struct drm_bridge *bridge); 259 260 /** 261 * @enable: 262 * 263 * This callback should enable the bridge. It is called right after 264 * the preceding element in the display pipe is enabled. If the 265 * preceding element is a bridge this means it's called after that 266 * bridge's @enable function. If the preceding element is a 267 * &drm_encoder it's called right after the encoder's 268 * &drm_encoder_helper_funcs.enable, &drm_encoder_helper_funcs.commit or 269 * &drm_encoder_helper_funcs.dpms hook. 270 * 271 * The bridge can assume that the display pipe (i.e. clocks and timing 272 * signals) feeding it is running when this callback is called. This 273 * callback must enable the display link feeding the next bridge in the 274 * chain if there is one. 275 * 276 * The @enable callback is optional. 277 * 278 * NOTE: 279 * 280 * This is deprecated, do not use! 281 * New drivers shall use &drm_bridge_funcs.atomic_enable. 282 */ 283 void (*enable)(struct drm_bridge *bridge); 284 285 /** 286 * @atomic_pre_enable: 287 * 288 * This callback should enable the bridge. It is called right before 289 * the preceding element in the display pipe is enabled. If the 290 * preceding element is a bridge this means it's called before that 291 * bridge's @atomic_pre_enable or @pre_enable function. If the preceding 292 * element is a &drm_encoder it's called right before the encoder's 293 * &drm_encoder_helper_funcs.atomic_enable hook. 294 * 295 * The display pipe (i.e. clocks and timing signals) feeding this bridge 296 * will not yet be running when this callback is called. The bridge must 297 * not enable the display link feeding the next bridge in the chain (if 298 * there is one) when this callback is called. 299 * 300 * Note that this function will only be invoked in the context of an 301 * atomic commit. It will not be invoked from 302 * &drm_bridge_chain_pre_enable. It would be prudent to also provide an 303 * implementation of @pre_enable if you are expecting driver calls into 304 * &drm_bridge_chain_pre_enable. 305 * 306 * The @atomic_pre_enable callback is optional. 307 */ 308 void (*atomic_pre_enable)(struct drm_bridge *bridge, 309 struct drm_bridge_state *old_bridge_state); 310 311 /** 312 * @atomic_enable: 313 * 314 * This callback should enable the bridge. It is called right after 315 * the preceding element in the display pipe is enabled. If the 316 * preceding element is a bridge this means it's called after that 317 * bridge's @atomic_enable or @enable function. If the preceding element 318 * is a &drm_encoder it's called right after the encoder's 319 * &drm_encoder_helper_funcs.atomic_enable hook. 320 * 321 * The bridge can assume that the display pipe (i.e. clocks and timing 322 * signals) feeding it is running when this callback is called. This 323 * callback must enable the display link feeding the next bridge in the 324 * chain if there is one. 325 * 326 * Note that this function will only be invoked in the context of an 327 * atomic commit. It will not be invoked from &drm_bridge_chain_enable. 328 * It would be prudent to also provide an implementation of @enable if 329 * you are expecting driver calls into &drm_bridge_chain_enable. 330 * 331 * The @atomic_enable callback is optional. 332 */ 333 void (*atomic_enable)(struct drm_bridge *bridge, 334 struct drm_bridge_state *old_bridge_state); 335 /** 336 * @atomic_disable: 337 * 338 * This callback should disable the bridge. It is called right before 339 * the preceding element in the display pipe is disabled. If the 340 * preceding element is a bridge this means it's called before that 341 * bridge's @atomic_disable or @disable vfunc. If the preceding element 342 * is a &drm_encoder it's called right before the 343 * &drm_encoder_helper_funcs.atomic_disable hook. 344 * 345 * The bridge can assume that the display pipe (i.e. clocks and timing 346 * signals) feeding it is still running when this callback is called. 347 * 348 * Note that this function will only be invoked in the context of an 349 * atomic commit. It will not be invoked from 350 * &drm_bridge_chain_disable. It would be prudent to also provide an 351 * implementation of @disable if you are expecting driver calls into 352 * &drm_bridge_chain_disable. 353 * 354 * The @atomic_disable callback is optional. 355 */ 356 void (*atomic_disable)(struct drm_bridge *bridge, 357 struct drm_bridge_state *old_bridge_state); 358 359 /** 360 * @atomic_post_disable: 361 * 362 * This callback should disable the bridge. It is called right after the 363 * preceding element in the display pipe is disabled. If the preceding 364 * element is a bridge this means it's called after that bridge's 365 * @atomic_post_disable or @post_disable function. If the preceding 366 * element is a &drm_encoder it's called right after the encoder's 367 * &drm_encoder_helper_funcs.atomic_disable hook. 368 * 369 * The bridge must assume that the display pipe (i.e. clocks and timing 370 * signals) feeding it is no longer running when this callback is 371 * called. 372 * 373 * Note that this function will only be invoked in the context of an 374 * atomic commit. It will not be invoked from 375 * &drm_bridge_chain_post_disable. 376 * It would be prudent to also provide an implementation of 377 * @post_disable if you are expecting driver calls into 378 * &drm_bridge_chain_post_disable. 379 * 380 * The @atomic_post_disable callback is optional. 381 */ 382 void (*atomic_post_disable)(struct drm_bridge *bridge, 383 struct drm_bridge_state *old_bridge_state); 384 385 /** 386 * @atomic_duplicate_state: 387 * 388 * Duplicate the current bridge state object (which is guaranteed to be 389 * non-NULL). 390 * 391 * The atomic_duplicate_state hook is mandatory if the bridge 392 * implements any of the atomic hooks, and should be left unassigned 393 * otherwise. For bridges that don't subclass &drm_bridge_state, the 394 * drm_atomic_helper_bridge_duplicate_state() helper function shall be 395 * used to implement this hook. 396 * 397 * RETURNS: 398 * A valid drm_bridge_state object or NULL if the allocation fails. 399 */ 400 struct drm_bridge_state *(*atomic_duplicate_state)(struct drm_bridge *bridge); 401 402 /** 403 * @atomic_destroy_state: 404 * 405 * Destroy a bridge state object previously allocated by 406 * &drm_bridge_funcs.atomic_duplicate_state(). 407 * 408 * The atomic_destroy_state hook is mandatory if the bridge implements 409 * any of the atomic hooks, and should be left unassigned otherwise. 410 * For bridges that don't subclass &drm_bridge_state, the 411 * drm_atomic_helper_bridge_destroy_state() helper function shall be 412 * used to implement this hook. 413 */ 414 void (*atomic_destroy_state)(struct drm_bridge *bridge, 415 struct drm_bridge_state *state); 416 417 /** 418 * @atomic_get_output_bus_fmts: 419 * 420 * Return the supported bus formats on the output end of a bridge. 421 * The returned array must be allocated with kmalloc() and will be 422 * freed by the caller. If the allocation fails, NULL should be 423 * returned. num_output_fmts must be set to the returned array size. 424 * Formats listed in the returned array should be listed in decreasing 425 * preference order (the core will try all formats until it finds one 426 * that works). 427 * 428 * This method is only called on the last element of the bridge chain 429 * as part of the bus format negotiation process that happens in 430 * &drm_atomic_bridge_chain_select_bus_fmts(). 431 * This method is optional. When not implemented, the core will 432 * fall back to &drm_connector.display_info.bus_formats[0] if 433 * &drm_connector.display_info.num_bus_formats > 0, 434 * or to MEDIA_BUS_FMT_FIXED otherwise. 435 */ 436 u32 *(*atomic_get_output_bus_fmts)(struct drm_bridge *bridge, 437 struct drm_bridge_state *bridge_state, 438 struct drm_crtc_state *crtc_state, 439 struct drm_connector_state *conn_state, 440 unsigned int *num_output_fmts); 441 442 /** 443 * @atomic_get_input_bus_fmts: 444 * 445 * Return the supported bus formats on the input end of a bridge for 446 * a specific output bus format. 447 * 448 * The returned array must be allocated with kmalloc() and will be 449 * freed by the caller. If the allocation fails, NULL should be 450 * returned. num_output_fmts must be set to the returned array size. 451 * Formats listed in the returned array should be listed in decreasing 452 * preference order (the core will try all formats until it finds one 453 * that works). When the format is not supported NULL should be 454 * returned and num_output_fmts should be set to 0. 455 * 456 * This method is called on all elements of the bridge chain as part of 457 * the bus format negotiation process that happens in 458 * drm_atomic_bridge_chain_select_bus_fmts(). 459 * This method is optional. When not implemented, the core will bypass 460 * bus format negotiation on this element of the bridge without 461 * failing, and the previous element in the chain will be passed 462 * MEDIA_BUS_FMT_FIXED as its output bus format. 463 * 464 * Bridge drivers that need to support being linked to bridges that are 465 * not supporting bus format negotiation should handle the 466 * output_fmt == MEDIA_BUS_FMT_FIXED case appropriately, by selecting a 467 * sensible default value or extracting this information from somewhere 468 * else (FW property, &drm_display_mode, &drm_display_info, ...) 469 * 470 * Note: Even if input format selection on the first bridge has no 471 * impact on the negotiation process (bus format negotiation stops once 472 * we reach the first element of the chain), drivers are expected to 473 * return accurate input formats as the input format may be used to 474 * configure the CRTC output appropriately. 475 */ 476 u32 *(*atomic_get_input_bus_fmts)(struct drm_bridge *bridge, 477 struct drm_bridge_state *bridge_state, 478 struct drm_crtc_state *crtc_state, 479 struct drm_connector_state *conn_state, 480 u32 output_fmt, 481 unsigned int *num_input_fmts); 482 483 /** 484 * @atomic_check: 485 * 486 * This method is responsible for checking bridge state correctness. 487 * It can also check the state of the surrounding components in chain 488 * to make sure the whole pipeline can work properly. 489 * 490 * &drm_bridge_funcs.atomic_check() hooks are called in reverse 491 * order (from the last to the first bridge). 492 * 493 * This method is optional. &drm_bridge_funcs.mode_fixup() is not 494 * called when &drm_bridge_funcs.atomic_check() is implemented, so only 495 * one of them should be provided. 496 * 497 * If drivers need to tweak &drm_bridge_state.input_bus_cfg.flags or 498 * &drm_bridge_state.output_bus_cfg.flags it should happen in 499 * this function. By default the &drm_bridge_state.output_bus_cfg.flags 500 * field is set to the next bridge 501 * &drm_bridge_state.input_bus_cfg.flags value or 502 * &drm_connector.display_info.bus_flags if the bridge is the last 503 * element in the chain. 504 * 505 * RETURNS: 506 * zero if the check passed, a negative error code otherwise. 507 */ 508 int (*atomic_check)(struct drm_bridge *bridge, 509 struct drm_bridge_state *bridge_state, 510 struct drm_crtc_state *crtc_state, 511 struct drm_connector_state *conn_state); 512 513 /** 514 * @atomic_reset: 515 * 516 * Reset the bridge to a predefined state (or retrieve its current 517 * state) and return a &drm_bridge_state object matching this state. 518 * This function is called at attach time. 519 * 520 * The atomic_reset hook is mandatory if the bridge implements any of 521 * the atomic hooks, and should be left unassigned otherwise. For 522 * bridges that don't subclass &drm_bridge_state, the 523 * drm_atomic_helper_bridge_reset() helper function shall be used to 524 * implement this hook. 525 * 526 * Note that the atomic_reset() semantics is not exactly matching the 527 * reset() semantics found on other components (connector, plane, ...). 528 * 529 * 1. The reset operation happens when the bridge is attached, not when 530 * drm_mode_config_reset() is called 531 * 2. It's meant to be used exclusively on bridges that have been 532 * converted to the ATOMIC API 533 * 534 * RETURNS: 535 * A valid drm_bridge_state object in case of success, an ERR_PTR() 536 * giving the reason of the failure otherwise. 537 */ 538 struct drm_bridge_state *(*atomic_reset)(struct drm_bridge *bridge); 539 540 /** 541 * @detect: 542 * 543 * Check if anything is attached to the bridge output. 544 * 545 * This callback is optional, if not implemented the bridge will be 546 * considered as always having a component attached to its output. 547 * Bridges that implement this callback shall set the 548 * DRM_BRIDGE_OP_DETECT flag in their &drm_bridge->ops. 549 * 550 * RETURNS: 551 * 552 * drm_connector_status indicating the bridge output status. 553 */ 554 enum drm_connector_status (*detect)(struct drm_bridge *bridge); 555 556 /** 557 * @get_modes: 558 * 559 * Fill all modes currently valid for the sink into the &drm_connector 560 * with drm_mode_probed_add(). 561 * 562 * The @get_modes callback is mostly intended to support non-probeable 563 * displays such as many fixed panels. Bridges that support reading 564 * EDID shall leave @get_modes unimplemented and implement the 565 * &drm_bridge_funcs->get_edid callback instead. 566 * 567 * This callback is optional. Bridges that implement it shall set the 568 * DRM_BRIDGE_OP_MODES flag in their &drm_bridge->ops. 569 * 570 * The connector parameter shall be used for the sole purpose of 571 * filling modes, and shall not be stored internally by bridge drivers 572 * for future usage. 573 * 574 * RETURNS: 575 * 576 * The number of modes added by calling drm_mode_probed_add(). 577 */ 578 int (*get_modes)(struct drm_bridge *bridge, 579 struct drm_connector *connector); 580 581 /** 582 * @get_edid: 583 * 584 * Read and parse the EDID data of the connected display. 585 * 586 * The @get_edid callback is the preferred way of reporting mode 587 * information for a display connected to the bridge output. Bridges 588 * that support reading EDID shall implement this callback and leave 589 * the @get_modes callback unimplemented. 590 * 591 * The caller of this operation shall first verify the output 592 * connection status and refrain from reading EDID from a disconnected 593 * output. 594 * 595 * This callback is optional. Bridges that implement it shall set the 596 * DRM_BRIDGE_OP_EDID flag in their &drm_bridge->ops. 597 * 598 * The connector parameter shall be used for the sole purpose of EDID 599 * retrieval and parsing, and shall not be stored internally by bridge 600 * drivers for future usage. 601 * 602 * RETURNS: 603 * 604 * An edid structure newly allocated with kmalloc() (or similar) on 605 * success, or NULL otherwise. The caller is responsible for freeing 606 * the returned edid structure with kfree(). 607 */ 608 struct edid *(*get_edid)(struct drm_bridge *bridge, 609 struct drm_connector *connector); 610 611 /** 612 * @hpd_notify: 613 * 614 * Notify the bridge of hot plug detection. 615 * 616 * This callback is optional, it may be implemented by bridges that 617 * need to be notified of display connection or disconnection for 618 * internal reasons. One use case is to reset the internal state of CEC 619 * controllers for HDMI bridges. 620 */ 621 void (*hpd_notify)(struct drm_bridge *bridge, 622 enum drm_connector_status status); 623 624 /** 625 * @hpd_enable: 626 * 627 * Enable hot plug detection. From now on the bridge shall call 628 * drm_bridge_hpd_notify() each time a change is detected in the output 629 * connection status, until hot plug detection gets disabled with 630 * @hpd_disable. 631 * 632 * This callback is optional and shall only be implemented by bridges 633 * that support hot-plug notification without polling. Bridges that 634 * implement it shall also implement the @hpd_disable callback and set 635 * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops. 636 */ 637 void (*hpd_enable)(struct drm_bridge *bridge); 638 639 /** 640 * @hpd_disable: 641 * 642 * Disable hot plug detection. Once this function returns the bridge 643 * shall not call drm_bridge_hpd_notify() when a change in the output 644 * connection status occurs. 645 * 646 * This callback is optional and shall only be implemented by bridges 647 * that support hot-plug notification without polling. Bridges that 648 * implement it shall also implement the @hpd_enable callback and set 649 * the DRM_BRIDGE_OP_HPD flag in their &drm_bridge->ops. 650 */ 651 void (*hpd_disable)(struct drm_bridge *bridge); 652 }; 653 654 /** 655 * struct drm_bridge_timings - timing information for the bridge 656 */ 657 struct drm_bridge_timings { 658 /** 659 * @input_bus_flags: 660 * 661 * Tells what additional settings for the pixel data on the bus 662 * this bridge requires (like pixel signal polarity). See also 663 * &drm_display_info->bus_flags. 664 */ 665 u32 input_bus_flags; 666 /** 667 * @setup_time_ps: 668 * 669 * Defines the time in picoseconds the input data lines must be 670 * stable before the clock edge. 671 */ 672 u32 setup_time_ps; 673 /** 674 * @hold_time_ps: 675 * 676 * Defines the time in picoseconds taken for the bridge to sample the 677 * input signal after the clock edge. 678 */ 679 u32 hold_time_ps; 680 /** 681 * @dual_link: 682 * 683 * True if the bus operates in dual-link mode. The exact meaning is 684 * dependent on the bus type. For LVDS buses, this indicates that even- 685 * and odd-numbered pixels are received on separate links. 686 */ 687 bool dual_link; 688 }; 689 690 /** 691 * enum drm_bridge_ops - Bitmask of operations supported by the bridge 692 */ 693 enum drm_bridge_ops { 694 /** 695 * @DRM_BRIDGE_OP_DETECT: The bridge can detect displays connected to 696 * its output. Bridges that set this flag shall implement the 697 * &drm_bridge_funcs->detect callback. 698 */ 699 DRM_BRIDGE_OP_DETECT = BIT(0), 700 /** 701 * @DRM_BRIDGE_OP_EDID: The bridge can retrieve the EDID of the display 702 * connected to its output. Bridges that set this flag shall implement 703 * the &drm_bridge_funcs->get_edid callback. 704 */ 705 DRM_BRIDGE_OP_EDID = BIT(1), 706 /** 707 * @DRM_BRIDGE_OP_HPD: The bridge can detect hot-plug and hot-unplug 708 * without requiring polling. Bridges that set this flag shall 709 * implement the &drm_bridge_funcs->hpd_enable and 710 * &drm_bridge_funcs->hpd_disable callbacks if they support enabling 711 * and disabling hot-plug detection dynamically. 712 */ 713 DRM_BRIDGE_OP_HPD = BIT(2), 714 /** 715 * @DRM_BRIDGE_OP_MODES: The bridge can retrieve the modes supported 716 * by the display at its output. This does not include reading EDID 717 * which is separately covered by @DRM_BRIDGE_OP_EDID. Bridges that set 718 * this flag shall implement the &drm_bridge_funcs->get_modes callback. 719 */ 720 DRM_BRIDGE_OP_MODES = BIT(3), 721 }; 722 723 /** 724 * struct drm_bridge - central DRM bridge control structure 725 */ 726 struct drm_bridge { 727 /** @base: inherit from &drm_private_object */ 728 struct drm_private_obj base; 729 /** @dev: DRM device this bridge belongs to */ 730 struct drm_device *dev; 731 /** @encoder: encoder to which this bridge is connected */ 732 struct drm_encoder *encoder; 733 /** @chain_node: used to form a bridge chain */ 734 struct list_head chain_node; 735 #ifdef CONFIG_OF 736 /** @of_node: device node pointer to the bridge */ 737 struct device_node *of_node; 738 #endif 739 /** @list: to keep track of all added bridges */ 740 struct list_head list; 741 /** 742 * @timings: 743 * 744 * the timing specification for the bridge, if any (may be NULL) 745 */ 746 const struct drm_bridge_timings *timings; 747 /** @funcs: control functions */ 748 const struct drm_bridge_funcs *funcs; 749 /** @driver_private: pointer to the bridge driver's internal context */ 750 void *driver_private; 751 /** @ops: bitmask of operations supported by the bridge */ 752 enum drm_bridge_ops ops; 753 /** 754 * @type: Type of the connection at the bridge output 755 * (DRM_MODE_CONNECTOR_*). For bridges at the end of this chain this 756 * identifies the type of connected display. 757 */ 758 int type; 759 /** 760 * @interlace_allowed: Indicate that the bridge can handle interlaced 761 * modes. 762 */ 763 bool interlace_allowed; 764 /** 765 * @ddc: Associated I2C adapter for DDC access, if any. 766 */ 767 struct i2c_adapter *ddc; 768 /** private: */ 769 /** 770 * @hpd_mutex: Protects the @hpd_cb and @hpd_data fields. 771 */ 772 struct mutex hpd_mutex; 773 /** 774 * @hpd_cb: Hot plug detection callback, registered with 775 * drm_bridge_hpd_enable(). 776 */ 777 void (*hpd_cb)(void *data, enum drm_connector_status status); 778 /** 779 * @hpd_data: Private data passed to the Hot plug detection callback 780 * @hpd_cb. 781 */ 782 void *hpd_data; 783 }; 784 785 static inline struct drm_bridge * 786 drm_priv_to_bridge(struct drm_private_obj *priv) 787 { 788 return container_of(priv, struct drm_bridge, base); 789 } 790 791 void drm_bridge_add(struct drm_bridge *bridge); 792 void drm_bridge_remove(struct drm_bridge *bridge); 793 int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge, 794 struct drm_bridge *previous, 795 enum drm_bridge_attach_flags flags); 796 797 #ifdef CONFIG_OF 798 struct drm_bridge *of_drm_find_bridge(struct device_node *np); 799 #else 800 static inline struct drm_bridge *of_drm_find_bridge(struct device_node *np) 801 { 802 return NULL; 803 } 804 #endif 805 806 /** 807 * drm_bridge_get_next_bridge() - Get the next bridge in the chain 808 * @bridge: bridge object 809 * 810 * RETURNS: 811 * the next bridge in the chain after @bridge, or NULL if @bridge is the last. 812 */ 813 static inline struct drm_bridge * 814 drm_bridge_get_next_bridge(struct drm_bridge *bridge) 815 { 816 if (list_is_last(&bridge->chain_node, &bridge->encoder->bridge_chain)) 817 return NULL; 818 819 return list_next_entry(bridge, chain_node); 820 } 821 822 /** 823 * drm_bridge_get_prev_bridge() - Get the previous bridge in the chain 824 * @bridge: bridge object 825 * 826 * RETURNS: 827 * the previous bridge in the chain, or NULL if @bridge is the first. 828 */ 829 static inline struct drm_bridge * 830 drm_bridge_get_prev_bridge(struct drm_bridge *bridge) 831 { 832 if (list_is_first(&bridge->chain_node, &bridge->encoder->bridge_chain)) 833 return NULL; 834 835 return list_prev_entry(bridge, chain_node); 836 } 837 838 /** 839 * drm_bridge_chain_get_first_bridge() - Get the first bridge in the chain 840 * @encoder: encoder object 841 * 842 * RETURNS: 843 * the first bridge in the chain, or NULL if @encoder has no bridge attached 844 * to it. 845 */ 846 static inline struct drm_bridge * 847 drm_bridge_chain_get_first_bridge(struct drm_encoder *encoder) 848 { 849 return list_first_entry_or_null(&encoder->bridge_chain, 850 struct drm_bridge, chain_node); 851 } 852 853 /** 854 * drm_for_each_bridge_in_chain() - Iterate over all bridges present in a chain 855 * @encoder: the encoder to iterate bridges on 856 * @bridge: a bridge pointer updated to point to the current bridge at each 857 * iteration 858 * 859 * Iterate over all bridges present in the bridge chain attached to @encoder. 860 */ 861 #define drm_for_each_bridge_in_chain(encoder, bridge) \ 862 list_for_each_entry(bridge, &(encoder)->bridge_chain, chain_node) 863 864 bool drm_bridge_chain_mode_fixup(struct drm_bridge *bridge, 865 const struct drm_display_mode *mode, 866 struct drm_display_mode *adjusted_mode); 867 enum drm_mode_status 868 drm_bridge_chain_mode_valid(struct drm_bridge *bridge, 869 const struct drm_display_info *info, 870 const struct drm_display_mode *mode); 871 void drm_bridge_chain_disable(struct drm_bridge *bridge); 872 void drm_bridge_chain_post_disable(struct drm_bridge *bridge); 873 void drm_bridge_chain_mode_set(struct drm_bridge *bridge, 874 const struct drm_display_mode *mode, 875 const struct drm_display_mode *adjusted_mode); 876 void drm_bridge_chain_pre_enable(struct drm_bridge *bridge); 877 void drm_bridge_chain_enable(struct drm_bridge *bridge); 878 879 int drm_atomic_bridge_chain_check(struct drm_bridge *bridge, 880 struct drm_crtc_state *crtc_state, 881 struct drm_connector_state *conn_state); 882 void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge, 883 struct drm_atomic_state *state); 884 void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge, 885 struct drm_atomic_state *state); 886 void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge, 887 struct drm_atomic_state *state); 888 void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge, 889 struct drm_atomic_state *state); 890 891 u32 * 892 drm_atomic_helper_bridge_propagate_bus_fmt(struct drm_bridge *bridge, 893 struct drm_bridge_state *bridge_state, 894 struct drm_crtc_state *crtc_state, 895 struct drm_connector_state *conn_state, 896 u32 output_fmt, 897 unsigned int *num_input_fmts); 898 899 enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge); 900 int drm_bridge_get_modes(struct drm_bridge *bridge, 901 struct drm_connector *connector); 902 struct edid *drm_bridge_get_edid(struct drm_bridge *bridge, 903 struct drm_connector *connector); 904 void drm_bridge_hpd_enable(struct drm_bridge *bridge, 905 void (*cb)(void *data, 906 enum drm_connector_status status), 907 void *data); 908 void drm_bridge_hpd_disable(struct drm_bridge *bridge); 909 void drm_bridge_hpd_notify(struct drm_bridge *bridge, 910 enum drm_connector_status status); 911 912 #ifdef CONFIG_DRM_PANEL_BRIDGE 913 struct drm_bridge *drm_panel_bridge_add(struct drm_panel *panel); 914 struct drm_bridge *drm_panel_bridge_add_typed(struct drm_panel *panel, 915 u32 connector_type); 916 void drm_panel_bridge_remove(struct drm_bridge *bridge); 917 struct drm_bridge *devm_drm_panel_bridge_add(struct device *dev, 918 struct drm_panel *panel); 919 struct drm_bridge *devm_drm_panel_bridge_add_typed(struct device *dev, 920 struct drm_panel *panel, 921 u32 connector_type); 922 struct drm_connector *drm_panel_bridge_connector(struct drm_bridge *bridge); 923 #endif 924 925 #if defined(CONFIG_OF) && defined(CONFIG_DRM_PANEL_BRIDGE) 926 struct drm_bridge *devm_drm_of_get_bridge(struct device *dev, struct device_node *node, 927 u32 port, u32 endpoint); 928 #else 929 static inline struct drm_bridge *devm_drm_of_get_bridge(struct device *dev, 930 struct device_node *node, 931 u32 port, 932 u32 endpoint) 933 { 934 return ERR_PTR(-ENODEV); 935 } 936 #endif 937 938 #endif 939