1337 lines · c
1/*2 * Copyright (c) 2014 Samsung Electronics Co., Ltd3 *4 * Permission is hereby granted, free of charge, to any person obtaining a5 * copy of this software and associated documentation files (the "Software"),6 * to deal in the Software without restriction, including without limitation7 * the rights to use, copy, modify, merge, publish, distribute, sub license,8 * and/or sell copies of the Software, and to permit persons to whom the9 * Software is furnished to do so, subject to the following conditions:10 *11 * The above copyright notice and this permission notice (including the12 * next paragraph) shall be included in all copies or substantial portions13 * of the Software.14 *15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,17 * FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT. IN NO EVENT SHALL18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER21 * DEALINGS IN THE SOFTWARE.22 */23 24#include <linux/err.h>25#include <linux/media-bus-format.h>26#include <linux/module.h>27#include <linux/mutex.h>28 29#include <drm/drm_atomic_state_helper.h>30#include <drm/drm_bridge.h>31#include <drm/drm_debugfs.h>32#include <drm/drm_edid.h>33#include <drm/drm_encoder.h>34#include <drm/drm_file.h>35#include <drm/drm_of.h>36#include <drm/drm_print.h>37 38#include "drm_crtc_internal.h"39 40/**41 * DOC: overview42 *43 * &struct drm_bridge represents a device that hangs on to an encoder. These are44 * handy when a regular &drm_encoder entity isn't enough to represent the entire45 * encoder chain.46 *47 * A bridge is always attached to a single &drm_encoder at a time, but can be48 * either connected to it directly, or through a chain of bridges::49 *50 * [ CRTC ---> ] Encoder ---> Bridge A ---> Bridge B51 *52 * Here, the output of the encoder feeds to bridge A, and that furthers feeds to53 * bridge B. Bridge chains can be arbitrarily long, and shall be fully linear:54 * Chaining multiple bridges to the output of a bridge, or the same bridge to55 * the output of different bridges, is not supported.56 *57 * &drm_bridge, like &drm_panel, aren't &drm_mode_object entities like planes,58 * CRTCs, encoders or connectors and hence are not visible to userspace. They59 * just provide additional hooks to get the desired output at the end of the60 * encoder chain.61 */62 63/**64 * DOC: display driver integration65 *66 * Display drivers are responsible for linking encoders with the first bridge67 * in the chains. This is done by acquiring the appropriate bridge with68 * devm_drm_of_get_bridge(). Once acquired, the bridge shall be attached to the69 * encoder with a call to drm_bridge_attach().70 *71 * Bridges are responsible for linking themselves with the next bridge in the72 * chain, if any. This is done the same way as for encoders, with the call to73 * drm_bridge_attach() occurring in the &drm_bridge_funcs.attach operation.74 *75 * Once these links are created, the bridges can participate along with encoder76 * functions to perform mode validation and fixup (through77 * drm_bridge_chain_mode_valid() and drm_atomic_bridge_chain_check()), mode78 * setting (through drm_bridge_chain_mode_set()), enable (through79 * drm_atomic_bridge_chain_pre_enable() and drm_atomic_bridge_chain_enable())80 * and disable (through drm_atomic_bridge_chain_disable() and81 * drm_atomic_bridge_chain_post_disable()). Those functions call the82 * corresponding operations provided in &drm_bridge_funcs in sequence for all83 * bridges in the chain.84 *85 * For display drivers that use the atomic helpers86 * drm_atomic_helper_check_modeset(),87 * drm_atomic_helper_commit_modeset_enables() and88 * drm_atomic_helper_commit_modeset_disables() (either directly in hand-rolled89 * commit check and commit tail handlers, or through the higher-level90 * drm_atomic_helper_check() and drm_atomic_helper_commit_tail() or91 * drm_atomic_helper_commit_tail_rpm() helpers), this is done transparently and92 * requires no intervention from the driver. For other drivers, the relevant93 * DRM bridge chain functions shall be called manually.94 *95 * Bridges also participate in implementing the &drm_connector at the end of96 * the bridge chain. Display drivers may use the drm_bridge_connector_init()97 * helper to create the &drm_connector, or implement it manually on top of the98 * connector-related operations exposed by the bridge (see the overview99 * documentation of bridge operations for more details).100 */101 102/**103 * DOC: special care dsi104 *105 * The interaction between the bridges and other frameworks involved in106 * the probing of the upstream driver and the bridge driver can be107 * challenging. Indeed, there's multiple cases that needs to be108 * considered:109 *110 * - The upstream driver doesn't use the component framework and isn't a111 * MIPI-DSI host. In this case, the bridge driver will probe at some112 * point and the upstream driver should try to probe again by returning113 * EPROBE_DEFER as long as the bridge driver hasn't probed.114 *115 * - The upstream driver doesn't use the component framework, but is a116 * MIPI-DSI host. The bridge device uses the MIPI-DCS commands to be117 * controlled. In this case, the bridge device is a child of the118 * display device and when it will probe it's assured that the display119 * device (and MIPI-DSI host) is present. The upstream driver will be120 * assured that the bridge driver is connected between the121 * &mipi_dsi_host_ops.attach and &mipi_dsi_host_ops.detach operations.122 * Therefore, it must run mipi_dsi_host_register() in its probe123 * function, and then run drm_bridge_attach() in its124 * &mipi_dsi_host_ops.attach hook.125 *126 * - The upstream driver uses the component framework and is a MIPI-DSI127 * host. The bridge device uses the MIPI-DCS commands to be128 * controlled. This is the same situation than above, and can run129 * mipi_dsi_host_register() in either its probe or bind hooks.130 *131 * - The upstream driver uses the component framework and is a MIPI-DSI132 * host. The bridge device uses a separate bus (such as I2C) to be133 * controlled. In this case, there's no correlation between the probe134 * of the bridge and upstream drivers, so care must be taken to avoid135 * an endless EPROBE_DEFER loop, with each driver waiting for the136 * other to probe.137 *138 * The ideal pattern to cover the last item (and all the others in the139 * MIPI-DSI host driver case) is to split the operations like this:140 *141 * - The MIPI-DSI host driver must run mipi_dsi_host_register() in its142 * probe hook. It will make sure that the MIPI-DSI host sticks around,143 * and that the driver's bind can be called.144 *145 * - In its probe hook, the bridge driver must try to find its MIPI-DSI146 * host, register as a MIPI-DSI device and attach the MIPI-DSI device147 * to its host. The bridge driver is now functional.148 *149 * - In its &struct mipi_dsi_host_ops.attach hook, the MIPI-DSI host can150 * now add its component. Its bind hook will now be called and since151 * the bridge driver is attached and registered, we can now look for152 * and attach it.153 *154 * At this point, we're now certain that both the upstream driver and155 * the bridge driver are functional and we can't have a deadlock-like156 * situation when probing.157 */158 159/**160 * DOC: dsi bridge operations161 *162 * DSI host interfaces are expected to be implemented as bridges rather than163 * encoders, however there are a few aspects of their operation that need to164 * be defined in order to provide a consistent interface.165 *166 * A DSI host should keep the PHY powered down until the pre_enable operation is167 * called. All lanes are in an undefined idle state up to this point, and it168 * must not be assumed that it is LP-11.169 * pre_enable should initialise the PHY, set the data lanes to LP-11, and the170 * clock lane to either LP-11 or HS depending on the mode_flag171 * %MIPI_DSI_CLOCK_NON_CONTINUOUS.172 *173 * Ordinarily the downstream bridge DSI peripheral pre_enable will have been174 * called before the DSI host. If the DSI peripheral requires LP-11 and/or175 * the clock lane to be in HS mode prior to pre_enable, then it can set the176 * &pre_enable_prev_first flag to request the pre_enable (and177 * post_disable) order to be altered to enable the DSI host first.178 *179 * Either the CRTC being enabled, or the DSI host enable operation should switch180 * the host to actively transmitting video on the data lanes.181 *182 * The reverse also applies. The DSI host disable operation or stopping the CRTC183 * should stop transmitting video, and the data lanes should return to the LP-11184 * state. The DSI host &post_disable operation should disable the PHY.185 * If the &pre_enable_prev_first flag is set, then the DSI peripheral's186 * bridge &post_disable will be called before the DSI host's post_disable.187 *188 * Whilst it is valid to call &host_transfer prior to pre_enable or after189 * post_disable, the exact state of the lanes is undefined at this point. The190 * DSI host should initialise the interface, transmit the data, and then disable191 * the interface again.192 *193 * Ultra Low Power State (ULPS) is not explicitly supported by DRM. If194 * implemented, it therefore needs to be handled entirely within the DSI Host195 * driver.196 */197 198static DEFINE_MUTEX(bridge_lock);199static LIST_HEAD(bridge_list);200 201/**202 * drm_bridge_add - add the given bridge to the global bridge list203 *204 * @bridge: bridge control structure205 */206void drm_bridge_add(struct drm_bridge *bridge)207{208 mutex_init(&bridge->hpd_mutex);209 210 mutex_lock(&bridge_lock);211 list_add_tail(&bridge->list, &bridge_list);212 mutex_unlock(&bridge_lock);213}214EXPORT_SYMBOL(drm_bridge_add);215 216static void drm_bridge_remove_void(void *bridge)217{218 drm_bridge_remove(bridge);219}220 221/**222 * devm_drm_bridge_add - devm managed version of drm_bridge_add()223 *224 * @dev: device to tie the bridge lifetime to225 * @bridge: bridge control structure226 *227 * This is the managed version of drm_bridge_add() which automatically228 * calls drm_bridge_remove() when @dev is unbound.229 *230 * Return: 0 if no error or negative error code.231 */232int devm_drm_bridge_add(struct device *dev, struct drm_bridge *bridge)233{234 drm_bridge_add(bridge);235 return devm_add_action_or_reset(dev, drm_bridge_remove_void, bridge);236}237EXPORT_SYMBOL(devm_drm_bridge_add);238 239/**240 * drm_bridge_remove - remove the given bridge from the global bridge list241 *242 * @bridge: bridge control structure243 */244void drm_bridge_remove(struct drm_bridge *bridge)245{246 mutex_lock(&bridge_lock);247 list_del_init(&bridge->list);248 mutex_unlock(&bridge_lock);249 250 mutex_destroy(&bridge->hpd_mutex);251}252EXPORT_SYMBOL(drm_bridge_remove);253 254static struct drm_private_state *255drm_bridge_atomic_duplicate_priv_state(struct drm_private_obj *obj)256{257 struct drm_bridge *bridge = drm_priv_to_bridge(obj);258 struct drm_bridge_state *state;259 260 state = bridge->funcs->atomic_duplicate_state(bridge);261 return state ? &state->base : NULL;262}263 264static void265drm_bridge_atomic_destroy_priv_state(struct drm_private_obj *obj,266 struct drm_private_state *s)267{268 struct drm_bridge_state *state = drm_priv_to_bridge_state(s);269 struct drm_bridge *bridge = drm_priv_to_bridge(obj);270 271 bridge->funcs->atomic_destroy_state(bridge, state);272}273 274static const struct drm_private_state_funcs drm_bridge_priv_state_funcs = {275 .atomic_duplicate_state = drm_bridge_atomic_duplicate_priv_state,276 .atomic_destroy_state = drm_bridge_atomic_destroy_priv_state,277};278 279/**280 * drm_bridge_attach - attach the bridge to an encoder's chain281 *282 * @encoder: DRM encoder283 * @bridge: bridge to attach284 * @previous: previous bridge in the chain (optional)285 * @flags: DRM_BRIDGE_ATTACH_* flags286 *287 * Called by a kms driver to link the bridge to an encoder's chain. The previous288 * argument specifies the previous bridge in the chain. If NULL, the bridge is289 * linked directly at the encoder's output. Otherwise it is linked at the290 * previous bridge's output.291 *292 * If non-NULL the previous bridge must be already attached by a call to this293 * function.294 *295 * Note that bridges attached to encoders are auto-detached during encoder296 * cleanup in drm_encoder_cleanup(), so drm_bridge_attach() should generally297 * *not* be balanced with a drm_bridge_detach() in driver code.298 *299 * RETURNS:300 * Zero on success, error code on failure301 */302int drm_bridge_attach(struct drm_encoder *encoder, struct drm_bridge *bridge,303 struct drm_bridge *previous,304 enum drm_bridge_attach_flags flags)305{306 int ret;307 308 if (!encoder || !bridge)309 return -EINVAL;310 311 if (previous && (!previous->dev || previous->encoder != encoder))312 return -EINVAL;313 314 if (bridge->dev)315 return -EBUSY;316 317 bridge->dev = encoder->dev;318 bridge->encoder = encoder;319 320 if (previous)321 list_add(&bridge->chain_node, &previous->chain_node);322 else323 list_add(&bridge->chain_node, &encoder->bridge_chain);324 325 if (bridge->funcs->attach) {326 ret = bridge->funcs->attach(bridge, flags);327 if (ret < 0)328 goto err_reset_bridge;329 }330 331 if (bridge->funcs->atomic_reset) {332 struct drm_bridge_state *state;333 334 state = bridge->funcs->atomic_reset(bridge);335 if (IS_ERR(state)) {336 ret = PTR_ERR(state);337 goto err_detach_bridge;338 }339 340 drm_atomic_private_obj_init(bridge->dev, &bridge->base,341 &state->base,342 &drm_bridge_priv_state_funcs);343 }344 345 return 0;346 347err_detach_bridge:348 if (bridge->funcs->detach)349 bridge->funcs->detach(bridge);350 351err_reset_bridge:352 bridge->dev = NULL;353 bridge->encoder = NULL;354 list_del(&bridge->chain_node);355 356 if (ret != -EPROBE_DEFER)357 DRM_ERROR("failed to attach bridge %pOF to encoder %s: %d\n",358 bridge->of_node, encoder->name, ret);359 else360 dev_err_probe(encoder->dev->dev, -EPROBE_DEFER,361 "failed to attach bridge %pOF to encoder %s\n",362 bridge->of_node, encoder->name);363 364 return ret;365}366EXPORT_SYMBOL(drm_bridge_attach);367 368void drm_bridge_detach(struct drm_bridge *bridge)369{370 if (WARN_ON(!bridge))371 return;372 373 if (WARN_ON(!bridge->dev))374 return;375 376 if (bridge->funcs->atomic_reset)377 drm_atomic_private_obj_fini(&bridge->base);378 379 if (bridge->funcs->detach)380 bridge->funcs->detach(bridge);381 382 list_del(&bridge->chain_node);383 bridge->dev = NULL;384}385 386/**387 * DOC: bridge operations388 *389 * Bridge drivers expose operations through the &drm_bridge_funcs structure.390 * The DRM internals (atomic and CRTC helpers) use the helpers defined in391 * drm_bridge.c to call bridge operations. Those operations are divided in392 * three big categories to support different parts of the bridge usage.393 *394 * - The encoder-related operations support control of the bridges in the395 * chain, and are roughly counterparts to the &drm_encoder_helper_funcs396 * operations. They are used by the legacy CRTC and the atomic modeset397 * helpers to perform mode validation, fixup and setting, and enable and398 * disable the bridge automatically.399 *400 * The enable and disable operations are split in401 * &drm_bridge_funcs.pre_enable, &drm_bridge_funcs.enable,402 * &drm_bridge_funcs.disable and &drm_bridge_funcs.post_disable to provide403 * finer-grained control.404 *405 * Bridge drivers may implement the legacy version of those operations, or406 * the atomic version (prefixed with atomic\_), in which case they shall also407 * implement the atomic state bookkeeping operations408 * (&drm_bridge_funcs.atomic_duplicate_state,409 * &drm_bridge_funcs.atomic_destroy_state and &drm_bridge_funcs.reset).410 * Mixing atomic and non-atomic versions of the operations is not supported.411 *412 * - The bus format negotiation operations413 * &drm_bridge_funcs.atomic_get_output_bus_fmts and414 * &drm_bridge_funcs.atomic_get_input_bus_fmts allow bridge drivers to415 * negotiate the formats transmitted between bridges in the chain when416 * multiple formats are supported. Negotiation for formats is performed417 * transparently for display drivers by the atomic modeset helpers. Only418 * atomic versions of those operations exist, bridge drivers that need to419 * implement them shall thus also implement the atomic version of the420 * encoder-related operations. This feature is not supported by the legacy421 * CRTC helpers.422 *423 * - The connector-related operations support implementing a &drm_connector424 * based on a chain of bridges. DRM bridges traditionally create a425 * &drm_connector for bridges meant to be used at the end of the chain. This426 * puts additional burden on bridge drivers, especially for bridges that may427 * be used in the middle of a chain or at the end of it. Furthermore, it428 * requires all operations of the &drm_connector to be handled by a single429 * bridge, which doesn't always match the hardware architecture.430 *431 * To simplify bridge drivers and make the connector implementation more432 * flexible, a new model allows bridges to unconditionally skip creation of433 * &drm_connector and instead expose &drm_bridge_funcs operations to support434 * an externally-implemented &drm_connector. Those operations are435 * &drm_bridge_funcs.detect, &drm_bridge_funcs.get_modes,436 * &drm_bridge_funcs.get_edid, &drm_bridge_funcs.hpd_notify,437 * &drm_bridge_funcs.hpd_enable and &drm_bridge_funcs.hpd_disable. When438 * implemented, display drivers shall create a &drm_connector instance for439 * each chain of bridges, and implement those connector instances based on440 * the bridge connector operations.441 *442 * Bridge drivers shall implement the connector-related operations for all443 * the features that the bridge hardware support. For instance, if a bridge444 * supports reading EDID, the &drm_bridge_funcs.get_edid shall be445 * implemented. This however doesn't mean that the DDC lines are wired to the446 * bridge on a particular platform, as they could also be connected to an I2C447 * controller of the SoC. Support for the connector-related operations on the448 * running platform is reported through the &drm_bridge.ops flags. Bridge449 * drivers shall detect which operations they can support on the platform450 * (usually this information is provided by ACPI or DT), and set the451 * &drm_bridge.ops flags for all supported operations. A flag shall only be452 * set if the corresponding &drm_bridge_funcs operation is implemented, but453 * an implemented operation doesn't necessarily imply that the corresponding454 * flag will be set. Display drivers shall use the &drm_bridge.ops flags to455 * decide which bridge to delegate a connector operation to. This mechanism456 * allows providing a single static const &drm_bridge_funcs instance in457 * bridge drivers, improving security by storing function pointers in458 * read-only memory.459 *460 * In order to ease transition, bridge drivers may support both the old and461 * new models by making connector creation optional and implementing the462 * connected-related bridge operations. Connector creation is then controlled463 * by the flags argument to the drm_bridge_attach() function. Display drivers464 * that support the new model and create connectors themselves shall set the465 * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag, and bridge drivers shall then skip466 * connector creation. For intermediate bridges in the chain, the flag shall467 * be passed to the drm_bridge_attach() call for the downstream bridge.468 * Bridge drivers that implement the new model only shall return an error469 * from their &drm_bridge_funcs.attach handler when the470 * %DRM_BRIDGE_ATTACH_NO_CONNECTOR flag is not set. New display drivers471 * should use the new model, and convert the bridge drivers they use if472 * needed, in order to gradually transition to the new model.473 */474 475/**476 * drm_bridge_chain_mode_valid - validate the mode against all bridges in the477 * encoder chain.478 * @bridge: bridge control structure479 * @info: display info against which the mode shall be validated480 * @mode: desired mode to be validated481 *482 * Calls &drm_bridge_funcs.mode_valid for all the bridges in the encoder483 * chain, starting from the first bridge to the last. If at least one bridge484 * does not accept the mode the function returns the error code.485 *486 * Note: the bridge passed should be the one closest to the encoder.487 *488 * RETURNS:489 * MODE_OK on success, drm_mode_status Enum error code on failure490 */491enum drm_mode_status492drm_bridge_chain_mode_valid(struct drm_bridge *bridge,493 const struct drm_display_info *info,494 const struct drm_display_mode *mode)495{496 struct drm_encoder *encoder;497 498 if (!bridge)499 return MODE_OK;500 501 encoder = bridge->encoder;502 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {503 enum drm_mode_status ret;504 505 if (!bridge->funcs->mode_valid)506 continue;507 508 ret = bridge->funcs->mode_valid(bridge, info, mode);509 if (ret != MODE_OK)510 return ret;511 }512 513 return MODE_OK;514}515EXPORT_SYMBOL(drm_bridge_chain_mode_valid);516 517/**518 * drm_bridge_chain_mode_set - set proposed mode for all bridges in the519 * encoder chain520 * @bridge: bridge control structure521 * @mode: desired mode to be set for the encoder chain522 * @adjusted_mode: updated mode that works for this encoder chain523 *524 * Calls &drm_bridge_funcs.mode_set op for all the bridges in the525 * encoder chain, starting from the first bridge to the last.526 *527 * Note: the bridge passed should be the one closest to the encoder528 */529void drm_bridge_chain_mode_set(struct drm_bridge *bridge,530 const struct drm_display_mode *mode,531 const struct drm_display_mode *adjusted_mode)532{533 struct drm_encoder *encoder;534 535 if (!bridge)536 return;537 538 encoder = bridge->encoder;539 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {540 if (bridge->funcs->mode_set)541 bridge->funcs->mode_set(bridge, mode, adjusted_mode);542 }543}544EXPORT_SYMBOL(drm_bridge_chain_mode_set);545 546/**547 * drm_atomic_bridge_chain_disable - disables all bridges in the encoder chain548 * @bridge: bridge control structure549 * @old_state: old atomic state550 *551 * Calls &drm_bridge_funcs.atomic_disable (falls back on552 * &drm_bridge_funcs.disable) op for all the bridges in the encoder chain,553 * starting from the last bridge to the first. These are called before calling554 * &drm_encoder_helper_funcs.atomic_disable555 *556 * Note: the bridge passed should be the one closest to the encoder557 */558void drm_atomic_bridge_chain_disable(struct drm_bridge *bridge,559 struct drm_atomic_state *old_state)560{561 struct drm_encoder *encoder;562 struct drm_bridge *iter;563 564 if (!bridge)565 return;566 567 encoder = bridge->encoder;568 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {569 if (iter->funcs->atomic_disable) {570 struct drm_bridge_state *old_bridge_state;571 572 old_bridge_state =573 drm_atomic_get_old_bridge_state(old_state,574 iter);575 if (WARN_ON(!old_bridge_state))576 return;577 578 iter->funcs->atomic_disable(iter, old_bridge_state);579 } else if (iter->funcs->disable) {580 iter->funcs->disable(iter);581 }582 583 if (iter == bridge)584 break;585 }586}587EXPORT_SYMBOL(drm_atomic_bridge_chain_disable);588 589static void drm_atomic_bridge_call_post_disable(struct drm_bridge *bridge,590 struct drm_atomic_state *old_state)591{592 if (old_state && bridge->funcs->atomic_post_disable) {593 struct drm_bridge_state *old_bridge_state;594 595 old_bridge_state =596 drm_atomic_get_old_bridge_state(old_state,597 bridge);598 if (WARN_ON(!old_bridge_state))599 return;600 601 bridge->funcs->atomic_post_disable(bridge,602 old_bridge_state);603 } else if (bridge->funcs->post_disable) {604 bridge->funcs->post_disable(bridge);605 }606}607 608/**609 * drm_atomic_bridge_chain_post_disable - cleans up after disabling all bridges610 * in the encoder chain611 * @bridge: bridge control structure612 * @old_state: old atomic state613 *614 * Calls &drm_bridge_funcs.atomic_post_disable (falls back on615 * &drm_bridge_funcs.post_disable) op for all the bridges in the encoder chain,616 * starting from the first bridge to the last. These are called after completing617 * &drm_encoder_helper_funcs.atomic_disable618 *619 * If a bridge sets @pre_enable_prev_first, then the @post_disable for that620 * bridge will be called before the previous one to reverse the @pre_enable621 * calling direction.622 *623 * Example:624 * Bridge A ---> Bridge B ---> Bridge C ---> Bridge D ---> Bridge E625 *626 * With pre_enable_prev_first flag enable in Bridge B, D, E then the resulting627 * @post_disable order would be,628 * Bridge B, Bridge A, Bridge E, Bridge D, Bridge C.629 *630 * Note: the bridge passed should be the one closest to the encoder631 */632void drm_atomic_bridge_chain_post_disable(struct drm_bridge *bridge,633 struct drm_atomic_state *old_state)634{635 struct drm_encoder *encoder;636 struct drm_bridge *next, *limit;637 638 if (!bridge)639 return;640 641 encoder = bridge->encoder;642 643 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {644 limit = NULL;645 646 if (!list_is_last(&bridge->chain_node, &encoder->bridge_chain)) {647 next = list_next_entry(bridge, chain_node);648 649 if (next->pre_enable_prev_first) {650 /* next bridge had requested that prev651 * was enabled first, so disabled last652 */653 limit = next;654 655 /* Find the next bridge that has NOT requested656 * prev to be enabled first / disabled last657 */658 list_for_each_entry_from(next, &encoder->bridge_chain,659 chain_node) {660 if (!next->pre_enable_prev_first) {661 next = list_prev_entry(next, chain_node);662 limit = next;663 break;664 }665 666 if (list_is_last(&next->chain_node,667 &encoder->bridge_chain)) {668 limit = next;669 break;670 }671 }672 673 /* Call these bridges in reverse order */674 list_for_each_entry_from_reverse(next, &encoder->bridge_chain,675 chain_node) {676 if (next == bridge)677 break;678 679 drm_atomic_bridge_call_post_disable(next,680 old_state);681 }682 }683 }684 685 drm_atomic_bridge_call_post_disable(bridge, old_state);686 687 if (limit)688 /* Jump all bridges that we have already post_disabled */689 bridge = limit;690 }691}692EXPORT_SYMBOL(drm_atomic_bridge_chain_post_disable);693 694static void drm_atomic_bridge_call_pre_enable(struct drm_bridge *bridge,695 struct drm_atomic_state *old_state)696{697 if (old_state && bridge->funcs->atomic_pre_enable) {698 struct drm_bridge_state *old_bridge_state;699 700 old_bridge_state =701 drm_atomic_get_old_bridge_state(old_state,702 bridge);703 if (WARN_ON(!old_bridge_state))704 return;705 706 bridge->funcs->atomic_pre_enable(bridge, old_bridge_state);707 } else if (bridge->funcs->pre_enable) {708 bridge->funcs->pre_enable(bridge);709 }710}711 712/**713 * drm_atomic_bridge_chain_pre_enable - prepares for enabling all bridges in714 * the encoder chain715 * @bridge: bridge control structure716 * @old_state: old atomic state717 *718 * Calls &drm_bridge_funcs.atomic_pre_enable (falls back on719 * &drm_bridge_funcs.pre_enable) op for all the bridges in the encoder chain,720 * starting from the last bridge to the first. These are called before calling721 * &drm_encoder_helper_funcs.atomic_enable722 *723 * If a bridge sets @pre_enable_prev_first, then the pre_enable for the724 * prev bridge will be called before pre_enable of this bridge.725 *726 * Example:727 * Bridge A ---> Bridge B ---> Bridge C ---> Bridge D ---> Bridge E728 *729 * With pre_enable_prev_first flag enable in Bridge B, D, E then the resulting730 * @pre_enable order would be,731 * Bridge C, Bridge D, Bridge E, Bridge A, Bridge B.732 *733 * Note: the bridge passed should be the one closest to the encoder734 */735void drm_atomic_bridge_chain_pre_enable(struct drm_bridge *bridge,736 struct drm_atomic_state *old_state)737{738 struct drm_encoder *encoder;739 struct drm_bridge *iter, *next, *limit;740 741 if (!bridge)742 return;743 744 encoder = bridge->encoder;745 746 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {747 if (iter->pre_enable_prev_first) {748 next = iter;749 limit = bridge;750 list_for_each_entry_from_reverse(next,751 &encoder->bridge_chain,752 chain_node) {753 if (next == bridge)754 break;755 756 if (!next->pre_enable_prev_first) {757 /* Found first bridge that does NOT758 * request prev to be enabled first759 */760 limit = next;761 break;762 }763 }764 765 list_for_each_entry_from(next, &encoder->bridge_chain, chain_node) {766 /* Call requested prev bridge pre_enable767 * in order.768 */769 if (next == iter)770 /* At the first bridge to request prev771 * bridges called first.772 */773 break;774 775 drm_atomic_bridge_call_pre_enable(next, old_state);776 }777 }778 779 drm_atomic_bridge_call_pre_enable(iter, old_state);780 781 if (iter->pre_enable_prev_first)782 /* Jump all bridges that we have already pre_enabled */783 iter = limit;784 785 if (iter == bridge)786 break;787 }788}789EXPORT_SYMBOL(drm_atomic_bridge_chain_pre_enable);790 791/**792 * drm_atomic_bridge_chain_enable - enables all bridges in the encoder chain793 * @bridge: bridge control structure794 * @old_state: old atomic state795 *796 * Calls &drm_bridge_funcs.atomic_enable (falls back on797 * &drm_bridge_funcs.enable) op for all the bridges in the encoder chain,798 * starting from the first bridge to the last. These are called after completing799 * &drm_encoder_helper_funcs.atomic_enable800 *801 * Note: the bridge passed should be the one closest to the encoder802 */803void drm_atomic_bridge_chain_enable(struct drm_bridge *bridge,804 struct drm_atomic_state *old_state)805{806 struct drm_encoder *encoder;807 808 if (!bridge)809 return;810 811 encoder = bridge->encoder;812 list_for_each_entry_from(bridge, &encoder->bridge_chain, chain_node) {813 if (bridge->funcs->atomic_enable) {814 struct drm_bridge_state *old_bridge_state;815 816 old_bridge_state =817 drm_atomic_get_old_bridge_state(old_state,818 bridge);819 if (WARN_ON(!old_bridge_state))820 return;821 822 bridge->funcs->atomic_enable(bridge, old_bridge_state);823 } else if (bridge->funcs->enable) {824 bridge->funcs->enable(bridge);825 }826 }827}828EXPORT_SYMBOL(drm_atomic_bridge_chain_enable);829 830static int drm_atomic_bridge_check(struct drm_bridge *bridge,831 struct drm_crtc_state *crtc_state,832 struct drm_connector_state *conn_state)833{834 if (bridge->funcs->atomic_check) {835 struct drm_bridge_state *bridge_state;836 int ret;837 838 bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,839 bridge);840 if (WARN_ON(!bridge_state))841 return -EINVAL;842 843 ret = bridge->funcs->atomic_check(bridge, bridge_state,844 crtc_state, conn_state);845 if (ret)846 return ret;847 } else if (bridge->funcs->mode_fixup) {848 if (!bridge->funcs->mode_fixup(bridge, &crtc_state->mode,849 &crtc_state->adjusted_mode))850 return -EINVAL;851 }852 853 return 0;854}855 856static int select_bus_fmt_recursive(struct drm_bridge *first_bridge,857 struct drm_bridge *cur_bridge,858 struct drm_crtc_state *crtc_state,859 struct drm_connector_state *conn_state,860 u32 out_bus_fmt)861{862 unsigned int i, num_in_bus_fmts = 0;863 struct drm_bridge_state *cur_state;864 struct drm_bridge *prev_bridge;865 u32 *in_bus_fmts;866 int ret;867 868 prev_bridge = drm_bridge_get_prev_bridge(cur_bridge);869 cur_state = drm_atomic_get_new_bridge_state(crtc_state->state,870 cur_bridge);871 872 /*873 * If bus format negotiation is not supported by this bridge, let's874 * pass MEDIA_BUS_FMT_FIXED to the previous bridge in the chain and875 * hope that it can handle this situation gracefully (by providing876 * appropriate default values).877 */878 if (!cur_bridge->funcs->atomic_get_input_bus_fmts) {879 if (cur_bridge != first_bridge) {880 ret = select_bus_fmt_recursive(first_bridge,881 prev_bridge, crtc_state,882 conn_state,883 MEDIA_BUS_FMT_FIXED);884 if (ret)885 return ret;886 }887 888 /*889 * Driver does not implement the atomic state hooks, but that's890 * fine, as long as it does not access the bridge state.891 */892 if (cur_state) {893 cur_state->input_bus_cfg.format = MEDIA_BUS_FMT_FIXED;894 cur_state->output_bus_cfg.format = out_bus_fmt;895 }896 897 return 0;898 }899 900 /*901 * If the driver implements ->atomic_get_input_bus_fmts() it902 * should also implement the atomic state hooks.903 */904 if (WARN_ON(!cur_state))905 return -EINVAL;906 907 in_bus_fmts = cur_bridge->funcs->atomic_get_input_bus_fmts(cur_bridge,908 cur_state,909 crtc_state,910 conn_state,911 out_bus_fmt,912 &num_in_bus_fmts);913 if (!num_in_bus_fmts)914 return -ENOTSUPP;915 else if (!in_bus_fmts)916 return -ENOMEM;917 918 if (first_bridge == cur_bridge) {919 cur_state->input_bus_cfg.format = in_bus_fmts[0];920 cur_state->output_bus_cfg.format = out_bus_fmt;921 kfree(in_bus_fmts);922 return 0;923 }924 925 for (i = 0; i < num_in_bus_fmts; i++) {926 ret = select_bus_fmt_recursive(first_bridge, prev_bridge,927 crtc_state, conn_state,928 in_bus_fmts[i]);929 if (ret != -ENOTSUPP)930 break;931 }932 933 if (!ret) {934 cur_state->input_bus_cfg.format = in_bus_fmts[i];935 cur_state->output_bus_cfg.format = out_bus_fmt;936 }937 938 kfree(in_bus_fmts);939 return ret;940}941 942/*943 * This function is called by &drm_atomic_bridge_chain_check() just before944 * calling &drm_bridge_funcs.atomic_check() on all elements of the chain.945 * It performs bus format negotiation between bridge elements. The negotiation946 * happens in reverse order, starting from the last element in the chain up to947 * @bridge.948 *949 * Negotiation starts by retrieving supported output bus formats on the last950 * bridge element and testing them one by one. The test is recursive, meaning951 * that for each tested output format, the whole chain will be walked backward,952 * and each element will have to choose an input bus format that can be953 * transcoded to the requested output format. When a bridge element does not954 * support transcoding into a specific output format -ENOTSUPP is returned and955 * the next bridge element will have to try a different format. If none of the956 * combinations worked, -ENOTSUPP is returned and the atomic modeset will fail.957 *958 * This implementation is relying on959 * &drm_bridge_funcs.atomic_get_output_bus_fmts() and960 * &drm_bridge_funcs.atomic_get_input_bus_fmts() to gather supported961 * input/output formats.962 *963 * When &drm_bridge_funcs.atomic_get_output_bus_fmts() is not implemented by964 * the last element of the chain, &drm_atomic_bridge_chain_select_bus_fmts()965 * tries a single format: &drm_connector.display_info.bus_formats[0] if966 * available, MEDIA_BUS_FMT_FIXED otherwise.967 *968 * When &drm_bridge_funcs.atomic_get_input_bus_fmts() is not implemented,969 * &drm_atomic_bridge_chain_select_bus_fmts() skips the negotiation on the970 * bridge element that lacks this hook and asks the previous element in the971 * chain to try MEDIA_BUS_FMT_FIXED. It's up to bridge drivers to decide what972 * to do in that case (fail if they want to enforce bus format negotiation, or973 * provide a reasonable default if they need to support pipelines where not974 * all elements support bus format negotiation).975 */976static int977drm_atomic_bridge_chain_select_bus_fmts(struct drm_bridge *bridge,978 struct drm_crtc_state *crtc_state,979 struct drm_connector_state *conn_state)980{981 struct drm_connector *conn = conn_state->connector;982 struct drm_encoder *encoder = bridge->encoder;983 struct drm_bridge_state *last_bridge_state;984 unsigned int i, num_out_bus_fmts = 0;985 struct drm_bridge *last_bridge;986 u32 *out_bus_fmts;987 int ret = 0;988 989 last_bridge = list_last_entry(&encoder->bridge_chain,990 struct drm_bridge, chain_node);991 last_bridge_state = drm_atomic_get_new_bridge_state(crtc_state->state,992 last_bridge);993 994 if (last_bridge->funcs->atomic_get_output_bus_fmts) {995 const struct drm_bridge_funcs *funcs = last_bridge->funcs;996 997 /*998 * If the driver implements ->atomic_get_output_bus_fmts() it999 * should also implement the atomic state hooks.1000 */1001 if (WARN_ON(!last_bridge_state))1002 return -EINVAL;1003 1004 out_bus_fmts = funcs->atomic_get_output_bus_fmts(last_bridge,1005 last_bridge_state,1006 crtc_state,1007 conn_state,1008 &num_out_bus_fmts);1009 if (!num_out_bus_fmts)1010 return -ENOTSUPP;1011 else if (!out_bus_fmts)1012 return -ENOMEM;1013 } else {1014 num_out_bus_fmts = 1;1015 out_bus_fmts = kmalloc(sizeof(*out_bus_fmts), GFP_KERNEL);1016 if (!out_bus_fmts)1017 return -ENOMEM;1018 1019 if (conn->display_info.num_bus_formats &&1020 conn->display_info.bus_formats)1021 out_bus_fmts[0] = conn->display_info.bus_formats[0];1022 else1023 out_bus_fmts[0] = MEDIA_BUS_FMT_FIXED;1024 }1025 1026 for (i = 0; i < num_out_bus_fmts; i++) {1027 ret = select_bus_fmt_recursive(bridge, last_bridge, crtc_state,1028 conn_state, out_bus_fmts[i]);1029 if (ret != -ENOTSUPP)1030 break;1031 }1032 1033 kfree(out_bus_fmts);1034 1035 return ret;1036}1037 1038static void1039drm_atomic_bridge_propagate_bus_flags(struct drm_bridge *bridge,1040 struct drm_connector *conn,1041 struct drm_atomic_state *state)1042{1043 struct drm_bridge_state *bridge_state, *next_bridge_state;1044 struct drm_bridge *next_bridge;1045 u32 output_flags = 0;1046 1047 bridge_state = drm_atomic_get_new_bridge_state(state, bridge);1048 1049 /* No bridge state attached to this bridge => nothing to propagate. */1050 if (!bridge_state)1051 return;1052 1053 next_bridge = drm_bridge_get_next_bridge(bridge);1054 1055 /*1056 * Let's try to apply the most common case here, that is, propagate1057 * display_info flags for the last bridge, and propagate the input1058 * flags of the next bridge element to the output end of the current1059 * bridge when the bridge is not the last one.1060 * There are exceptions to this rule, like when signal inversion is1061 * happening at the board level, but that's something drivers can deal1062 * with from their &drm_bridge_funcs.atomic_check() implementation by1063 * simply overriding the flags value we've set here.1064 */1065 if (!next_bridge) {1066 output_flags = conn->display_info.bus_flags;1067 } else {1068 next_bridge_state = drm_atomic_get_new_bridge_state(state,1069 next_bridge);1070 /*1071 * No bridge state attached to the next bridge, just leave the1072 * flags to 0.1073 */1074 if (next_bridge_state)1075 output_flags = next_bridge_state->input_bus_cfg.flags;1076 }1077 1078 bridge_state->output_bus_cfg.flags = output_flags;1079 1080 /*1081 * Propagate the output flags to the input end of the bridge. Again, it's1082 * not necessarily what all bridges want, but that's what most of them1083 * do, and by doing that by default we avoid forcing drivers to1084 * duplicate the "dummy propagation" logic.1085 */1086 bridge_state->input_bus_cfg.flags = output_flags;1087}1088 1089/**1090 * drm_atomic_bridge_chain_check() - Do an atomic check on the bridge chain1091 * @bridge: bridge control structure1092 * @crtc_state: new CRTC state1093 * @conn_state: new connector state1094 *1095 * First trigger a bus format negotiation before calling1096 * &drm_bridge_funcs.atomic_check() (falls back on1097 * &drm_bridge_funcs.mode_fixup()) op for all the bridges in the encoder chain,1098 * starting from the last bridge to the first. These are called before calling1099 * &drm_encoder_helper_funcs.atomic_check()1100 *1101 * RETURNS:1102 * 0 on success, a negative error code on failure1103 */1104int drm_atomic_bridge_chain_check(struct drm_bridge *bridge,1105 struct drm_crtc_state *crtc_state,1106 struct drm_connector_state *conn_state)1107{1108 struct drm_connector *conn = conn_state->connector;1109 struct drm_encoder *encoder;1110 struct drm_bridge *iter;1111 int ret;1112 1113 if (!bridge)1114 return 0;1115 1116 ret = drm_atomic_bridge_chain_select_bus_fmts(bridge, crtc_state,1117 conn_state);1118 if (ret)1119 return ret;1120 1121 encoder = bridge->encoder;1122 list_for_each_entry_reverse(iter, &encoder->bridge_chain, chain_node) {1123 int ret;1124 1125 /*1126 * Bus flags are propagated by default. If a bridge needs to1127 * tweak the input bus flags for any reason, it should happen1128 * in its &drm_bridge_funcs.atomic_check() implementation such1129 * that preceding bridges in the chain can propagate the new1130 * bus flags.1131 */1132 drm_atomic_bridge_propagate_bus_flags(iter, conn,1133 crtc_state->state);1134 1135 ret = drm_atomic_bridge_check(iter, crtc_state, conn_state);1136 if (ret)1137 return ret;1138 1139 if (iter == bridge)1140 break;1141 }1142 1143 return 0;1144}1145EXPORT_SYMBOL(drm_atomic_bridge_chain_check);1146 1147/**1148 * drm_bridge_detect - check if anything is attached to the bridge output1149 * @bridge: bridge control structure1150 *1151 * If the bridge supports output detection, as reported by the1152 * DRM_BRIDGE_OP_DETECT bridge ops flag, call &drm_bridge_funcs.detect for the1153 * bridge and return the connection status. Otherwise return1154 * connector_status_unknown.1155 *1156 * RETURNS:1157 * The detection status on success, or connector_status_unknown if the bridge1158 * doesn't support output detection.1159 */1160enum drm_connector_status drm_bridge_detect(struct drm_bridge *bridge)1161{1162 if (!(bridge->ops & DRM_BRIDGE_OP_DETECT))1163 return connector_status_unknown;1164 1165 return bridge->funcs->detect(bridge);1166}1167EXPORT_SYMBOL_GPL(drm_bridge_detect);1168 1169/**1170 * drm_bridge_get_modes - fill all modes currently valid for the sink into the1171 * @connector1172 * @bridge: bridge control structure1173 * @connector: the connector to fill with modes1174 *1175 * If the bridge supports output modes retrieval, as reported by the1176 * DRM_BRIDGE_OP_MODES bridge ops flag, call &drm_bridge_funcs.get_modes to1177 * fill the connector with all valid modes and return the number of modes1178 * added. Otherwise return 0.1179 *1180 * RETURNS:1181 * The number of modes added to the connector.1182 */1183int drm_bridge_get_modes(struct drm_bridge *bridge,1184 struct drm_connector *connector)1185{1186 if (!(bridge->ops & DRM_BRIDGE_OP_MODES))1187 return 0;1188 1189 return bridge->funcs->get_modes(bridge, connector);1190}1191EXPORT_SYMBOL_GPL(drm_bridge_get_modes);1192 1193/**1194 * drm_bridge_edid_read - read the EDID data of the connected display1195 * @bridge: bridge control structure1196 * @connector: the connector to read EDID for1197 *1198 * If the bridge supports output EDID retrieval, as reported by the1199 * DRM_BRIDGE_OP_EDID bridge ops flag, call &drm_bridge_funcs.edid_read to get1200 * the EDID and return it. Otherwise return NULL.1201 *1202 * RETURNS:1203 * The retrieved EDID on success, or NULL otherwise.1204 */1205const struct drm_edid *drm_bridge_edid_read(struct drm_bridge *bridge,1206 struct drm_connector *connector)1207{1208 if (!(bridge->ops & DRM_BRIDGE_OP_EDID))1209 return NULL;1210 1211 return bridge->funcs->edid_read(bridge, connector);1212}1213EXPORT_SYMBOL_GPL(drm_bridge_edid_read);1214 1215/**1216 * drm_bridge_hpd_enable - enable hot plug detection for the bridge1217 * @bridge: bridge control structure1218 * @cb: hot-plug detection callback1219 * @data: data to be passed to the hot-plug detection callback1220 *1221 * Call &drm_bridge_funcs.hpd_enable if implemented and register the given @cb1222 * and @data as hot plug notification callback. From now on the @cb will be1223 * called with @data when an output status change is detected by the bridge,1224 * until hot plug notification gets disabled with drm_bridge_hpd_disable().1225 *1226 * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in1227 * bridge->ops. This function shall not be called when the flag is not set.1228 *1229 * Only one hot plug detection callback can be registered at a time, it is an1230 * error to call this function when hot plug detection is already enabled for1231 * the bridge.1232 */1233void drm_bridge_hpd_enable(struct drm_bridge *bridge,1234 void (*cb)(void *data,1235 enum drm_connector_status status),1236 void *data)1237{1238 if (!(bridge->ops & DRM_BRIDGE_OP_HPD))1239 return;1240 1241 mutex_lock(&bridge->hpd_mutex);1242 1243 if (WARN(bridge->hpd_cb, "Hot plug detection already enabled\n"))1244 goto unlock;1245 1246 bridge->hpd_cb = cb;1247 bridge->hpd_data = data;1248 1249 if (bridge->funcs->hpd_enable)1250 bridge->funcs->hpd_enable(bridge);1251 1252unlock:1253 mutex_unlock(&bridge->hpd_mutex);1254}1255EXPORT_SYMBOL_GPL(drm_bridge_hpd_enable);1256 1257/**1258 * drm_bridge_hpd_disable - disable hot plug detection for the bridge1259 * @bridge: bridge control structure1260 *1261 * Call &drm_bridge_funcs.hpd_disable if implemented and unregister the hot1262 * plug detection callback previously registered with drm_bridge_hpd_enable().1263 * Once this function returns the callback will not be called by the bridge1264 * when an output status change occurs.1265 *1266 * Hot plug detection is supported only if the DRM_BRIDGE_OP_HPD flag is set in1267 * bridge->ops. This function shall not be called when the flag is not set.1268 */1269void drm_bridge_hpd_disable(struct drm_bridge *bridge)1270{1271 if (!(bridge->ops & DRM_BRIDGE_OP_HPD))1272 return;1273 1274 mutex_lock(&bridge->hpd_mutex);1275 if (bridge->funcs->hpd_disable)1276 bridge->funcs->hpd_disable(bridge);1277 1278 bridge->hpd_cb = NULL;1279 bridge->hpd_data = NULL;1280 mutex_unlock(&bridge->hpd_mutex);1281}1282EXPORT_SYMBOL_GPL(drm_bridge_hpd_disable);1283 1284/**1285 * drm_bridge_hpd_notify - notify hot plug detection events1286 * @bridge: bridge control structure1287 * @status: output connection status1288 *1289 * Bridge drivers shall call this function to report hot plug events when they1290 * detect a change in the output status, when hot plug detection has been1291 * enabled by drm_bridge_hpd_enable().1292 *1293 * This function shall be called in a context that can sleep.1294 */1295void drm_bridge_hpd_notify(struct drm_bridge *bridge,1296 enum drm_connector_status status)1297{1298 mutex_lock(&bridge->hpd_mutex);1299 if (bridge->hpd_cb)1300 bridge->hpd_cb(bridge->hpd_data, status);1301 mutex_unlock(&bridge->hpd_mutex);1302}1303EXPORT_SYMBOL_GPL(drm_bridge_hpd_notify);1304 1305#ifdef CONFIG_OF1306/**1307 * of_drm_find_bridge - find the bridge corresponding to the device node in1308 * the global bridge list1309 *1310 * @np: device node1311 *1312 * RETURNS:1313 * drm_bridge control struct on success, NULL on failure1314 */1315struct drm_bridge *of_drm_find_bridge(struct device_node *np)1316{1317 struct drm_bridge *bridge;1318 1319 mutex_lock(&bridge_lock);1320 1321 list_for_each_entry(bridge, &bridge_list, list) {1322 if (bridge->of_node == np) {1323 mutex_unlock(&bridge_lock);1324 return bridge;1325 }1326 }1327 1328 mutex_unlock(&bridge_lock);1329 return NULL;1330}1331EXPORT_SYMBOL(of_drm_find_bridge);1332#endif1333 1334MODULE_AUTHOR("Ajay Kumar <ajaykumar.rs@samsung.com>");1335MODULE_DESCRIPTION("DRM bridge infrastructure");1336MODULE_LICENSE("GPL and additional rights");1337