Subversion Repositories Kolibri OS

Rev

Rev 6084 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (C) 2014 Intel Corporation
  3.  *
  4.  * DRM universal plane helper functions
  5.  *
  6.  * Permission is hereby granted, free of charge, to any person obtaining a
  7.  * copy of this software and associated documentation files (the "Software"),
  8.  * to deal in the Software without restriction, including without limitation
  9.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  10.  * and/or sell copies of the Software, and to permit persons to whom the
  11.  * Software is furnished to do so, subject to the following conditions:
  12.  *
  13.  * The above copyright notice and this permission notice (including the next
  14.  * paragraph) shall be included in all copies or substantial portions of the
  15.  * Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  21.  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  22.  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  23.  * SOFTWARE.
  24.  */
  25.  
  26. #include <linux/list.h>
  27. #include <drm/drmP.h>
  28. #include <drm/drm_plane_helper.h>
  29. #include <drm/drm_rect.h>
  30. #include <drm/drm_atomic.h>
  31. #include <drm/drm_crtc_helper.h>
  32. #include <drm/drm_atomic_helper.h>
  33.  
  34. #define SUBPIXEL_MASK 0xffff
  35.  
  36. /**
  37.  * DOC: overview
  38.  *
  39.  * This helper library has two parts. The first part has support to implement
  40.  * primary plane support on top of the normal CRTC configuration interface.
  41.  * Since the legacy ->set_config interface ties the primary plane together with
  42.  * the CRTC state this does not allow userspace to disable the primary plane
  43.  * itself.  To avoid too much duplicated code use
  44.  * drm_plane_helper_check_update() which can be used to enforce the same
  45.  * restrictions as primary planes had thus. The default primary plane only
  46.  * expose XRBG8888 and ARGB8888 as valid pixel formats for the attached
  47.  * framebuffer.
  48.  *
  49.  * Drivers are highly recommended to implement proper support for primary
  50.  * planes, and newly merged drivers must not rely upon these transitional
  51.  * helpers.
  52.  *
  53.  * The second part also implements transitional helpers which allow drivers to
  54.  * gradually switch to the atomic helper infrastructure for plane updates. Once
  55.  * that switch is complete drivers shouldn't use these any longer, instead using
  56.  * the proper legacy implementations for update and disable plane hooks provided
  57.  * by the atomic helpers.
  58.  *
  59.  * Again drivers are strongly urged to switch to the new interfaces.
  60.  *
  61.  * The plane helpers share the function table structures with other helpers,
  62.  * specifically also the atomic helpers. See struct &drm_plane_helper_funcs for
  63.  * the details.
  64.  */
  65.  
  66. /*
  67.  * This is the minimal list of formats that seem to be safe for modeset use
  68.  * with all current DRM drivers.  Most hardware can actually support more
  69.  * formats than this and drivers may specify a more accurate list when
  70.  * creating the primary plane.  However drivers that still call
  71.  * drm_plane_init() will use this minimal format list as the default.
  72.  */
  73. static const uint32_t safe_modeset_formats[] = {
  74.         DRM_FORMAT_XRGB8888,
  75.         DRM_FORMAT_ARGB8888,
  76. };
  77.  
  78. /*
  79.  * Returns the connectors currently associated with a CRTC.  This function
  80.  * should be called twice:  once with a NULL connector list to retrieve
  81.  * the list size, and once with the properly allocated list to be filled in.
  82.  */
  83. static int get_connectors_for_crtc(struct drm_crtc *crtc,
  84.                                    struct drm_connector **connector_list,
  85.                                    int num_connectors)
  86. {
  87.         struct drm_device *dev = crtc->dev;
  88.         struct drm_connector *connector;
  89.         int count = 0;
  90.  
  91.         /*
  92.          * Note: Once we change the plane hooks to more fine-grained locking we
  93.          * need to grab the connection_mutex here to be able to make these
  94.          * checks.
  95.          */
  96.         WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  97.  
  98.         drm_for_each_connector(connector, dev) {
  99.                 if (connector->encoder && connector->encoder->crtc == crtc) {
  100.                         if (connector_list != NULL && count < num_connectors)
  101.                                 *(connector_list++) = connector;
  102.  
  103.                         count++;
  104.                 }
  105.         }
  106.  
  107.         return count;
  108. }
  109.  
  110. /**
  111.  * drm_plane_helper_check_update() - Check plane update for validity
  112.  * @plane: plane object to update
  113.  * @crtc: owning CRTC of owning plane
  114.  * @fb: framebuffer to flip onto plane
  115.  * @src: source coordinates in 16.16 fixed point
  116.  * @dest: integer destination coordinates
  117.  * @clip: integer clipping coordinates
  118.  * @min_scale: minimum @src:@dest scaling factor in 16.16 fixed point
  119.  * @max_scale: maximum @src:@dest scaling factor in 16.16 fixed point
  120.  * @can_position: is it legal to position the plane such that it
  121.  *                doesn't cover the entire crtc?  This will generally
  122.  *                only be false for primary planes.
  123.  * @can_update_disabled: can the plane be updated while the crtc
  124.  *                       is disabled?
  125.  * @visible: output parameter indicating whether plane is still visible after
  126.  *           clipping
  127.  *
  128.  * Checks that a desired plane update is valid.  Drivers that provide
  129.  * their own plane handling rather than helper-provided implementations may
  130.  * still wish to call this function to avoid duplication of error checking
  131.  * code.
  132.  *
  133.  * RETURNS:
  134.  * Zero if update appears valid, error code on failure
  135.  */
  136. int drm_plane_helper_check_update(struct drm_plane *plane,
  137.                                     struct drm_crtc *crtc,
  138.                                     struct drm_framebuffer *fb,
  139.                                     struct drm_rect *src,
  140.                                     struct drm_rect *dest,
  141.                                     const struct drm_rect *clip,
  142.                                     int min_scale,
  143.                                     int max_scale,
  144.                                     bool can_position,
  145.                                     bool can_update_disabled,
  146.                                     bool *visible)
  147. {
  148.         int hscale, vscale;
  149.  
  150.         if (!fb) {
  151.                 *visible = false;
  152.                 return 0;
  153.         }
  154.  
  155.         /* crtc should only be NULL when disabling (i.e., !fb) */
  156.         if (WARN_ON(!crtc)) {
  157.                 *visible = false;
  158.                 return 0;
  159.         }
  160.  
  161.         if (!crtc->enabled && !can_update_disabled) {
  162.                 DRM_DEBUG_KMS("Cannot update plane of a disabled CRTC.\n");
  163.                 return -EINVAL;
  164.         }
  165.  
  166.         /* Check scaling */
  167.         hscale = drm_rect_calc_hscale(src, dest, min_scale, max_scale);
  168.         vscale = drm_rect_calc_vscale(src, dest, min_scale, max_scale);
  169.         if (hscale < 0 || vscale < 0) {
  170.                 DRM_DEBUG_KMS("Invalid scaling of plane\n");
  171.                 drm_rect_debug_print("src: ", src, true);
  172.                 drm_rect_debug_print("dst: ", dest, false);
  173.                 return -ERANGE;
  174.         }
  175.  
  176.         *visible = drm_rect_clip_scaled(src, dest, clip, hscale, vscale);
  177.         if (!*visible)
  178.                 /*
  179.                  * Plane isn't visible; some drivers can handle this
  180.                  * so we just return success here.  Drivers that can't
  181.                  * (including those that use the primary plane helper's
  182.                  * update function) will return an error from their
  183.                  * update_plane handler.
  184.                  */
  185.                 return 0;
  186.  
  187.         if (!can_position && !drm_rect_equals(dest, clip)) {
  188.                 DRM_DEBUG_KMS("Plane must cover entire CRTC\n");
  189.                 drm_rect_debug_print("dst: ", dest, false);
  190.                 drm_rect_debug_print("clip: ", clip, false);
  191.                 return -EINVAL;
  192.         }
  193.  
  194.         return 0;
  195. }
  196. EXPORT_SYMBOL(drm_plane_helper_check_update);
  197.  
  198. /**
  199.  * drm_primary_helper_update() - Helper for primary plane update
  200.  * @plane: plane object to update
  201.  * @crtc: owning CRTC of owning plane
  202.  * @fb: framebuffer to flip onto plane
  203.  * @crtc_x: x offset of primary plane on crtc
  204.  * @crtc_y: y offset of primary plane on crtc
  205.  * @crtc_w: width of primary plane rectangle on crtc
  206.  * @crtc_h: height of primary plane rectangle on crtc
  207.  * @src_x: x offset of @fb for panning
  208.  * @src_y: y offset of @fb for panning
  209.  * @src_w: width of source rectangle in @fb
  210.  * @src_h: height of source rectangle in @fb
  211.  *
  212.  * Provides a default plane update handler for primary planes.  This is handler
  213.  * is called in response to a userspace SetPlane operation on the plane with a
  214.  * non-NULL framebuffer.  We call the driver's modeset handler to update the
  215.  * framebuffer.
  216.  *
  217.  * SetPlane() on a primary plane of a disabled CRTC is not supported, and will
  218.  * return an error.
  219.  *
  220.  * Note that we make some assumptions about hardware limitations that may not be
  221.  * true for all hardware --
  222.  *   1) Primary plane cannot be repositioned.
  223.  *   2) Primary plane cannot be scaled.
  224.  *   3) Primary plane must cover the entire CRTC.
  225.  *   4) Subpixel positioning is not supported.
  226.  * Drivers for hardware that don't have these restrictions can provide their
  227.  * own implementation rather than using this helper.
  228.  *
  229.  * RETURNS:
  230.  * Zero on success, error code on failure
  231.  */
  232. int drm_primary_helper_update(struct drm_plane *plane, struct drm_crtc *crtc,
  233.                               struct drm_framebuffer *fb,
  234.                               int crtc_x, int crtc_y,
  235.                               unsigned int crtc_w, unsigned int crtc_h,
  236.                               uint32_t src_x, uint32_t src_y,
  237.                               uint32_t src_w, uint32_t src_h)
  238. {
  239.         struct drm_mode_set set = {
  240.                 .crtc = crtc,
  241.                 .fb = fb,
  242.                 .mode = &crtc->mode,
  243.                 .x = src_x >> 16,
  244.                 .y = src_y >> 16,
  245.         };
  246.         struct drm_rect src = {
  247.                 .x1 = src_x,
  248.                 .y1 = src_y,
  249.                 .x2 = src_x + src_w,
  250.                 .y2 = src_y + src_h,
  251.         };
  252.         struct drm_rect dest = {
  253.                 .x1 = crtc_x,
  254.                 .y1 = crtc_y,
  255.                 .x2 = crtc_x + crtc_w,
  256.                 .y2 = crtc_y + crtc_h,
  257.         };
  258.         const struct drm_rect clip = {
  259.                 .x2 = crtc->mode.hdisplay,
  260.                 .y2 = crtc->mode.vdisplay,
  261.         };
  262.         struct drm_connector **connector_list;
  263.         int num_connectors, ret;
  264.         bool visible;
  265.  
  266.         ret = drm_plane_helper_check_update(plane, crtc, fb,
  267.                                             &src, &dest, &clip,
  268.                                             DRM_PLANE_HELPER_NO_SCALING,
  269.                                             DRM_PLANE_HELPER_NO_SCALING,
  270.                                             false, false, &visible);
  271.         if (ret)
  272.                 return ret;
  273.  
  274.         if (!visible)
  275.                 /*
  276.                  * Primary plane isn't visible.  Note that unless a driver
  277.                  * provides their own disable function, this will just
  278.                  * wind up returning -EINVAL to userspace.
  279.                  */
  280.                 return plane->funcs->disable_plane(plane);
  281.  
  282.         /* Find current connectors for CRTC */
  283.         num_connectors = get_connectors_for_crtc(crtc, NULL, 0);
  284.         BUG_ON(num_connectors == 0);
  285.         connector_list = kzalloc(num_connectors * sizeof(*connector_list),
  286.                                  GFP_KERNEL);
  287.         if (!connector_list)
  288.                 return -ENOMEM;
  289.         get_connectors_for_crtc(crtc, connector_list, num_connectors);
  290.  
  291.         set.connectors = connector_list;
  292.         set.num_connectors = num_connectors;
  293.  
  294.         /*
  295.          * We call set_config() directly here rather than using
  296.          * drm_mode_set_config_internal.  We're reprogramming the same
  297.          * connectors that were already in use, so we shouldn't need the extra
  298.          * cross-CRTC fb refcounting to accomodate stealing connectors.
  299.          * drm_mode_setplane() already handles the basic refcounting for the
  300.          * framebuffers involved in this operation.
  301.          */
  302.         ret = crtc->funcs->set_config(&set);
  303.  
  304.         kfree(connector_list);
  305.         return ret;
  306. }
  307. EXPORT_SYMBOL(drm_primary_helper_update);
  308.  
  309. /**
  310.  * drm_primary_helper_disable() - Helper for primary plane disable
  311.  * @plane: plane to disable
  312.  *
  313.  * Provides a default plane disable handler for primary planes.  This is handler
  314.  * is called in response to a userspace SetPlane operation on the plane with a
  315.  * NULL framebuffer parameter.  It unconditionally fails the disable call with
  316.  * -EINVAL the only way to disable the primary plane without driver support is
  317.  * to disable the entier CRTC. Which does not match the plane ->disable hook.
  318.  *
  319.  * Note that some hardware may be able to disable the primary plane without
  320.  * disabling the whole CRTC.  Drivers for such hardware should provide their
  321.  * own disable handler that disables just the primary plane (and they'll likely
  322.  * need to provide their own update handler as well to properly re-enable a
  323.  * disabled primary plane).
  324.  *
  325.  * RETURNS:
  326.  * Unconditionally returns -EINVAL.
  327.  */
  328. int drm_primary_helper_disable(struct drm_plane *plane)
  329. {
  330.         return -EINVAL;
  331. }
  332. EXPORT_SYMBOL(drm_primary_helper_disable);
  333.  
  334. /**
  335.  * drm_primary_helper_destroy() - Helper for primary plane destruction
  336.  * @plane: plane to destroy
  337.  *
  338.  * Provides a default plane destroy handler for primary planes.  This handler
  339.  * is called during CRTC destruction.  We disable the primary plane, remove
  340.  * it from the DRM plane list, and deallocate the plane structure.
  341.  */
  342. void drm_primary_helper_destroy(struct drm_plane *plane)
  343. {
  344.         drm_plane_cleanup(plane);
  345.         kfree(plane);
  346. }
  347. EXPORT_SYMBOL(drm_primary_helper_destroy);
  348.  
  349. const struct drm_plane_funcs drm_primary_helper_funcs = {
  350.         .update_plane = drm_primary_helper_update,
  351.         .disable_plane = drm_primary_helper_disable,
  352.         .destroy = drm_primary_helper_destroy,
  353. };
  354. EXPORT_SYMBOL(drm_primary_helper_funcs);
  355.  
  356. static struct drm_plane *create_primary_plane(struct drm_device *dev)
  357. {
  358.         struct drm_plane *primary;
  359.         int ret;
  360.  
  361.         primary = kzalloc(sizeof(*primary), GFP_KERNEL);
  362.         if (primary == NULL) {
  363.                 DRM_DEBUG_KMS("Failed to allocate primary plane\n");
  364.                 return NULL;
  365.         }
  366.  
  367.         /*
  368.          * Remove the format_default field from drm_plane when dropping
  369.          * this helper.
  370.          */
  371.         primary->format_default = true;
  372.  
  373.         /* possible_crtc's will be filled in later by crtc_init */
  374.         ret = drm_universal_plane_init(dev, primary, 0,
  375.                                        &drm_primary_helper_funcs,
  376.                                        safe_modeset_formats,
  377.                                        ARRAY_SIZE(safe_modeset_formats),
  378.                                        DRM_PLANE_TYPE_PRIMARY, NULL);
  379.         if (ret) {
  380.                 kfree(primary);
  381.                 primary = NULL;
  382.         }
  383.  
  384.         return primary;
  385. }
  386.  
  387. /**
  388.  * drm_crtc_init - Legacy CRTC initialization function
  389.  * @dev: DRM device
  390.  * @crtc: CRTC object to init
  391.  * @funcs: callbacks for the new CRTC
  392.  *
  393.  * Initialize a CRTC object with a default helper-provided primary plane and no
  394.  * cursor plane.
  395.  *
  396.  * Returns:
  397.  * Zero on success, error code on failure.
  398.  */
  399. int drm_crtc_init(struct drm_device *dev, struct drm_crtc *crtc,
  400.                   const struct drm_crtc_funcs *funcs)
  401. {
  402.         struct drm_plane *primary;
  403.  
  404.         primary = create_primary_plane(dev);
  405.         return drm_crtc_init_with_planes(dev, crtc, primary, NULL, funcs,
  406.                                          NULL);
  407. }
  408. EXPORT_SYMBOL(drm_crtc_init);
  409.  
  410. int drm_plane_helper_commit(struct drm_plane *plane,
  411.                             struct drm_plane_state *plane_state,
  412.                             struct drm_framebuffer *old_fb)
  413. {
  414.         const struct drm_plane_helper_funcs *plane_funcs;
  415.         struct drm_crtc *crtc[2];
  416.         const struct drm_crtc_helper_funcs *crtc_funcs[2];
  417.         int i, ret = 0;
  418.  
  419.         plane_funcs = plane->helper_private;
  420.  
  421.         /* Since this is a transitional helper we can't assume that plane->state
  422.          * is always valid. Hence we need to use plane->crtc instead of
  423.          * plane->state->crtc as the old crtc. */
  424.         crtc[0] = plane->crtc;
  425.         crtc[1] = crtc[0] != plane_state->crtc ? plane_state->crtc : NULL;
  426.  
  427.         for (i = 0; i < 2; i++)
  428.                 crtc_funcs[i] = crtc[i] ? crtc[i]->helper_private : NULL;
  429.  
  430.         if (plane_funcs->atomic_check) {
  431.                 ret = plane_funcs->atomic_check(plane, plane_state);
  432.                 if (ret)
  433.                         goto out;
  434.         }
  435.  
  436.         if (plane_funcs->prepare_fb && plane_state->fb &&
  437.             plane_state->fb != old_fb) {
  438.                 ret = plane_funcs->prepare_fb(plane,
  439.                                               plane_state);
  440.                 if (ret)
  441.                         goto out;
  442.         }
  443.  
  444.         /* Point of no return, commit sw state. */
  445.         swap(plane->state, plane_state);
  446.  
  447.         for (i = 0; i < 2; i++) {
  448.                 if (crtc_funcs[i] && crtc_funcs[i]->atomic_begin)
  449.                         crtc_funcs[i]->atomic_begin(crtc[i], crtc[i]->state);
  450.         }
  451.  
  452.         /*
  453.          * Drivers may optionally implement the ->atomic_disable callback, so
  454.          * special-case that here.
  455.          */
  456.         if (drm_atomic_plane_disabling(plane, plane_state) &&
  457.             plane_funcs->atomic_disable)
  458.                 plane_funcs->atomic_disable(plane, plane_state);
  459.         else
  460.                 plane_funcs->atomic_update(plane, plane_state);
  461.  
  462.         for (i = 0; i < 2; i++) {
  463.                 if (crtc_funcs[i] && crtc_funcs[i]->atomic_flush)
  464.                         crtc_funcs[i]->atomic_flush(crtc[i], crtc[i]->state);
  465.         }
  466.  
  467.         /*
  468.          * If we only moved the plane and didn't change fb's, there's no need to
  469.          * wait for vblank.
  470.          */
  471.         if (plane->state->fb == old_fb)
  472.                 goto out;
  473.  
  474.         for (i = 0; i < 2; i++) {
  475.                 if (!crtc[i])
  476.                         continue;
  477.  
  478.                 if (crtc[i]->cursor == plane)
  479.                         continue;
  480.  
  481.                 /* There's no other way to figure out whether the crtc is running. */
  482.                 ret = drm_crtc_vblank_get(crtc[i]);
  483.                 if (ret == 0) {
  484.                         drm_crtc_wait_one_vblank(crtc[i]);
  485.                         drm_crtc_vblank_put(crtc[i]);
  486.                 }
  487.  
  488.                 ret = 0;
  489.         }
  490.  
  491.         if (plane_funcs->cleanup_fb)
  492.                 plane_funcs->cleanup_fb(plane, plane_state);
  493. out:
  494.         if (plane_state) {
  495.                 if (plane->funcs->atomic_destroy_state)
  496.                         plane->funcs->atomic_destroy_state(plane, plane_state);
  497.                 else
  498.                         drm_atomic_helper_plane_destroy_state(plane, plane_state);
  499.         }
  500.  
  501.         return ret;
  502. }
  503.  
  504. /**
  505.  * drm_plane_helper_update() - Transitional helper for plane update
  506.  * @plane: plane object to update
  507.  * @crtc: owning CRTC of owning plane
  508.  * @fb: framebuffer to flip onto plane
  509.  * @crtc_x: x offset of primary plane on crtc
  510.  * @crtc_y: y offset of primary plane on crtc
  511.  * @crtc_w: width of primary plane rectangle on crtc
  512.  * @crtc_h: height of primary plane rectangle on crtc
  513.  * @src_x: x offset of @fb for panning
  514.  * @src_y: y offset of @fb for panning
  515.  * @src_w: width of source rectangle in @fb
  516.  * @src_h: height of source rectangle in @fb
  517.  *
  518.  * Provides a default plane update handler using the atomic plane update
  519.  * functions. It is fully left to the driver to check plane constraints and
  520.  * handle corner-cases like a fully occluded or otherwise invisible plane.
  521.  *
  522.  * This is useful for piecewise transitioning of a driver to the atomic helpers.
  523.  *
  524.  * RETURNS:
  525.  * Zero on success, error code on failure
  526.  */
  527. int drm_plane_helper_update(struct drm_plane *plane, struct drm_crtc *crtc,
  528.                             struct drm_framebuffer *fb,
  529.                             int crtc_x, int crtc_y,
  530.                             unsigned int crtc_w, unsigned int crtc_h,
  531.                             uint32_t src_x, uint32_t src_y,
  532.                             uint32_t src_w, uint32_t src_h)
  533. {
  534.         struct drm_plane_state *plane_state;
  535.  
  536.         if (plane->funcs->atomic_duplicate_state)
  537.                 plane_state = plane->funcs->atomic_duplicate_state(plane);
  538.         else {
  539.                 if (!plane->state)
  540.                         drm_atomic_helper_plane_reset(plane);
  541.  
  542.                 plane_state = drm_atomic_helper_plane_duplicate_state(plane);
  543.         }
  544.         if (!plane_state)
  545.                 return -ENOMEM;
  546.         plane_state->plane = plane;
  547.  
  548.         plane_state->crtc = crtc;
  549.         drm_atomic_set_fb_for_plane(plane_state, fb);
  550.         plane_state->crtc_x = crtc_x;
  551.         plane_state->crtc_y = crtc_y;
  552.         plane_state->crtc_h = crtc_h;
  553.         plane_state->crtc_w = crtc_w;
  554.         plane_state->src_x = src_x;
  555.         plane_state->src_y = src_y;
  556.         plane_state->src_h = src_h;
  557.         plane_state->src_w = src_w;
  558.  
  559.         return drm_plane_helper_commit(plane, plane_state, plane->fb);
  560. }
  561. EXPORT_SYMBOL(drm_plane_helper_update);
  562.  
  563. /**
  564.  * drm_plane_helper_disable() - Transitional helper for plane disable
  565.  * @plane: plane to disable
  566.  *
  567.  * Provides a default plane disable handler using the atomic plane update
  568.  * functions. It is fully left to the driver to check plane constraints and
  569.  * handle corner-cases like a fully occluded or otherwise invisible plane.
  570.  *
  571.  * This is useful for piecewise transitioning of a driver to the atomic helpers.
  572.  *
  573.  * RETURNS:
  574.  * Zero on success, error code on failure
  575.  */
  576. int drm_plane_helper_disable(struct drm_plane *plane)
  577. {
  578.         struct drm_plane_state *plane_state;
  579.  
  580.         /* crtc helpers love to call disable functions for already disabled hw
  581.          * functions. So cope with that. */
  582.         if (!plane->crtc)
  583.                 return 0;
  584.  
  585.         if (plane->funcs->atomic_duplicate_state)
  586.                 plane_state = plane->funcs->atomic_duplicate_state(plane);
  587.         else {
  588.                 if (!plane->state)
  589.                         drm_atomic_helper_plane_reset(plane);
  590.  
  591.                 plane_state = drm_atomic_helper_plane_duplicate_state(plane);
  592.         }
  593.         if (!plane_state)
  594.                 return -ENOMEM;
  595.         plane_state->plane = plane;
  596.  
  597.         plane_state->crtc = NULL;
  598.         drm_atomic_set_fb_for_plane(plane_state, NULL);
  599.  
  600.         return drm_plane_helper_commit(plane, plane_state, plane->fb);
  601. }
  602. EXPORT_SYMBOL(drm_plane_helper_disable);
  603.