Subversion Repositories Kolibri OS

Rev

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

  1. /*
  2.  * Copyright (C) 2014 Red Hat
  3.  * Copyright (C) 2014 Intel Corp.
  4.  *
  5.  * Permission is hereby granted, free of charge, to any person obtaining a
  6.  * copy of this software and associated documentation files (the "Software"),
  7.  * to deal in the Software without restriction, including without limitation
  8.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  9.  * and/or sell copies of the Software, and to permit persons to whom the
  10.  * Software is furnished to do so, subject to the following conditions:
  11.  *
  12.  * The above copyright notice and this permission notice shall be included in
  13.  * all copies or substantial portions of the Software.
  14.  *
  15.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  16.  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  17.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  18.  * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  19.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  20.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  21.  * OTHER DEALINGS IN THE SOFTWARE.
  22.  *
  23.  * Authors:
  24.  * Rob Clark <robdclark@gmail.com>
  25.  * Daniel Vetter <daniel.vetter@ffwll.ch>
  26.  */
  27.  
  28. #include <drm/drmP.h>
  29. #include <drm/drm_atomic.h>
  30. #include <drm/drm_plane_helper.h>
  31. #include <drm/drm_crtc_helper.h>
  32. #include <drm/drm_atomic_helper.h>
  33. #include <linux/fence.h>
  34.  
  35. /**
  36.  * DOC: overview
  37.  *
  38.  * This helper library provides implementations of check and commit functions on
  39.  * top of the CRTC modeset helper callbacks and the plane helper callbacks. It
  40.  * also provides convenience implementations for the atomic state handling
  41.  * callbacks for drivers which don't need to subclass the drm core structures to
  42.  * add their own additional internal state.
  43.  *
  44.  * This library also provides default implementations for the check callback in
  45.  * drm_atomic_helper_check() and for the commit callback with
  46.  * drm_atomic_helper_commit(). But the individual stages and callbacks are
  47.  * exposed to allow drivers to mix and match and e.g. use the plane helpers only
  48.  * together with a driver private modeset implementation.
  49.  *
  50.  * This library also provides implementations for all the legacy driver
  51.  * interfaces on top of the atomic interface. See drm_atomic_helper_set_config(),
  52.  * drm_atomic_helper_disable_plane(), drm_atomic_helper_disable_plane() and the
  53.  * various functions to implement set_property callbacks. New drivers must not
  54.  * implement these functions themselves but must use the provided helpers.
  55.  *
  56.  * The atomic helper uses the same function table structures as all other
  57.  * modesetting helpers. See the documentation for struct &drm_crtc_helper_funcs,
  58.  * struct &drm_encoder_helper_funcs and struct &drm_connector_helper_funcs. It
  59.  * also shares the struct &drm_plane_helper_funcs function table with the plane
  60.  * helpers.
  61.  */
  62. static void
  63. drm_atomic_helper_plane_changed(struct drm_atomic_state *state,
  64.                                 struct drm_plane_state *plane_state,
  65.                                 struct drm_plane *plane)
  66. {
  67.         struct drm_crtc_state *crtc_state;
  68.  
  69.         if (plane->state->crtc) {
  70.                 crtc_state = drm_atomic_get_existing_crtc_state(state,
  71.                                                                 plane->state->crtc);
  72.  
  73.                 if (WARN_ON(!crtc_state))
  74.                         return;
  75.  
  76.                 crtc_state->planes_changed = true;
  77.         }
  78.  
  79.         if (plane_state->crtc) {
  80.                 crtc_state = drm_atomic_get_existing_crtc_state(state,
  81.                                                                 plane_state->crtc);
  82.  
  83.                 if (WARN_ON(!crtc_state))
  84.                         return;
  85.  
  86.                 crtc_state->planes_changed = true;
  87.         }
  88. }
  89.  
  90. static int handle_conflicting_encoders(struct drm_atomic_state *state,
  91.                                        bool disable_conflicting_encoders)
  92. {
  93.         struct drm_connector_state *conn_state;
  94.         struct drm_connector *connector;
  95.         struct drm_encoder *encoder;
  96.         unsigned encoder_mask = 0;
  97.         int i, ret;
  98.  
  99.         /*
  100.          * First loop, find all newly assigned encoders from the connectors
  101.          * part of the state. If the same encoder is assigned to multiple
  102.          * connectors bail out.
  103.          */
  104.         for_each_connector_in_state(state, connector, conn_state, i) {
  105.                 const struct drm_connector_helper_funcs *funcs = connector->helper_private;
  106.                 struct drm_encoder *new_encoder;
  107.  
  108.                 if (!conn_state->crtc)
  109.                         continue;
  110.  
  111.                 if (funcs->atomic_best_encoder)
  112.                         new_encoder = funcs->atomic_best_encoder(connector, conn_state);
  113.                 else
  114.                         new_encoder = funcs->best_encoder(connector);
  115.  
  116.                 if (new_encoder) {
  117.                         if (encoder_mask & (1 << drm_encoder_index(new_encoder))) {
  118.                                 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] on [CONNECTOR:%d:%s] already assigned\n",
  119.                                         new_encoder->base.id, new_encoder->name,
  120.                                         connector->base.id, connector->name);
  121.  
  122.                                 return -EINVAL;
  123.                         }
  124.  
  125.                         encoder_mask |= 1 << drm_encoder_index(new_encoder);
  126.                 }
  127.         }
  128.  
  129.         if (!encoder_mask)
  130.                 return 0;
  131.  
  132.         /*
  133.          * Second loop, iterate over all connectors not part of the state.
  134.          *
  135.          * If a conflicting encoder is found and disable_conflicting_encoders
  136.          * is not set, an error is returned. Userspace can provide a solution
  137.          * through the atomic ioctl.
  138.          *
  139.          * If the flag is set conflicting connectors are removed from the crtc
  140.          * and the crtc is disabled if no encoder is left. This preserves
  141.          * compatibility with the legacy set_config behavior.
  142.          */
  143.         drm_for_each_connector(connector, state->dev) {
  144.                 struct drm_crtc_state *crtc_state;
  145.  
  146.                 if (drm_atomic_get_existing_connector_state(state, connector))
  147.                         continue;
  148.  
  149.                 encoder = connector->state->best_encoder;
  150.                 if (!encoder || !(encoder_mask & (1 << drm_encoder_index(encoder))))
  151.                         continue;
  152.  
  153.                 if (!disable_conflicting_encoders) {
  154.                         DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s] by [CONNECTOR:%d:%s]\n",
  155.                                          encoder->base.id, encoder->name,
  156.                                          connector->state->crtc->base.id,
  157.                                          connector->state->crtc->name,
  158.                                          connector->base.id, connector->name);
  159.                         return -EINVAL;
  160.                 }
  161.  
  162.                 conn_state = drm_atomic_get_connector_state(state, connector);
  163.                 if (IS_ERR(conn_state))
  164.                         return PTR_ERR(conn_state);
  165.  
  166.                 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], disabling [CONNECTOR:%d:%s]\n",
  167.                                  encoder->base.id, encoder->name,
  168.                                  conn_state->crtc->base.id, conn_state->crtc->name,
  169.                                  connector->base.id, connector->name);
  170.  
  171.                 crtc_state = drm_atomic_get_existing_crtc_state(state, conn_state->crtc);
  172.  
  173.                 ret = drm_atomic_set_crtc_for_connector(conn_state, NULL);
  174.                 if (ret)
  175.                         return ret;
  176.  
  177.                 if (!crtc_state->connector_mask) {
  178.                         ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
  179.                                                                 NULL);
  180.                         if (ret < 0)
  181.                                 return ret;
  182.  
  183.                         crtc_state->active = false;
  184.                 }
  185.         }
  186.  
  187.         return 0;
  188. }
  189.  
  190. static void
  191. set_best_encoder(struct drm_atomic_state *state,
  192.                  struct drm_connector_state *conn_state,
  193.                  struct drm_encoder *encoder)
  194. {
  195.         struct drm_crtc_state *crtc_state;
  196.         struct drm_crtc *crtc;
  197.  
  198.         if (conn_state->best_encoder) {
  199.                 /* Unset the encoder_mask in the old crtc state. */
  200.                 crtc = conn_state->connector->state->crtc;
  201.  
  202.                 /* A NULL crtc is an error here because we should have
  203.                  *  duplicated a NULL best_encoder when crtc was NULL.
  204.                  * As an exception restoring duplicated atomic state
  205.                  * during resume is allowed, so don't warn when
  206.                  * best_encoder is equal to encoder we intend to set.
  207.                  */
  208.                 WARN_ON(!crtc && encoder != conn_state->best_encoder);
  209.                 if (crtc) {
  210.                         crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
  211.  
  212.                         crtc_state->encoder_mask &=
  213.                                 ~(1 << drm_encoder_index(conn_state->best_encoder));
  214.                 }
  215.         }
  216.  
  217.         if (encoder) {
  218.                 crtc = conn_state->crtc;
  219.                 WARN_ON(!crtc);
  220.                 if (crtc) {
  221.                         crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
  222.  
  223.                         crtc_state->encoder_mask |=
  224.                                 1 << drm_encoder_index(encoder);
  225.                 }
  226.         }
  227.  
  228.         conn_state->best_encoder = encoder;
  229. }
  230.  
  231. static void
  232. steal_encoder(struct drm_atomic_state *state,
  233.               struct drm_encoder *encoder)
  234. {
  235.         struct drm_crtc_state *crtc_state;
  236.         struct drm_connector *connector;
  237.         struct drm_connector_state *connector_state;
  238.         int i;
  239.  
  240.         for_each_connector_in_state(state, connector, connector_state, i) {
  241.                 struct drm_crtc *encoder_crtc;
  242.  
  243.                 if (connector_state->best_encoder != encoder)
  244.                         continue;
  245.  
  246.                 encoder_crtc = connector->state->crtc;
  247.  
  248.                 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] in use on [CRTC:%d:%s], stealing it\n",
  249.                                  encoder->base.id, encoder->name,
  250.                                  encoder_crtc->base.id, encoder_crtc->name);
  251.  
  252.                 set_best_encoder(state, connector_state, NULL);
  253.  
  254.                 crtc_state = drm_atomic_get_existing_crtc_state(state, encoder_crtc);
  255.                 crtc_state->connectors_changed = true;
  256.  
  257.                 return;
  258.         }
  259. }
  260.  
  261. static int
  262. update_connector_routing(struct drm_atomic_state *state,
  263.                          struct drm_connector *connector,
  264.                          struct drm_connector_state *connector_state)
  265. {
  266.         const struct drm_connector_helper_funcs *funcs;
  267.         struct drm_encoder *new_encoder;
  268.         struct drm_crtc_state *crtc_state;
  269.  
  270.         DRM_DEBUG_ATOMIC("Updating routing for [CONNECTOR:%d:%s]\n",
  271.                          connector->base.id,
  272.                          connector->name);
  273.  
  274.         if (connector->state->crtc != connector_state->crtc) {
  275.                 if (connector->state->crtc) {
  276.                         crtc_state = drm_atomic_get_existing_crtc_state(state, connector->state->crtc);
  277.                         crtc_state->connectors_changed = true;
  278.                 }
  279.  
  280.                 if (connector_state->crtc) {
  281.                         crtc_state = drm_atomic_get_existing_crtc_state(state, connector_state->crtc);
  282.                         crtc_state->connectors_changed = true;
  283.                 }
  284.         }
  285.  
  286.         if (!connector_state->crtc) {
  287.                 DRM_DEBUG_ATOMIC("Disabling [CONNECTOR:%d:%s]\n",
  288.                                 connector->base.id,
  289.                                 connector->name);
  290.  
  291.                 set_best_encoder(state, connector_state, NULL);
  292.  
  293.                 return 0;
  294.         }
  295.  
  296.         funcs = connector->helper_private;
  297.  
  298.         if (funcs->atomic_best_encoder)
  299.                 new_encoder = funcs->atomic_best_encoder(connector,
  300.                                                          connector_state);
  301.         else
  302.                 new_encoder = funcs->best_encoder(connector);
  303.  
  304.         if (!new_encoder) {
  305.                 DRM_DEBUG_ATOMIC("No suitable encoder found for [CONNECTOR:%d:%s]\n",
  306.                                  connector->base.id,
  307.                                  connector->name);
  308.                 return -EINVAL;
  309.         }
  310.  
  311.         if (!drm_encoder_crtc_ok(new_encoder, connector_state->crtc)) {
  312.                 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] incompatible with [CRTC:%d]\n",
  313.                                  new_encoder->base.id,
  314.                                  new_encoder->name,
  315.                                  connector_state->crtc->base.id);
  316.                 return -EINVAL;
  317.         }
  318.  
  319.         if (new_encoder == connector_state->best_encoder) {
  320.                 set_best_encoder(state, connector_state, new_encoder);
  321.  
  322.                 DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] keeps [ENCODER:%d:%s], now on [CRTC:%d:%s]\n",
  323.                                  connector->base.id,
  324.                                  connector->name,
  325.                                  new_encoder->base.id,
  326.                                  new_encoder->name,
  327.                                  connector_state->crtc->base.id,
  328.                                  connector_state->crtc->name);
  329.  
  330.                 return 0;
  331.         }
  332.  
  333.         steal_encoder(state, new_encoder);
  334.  
  335.         set_best_encoder(state, connector_state, new_encoder);
  336.  
  337.         crtc_state = drm_atomic_get_existing_crtc_state(state, connector_state->crtc);
  338.         crtc_state->connectors_changed = true;
  339.  
  340.         DRM_DEBUG_ATOMIC("[CONNECTOR:%d:%s] using [ENCODER:%d:%s] on [CRTC:%d:%s]\n",
  341.                          connector->base.id,
  342.                          connector->name,
  343.                          new_encoder->base.id,
  344.                          new_encoder->name,
  345.                          connector_state->crtc->base.id,
  346.                          connector_state->crtc->name);
  347.  
  348.         return 0;
  349. }
  350.  
  351. static int
  352. mode_fixup(struct drm_atomic_state *state)
  353. {
  354.         struct drm_crtc *crtc;
  355.         struct drm_crtc_state *crtc_state;
  356.         struct drm_connector *connector;
  357.         struct drm_connector_state *conn_state;
  358.         int i;
  359.         bool ret;
  360.  
  361.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  362.                 if (!crtc_state->mode_changed &&
  363.                     !crtc_state->connectors_changed)
  364.                         continue;
  365.  
  366.                 drm_mode_copy(&crtc_state->adjusted_mode, &crtc_state->mode);
  367.         }
  368.  
  369.         for_each_connector_in_state(state, connector, conn_state, i) {
  370.                 const struct drm_encoder_helper_funcs *funcs;
  371.                 struct drm_encoder *encoder;
  372.  
  373.                 WARN_ON(!!conn_state->best_encoder != !!conn_state->crtc);
  374.  
  375.                 if (!conn_state->crtc || !conn_state->best_encoder)
  376.                         continue;
  377.  
  378.                 crtc_state = drm_atomic_get_existing_crtc_state(state,
  379.                                                                 conn_state->crtc);
  380.  
  381.                 /*
  382.                  * Each encoder has at most one connector (since we always steal
  383.                  * it away), so we won't call ->mode_fixup twice.
  384.                  */
  385.                 encoder = conn_state->best_encoder;
  386.                 funcs = encoder->helper_private;
  387.                 if (!funcs)
  388.                         continue;
  389.  
  390.                 ret = drm_bridge_mode_fixup(encoder->bridge, &crtc_state->mode,
  391.                                 &crtc_state->adjusted_mode);
  392.                 if (!ret) {
  393.                         DRM_DEBUG_ATOMIC("Bridge fixup failed\n");
  394.                         return -EINVAL;
  395.                 }
  396.  
  397.                 if (funcs->atomic_check) {
  398.                         ret = funcs->atomic_check(encoder, crtc_state,
  399.                                                   conn_state);
  400.                         if (ret) {
  401.                                 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] check failed\n",
  402.                                                  encoder->base.id, encoder->name);
  403.                                 return ret;
  404.                         }
  405.                 } else if (funcs->mode_fixup) {
  406.                         ret = funcs->mode_fixup(encoder, &crtc_state->mode,
  407.                                                 &crtc_state->adjusted_mode);
  408.                         if (!ret) {
  409.                                 DRM_DEBUG_ATOMIC("[ENCODER:%d:%s] fixup failed\n",
  410.                                                  encoder->base.id, encoder->name);
  411.                                 return -EINVAL;
  412.                         }
  413.                 }
  414.         }
  415.  
  416.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  417.                 const struct drm_crtc_helper_funcs *funcs;
  418.  
  419.                 if (!crtc_state->mode_changed &&
  420.                     !crtc_state->connectors_changed)
  421.                         continue;
  422.  
  423.                 funcs = crtc->helper_private;
  424.                 if (!funcs->mode_fixup)
  425.                         continue;
  426.  
  427.                 ret = funcs->mode_fixup(crtc, &crtc_state->mode,
  428.                                         &crtc_state->adjusted_mode);
  429.                 if (!ret) {
  430.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] fixup failed\n",
  431.                                          crtc->base.id, crtc->name);
  432.                         return -EINVAL;
  433.                 }
  434.         }
  435.  
  436.         return 0;
  437. }
  438.  
  439. /**
  440.  * drm_atomic_helper_check_modeset - validate state object for modeset changes
  441.  * @dev: DRM device
  442.  * @state: the driver state object
  443.  *
  444.  * Check the state object to see if the requested state is physically possible.
  445.  * This does all the crtc and connector related computations for an atomic
  446.  * update and adds any additional connectors needed for full modesets and calls
  447.  * down into ->mode_fixup functions of the driver backend.
  448.  *
  449.  * crtc_state->mode_changed is set when the input mode is changed.
  450.  * crtc_state->connectors_changed is set when a connector is added or
  451.  * removed from the crtc.
  452.  * crtc_state->active_changed is set when crtc_state->active changes,
  453.  * which is used for dpms.
  454.  *
  455.  * IMPORTANT:
  456.  *
  457.  * Drivers which update ->mode_changed (e.g. in their ->atomic_check hooks if a
  458.  * plane update can't be done without a full modeset) _must_ call this function
  459.  * afterwards after that change. It is permitted to call this function multiple
  460.  * times for the same update, e.g. when the ->atomic_check functions depend upon
  461.  * the adjusted dotclock for fifo space allocation and watermark computation.
  462.  *
  463.  * RETURNS
  464.  * Zero for success or -errno
  465.  */
  466. int
  467. drm_atomic_helper_check_modeset(struct drm_device *dev,
  468.                                 struct drm_atomic_state *state)
  469. {
  470.         struct drm_crtc *crtc;
  471.         struct drm_crtc_state *crtc_state;
  472.         struct drm_connector *connector;
  473.         struct drm_connector_state *connector_state;
  474.         int i, ret;
  475.  
  476.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  477.                 if (!drm_mode_equal(&crtc->state->mode, &crtc_state->mode)) {
  478.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] mode changed\n",
  479.                                          crtc->base.id, crtc->name);
  480.                         crtc_state->mode_changed = true;
  481.                 }
  482.  
  483.                 if (crtc->state->enable != crtc_state->enable) {
  484.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enable changed\n",
  485.                                          crtc->base.id, crtc->name);
  486.  
  487.                         /*
  488.                          * For clarity this assignment is done here, but
  489.                          * enable == 0 is only true when there are no
  490.                          * connectors and a NULL mode.
  491.                          *
  492.                          * The other way around is true as well. enable != 0
  493.                          * iff connectors are attached and a mode is set.
  494.                          */
  495.                         crtc_state->mode_changed = true;
  496.                         crtc_state->connectors_changed = true;
  497.                 }
  498.         }
  499.  
  500.         ret = handle_conflicting_encoders(state, state->legacy_set_config);
  501.         if (ret)
  502.                 return ret;
  503.  
  504.         for_each_connector_in_state(state, connector, connector_state, i) {
  505.                 /*
  506.                  * This only sets crtc->mode_changed for routing changes,
  507.                  * drivers must set crtc->mode_changed themselves when connector
  508.                  * properties need to be updated.
  509.                  */
  510.                 ret = update_connector_routing(state, connector,
  511.                                                connector_state);
  512.                 if (ret)
  513.                         return ret;
  514.         }
  515.  
  516.         /*
  517.          * After all the routing has been prepared we need to add in any
  518.          * connector which is itself unchanged, but who's crtc changes it's
  519.          * configuration. This must be done before calling mode_fixup in case a
  520.          * crtc only changed its mode but has the same set of connectors.
  521.          */
  522.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  523.                 bool has_connectors =
  524.                         !!crtc_state->connector_mask;
  525.  
  526.                 /*
  527.                  * We must set ->active_changed after walking connectors for
  528.                  * otherwise an update that only changes active would result in
  529.                  * a full modeset because update_connector_routing force that.
  530.                  */
  531.                 if (crtc->state->active != crtc_state->active) {
  532.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active changed\n",
  533.                                          crtc->base.id, crtc->name);
  534.                         crtc_state->active_changed = true;
  535.                 }
  536.  
  537.                 if (!drm_atomic_crtc_needs_modeset(crtc_state))
  538.                         continue;
  539.  
  540.                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] needs all connectors, enable: %c, active: %c\n",
  541.                                  crtc->base.id, crtc->name,
  542.                                  crtc_state->enable ? 'y' : 'n',
  543.                                  crtc_state->active ? 'y' : 'n');
  544.  
  545.                 ret = drm_atomic_add_affected_connectors(state, crtc);
  546.                 if (ret != 0)
  547.                         return ret;
  548.  
  549.                 ret = drm_atomic_add_affected_planes(state, crtc);
  550.                 if (ret != 0)
  551.                         return ret;
  552.  
  553.                 if (crtc_state->enable != has_connectors) {
  554.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled/connectors mismatch\n",
  555.                                          crtc->base.id, crtc->name);
  556.  
  557.                         return -EINVAL;
  558.                 }
  559.         }
  560.  
  561.         return mode_fixup(state);
  562. }
  563. EXPORT_SYMBOL(drm_atomic_helper_check_modeset);
  564.  
  565. /**
  566.  * drm_atomic_helper_check_planes - validate state object for planes changes
  567.  * @dev: DRM device
  568.  * @state: the driver state object
  569.  *
  570.  * Check the state object to see if the requested state is physically possible.
  571.  * This does all the plane update related checks using by calling into the
  572.  * ->atomic_check hooks provided by the driver.
  573.  *
  574.  * It also sets crtc_state->planes_changed to indicate that a crtc has
  575.  * updated planes.
  576.  *
  577.  * RETURNS
  578.  * Zero for success or -errno
  579.  */
  580. int
  581. drm_atomic_helper_check_planes(struct drm_device *dev,
  582.                                struct drm_atomic_state *state)
  583. {
  584.         struct drm_crtc *crtc;
  585.         struct drm_crtc_state *crtc_state;
  586.         struct drm_plane *plane;
  587.         struct drm_plane_state *plane_state;
  588.         int i, ret = 0;
  589.  
  590.         for_each_plane_in_state(state, plane, plane_state, i) {
  591.                 const struct drm_plane_helper_funcs *funcs;
  592.  
  593.                 funcs = plane->helper_private;
  594.  
  595.                 drm_atomic_helper_plane_changed(state, plane_state, plane);
  596.  
  597.                 if (!funcs || !funcs->atomic_check)
  598.                         continue;
  599.  
  600.                 ret = funcs->atomic_check(plane, plane_state);
  601.                 if (ret) {
  602.                         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic driver check failed\n",
  603.                                          plane->base.id, plane->name);
  604.                         return ret;
  605.                 }
  606.         }
  607.  
  608.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  609.                 const struct drm_crtc_helper_funcs *funcs;
  610.  
  611.                 funcs = crtc->helper_private;
  612.  
  613.                 if (!funcs || !funcs->atomic_check)
  614.                         continue;
  615.  
  616.                 ret = funcs->atomic_check(crtc, state->crtc_states[i]);
  617.                 if (ret) {
  618.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic driver check failed\n",
  619.                                          crtc->base.id, crtc->name);
  620.                         return ret;
  621.                 }
  622.         }
  623.  
  624.         return ret;
  625. }
  626. EXPORT_SYMBOL(drm_atomic_helper_check_planes);
  627.  
  628. /**
  629.  * drm_atomic_helper_check - validate state object
  630.  * @dev: DRM device
  631.  * @state: the driver state object
  632.  *
  633.  * Check the state object to see if the requested state is physically possible.
  634.  * Only crtcs and planes have check callbacks, so for any additional (global)
  635.  * checking that a driver needs it can simply wrap that around this function.
  636.  * Drivers without such needs can directly use this as their ->atomic_check()
  637.  * callback.
  638.  *
  639.  * This just wraps the two parts of the state checking for planes and modeset
  640.  * state in the default order: First it calls drm_atomic_helper_check_modeset()
  641.  * and then drm_atomic_helper_check_planes(). The assumption is that the
  642.  * ->atomic_check functions depend upon an updated adjusted_mode.clock to
  643.  * e.g. properly compute watermarks.
  644.  *
  645.  * RETURNS
  646.  * Zero for success or -errno
  647.  */
  648. int drm_atomic_helper_check(struct drm_device *dev,
  649.                             struct drm_atomic_state *state)
  650. {
  651.         int ret;
  652.  
  653.         ret = drm_atomic_helper_check_modeset(dev, state);
  654.         if (ret)
  655.                 return ret;
  656.  
  657.         ret = drm_atomic_helper_check_planes(dev, state);
  658.         if (ret)
  659.                 return ret;
  660.  
  661.         return ret;
  662. }
  663. EXPORT_SYMBOL(drm_atomic_helper_check);
  664.  
  665. static void
  666. disable_outputs(struct drm_device *dev, struct drm_atomic_state *old_state)
  667. {
  668.         struct drm_connector *connector;
  669.         struct drm_connector_state *old_conn_state;
  670.         struct drm_crtc *crtc;
  671.         struct drm_crtc_state *old_crtc_state;
  672.         int i;
  673.  
  674.         for_each_connector_in_state(old_state, connector, old_conn_state, i) {
  675.                 const struct drm_encoder_helper_funcs *funcs;
  676.                 struct drm_encoder *encoder;
  677.  
  678.                 /* Shut down everything that's in the changeset and currently
  679.                  * still on. So need to check the old, saved state. */
  680.                 if (!old_conn_state->crtc)
  681.                         continue;
  682.  
  683.                 old_crtc_state = drm_atomic_get_existing_crtc_state(old_state,
  684.                                                                     old_conn_state->crtc);
  685.  
  686.                 if (!old_crtc_state->active ||
  687.                     !drm_atomic_crtc_needs_modeset(old_conn_state->crtc->state))
  688.                         continue;
  689.  
  690.                 encoder = old_conn_state->best_encoder;
  691.  
  692.                 /* We shouldn't get this far if we didn't previously have
  693.                  * an encoder.. but WARN_ON() rather than explode.
  694.                  */
  695.                 if (WARN_ON(!encoder))
  696.                         continue;
  697.  
  698.                 funcs = encoder->helper_private;
  699.  
  700.                 DRM_DEBUG_ATOMIC("disabling [ENCODER:%d:%s]\n",
  701.                                  encoder->base.id, encoder->name);
  702.  
  703.                 /*
  704.                  * Each encoder has at most one connector (since we always steal
  705.                  * it away), so we won't call disable hooks twice.
  706.                  */
  707.                 drm_bridge_disable(encoder->bridge);
  708.  
  709.                 /* Right function depends upon target state. */
  710.                 if (connector->state->crtc && funcs->prepare)
  711.                         funcs->prepare(encoder);
  712.                 else if (funcs->disable)
  713.                         funcs->disable(encoder);
  714.                 else
  715.                         funcs->dpms(encoder, DRM_MODE_DPMS_OFF);
  716.  
  717.                 drm_bridge_post_disable(encoder->bridge);
  718.         }
  719.  
  720.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  721.                 const struct drm_crtc_helper_funcs *funcs;
  722.  
  723.                 /* Shut down everything that needs a full modeset. */
  724.                 if (!drm_atomic_crtc_needs_modeset(crtc->state))
  725.                         continue;
  726.  
  727.                 if (!old_crtc_state->active)
  728.                         continue;
  729.  
  730.                 funcs = crtc->helper_private;
  731.  
  732.                 DRM_DEBUG_ATOMIC("disabling [CRTC:%d:%s]\n",
  733.                                  crtc->base.id, crtc->name);
  734.  
  735.  
  736.                 /* Right function depends upon target state. */
  737.                 if (crtc->state->enable && funcs->prepare)
  738.                         funcs->prepare(crtc);
  739.                 else if (funcs->disable)
  740.                         funcs->disable(crtc);
  741.                 else
  742.                         funcs->dpms(crtc, DRM_MODE_DPMS_OFF);
  743.         }
  744. }
  745.  
  746. /**
  747.  * drm_atomic_helper_update_legacy_modeset_state - update legacy modeset state
  748.  * @dev: DRM device
  749.  * @old_state: atomic state object with old state structures
  750.  *
  751.  * This function updates all the various legacy modeset state pointers in
  752.  * connectors, encoders and crtcs. It also updates the timestamping constants
  753.  * used for precise vblank timestamps by calling
  754.  * drm_calc_timestamping_constants().
  755.  *
  756.  * Drivers can use this for building their own atomic commit if they don't have
  757.  * a pure helper-based modeset implementation.
  758.  */
  759. void
  760. drm_atomic_helper_update_legacy_modeset_state(struct drm_device *dev,
  761.                                               struct drm_atomic_state *old_state)
  762. {
  763.         struct drm_connector *connector;
  764.         struct drm_connector_state *old_conn_state;
  765.         struct drm_crtc *crtc;
  766.         struct drm_crtc_state *old_crtc_state;
  767.         int i;
  768.  
  769.         /* clear out existing links and update dpms */
  770.         for_each_connector_in_state(old_state, connector, old_conn_state, i) {
  771.                 if (connector->encoder) {
  772.                         WARN_ON(!connector->encoder->crtc);
  773.  
  774.                         connector->encoder->crtc = NULL;
  775.                         connector->encoder = NULL;
  776.                 }
  777.  
  778.                 crtc = connector->state->crtc;
  779.                 if ((!crtc && old_conn_state->crtc) ||
  780.                     (crtc && drm_atomic_crtc_needs_modeset(crtc->state))) {
  781.                         struct drm_property *dpms_prop =
  782.                                 dev->mode_config.dpms_property;
  783.                         int mode = DRM_MODE_DPMS_OFF;
  784.  
  785.                         if (crtc && crtc->state->active)
  786.                                 mode = DRM_MODE_DPMS_ON;
  787.  
  788.                         connector->dpms = mode;
  789.                         drm_object_property_set_value(&connector->base,
  790.                                                       dpms_prop, mode);
  791.                 }
  792.         }
  793.  
  794.         /* set new links */
  795.         for_each_connector_in_state(old_state, connector, old_conn_state, i) {
  796.                 if (!connector->state->crtc)
  797.                         continue;
  798.  
  799.                 if (WARN_ON(!connector->state->best_encoder))
  800.                         continue;
  801.  
  802.                 connector->encoder = connector->state->best_encoder;
  803.                 connector->encoder->crtc = connector->state->crtc;
  804.         }
  805.  
  806.         /* set legacy state in the crtc structure */
  807.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  808.                 struct drm_plane *primary = crtc->primary;
  809.  
  810.                 crtc->mode = crtc->state->mode;
  811.                 crtc->enabled = crtc->state->enable;
  812.  
  813.                 if (drm_atomic_get_existing_plane_state(old_state, primary) &&
  814.                     primary->state->crtc == crtc) {
  815.                         crtc->x = primary->state->src_x >> 16;
  816.                         crtc->y = primary->state->src_y >> 16;
  817.                 }
  818.  
  819.                 if (crtc->state->enable)
  820.                         drm_calc_timestamping_constants(crtc,
  821.                                                         &crtc->state->adjusted_mode);
  822.         }
  823. }
  824. EXPORT_SYMBOL(drm_atomic_helper_update_legacy_modeset_state);
  825.  
  826. static void
  827. crtc_set_mode(struct drm_device *dev, struct drm_atomic_state *old_state)
  828. {
  829.         struct drm_crtc *crtc;
  830.         struct drm_crtc_state *old_crtc_state;
  831.         struct drm_connector *connector;
  832.         struct drm_connector_state *old_conn_state;
  833.         int i;
  834.  
  835.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  836.                 const struct drm_crtc_helper_funcs *funcs;
  837.  
  838.                 if (!crtc->state->mode_changed)
  839.                         continue;
  840.  
  841.                 funcs = crtc->helper_private;
  842.  
  843.                 if (crtc->state->enable && funcs->mode_set_nofb) {
  844.                         DRM_DEBUG_ATOMIC("modeset on [CRTC:%d:%s]\n",
  845.                                          crtc->base.id, crtc->name);
  846.  
  847.                         funcs->mode_set_nofb(crtc);
  848.                 }
  849.         }
  850.  
  851.         for_each_connector_in_state(old_state, connector, old_conn_state, i) {
  852.                 const struct drm_encoder_helper_funcs *funcs;
  853.                 struct drm_crtc_state *new_crtc_state;
  854.                 struct drm_encoder *encoder;
  855.                 struct drm_display_mode *mode, *adjusted_mode;
  856.  
  857.                 if (!connector->state->best_encoder)
  858.                         continue;
  859.  
  860.                 encoder = connector->state->best_encoder;
  861.                 funcs = encoder->helper_private;
  862.                 new_crtc_state = connector->state->crtc->state;
  863.                 mode = &new_crtc_state->mode;
  864.                 adjusted_mode = &new_crtc_state->adjusted_mode;
  865.  
  866.                 if (!new_crtc_state->mode_changed)
  867.                         continue;
  868.  
  869.                 DRM_DEBUG_ATOMIC("modeset on [ENCODER:%d:%s]\n",
  870.                                  encoder->base.id, encoder->name);
  871.  
  872.                 /*
  873.                  * Each encoder has at most one connector (since we always steal
  874.                  * it away), so we won't call mode_set hooks twice.
  875.                  */
  876.                 if (funcs->mode_set)
  877.                         funcs->mode_set(encoder, mode, adjusted_mode);
  878.  
  879.                 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
  880.         }
  881. }
  882.  
  883. /**
  884.  * drm_atomic_helper_commit_modeset_disables - modeset commit to disable outputs
  885.  * @dev: DRM device
  886.  * @old_state: atomic state object with old state structures
  887.  *
  888.  * This function shuts down all the outputs that need to be shut down and
  889.  * prepares them (if required) with the new mode.
  890.  *
  891.  * For compatibility with legacy crtc helpers this should be called before
  892.  * drm_atomic_helper_commit_planes(), which is what the default commit function
  893.  * does. But drivers with different needs can group the modeset commits together
  894.  * and do the plane commits at the end. This is useful for drivers doing runtime
  895.  * PM since planes updates then only happen when the CRTC is actually enabled.
  896.  */
  897. void drm_atomic_helper_commit_modeset_disables(struct drm_device *dev,
  898.                                                struct drm_atomic_state *old_state)
  899. {
  900.         disable_outputs(dev, old_state);
  901.  
  902.         drm_atomic_helper_update_legacy_modeset_state(dev, old_state);
  903.  
  904.         crtc_set_mode(dev, old_state);
  905. }
  906. EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_disables);
  907.  
  908. /**
  909.  * drm_atomic_helper_commit_modeset_enables - modeset commit to enable outputs
  910.  * @dev: DRM device
  911.  * @old_state: atomic state object with old state structures
  912.  *
  913.  * This function enables all the outputs with the new configuration which had to
  914.  * be turned off for the update.
  915.  *
  916.  * For compatibility with legacy crtc helpers this should be called after
  917.  * drm_atomic_helper_commit_planes(), which is what the default commit function
  918.  * does. But drivers with different needs can group the modeset commits together
  919.  * and do the plane commits at the end. This is useful for drivers doing runtime
  920.  * PM since planes updates then only happen when the CRTC is actually enabled.
  921.  */
  922. void drm_atomic_helper_commit_modeset_enables(struct drm_device *dev,
  923.                                               struct drm_atomic_state *old_state)
  924. {
  925.         struct drm_crtc *crtc;
  926.         struct drm_crtc_state *old_crtc_state;
  927.         struct drm_connector *connector;
  928.         struct drm_connector_state *old_conn_state;
  929.         int i;
  930.  
  931.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  932.                 const struct drm_crtc_helper_funcs *funcs;
  933.  
  934.                 /* Need to filter out CRTCs where only planes change. */
  935.                 if (!drm_atomic_crtc_needs_modeset(crtc->state))
  936.                         continue;
  937.  
  938.                 if (!crtc->state->active)
  939.                         continue;
  940.  
  941.                 funcs = crtc->helper_private;
  942.  
  943.                 if (crtc->state->enable) {
  944.                         DRM_DEBUG_ATOMIC("enabling [CRTC:%d:%s]\n",
  945.                                          crtc->base.id, crtc->name);
  946.  
  947.                         if (funcs->enable)
  948.                                 funcs->enable(crtc);
  949.                         else
  950.                                 funcs->commit(crtc);
  951.                 }
  952.         }
  953.  
  954.         for_each_connector_in_state(old_state, connector, old_conn_state, i) {
  955.                 const struct drm_encoder_helper_funcs *funcs;
  956.                 struct drm_encoder *encoder;
  957.  
  958.                 if (!connector->state->best_encoder)
  959.                         continue;
  960.  
  961.                 if (!connector->state->crtc->state->active ||
  962.                     !drm_atomic_crtc_needs_modeset(connector->state->crtc->state))
  963.                         continue;
  964.  
  965.                 encoder = connector->state->best_encoder;
  966.                 funcs = encoder->helper_private;
  967.  
  968.                 DRM_DEBUG_ATOMIC("enabling [ENCODER:%d:%s]\n",
  969.                                  encoder->base.id, encoder->name);
  970.  
  971.                 /*
  972.                  * Each encoder has at most one connector (since we always steal
  973.                  * it away), so we won't call enable hooks twice.
  974.                  */
  975.                 drm_bridge_pre_enable(encoder->bridge);
  976.  
  977.                 if (funcs->enable)
  978.                         funcs->enable(encoder);
  979.                 else
  980.                         funcs->commit(encoder);
  981.  
  982.                 drm_bridge_enable(encoder->bridge);
  983.         }
  984. }
  985. EXPORT_SYMBOL(drm_atomic_helper_commit_modeset_enables);
  986.  
  987. static void wait_for_fences(struct drm_device *dev,
  988.                             struct drm_atomic_state *state)
  989. {
  990.         struct drm_plane *plane;
  991.         struct drm_plane_state *plane_state;
  992.         int i;
  993.  
  994.         for_each_plane_in_state(state, plane, plane_state, i) {
  995.                 if (!plane->state->fence)
  996.                         continue;
  997.  
  998.                 WARN_ON(!plane->state->fb);
  999.  
  1000.                 fence_wait(plane->state->fence, false);
  1001.                 fence_put(plane->state->fence);
  1002.                 plane->state->fence = NULL;
  1003.         }
  1004. }
  1005.  
  1006. /**
  1007.  * drm_atomic_helper_framebuffer_changed - check if framebuffer has changed
  1008.  * @dev: DRM device
  1009.  * @old_state: atomic state object with old state structures
  1010.  * @crtc: DRM crtc
  1011.  *
  1012.  * Checks whether the framebuffer used for this CRTC changes as a result of
  1013.  * the atomic update.  This is useful for drivers which cannot use
  1014.  * drm_atomic_helper_wait_for_vblanks() and need to reimplement its
  1015.  * functionality.
  1016.  *
  1017.  * Returns:
  1018.  * true if the framebuffer changed.
  1019.  */
  1020. bool drm_atomic_helper_framebuffer_changed(struct drm_device *dev,
  1021.                                            struct drm_atomic_state *old_state,
  1022.                                            struct drm_crtc *crtc)
  1023. {
  1024.         struct drm_plane *plane;
  1025.         struct drm_plane_state *old_plane_state;
  1026.         int i;
  1027.  
  1028.         for_each_plane_in_state(old_state, plane, old_plane_state, i) {
  1029.                 if (plane->state->crtc != crtc &&
  1030.                     old_plane_state->crtc != crtc)
  1031.                         continue;
  1032.  
  1033.                 if (plane->state->fb != old_plane_state->fb)
  1034.                         return true;
  1035.         }
  1036.  
  1037.         return false;
  1038. }
  1039. EXPORT_SYMBOL(drm_atomic_helper_framebuffer_changed);
  1040.  
  1041. /**
  1042.  * drm_atomic_helper_wait_for_vblanks - wait for vblank on crtcs
  1043.  * @dev: DRM device
  1044.  * @old_state: atomic state object with old state structures
  1045.  *
  1046.  * Helper to, after atomic commit, wait for vblanks on all effected
  1047.  * crtcs (ie. before cleaning up old framebuffers using
  1048.  * drm_atomic_helper_cleanup_planes()). It will only wait on crtcs where the
  1049.  * framebuffers have actually changed to optimize for the legacy cursor and
  1050.  * plane update use-case.
  1051.  */
  1052. void
  1053. drm_atomic_helper_wait_for_vblanks(struct drm_device *dev,
  1054.                 struct drm_atomic_state *old_state)
  1055. {
  1056.         struct drm_crtc *crtc;
  1057.         struct drm_crtc_state *old_crtc_state;
  1058.         int i, ret;
  1059.  
  1060.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  1061.                 /* No one cares about the old state, so abuse it for tracking
  1062.                  * and store whether we hold a vblank reference (and should do a
  1063.                  * vblank wait) in the ->enable boolean. */
  1064.                 old_crtc_state->enable = false;
  1065.  
  1066.                 if (!crtc->state->enable)
  1067.                         continue;
  1068.  
  1069.                 /* Legacy cursor ioctls are completely unsynced, and userspace
  1070.                  * relies on that (by doing tons of cursor updates). */
  1071.                 if (old_state->legacy_cursor_update)
  1072.                         continue;
  1073.  
  1074.                 if (!drm_atomic_helper_framebuffer_changed(dev,
  1075.                                 old_state, crtc))
  1076.                         continue;
  1077.  
  1078.                 ret = drm_crtc_vblank_get(crtc);
  1079.                 if (ret != 0)
  1080.                         continue;
  1081.  
  1082.                 old_crtc_state->enable = true;
  1083.                 old_crtc_state->last_vblank_count = drm_crtc_vblank_count(crtc);
  1084.         }
  1085.  
  1086.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  1087.                 if (!old_crtc_state->enable)
  1088.                         continue;
  1089.  
  1090.                 ret = wait_event_timeout(dev->vblank[i].queue,
  1091.                                 old_crtc_state->last_vblank_count !=
  1092.                                         drm_crtc_vblank_count(crtc),
  1093.                                 msecs_to_jiffies(50));
  1094.  
  1095.                 drm_crtc_vblank_put(crtc);
  1096.         }
  1097. }
  1098. EXPORT_SYMBOL(drm_atomic_helper_wait_for_vblanks);
  1099.  
  1100. /**
  1101.  * drm_atomic_helper_commit - commit validated state object
  1102.  * @dev: DRM device
  1103.  * @state: the driver state object
  1104.  * @async: asynchronous commit
  1105.  *
  1106.  * This function commits a with drm_atomic_helper_check() pre-validated state
  1107.  * object. This can still fail when e.g. the framebuffer reservation fails. For
  1108.  * now this doesn't implement asynchronous commits.
  1109.  *
  1110.  * Note that right now this function does not support async commits, and hence
  1111.  * driver writers must implement their own version for now. Also note that the
  1112.  * default ordering of how the various stages are called is to match the legacy
  1113.  * modeset helper library closest. One peculiarity of that is that it doesn't
  1114.  * mesh well with runtime PM at all.
  1115.  *
  1116.  * For drivers supporting runtime PM the recommended sequence is
  1117.  *
  1118.  *     drm_atomic_helper_commit_modeset_disables(dev, state);
  1119.  *
  1120.  *     drm_atomic_helper_commit_modeset_enables(dev, state);
  1121.  *
  1122.  *     drm_atomic_helper_commit_planes(dev, state, true);
  1123.  *
  1124.  * See the kerneldoc entries for these three functions for more details.
  1125.  *
  1126.  * RETURNS
  1127.  * Zero for success or -errno.
  1128.  */
  1129. int drm_atomic_helper_commit(struct drm_device *dev,
  1130.                              struct drm_atomic_state *state,
  1131.                              bool async)
  1132. {
  1133.         int ret;
  1134.  
  1135.         if (async)
  1136.                 return -EBUSY;
  1137.  
  1138.         ret = drm_atomic_helper_prepare_planes(dev, state);
  1139.         if (ret)
  1140.                 return ret;
  1141.  
  1142.         /*
  1143.          * This is the point of no return - everything below never fails except
  1144.          * when the hw goes bonghits. Which means we can commit the new state on
  1145.          * the software side now.
  1146.          */
  1147.  
  1148.         drm_atomic_helper_swap_state(dev, state);
  1149.  
  1150.         /*
  1151.          * Everything below can be run asynchronously without the need to grab
  1152.          * any modeset locks at all under one condition: It must be guaranteed
  1153.          * that the asynchronous work has either been cancelled (if the driver
  1154.          * supports it, which at least requires that the framebuffers get
  1155.          * cleaned up with drm_atomic_helper_cleanup_planes()) or completed
  1156.          * before the new state gets committed on the software side with
  1157.          * drm_atomic_helper_swap_state().
  1158.          *
  1159.          * This scheme allows new atomic state updates to be prepared and
  1160.          * checked in parallel to the asynchronous completion of the previous
  1161.          * update. Which is important since compositors need to figure out the
  1162.          * composition of the next frame right after having submitted the
  1163.          * current layout.
  1164.          */
  1165.  
  1166.         wait_for_fences(dev, state);
  1167.  
  1168.         drm_atomic_helper_commit_modeset_disables(dev, state);
  1169.  
  1170.         drm_atomic_helper_commit_planes(dev, state, false);
  1171.  
  1172.         drm_atomic_helper_commit_modeset_enables(dev, state);
  1173.  
  1174.         drm_atomic_helper_wait_for_vblanks(dev, state);
  1175.  
  1176.         drm_atomic_helper_cleanup_planes(dev, state);
  1177.  
  1178.         drm_atomic_state_free(state);
  1179.  
  1180.         return 0;
  1181. }
  1182. EXPORT_SYMBOL(drm_atomic_helper_commit);
  1183.  
  1184. /**
  1185.  * DOC: implementing async commit
  1186.  *
  1187.  * For now the atomic helpers don't support async commit directly. If there is
  1188.  * real need it could be added though, using the dma-buf fence infrastructure
  1189.  * for generic synchronization with outstanding rendering.
  1190.  *
  1191.  * For now drivers have to implement async commit themselves, with the following
  1192.  * sequence being the recommended one:
  1193.  *
  1194.  * 1. Run drm_atomic_helper_prepare_planes() first. This is the only function
  1195.  * which commit needs to call which can fail, so we want to run it first and
  1196.  * synchronously.
  1197.  *
  1198.  * 2. Synchronize with any outstanding asynchronous commit worker threads which
  1199.  * might be affected the new state update. This can be done by either cancelling
  1200.  * or flushing the work items, depending upon whether the driver can deal with
  1201.  * cancelled updates. Note that it is important to ensure that the framebuffer
  1202.  * cleanup is still done when cancelling.
  1203.  *
  1204.  * For sufficient parallelism it is recommended to have a work item per crtc
  1205.  * (for updates which don't touch global state) and a global one. Then we only
  1206.  * need to synchronize with the crtc work items for changed crtcs and the global
  1207.  * work item, which allows nice concurrent updates on disjoint sets of crtcs.
  1208.  *
  1209.  * 3. The software state is updated synchronously with
  1210.  * drm_atomic_helper_swap_state(). Doing this under the protection of all modeset
  1211.  * locks means concurrent callers never see inconsistent state. And doing this
  1212.  * while it's guaranteed that no relevant async worker runs means that async
  1213.  * workers do not need grab any locks. Actually they must not grab locks, for
  1214.  * otherwise the work flushing will deadlock.
  1215.  *
  1216.  * 4. Schedule a work item to do all subsequent steps, using the split-out
  1217.  * commit helpers: a) pre-plane commit b) plane commit c) post-plane commit and
  1218.  * then cleaning up the framebuffers after the old framebuffer is no longer
  1219.  * being displayed.
  1220.  */
  1221.  
  1222. /**
  1223.  * drm_atomic_helper_prepare_planes - prepare plane resources before commit
  1224.  * @dev: DRM device
  1225.  * @state: atomic state object with new state structures
  1226.  *
  1227.  * This function prepares plane state, specifically framebuffers, for the new
  1228.  * configuration. If any failure is encountered this function will call
  1229.  * ->cleanup_fb on any already successfully prepared framebuffer.
  1230.  *
  1231.  * Returns:
  1232.  * 0 on success, negative error code on failure.
  1233.  */
  1234. int drm_atomic_helper_prepare_planes(struct drm_device *dev,
  1235.                                      struct drm_atomic_state *state)
  1236. {
  1237.         int nplanes = dev->mode_config.num_total_plane;
  1238.         int ret, i;
  1239.  
  1240.         for (i = 0; i < nplanes; i++) {
  1241.                 const struct drm_plane_helper_funcs *funcs;
  1242.                 struct drm_plane *plane = state->planes[i];
  1243.                 struct drm_plane_state *plane_state = state->plane_states[i];
  1244.  
  1245.                 if (!plane)
  1246.                         continue;
  1247.  
  1248.                 funcs = plane->helper_private;
  1249.  
  1250.                 if (funcs->prepare_fb) {
  1251.                         ret = funcs->prepare_fb(plane, plane_state);
  1252.                         if (ret)
  1253.                                 goto fail;
  1254.                 }
  1255.         }
  1256.  
  1257.         return 0;
  1258.  
  1259. fail:
  1260.         for (i--; i >= 0; i--) {
  1261.                 const struct drm_plane_helper_funcs *funcs;
  1262.                 struct drm_plane *plane = state->planes[i];
  1263.                 struct drm_plane_state *plane_state = state->plane_states[i];
  1264.  
  1265.                 if (!plane)
  1266.                         continue;
  1267.  
  1268.                 funcs = plane->helper_private;
  1269.  
  1270.                 if (funcs->cleanup_fb)
  1271.                         funcs->cleanup_fb(plane, plane_state);
  1272.  
  1273.         }
  1274.  
  1275.         return ret;
  1276. }
  1277. EXPORT_SYMBOL(drm_atomic_helper_prepare_planes);
  1278.  
  1279. bool plane_crtc_active(struct drm_plane_state *state)
  1280. {
  1281.         return state->crtc && state->crtc->state->active;
  1282. }
  1283.  
  1284. /**
  1285.  * drm_atomic_helper_commit_planes - commit plane state
  1286.  * @dev: DRM device
  1287.  * @old_state: atomic state object with old state structures
  1288.  * @active_only: Only commit on active CRTC if set
  1289.  *
  1290.  * This function commits the new plane state using the plane and atomic helper
  1291.  * functions for planes and crtcs. It assumes that the atomic state has already
  1292.  * been pushed into the relevant object state pointers, since this step can no
  1293.  * longer fail.
  1294.  *
  1295.  * It still requires the global state object @old_state to know which planes and
  1296.  * crtcs need to be updated though.
  1297.  *
  1298.  * Note that this function does all plane updates across all CRTCs in one step.
  1299.  * If the hardware can't support this approach look at
  1300.  * drm_atomic_helper_commit_planes_on_crtc() instead.
  1301.  *
  1302.  * Plane parameters can be updated by applications while the associated CRTC is
  1303.  * disabled. The DRM/KMS core will store the parameters in the plane state,
  1304.  * which will be available to the driver when the CRTC is turned on. As a result
  1305.  * most drivers don't need to be immediately notified of plane updates for a
  1306.  * disabled CRTC.
  1307.  *
  1308.  * Unless otherwise needed, drivers are advised to set the @active_only
  1309.  * parameters to true in order not to receive plane update notifications related
  1310.  * to a disabled CRTC. This avoids the need to manually ignore plane updates in
  1311.  * driver code when the driver and/or hardware can't or just don't need to deal
  1312.  * with updates on disabled CRTCs, for example when supporting runtime PM.
  1313.  *
  1314.  * The drm_atomic_helper_commit() default implementation only sets @active_only
  1315.  * to false to most closely match the behaviour of the legacy helpers. This should
  1316.  * not be copied blindly by drivers.
  1317.  */
  1318. void drm_atomic_helper_commit_planes(struct drm_device *dev,
  1319.                                      struct drm_atomic_state *old_state,
  1320.                                      bool active_only)
  1321. {
  1322.         struct drm_crtc *crtc;
  1323.         struct drm_crtc_state *old_crtc_state;
  1324.         struct drm_plane *plane;
  1325.         struct drm_plane_state *old_plane_state;
  1326.         int i;
  1327.  
  1328.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  1329.                 const struct drm_crtc_helper_funcs *funcs;
  1330.  
  1331.                 funcs = crtc->helper_private;
  1332.  
  1333.                 if (!funcs || !funcs->atomic_begin)
  1334.                         continue;
  1335.  
  1336.                 if (active_only && !crtc->state->active)
  1337.                         continue;
  1338.  
  1339.                 funcs->atomic_begin(crtc, old_crtc_state);
  1340.         }
  1341.  
  1342.         for_each_plane_in_state(old_state, plane, old_plane_state, i) {
  1343.                 const struct drm_plane_helper_funcs *funcs;
  1344.                 bool disabling;
  1345.  
  1346.                 funcs = plane->helper_private;
  1347.  
  1348.                 if (!funcs)
  1349.                         continue;
  1350.  
  1351.                 disabling = drm_atomic_plane_disabling(plane, old_plane_state);
  1352.  
  1353.                 if (active_only) {
  1354.                         /*
  1355.                          * Skip planes related to inactive CRTCs. If the plane
  1356.                          * is enabled use the state of the current CRTC. If the
  1357.                          * plane is being disabled use the state of the old
  1358.                          * CRTC to avoid skipping planes being disabled on an
  1359.                          * active CRTC.
  1360.                          */
  1361.                         if (!disabling && !plane_crtc_active(plane->state))
  1362.                                 continue;
  1363.                         if (disabling && !plane_crtc_active(old_plane_state))
  1364.                                 continue;
  1365.                 }
  1366.  
  1367.                 /*
  1368.                  * Special-case disabling the plane if drivers support it.
  1369.                  */
  1370.                 if (disabling && funcs->atomic_disable)
  1371.                         funcs->atomic_disable(plane, old_plane_state);
  1372.                 else if (plane->state->crtc || disabling)
  1373.                         funcs->atomic_update(plane, old_plane_state);
  1374.         }
  1375.  
  1376.         for_each_crtc_in_state(old_state, crtc, old_crtc_state, i) {
  1377.                 const struct drm_crtc_helper_funcs *funcs;
  1378.  
  1379.                 funcs = crtc->helper_private;
  1380.  
  1381.                 if (!funcs || !funcs->atomic_flush)
  1382.                         continue;
  1383.  
  1384.                 if (active_only && !crtc->state->active)
  1385.                         continue;
  1386.  
  1387.                 funcs->atomic_flush(crtc, old_crtc_state);
  1388.         }
  1389. }
  1390. EXPORT_SYMBOL(drm_atomic_helper_commit_planes);
  1391.  
  1392. /**
  1393.  * drm_atomic_helper_commit_planes_on_crtc - commit plane state for a crtc
  1394.  * @old_crtc_state: atomic state object with the old crtc state
  1395.  *
  1396.  * This function commits the new plane state using the plane and atomic helper
  1397.  * functions for planes on the specific crtc. It assumes that the atomic state
  1398.  * has already been pushed into the relevant object state pointers, since this
  1399.  * step can no longer fail.
  1400.  *
  1401.  * This function is useful when plane updates should be done crtc-by-crtc
  1402.  * instead of one global step like drm_atomic_helper_commit_planes() does.
  1403.  *
  1404.  * This function can only be savely used when planes are not allowed to move
  1405.  * between different CRTCs because this function doesn't handle inter-CRTC
  1406.  * depencies. Callers need to ensure that either no such depencies exist,
  1407.  * resolve them through ordering of commit calls or through some other means.
  1408.  */
  1409. void
  1410. drm_atomic_helper_commit_planes_on_crtc(struct drm_crtc_state *old_crtc_state)
  1411. {
  1412.         const struct drm_crtc_helper_funcs *crtc_funcs;
  1413.         struct drm_crtc *crtc = old_crtc_state->crtc;
  1414.         struct drm_atomic_state *old_state = old_crtc_state->state;
  1415.         struct drm_plane *plane;
  1416.         unsigned plane_mask;
  1417.  
  1418.         plane_mask = old_crtc_state->plane_mask;
  1419.         plane_mask |= crtc->state->plane_mask;
  1420.  
  1421.         crtc_funcs = crtc->helper_private;
  1422.         if (crtc_funcs && crtc_funcs->atomic_begin)
  1423.                 crtc_funcs->atomic_begin(crtc, old_crtc_state);
  1424.  
  1425.         drm_for_each_plane_mask(plane, crtc->dev, plane_mask) {
  1426.                 struct drm_plane_state *old_plane_state =
  1427.                         drm_atomic_get_existing_plane_state(old_state, plane);
  1428.                 const struct drm_plane_helper_funcs *plane_funcs;
  1429.  
  1430.                 plane_funcs = plane->helper_private;
  1431.  
  1432.                 if (!old_plane_state || !plane_funcs)
  1433.                         continue;
  1434.  
  1435.                 WARN_ON(plane->state->crtc && plane->state->crtc != crtc);
  1436.  
  1437.                 if (drm_atomic_plane_disabling(plane, old_plane_state) &&
  1438.                     plane_funcs->atomic_disable)
  1439.                         plane_funcs->atomic_disable(plane, old_plane_state);
  1440.                 else if (plane->state->crtc ||
  1441.                          drm_atomic_plane_disabling(plane, old_plane_state))
  1442.                         plane_funcs->atomic_update(plane, old_plane_state);
  1443.         }
  1444.  
  1445.         if (crtc_funcs && crtc_funcs->atomic_flush)
  1446.                 crtc_funcs->atomic_flush(crtc, old_crtc_state);
  1447. }
  1448. EXPORT_SYMBOL(drm_atomic_helper_commit_planes_on_crtc);
  1449.  
  1450. /**
  1451.  * drm_atomic_helper_disable_planes_on_crtc - helper to disable CRTC's planes
  1452.  * @crtc: CRTC
  1453.  * @atomic: if set, synchronize with CRTC's atomic_begin/flush hooks
  1454.  *
  1455.  * Disables all planes associated with the given CRTC. This can be
  1456.  * used for instance in the CRTC helper disable callback to disable
  1457.  * all planes before shutting down the display pipeline.
  1458.  *
  1459.  * If the atomic-parameter is set the function calls the CRTC's
  1460.  * atomic_begin hook before and atomic_flush hook after disabling the
  1461.  * planes.
  1462.  *
  1463.  * It is a bug to call this function without having implemented the
  1464.  * ->atomic_disable() plane hook.
  1465.  */
  1466. void drm_atomic_helper_disable_planes_on_crtc(struct drm_crtc *crtc,
  1467.                                               bool atomic)
  1468. {
  1469.         const struct drm_crtc_helper_funcs *crtc_funcs =
  1470.                 crtc->helper_private;
  1471.         struct drm_plane *plane;
  1472.  
  1473.         if (atomic && crtc_funcs && crtc_funcs->atomic_begin)
  1474.                 crtc_funcs->atomic_begin(crtc, NULL);
  1475.  
  1476.         drm_for_each_plane(plane, crtc->dev) {
  1477.                 const struct drm_plane_helper_funcs *plane_funcs =
  1478.                         plane->helper_private;
  1479.  
  1480.                 if (plane->state->crtc != crtc || !plane_funcs)
  1481.                         continue;
  1482.  
  1483.                 WARN_ON(!plane_funcs->atomic_disable);
  1484.                 if (plane_funcs->atomic_disable)
  1485.                         plane_funcs->atomic_disable(plane, NULL);
  1486.         }
  1487.  
  1488.         if (atomic && crtc_funcs && crtc_funcs->atomic_flush)
  1489.                 crtc_funcs->atomic_flush(crtc, NULL);
  1490. }
  1491. EXPORT_SYMBOL(drm_atomic_helper_disable_planes_on_crtc);
  1492.  
  1493. /**
  1494.  * drm_atomic_helper_cleanup_planes - cleanup plane resources after commit
  1495.  * @dev: DRM device
  1496.  * @old_state: atomic state object with old state structures
  1497.  *
  1498.  * This function cleans up plane state, specifically framebuffers, from the old
  1499.  * configuration. Hence the old configuration must be perserved in @old_state to
  1500.  * be able to call this function.
  1501.  *
  1502.  * This function must also be called on the new state when the atomic update
  1503.  * fails at any point after calling drm_atomic_helper_prepare_planes().
  1504.  */
  1505. void drm_atomic_helper_cleanup_planes(struct drm_device *dev,
  1506.                                       struct drm_atomic_state *old_state)
  1507. {
  1508.         struct drm_plane *plane;
  1509.         struct drm_plane_state *plane_state;
  1510.         int i;
  1511.  
  1512.         for_each_plane_in_state(old_state, plane, plane_state, i) {
  1513.                 const struct drm_plane_helper_funcs *funcs;
  1514.  
  1515.                 funcs = plane->helper_private;
  1516.  
  1517.                 if (funcs->cleanup_fb)
  1518.                         funcs->cleanup_fb(plane, plane_state);
  1519.         }
  1520. }
  1521. EXPORT_SYMBOL(drm_atomic_helper_cleanup_planes);
  1522.  
  1523. /**
  1524.  * drm_atomic_helper_swap_state - store atomic state into current sw state
  1525.  * @dev: DRM device
  1526.  * @state: atomic state
  1527.  *
  1528.  * This function stores the atomic state into the current state pointers in all
  1529.  * driver objects. It should be called after all failing steps have been done
  1530.  * and succeeded, but before the actual hardware state is committed.
  1531.  *
  1532.  * For cleanup and error recovery the current state for all changed objects will
  1533.  * be swaped into @state.
  1534.  *
  1535.  * With that sequence it fits perfectly into the plane prepare/cleanup sequence:
  1536.  *
  1537.  * 1. Call drm_atomic_helper_prepare_planes() with the staged atomic state.
  1538.  *
  1539.  * 2. Do any other steps that might fail.
  1540.  *
  1541.  * 3. Put the staged state into the current state pointers with this function.
  1542.  *
  1543.  * 4. Actually commit the hardware state.
  1544.  *
  1545.  * 5. Call drm_atomic_helper_cleanup_planes() with @state, which since step 3
  1546.  * contains the old state. Also do any other cleanup required with that state.
  1547.  */
  1548. void drm_atomic_helper_swap_state(struct drm_device *dev,
  1549.                                   struct drm_atomic_state *state)
  1550. {
  1551.         int i;
  1552.  
  1553.         for (i = 0; i < state->num_connector; i++) {
  1554.                 struct drm_connector *connector = state->connectors[i];
  1555.  
  1556.                 if (!connector)
  1557.                         continue;
  1558.  
  1559.                 connector->state->state = state;
  1560.                 swap(state->connector_states[i], connector->state);
  1561.                 connector->state->state = NULL;
  1562.         }
  1563.  
  1564.         for (i = 0; i < dev->mode_config.num_crtc; i++) {
  1565.                 struct drm_crtc *crtc = state->crtcs[i];
  1566.  
  1567.                 if (!crtc)
  1568.                         continue;
  1569.  
  1570.                 crtc->state->state = state;
  1571.                 swap(state->crtc_states[i], crtc->state);
  1572.                 crtc->state->state = NULL;
  1573.         }
  1574.  
  1575.         for (i = 0; i < dev->mode_config.num_total_plane; i++) {
  1576.                 struct drm_plane *plane = state->planes[i];
  1577.  
  1578.                 if (!plane)
  1579.                         continue;
  1580.  
  1581.                 plane->state->state = state;
  1582.                 swap(state->plane_states[i], plane->state);
  1583.                 plane->state->state = NULL;
  1584.         }
  1585. }
  1586. EXPORT_SYMBOL(drm_atomic_helper_swap_state);
  1587.  
  1588. /**
  1589.  * drm_atomic_helper_update_plane - Helper for primary plane update using atomic
  1590.  * @plane: plane object to update
  1591.  * @crtc: owning CRTC of owning plane
  1592.  * @fb: framebuffer to flip onto plane
  1593.  * @crtc_x: x offset of primary plane on crtc
  1594.  * @crtc_y: y offset of primary plane on crtc
  1595.  * @crtc_w: width of primary plane rectangle on crtc
  1596.  * @crtc_h: height of primary plane rectangle on crtc
  1597.  * @src_x: x offset of @fb for panning
  1598.  * @src_y: y offset of @fb for panning
  1599.  * @src_w: width of source rectangle in @fb
  1600.  * @src_h: height of source rectangle in @fb
  1601.  *
  1602.  * Provides a default plane update handler using the atomic driver interface.
  1603.  *
  1604.  * RETURNS:
  1605.  * Zero on success, error code on failure
  1606.  */
  1607. int drm_atomic_helper_update_plane(struct drm_plane *plane,
  1608.                                    struct drm_crtc *crtc,
  1609.                                    struct drm_framebuffer *fb,
  1610.                                    int crtc_x, int crtc_y,
  1611.                                    unsigned int crtc_w, unsigned int crtc_h,
  1612.                                    uint32_t src_x, uint32_t src_y,
  1613.                                    uint32_t src_w, uint32_t src_h)
  1614. {
  1615.         struct drm_atomic_state *state;
  1616.         struct drm_plane_state *plane_state;
  1617.         int ret = 0;
  1618.  
  1619.         state = drm_atomic_state_alloc(plane->dev);
  1620.         if (!state)
  1621.                 return -ENOMEM;
  1622.  
  1623.         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
  1624. retry:
  1625.         plane_state = drm_atomic_get_plane_state(state, plane);
  1626.         if (IS_ERR(plane_state)) {
  1627.                 ret = PTR_ERR(plane_state);
  1628.                 goto fail;
  1629.         }
  1630.  
  1631.         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
  1632.         if (ret != 0)
  1633.                 goto fail;
  1634.         drm_atomic_set_fb_for_plane(plane_state, fb);
  1635.         plane_state->crtc_x = crtc_x;
  1636.         plane_state->crtc_y = crtc_y;
  1637.         plane_state->crtc_w = crtc_w;
  1638.         plane_state->crtc_h = crtc_h;
  1639.         plane_state->src_x = src_x;
  1640.         plane_state->src_y = src_y;
  1641.         plane_state->src_w = src_w;
  1642.         plane_state->src_h = src_h;
  1643.  
  1644.         if (plane == crtc->cursor)
  1645.                 state->legacy_cursor_update = true;
  1646.  
  1647.         ret = drm_atomic_commit(state);
  1648.         if (ret != 0)
  1649.                 goto fail;
  1650.  
  1651.         /* Driver takes ownership of state on successful commit. */
  1652.         return 0;
  1653. fail:
  1654.         if (ret == -EDEADLK)
  1655.                 goto backoff;
  1656.  
  1657.         drm_atomic_state_free(state);
  1658.  
  1659.         return ret;
  1660. backoff:
  1661.         drm_atomic_state_clear(state);
  1662.         drm_atomic_legacy_backoff(state);
  1663.  
  1664.         /*
  1665.          * Someone might have exchanged the framebuffer while we dropped locks
  1666.          * in the backoff code. We need to fix up the fb refcount tracking the
  1667.          * core does for us.
  1668.          */
  1669.         plane->old_fb = plane->fb;
  1670.  
  1671.         goto retry;
  1672. }
  1673. EXPORT_SYMBOL(drm_atomic_helper_update_plane);
  1674.  
  1675. /**
  1676.  * drm_atomic_helper_disable_plane - Helper for primary plane disable using * atomic
  1677.  * @plane: plane to disable
  1678.  *
  1679.  * Provides a default plane disable handler using the atomic driver interface.
  1680.  *
  1681.  * RETURNS:
  1682.  * Zero on success, error code on failure
  1683.  */
  1684. int drm_atomic_helper_disable_plane(struct drm_plane *plane)
  1685. {
  1686.         struct drm_atomic_state *state;
  1687.         struct drm_plane_state *plane_state;
  1688.         int ret = 0;
  1689.  
  1690.         /*
  1691.          * FIXME: Without plane->crtc set we can't get at the implicit legacy
  1692.          * acquire context. The real fix will be to wire the acquire ctx through
  1693.          * everywhere we need it, but meanwhile prevent chaos by just skipping
  1694.          * this noop. The critical case is the cursor ioctls which a) only grab
  1695.          * crtc/cursor-plane locks (so we need the crtc to get at the right
  1696.          * acquire context) and b) can try to disable the plane multiple times.
  1697.          */
  1698.         if (!plane->crtc)
  1699.                 return 0;
  1700.  
  1701.         state = drm_atomic_state_alloc(plane->dev);
  1702.         if (!state)
  1703.                 return -ENOMEM;
  1704.  
  1705.         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(plane->crtc);
  1706. retry:
  1707.         plane_state = drm_atomic_get_plane_state(state, plane);
  1708.         if (IS_ERR(plane_state)) {
  1709.                 ret = PTR_ERR(plane_state);
  1710.                 goto fail;
  1711.         }
  1712.  
  1713.         if (plane_state->crtc && (plane == plane->crtc->cursor))
  1714.                 plane_state->state->legacy_cursor_update = true;
  1715.  
  1716.         ret = __drm_atomic_helper_disable_plane(plane, plane_state);
  1717.         if (ret != 0)
  1718.                 goto fail;
  1719.  
  1720.         ret = drm_atomic_commit(state);
  1721.         if (ret != 0)
  1722.                 goto fail;
  1723.  
  1724.         /* Driver takes ownership of state on successful commit. */
  1725.         return 0;
  1726. fail:
  1727.         if (ret == -EDEADLK)
  1728.                 goto backoff;
  1729.  
  1730.         drm_atomic_state_free(state);
  1731.  
  1732.         return ret;
  1733. backoff:
  1734.         drm_atomic_state_clear(state);
  1735.         drm_atomic_legacy_backoff(state);
  1736.  
  1737.         /*
  1738.          * Someone might have exchanged the framebuffer while we dropped locks
  1739.          * in the backoff code. We need to fix up the fb refcount tracking the
  1740.          * core does for us.
  1741.          */
  1742.         plane->old_fb = plane->fb;
  1743.  
  1744.         goto retry;
  1745. }
  1746. EXPORT_SYMBOL(drm_atomic_helper_disable_plane);
  1747.  
  1748. /* just used from fb-helper and atomic-helper: */
  1749. int __drm_atomic_helper_disable_plane(struct drm_plane *plane,
  1750.                 struct drm_plane_state *plane_state)
  1751. {
  1752.         int ret;
  1753.  
  1754.         ret = drm_atomic_set_crtc_for_plane(plane_state, NULL);
  1755.         if (ret != 0)
  1756.                 return ret;
  1757.  
  1758.         drm_atomic_set_fb_for_plane(plane_state, NULL);
  1759.         plane_state->crtc_x = 0;
  1760.         plane_state->crtc_y = 0;
  1761.         plane_state->crtc_w = 0;
  1762.         plane_state->crtc_h = 0;
  1763.         plane_state->src_x = 0;
  1764.         plane_state->src_y = 0;
  1765.         plane_state->src_w = 0;
  1766.         plane_state->src_h = 0;
  1767.  
  1768.         return 0;
  1769. }
  1770.  
  1771. static int update_output_state(struct drm_atomic_state *state,
  1772.                                struct drm_mode_set *set)
  1773. {
  1774.         struct drm_device *dev = set->crtc->dev;
  1775.         struct drm_crtc *crtc;
  1776.         struct drm_crtc_state *crtc_state;
  1777.         struct drm_connector *connector;
  1778.         struct drm_connector_state *conn_state;
  1779.         int ret, i;
  1780.  
  1781.         ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
  1782.                                state->acquire_ctx);
  1783.         if (ret)
  1784.                 return ret;
  1785.  
  1786.         /* First disable all connectors on the target crtc. */
  1787.         ret = drm_atomic_add_affected_connectors(state, set->crtc);
  1788.         if (ret)
  1789.                 return ret;
  1790.  
  1791.         for_each_connector_in_state(state, connector, conn_state, i) {
  1792.                 if (conn_state->crtc == set->crtc) {
  1793.                         ret = drm_atomic_set_crtc_for_connector(conn_state,
  1794.                                                                 NULL);
  1795.                         if (ret)
  1796.                                 return ret;
  1797.                 }
  1798.         }
  1799.  
  1800.         /* Then set all connectors from set->connectors on the target crtc */
  1801.         for (i = 0; i < set->num_connectors; i++) {
  1802.                 conn_state = drm_atomic_get_connector_state(state,
  1803.                                                             set->connectors[i]);
  1804.                 if (IS_ERR(conn_state))
  1805.                         return PTR_ERR(conn_state);
  1806.  
  1807.                 ret = drm_atomic_set_crtc_for_connector(conn_state,
  1808.                                                         set->crtc);
  1809.                 if (ret)
  1810.                         return ret;
  1811.         }
  1812.  
  1813.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  1814.                 /* Don't update ->enable for the CRTC in the set_config request,
  1815.                  * since a mismatch would indicate a bug in the upper layers.
  1816.                  * The actual modeset code later on will catch any
  1817.                  * inconsistencies here. */
  1818.                 if (crtc == set->crtc)
  1819.                         continue;
  1820.  
  1821.                 if (!crtc_state->connector_mask) {
  1822.                         ret = drm_atomic_set_mode_prop_for_crtc(crtc_state,
  1823.                                                                 NULL);
  1824.                         if (ret < 0)
  1825.                                 return ret;
  1826.  
  1827.                         crtc_state->active = false;
  1828.                 }
  1829.         }
  1830.  
  1831.         return 0;
  1832. }
  1833.  
  1834. /**
  1835.  * drm_atomic_helper_set_config - set a new config from userspace
  1836.  * @set: mode set configuration
  1837.  *
  1838.  * Provides a default crtc set_config handler using the atomic driver interface.
  1839.  *
  1840.  * Returns:
  1841.  * Returns 0 on success, negative errno numbers on failure.
  1842.  */
  1843. int drm_atomic_helper_set_config(struct drm_mode_set *set)
  1844. {
  1845.         struct drm_atomic_state *state;
  1846.         struct drm_crtc *crtc = set->crtc;
  1847.         int ret = 0;
  1848.  
  1849.         state = drm_atomic_state_alloc(crtc->dev);
  1850.         if (!state)
  1851.                 return -ENOMEM;
  1852.  
  1853.         state->legacy_set_config = true;
  1854.         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
  1855. retry:
  1856.         ret = __drm_atomic_helper_set_config(set, state);
  1857.         if (ret != 0)
  1858.                 goto fail;
  1859.  
  1860.         ret = drm_atomic_commit(state);
  1861.         if (ret != 0)
  1862.                 goto fail;
  1863.  
  1864.         /* Driver takes ownership of state on successful commit. */
  1865.         return 0;
  1866. fail:
  1867.         if (ret == -EDEADLK)
  1868.                 goto backoff;
  1869.  
  1870.         drm_atomic_state_free(state);
  1871.  
  1872.         return ret;
  1873. backoff:
  1874.         drm_atomic_state_clear(state);
  1875.         drm_atomic_legacy_backoff(state);
  1876.  
  1877.         /*
  1878.          * Someone might have exchanged the framebuffer while we dropped locks
  1879.          * in the backoff code. We need to fix up the fb refcount tracking the
  1880.          * core does for us.
  1881.          */
  1882.         crtc->primary->old_fb = crtc->primary->fb;
  1883.  
  1884.         goto retry;
  1885. }
  1886. EXPORT_SYMBOL(drm_atomic_helper_set_config);
  1887.  
  1888. /* just used from fb-helper and atomic-helper: */
  1889. int __drm_atomic_helper_set_config(struct drm_mode_set *set,
  1890.                 struct drm_atomic_state *state)
  1891. {
  1892.         struct drm_crtc_state *crtc_state;
  1893.         struct drm_plane_state *primary_state;
  1894.         struct drm_crtc *crtc = set->crtc;
  1895.         int hdisplay, vdisplay;
  1896.         int ret;
  1897.  
  1898.         crtc_state = drm_atomic_get_crtc_state(state, crtc);
  1899.         if (IS_ERR(crtc_state))
  1900.                 return PTR_ERR(crtc_state);
  1901.  
  1902.         primary_state = drm_atomic_get_plane_state(state, crtc->primary);
  1903.         if (IS_ERR(primary_state))
  1904.                 return PTR_ERR(primary_state);
  1905.  
  1906.         if (!set->mode) {
  1907.                 WARN_ON(set->fb);
  1908.                 WARN_ON(set->num_connectors);
  1909.  
  1910.                 ret = drm_atomic_set_mode_for_crtc(crtc_state, NULL);
  1911.                 if (ret != 0)
  1912.                         return ret;
  1913.  
  1914.                 crtc_state->active = false;
  1915.  
  1916.                 ret = drm_atomic_set_crtc_for_plane(primary_state, NULL);
  1917.                 if (ret != 0)
  1918.                         return ret;
  1919.  
  1920.                 drm_atomic_set_fb_for_plane(primary_state, NULL);
  1921.  
  1922.                 goto commit;
  1923.         }
  1924.  
  1925.         WARN_ON(!set->fb);
  1926.         WARN_ON(!set->num_connectors);
  1927.  
  1928.         ret = drm_atomic_set_mode_for_crtc(crtc_state, set->mode);
  1929.         if (ret != 0)
  1930.                 return ret;
  1931.  
  1932.         crtc_state->active = true;
  1933.  
  1934.         ret = drm_atomic_set_crtc_for_plane(primary_state, crtc);
  1935.         if (ret != 0)
  1936.                 return ret;
  1937.  
  1938.         drm_crtc_get_hv_timing(set->mode, &hdisplay, &vdisplay);
  1939.  
  1940.         drm_atomic_set_fb_for_plane(primary_state, set->fb);
  1941.         primary_state->crtc_x = 0;
  1942.         primary_state->crtc_y = 0;
  1943.         primary_state->crtc_w = hdisplay;
  1944.         primary_state->crtc_h = vdisplay;
  1945.         primary_state->src_x = set->x << 16;
  1946.         primary_state->src_y = set->y << 16;
  1947.         if (primary_state->rotation & (BIT(DRM_ROTATE_90) | BIT(DRM_ROTATE_270))) {
  1948.                 primary_state->src_w = vdisplay << 16;
  1949.                 primary_state->src_h = hdisplay << 16;
  1950.         } else {
  1951.                 primary_state->src_w = hdisplay << 16;
  1952.                 primary_state->src_h = vdisplay << 16;
  1953.         }
  1954.  
  1955. commit:
  1956.         ret = update_output_state(state, set);
  1957.         if (ret)
  1958.                 return ret;
  1959.  
  1960.         return 0;
  1961. }
  1962.  
  1963. /**
  1964.  * drm_atomic_helper_disable_all - disable all currently active outputs
  1965.  * @dev: DRM device
  1966.  * @ctx: lock acquisition context
  1967.  *
  1968.  * Loops through all connectors, finding those that aren't turned off and then
  1969.  * turns them off by setting their DPMS mode to OFF and deactivating the CRTC
  1970.  * that they are connected to.
  1971.  *
  1972.  * This is used for example in suspend/resume to disable all currently active
  1973.  * functions when suspending.
  1974.  *
  1975.  * Note that if callers haven't already acquired all modeset locks this might
  1976.  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
  1977.  *
  1978.  * Returns:
  1979.  * 0 on success or a negative error code on failure.
  1980.  *
  1981.  * See also:
  1982.  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
  1983.  */
  1984. int drm_atomic_helper_disable_all(struct drm_device *dev,
  1985.                                   struct drm_modeset_acquire_ctx *ctx)
  1986. {
  1987.         struct drm_atomic_state *state;
  1988.         struct drm_connector *conn;
  1989.         int err;
  1990.  
  1991.         state = drm_atomic_state_alloc(dev);
  1992.         if (!state)
  1993.                 return -ENOMEM;
  1994.  
  1995.         state->acquire_ctx = ctx;
  1996.  
  1997.         drm_for_each_connector(conn, dev) {
  1998.                 struct drm_crtc *crtc = conn->state->crtc;
  1999.                 struct drm_crtc_state *crtc_state;
  2000.  
  2001.                 if (!crtc || conn->dpms != DRM_MODE_DPMS_ON)
  2002.                         continue;
  2003.  
  2004.                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
  2005.                 if (IS_ERR(crtc_state)) {
  2006.                         err = PTR_ERR(crtc_state);
  2007.                         goto free;
  2008.                 }
  2009.  
  2010.                 crtc_state->active = false;
  2011.         }
  2012.  
  2013.         err = drm_atomic_commit(state);
  2014.  
  2015. free:
  2016.         if (err < 0)
  2017.                 drm_atomic_state_free(state);
  2018.  
  2019.         return err;
  2020. }
  2021. EXPORT_SYMBOL(drm_atomic_helper_disable_all);
  2022.  
  2023. /**
  2024.  * drm_atomic_helper_suspend - subsystem-level suspend helper
  2025.  * @dev: DRM device
  2026.  *
  2027.  * Duplicates the current atomic state, disables all active outputs and then
  2028.  * returns a pointer to the original atomic state to the caller. Drivers can
  2029.  * pass this pointer to the drm_atomic_helper_resume() helper upon resume to
  2030.  * restore the output configuration that was active at the time the system
  2031.  * entered suspend.
  2032.  *
  2033.  * Note that it is potentially unsafe to use this. The atomic state object
  2034.  * returned by this function is assumed to be persistent. Drivers must ensure
  2035.  * that this holds true. Before calling this function, drivers must make sure
  2036.  * to suspend fbdev emulation so that nothing can be using the device.
  2037.  *
  2038.  * Returns:
  2039.  * A pointer to a copy of the state before suspend on success or an ERR_PTR()-
  2040.  * encoded error code on failure. Drivers should store the returned atomic
  2041.  * state object and pass it to the drm_atomic_helper_resume() helper upon
  2042.  * resume.
  2043.  *
  2044.  * See also:
  2045.  * drm_atomic_helper_duplicate_state(), drm_atomic_helper_disable_all(),
  2046.  * drm_atomic_helper_resume()
  2047.  */
  2048. struct drm_atomic_state *drm_atomic_helper_suspend(struct drm_device *dev)
  2049. {
  2050.         struct drm_modeset_acquire_ctx ctx;
  2051.         struct drm_atomic_state *state;
  2052.         int err;
  2053.  
  2054.         drm_modeset_acquire_init(&ctx, 0);
  2055.  
  2056. retry:
  2057.         err = drm_modeset_lock_all_ctx(dev, &ctx);
  2058.         if (err < 0) {
  2059.                 state = ERR_PTR(err);
  2060.                 goto unlock;
  2061.         }
  2062.  
  2063.         state = drm_atomic_helper_duplicate_state(dev, &ctx);
  2064.         if (IS_ERR(state))
  2065.                 goto unlock;
  2066.  
  2067.         err = drm_atomic_helper_disable_all(dev, &ctx);
  2068.         if (err < 0) {
  2069.                 drm_atomic_state_free(state);
  2070.                 state = ERR_PTR(err);
  2071.                 goto unlock;
  2072.         }
  2073.  
  2074. unlock:
  2075.         if (PTR_ERR(state) == -EDEADLK) {
  2076.                 drm_modeset_backoff(&ctx);
  2077.                 goto retry;
  2078.         }
  2079.  
  2080.         drm_modeset_drop_locks(&ctx);
  2081.         drm_modeset_acquire_fini(&ctx);
  2082.         return state;
  2083. }
  2084. EXPORT_SYMBOL(drm_atomic_helper_suspend);
  2085.  
  2086. /**
  2087.  * drm_atomic_helper_resume - subsystem-level resume helper
  2088.  * @dev: DRM device
  2089.  * @state: atomic state to resume to
  2090.  *
  2091.  * Calls drm_mode_config_reset() to synchronize hardware and software states,
  2092.  * grabs all modeset locks and commits the atomic state object. This can be
  2093.  * used in conjunction with the drm_atomic_helper_suspend() helper to
  2094.  * implement suspend/resume for drivers that support atomic mode-setting.
  2095.  *
  2096.  * Returns:
  2097.  * 0 on success or a negative error code on failure.
  2098.  *
  2099.  * See also:
  2100.  * drm_atomic_helper_suspend()
  2101.  */
  2102. int drm_atomic_helper_resume(struct drm_device *dev,
  2103.                              struct drm_atomic_state *state)
  2104. {
  2105.         struct drm_mode_config *config = &dev->mode_config;
  2106.         int err;
  2107.  
  2108.         drm_mode_config_reset(dev);
  2109.         drm_modeset_lock_all(dev);
  2110.         state->acquire_ctx = config->acquire_ctx;
  2111.         err = drm_atomic_commit(state);
  2112.         drm_modeset_unlock_all(dev);
  2113.  
  2114.         return err;
  2115. }
  2116. EXPORT_SYMBOL(drm_atomic_helper_resume);
  2117.  
  2118. /**
  2119.  * drm_atomic_helper_crtc_set_property - helper for crtc properties
  2120.  * @crtc: DRM crtc
  2121.  * @property: DRM property
  2122.  * @val: value of property
  2123.  *
  2124.  * Provides a default crtc set_property handler using the atomic driver
  2125.  * interface.
  2126.  *
  2127.  * RETURNS:
  2128.  * Zero on success, error code on failure
  2129.  */
  2130. int
  2131. drm_atomic_helper_crtc_set_property(struct drm_crtc *crtc,
  2132.                                     struct drm_property *property,
  2133.                                     uint64_t val)
  2134. {
  2135.         struct drm_atomic_state *state;
  2136.         struct drm_crtc_state *crtc_state;
  2137.         int ret = 0;
  2138.  
  2139.         state = drm_atomic_state_alloc(crtc->dev);
  2140.         if (!state)
  2141.                 return -ENOMEM;
  2142.  
  2143.         /* ->set_property is always called with all locks held. */
  2144.         state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
  2145. retry:
  2146.         crtc_state = drm_atomic_get_crtc_state(state, crtc);
  2147.         if (IS_ERR(crtc_state)) {
  2148.                 ret = PTR_ERR(crtc_state);
  2149.                 goto fail;
  2150.         }
  2151.  
  2152.         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
  2153.                         property, val);
  2154.         if (ret)
  2155.                 goto fail;
  2156.  
  2157.         ret = drm_atomic_commit(state);
  2158.         if (ret != 0)
  2159.                 goto fail;
  2160.  
  2161.         /* Driver takes ownership of state on successful commit. */
  2162.         return 0;
  2163. fail:
  2164.         if (ret == -EDEADLK)
  2165.                 goto backoff;
  2166.  
  2167.         drm_atomic_state_free(state);
  2168.  
  2169.         return ret;
  2170. backoff:
  2171.         drm_atomic_state_clear(state);
  2172.         drm_atomic_legacy_backoff(state);
  2173.  
  2174.         goto retry;
  2175. }
  2176. EXPORT_SYMBOL(drm_atomic_helper_crtc_set_property);
  2177.  
  2178. /**
  2179.  * drm_atomic_helper_plane_set_property - helper for plane properties
  2180.  * @plane: DRM plane
  2181.  * @property: DRM property
  2182.  * @val: value of property
  2183.  *
  2184.  * Provides a default plane set_property handler using the atomic driver
  2185.  * interface.
  2186.  *
  2187.  * RETURNS:
  2188.  * Zero on success, error code on failure
  2189.  */
  2190. int
  2191. drm_atomic_helper_plane_set_property(struct drm_plane *plane,
  2192.                                     struct drm_property *property,
  2193.                                     uint64_t val)
  2194. {
  2195.         struct drm_atomic_state *state;
  2196.         struct drm_plane_state *plane_state;
  2197.         int ret = 0;
  2198.  
  2199.         state = drm_atomic_state_alloc(plane->dev);
  2200.         if (!state)
  2201.                 return -ENOMEM;
  2202.  
  2203.         /* ->set_property is always called with all locks held. */
  2204.         state->acquire_ctx = plane->dev->mode_config.acquire_ctx;
  2205. retry:
  2206.         plane_state = drm_atomic_get_plane_state(state, plane);
  2207.         if (IS_ERR(plane_state)) {
  2208.                 ret = PTR_ERR(plane_state);
  2209.                 goto fail;
  2210.         }
  2211.  
  2212.         ret = drm_atomic_plane_set_property(plane, plane_state,
  2213.                         property, val);
  2214.         if (ret)
  2215.                 goto fail;
  2216.  
  2217.         ret = drm_atomic_commit(state);
  2218.         if (ret != 0)
  2219.                 goto fail;
  2220.  
  2221.         /* Driver takes ownership of state on successful commit. */
  2222.         return 0;
  2223. fail:
  2224.         if (ret == -EDEADLK)
  2225.                 goto backoff;
  2226.  
  2227.         drm_atomic_state_free(state);
  2228.  
  2229.         return ret;
  2230. backoff:
  2231.         drm_atomic_state_clear(state);
  2232.         drm_atomic_legacy_backoff(state);
  2233.  
  2234.         goto retry;
  2235. }
  2236. EXPORT_SYMBOL(drm_atomic_helper_plane_set_property);
  2237.  
  2238. /**
  2239.  * drm_atomic_helper_connector_set_property - helper for connector properties
  2240.  * @connector: DRM connector
  2241.  * @property: DRM property
  2242.  * @val: value of property
  2243.  *
  2244.  * Provides a default connector set_property handler using the atomic driver
  2245.  * interface.
  2246.  *
  2247.  * RETURNS:
  2248.  * Zero on success, error code on failure
  2249.  */
  2250. int
  2251. drm_atomic_helper_connector_set_property(struct drm_connector *connector,
  2252.                                     struct drm_property *property,
  2253.                                     uint64_t val)
  2254. {
  2255.         struct drm_atomic_state *state;
  2256.         struct drm_connector_state *connector_state;
  2257.         int ret = 0;
  2258.  
  2259.         state = drm_atomic_state_alloc(connector->dev);
  2260.         if (!state)
  2261.                 return -ENOMEM;
  2262.  
  2263.         /* ->set_property is always called with all locks held. */
  2264.         state->acquire_ctx = connector->dev->mode_config.acquire_ctx;
  2265. retry:
  2266.         connector_state = drm_atomic_get_connector_state(state, connector);
  2267.         if (IS_ERR(connector_state)) {
  2268.                 ret = PTR_ERR(connector_state);
  2269.                 goto fail;
  2270.         }
  2271.  
  2272.         ret = drm_atomic_connector_set_property(connector, connector_state,
  2273.                         property, val);
  2274.         if (ret)
  2275.                 goto fail;
  2276.  
  2277.         ret = drm_atomic_commit(state);
  2278.         if (ret != 0)
  2279.                 goto fail;
  2280.  
  2281.         /* Driver takes ownership of state on successful commit. */
  2282.         return 0;
  2283. fail:
  2284.         if (ret == -EDEADLK)
  2285.                 goto backoff;
  2286.  
  2287.         drm_atomic_state_free(state);
  2288.  
  2289.         return ret;
  2290. backoff:
  2291.         drm_atomic_state_clear(state);
  2292.         drm_atomic_legacy_backoff(state);
  2293.  
  2294.         goto retry;
  2295. }
  2296. EXPORT_SYMBOL(drm_atomic_helper_connector_set_property);
  2297.  
  2298. /**
  2299.  * drm_atomic_helper_page_flip - execute a legacy page flip
  2300.  * @crtc: DRM crtc
  2301.  * @fb: DRM framebuffer
  2302.  * @event: optional DRM event to signal upon completion
  2303.  * @flags: flip flags for non-vblank sync'ed updates
  2304.  *
  2305.  * Provides a default page flip implementation using the atomic driver interface.
  2306.  *
  2307.  * Note that for now so called async page flips (i.e. updates which are not
  2308.  * synchronized to vblank) are not supported, since the atomic interfaces have
  2309.  * no provisions for this yet.
  2310.  *
  2311.  * Returns:
  2312.  * Returns 0 on success, negative errno numbers on failure.
  2313.  */
  2314. int drm_atomic_helper_page_flip(struct drm_crtc *crtc,
  2315.                                 struct drm_framebuffer *fb,
  2316.                                 struct drm_pending_vblank_event *event,
  2317.                                 uint32_t flags)
  2318. {
  2319.         struct drm_plane *plane = crtc->primary;
  2320.         struct drm_atomic_state *state;
  2321.         struct drm_plane_state *plane_state;
  2322.         struct drm_crtc_state *crtc_state;
  2323.         int ret = 0;
  2324.  
  2325.         if (flags & DRM_MODE_PAGE_FLIP_ASYNC)
  2326.                 return -EINVAL;
  2327.  
  2328.         state = drm_atomic_state_alloc(plane->dev);
  2329.         if (!state)
  2330.                 return -ENOMEM;
  2331.  
  2332.         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
  2333. retry:
  2334.         crtc_state = drm_atomic_get_crtc_state(state, crtc);
  2335.         if (IS_ERR(crtc_state)) {
  2336.                 ret = PTR_ERR(crtc_state);
  2337.                 goto fail;
  2338.         }
  2339.         crtc_state->event = event;
  2340.  
  2341.         plane_state = drm_atomic_get_plane_state(state, plane);
  2342.         if (IS_ERR(plane_state)) {
  2343.                 ret = PTR_ERR(plane_state);
  2344.                 goto fail;
  2345.         }
  2346.  
  2347.         ret = drm_atomic_set_crtc_for_plane(plane_state, crtc);
  2348.         if (ret != 0)
  2349.                 goto fail;
  2350.         drm_atomic_set_fb_for_plane(plane_state, fb);
  2351.  
  2352.         /* Make sure we don't accidentally do a full modeset. */
  2353.         state->allow_modeset = false;
  2354.         if (!crtc_state->active) {
  2355.                 DRM_DEBUG_ATOMIC("[CRTC:%d] disabled, rejecting legacy flip\n",
  2356.                                  crtc->base.id);
  2357.                 ret = -EINVAL;
  2358.                 goto fail;
  2359.         }
  2360.  
  2361.         ret = drm_atomic_async_commit(state);
  2362.         if (ret != 0)
  2363.                 goto fail;
  2364.  
  2365.         /* Driver takes ownership of state on successful async commit. */
  2366.         return 0;
  2367. fail:
  2368.         if (ret == -EDEADLK)
  2369.                 goto backoff;
  2370.  
  2371.         drm_atomic_state_free(state);
  2372.  
  2373.         return ret;
  2374. backoff:
  2375.         drm_atomic_state_clear(state);
  2376.         drm_atomic_legacy_backoff(state);
  2377.  
  2378.         /*
  2379.          * Someone might have exchanged the framebuffer while we dropped locks
  2380.          * in the backoff code. We need to fix up the fb refcount tracking the
  2381.          * core does for us.
  2382.          */
  2383.         plane->old_fb = plane->fb;
  2384.  
  2385.         goto retry;
  2386. }
  2387. EXPORT_SYMBOL(drm_atomic_helper_page_flip);
  2388.  
  2389. /**
  2390.  * drm_atomic_helper_connector_dpms() - connector dpms helper implementation
  2391.  * @connector: affected connector
  2392.  * @mode: DPMS mode
  2393.  *
  2394.  * This is the main helper function provided by the atomic helper framework for
  2395.  * implementing the legacy DPMS connector interface. It computes the new desired
  2396.  * ->active state for the corresponding CRTC (if the connector is enabled) and
  2397.  *  updates it.
  2398.  *
  2399.  * Returns:
  2400.  * Returns 0 on success, negative errno numbers on failure.
  2401.  */
  2402. int drm_atomic_helper_connector_dpms(struct drm_connector *connector,
  2403.                                      int mode)
  2404. {
  2405.         struct drm_mode_config *config = &connector->dev->mode_config;
  2406.         struct drm_atomic_state *state;
  2407.         struct drm_crtc_state *crtc_state;
  2408.         struct drm_crtc *crtc;
  2409.         struct drm_connector *tmp_connector;
  2410.         int ret;
  2411.         bool active = false;
  2412.         int old_mode = connector->dpms;
  2413.  
  2414.         if (mode != DRM_MODE_DPMS_ON)
  2415.                 mode = DRM_MODE_DPMS_OFF;
  2416.  
  2417.         connector->dpms = mode;
  2418.         crtc = connector->state->crtc;
  2419.  
  2420.         if (!crtc)
  2421.                 return 0;
  2422.  
  2423.         state = drm_atomic_state_alloc(connector->dev);
  2424.         if (!state)
  2425.                 return -ENOMEM;
  2426.  
  2427.         state->acquire_ctx = drm_modeset_legacy_acquire_ctx(crtc);
  2428. retry:
  2429.         crtc_state = drm_atomic_get_crtc_state(state, crtc);
  2430.         if (IS_ERR(crtc_state)) {
  2431.                 ret = PTR_ERR(crtc_state);
  2432.                 goto fail;
  2433.         }
  2434.  
  2435.         WARN_ON(!drm_modeset_is_locked(&config->connection_mutex));
  2436.  
  2437.         drm_for_each_connector(tmp_connector, connector->dev) {
  2438.                 if (tmp_connector->state->crtc != crtc)
  2439.                         continue;
  2440.  
  2441.                 if (tmp_connector->dpms == DRM_MODE_DPMS_ON) {
  2442.                         active = true;
  2443.                         break;
  2444.                 }
  2445.         }
  2446.         crtc_state->active = active;
  2447.  
  2448.         ret = drm_atomic_commit(state);
  2449.         if (ret != 0)
  2450.                 goto fail;
  2451.  
  2452.         /* Driver takes ownership of state on successful commit. */
  2453.         return 0;
  2454. fail:
  2455.         if (ret == -EDEADLK)
  2456.                 goto backoff;
  2457.  
  2458.         connector->dpms = old_mode;
  2459.         drm_atomic_state_free(state);
  2460.  
  2461.         return ret;
  2462. backoff:
  2463.         drm_atomic_state_clear(state);
  2464.         drm_atomic_legacy_backoff(state);
  2465.  
  2466.         goto retry;
  2467. }
  2468. EXPORT_SYMBOL(drm_atomic_helper_connector_dpms);
  2469.  
  2470. /**
  2471.  * DOC: atomic state reset and initialization
  2472.  *
  2473.  * Both the drm core and the atomic helpers assume that there is always the full
  2474.  * and correct atomic software state for all connectors, CRTCs and planes
  2475.  * available. Which is a bit a problem on driver load and also after system
  2476.  * suspend. One way to solve this is to have a hardware state read-out
  2477.  * infrastructure which reconstructs the full software state (e.g. the i915
  2478.  * driver).
  2479.  *
  2480.  * The simpler solution is to just reset the software state to everything off,
  2481.  * which is easiest to do by calling drm_mode_config_reset(). To facilitate this
  2482.  * the atomic helpers provide default reset implementations for all hooks.
  2483.  *
  2484.  * On the upside the precise state tracking of atomic simplifies system suspend
  2485.  * and resume a lot. For drivers using drm_mode_config_reset() a complete recipe
  2486.  * is implemented in drm_atomic_helper_suspend() and drm_atomic_helper_resume().
  2487.  * For other drivers the building blocks are split out, see the documentation
  2488.  * for these functions.
  2489.  */
  2490.  
  2491. /**
  2492.  * drm_atomic_helper_crtc_reset - default ->reset hook for CRTCs
  2493.  * @crtc: drm CRTC
  2494.  *
  2495.  * Resets the atomic state for @crtc by freeing the state pointer (which might
  2496.  * be NULL, e.g. at driver load time) and allocating a new empty state object.
  2497.  */
  2498. void drm_atomic_helper_crtc_reset(struct drm_crtc *crtc)
  2499. {
  2500.         if (crtc->state) {
  2501.                 drm_property_unreference_blob(crtc->state->mode_blob);
  2502.                 drm_property_unreference_blob(crtc->state->degamma_lut);
  2503.                 drm_property_unreference_blob(crtc->state->ctm);
  2504.                 drm_property_unreference_blob(crtc->state->gamma_lut);
  2505.         }
  2506.         kfree(crtc->state);
  2507.         crtc->state = kzalloc(sizeof(*crtc->state), GFP_KERNEL);
  2508.  
  2509.         if (crtc->state)
  2510.                 crtc->state->crtc = crtc;
  2511. }
  2512. EXPORT_SYMBOL(drm_atomic_helper_crtc_reset);
  2513.  
  2514. /**
  2515.  * __drm_atomic_helper_crtc_duplicate_state - copy atomic CRTC state
  2516.  * @crtc: CRTC object
  2517.  * @state: atomic CRTC state
  2518.  *
  2519.  * Copies atomic state from a CRTC's current state and resets inferred values.
  2520.  * This is useful for drivers that subclass the CRTC state.
  2521.  */
  2522. void __drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc,
  2523.                                               struct drm_crtc_state *state)
  2524. {
  2525.         memcpy(state, crtc->state, sizeof(*state));
  2526.  
  2527.         if (state->mode_blob)
  2528.                 drm_property_reference_blob(state->mode_blob);
  2529.         if (state->degamma_lut)
  2530.                 drm_property_reference_blob(state->degamma_lut);
  2531.         if (state->ctm)
  2532.                 drm_property_reference_blob(state->ctm);
  2533.         if (state->gamma_lut)
  2534.                 drm_property_reference_blob(state->gamma_lut);
  2535.         state->mode_changed = false;
  2536.         state->active_changed = false;
  2537.         state->planes_changed = false;
  2538.         state->connectors_changed = false;
  2539.         state->color_mgmt_changed = false;
  2540.         state->event = NULL;
  2541. }
  2542. EXPORT_SYMBOL(__drm_atomic_helper_crtc_duplicate_state);
  2543.  
  2544. /**
  2545.  * drm_atomic_helper_crtc_duplicate_state - default state duplicate hook
  2546.  * @crtc: drm CRTC
  2547.  *
  2548.  * Default CRTC state duplicate hook for drivers which don't have their own
  2549.  * subclassed CRTC state structure.
  2550.  */
  2551. struct drm_crtc_state *
  2552. drm_atomic_helper_crtc_duplicate_state(struct drm_crtc *crtc)
  2553. {
  2554.         struct drm_crtc_state *state;
  2555.  
  2556.         if (WARN_ON(!crtc->state))
  2557.                 return NULL;
  2558.  
  2559.         state = kmalloc(sizeof(*state), GFP_KERNEL);
  2560.         if (state)
  2561.                 __drm_atomic_helper_crtc_duplicate_state(crtc, state);
  2562.  
  2563.         return state;
  2564. }
  2565. EXPORT_SYMBOL(drm_atomic_helper_crtc_duplicate_state);
  2566.  
  2567. /**
  2568.  * __drm_atomic_helper_crtc_destroy_state - release CRTC state
  2569.  * @crtc: CRTC object
  2570.  * @state: CRTC state object to release
  2571.  *
  2572.  * Releases all resources stored in the CRTC state without actually freeing
  2573.  * the memory of the CRTC state. This is useful for drivers that subclass the
  2574.  * CRTC state.
  2575.  */
  2576. void __drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
  2577.                                             struct drm_crtc_state *state)
  2578. {
  2579.         drm_property_unreference_blob(state->mode_blob);
  2580.         drm_property_unreference_blob(state->degamma_lut);
  2581.         drm_property_unreference_blob(state->ctm);
  2582.         drm_property_unreference_blob(state->gamma_lut);
  2583. }
  2584. EXPORT_SYMBOL(__drm_atomic_helper_crtc_destroy_state);
  2585.  
  2586. /**
  2587.  * drm_atomic_helper_crtc_destroy_state - default state destroy hook
  2588.  * @crtc: drm CRTC
  2589.  * @state: CRTC state object to release
  2590.  *
  2591.  * Default CRTC state destroy hook for drivers which don't have their own
  2592.  * subclassed CRTC state structure.
  2593.  */
  2594. void drm_atomic_helper_crtc_destroy_state(struct drm_crtc *crtc,
  2595.                                           struct drm_crtc_state *state)
  2596. {
  2597.         __drm_atomic_helper_crtc_destroy_state(crtc, state);
  2598.         kfree(state);
  2599. }
  2600. EXPORT_SYMBOL(drm_atomic_helper_crtc_destroy_state);
  2601.  
  2602. /**
  2603.  * drm_atomic_helper_plane_reset - default ->reset hook for planes
  2604.  * @plane: drm plane
  2605.  *
  2606.  * Resets the atomic state for @plane by freeing the state pointer (which might
  2607.  * be NULL, e.g. at driver load time) and allocating a new empty state object.
  2608.  */
  2609. void drm_atomic_helper_plane_reset(struct drm_plane *plane)
  2610. {
  2611.         if (plane->state && plane->state->fb)
  2612.                 drm_framebuffer_unreference(plane->state->fb);
  2613.  
  2614.         kfree(plane->state);
  2615.         plane->state = kzalloc(sizeof(*plane->state), GFP_KERNEL);
  2616.  
  2617.         if (plane->state) {
  2618.                 plane->state->plane = plane;
  2619.                 plane->state->rotation = BIT(DRM_ROTATE_0);
  2620.         }
  2621. }
  2622. EXPORT_SYMBOL(drm_atomic_helper_plane_reset);
  2623.  
  2624. /**
  2625.  * __drm_atomic_helper_plane_duplicate_state - copy atomic plane state
  2626.  * @plane: plane object
  2627.  * @state: atomic plane state
  2628.  *
  2629.  * Copies atomic state from a plane's current state. This is useful for
  2630.  * drivers that subclass the plane state.
  2631.  */
  2632. void __drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane,
  2633.                                                struct drm_plane_state *state)
  2634. {
  2635.         memcpy(state, plane->state, sizeof(*state));
  2636.  
  2637.         if (state->fb)
  2638.                 drm_framebuffer_reference(state->fb);
  2639. }
  2640. EXPORT_SYMBOL(__drm_atomic_helper_plane_duplicate_state);
  2641.  
  2642. /**
  2643.  * drm_atomic_helper_plane_duplicate_state - default state duplicate hook
  2644.  * @plane: drm plane
  2645.  *
  2646.  * Default plane state duplicate hook for drivers which don't have their own
  2647.  * subclassed plane state structure.
  2648.  */
  2649. struct drm_plane_state *
  2650. drm_atomic_helper_plane_duplicate_state(struct drm_plane *plane)
  2651. {
  2652.         struct drm_plane_state *state;
  2653.  
  2654.         if (WARN_ON(!plane->state))
  2655.                 return NULL;
  2656.  
  2657.         state = kmalloc(sizeof(*state), GFP_KERNEL);
  2658.         if (state)
  2659.                 __drm_atomic_helper_plane_duplicate_state(plane, state);
  2660.  
  2661.         return state;
  2662. }
  2663. EXPORT_SYMBOL(drm_atomic_helper_plane_duplicate_state);
  2664.  
  2665. /**
  2666.  * __drm_atomic_helper_plane_destroy_state - release plane state
  2667.  * @plane: plane object
  2668.  * @state: plane state object to release
  2669.  *
  2670.  * Releases all resources stored in the plane state without actually freeing
  2671.  * the memory of the plane state. This is useful for drivers that subclass the
  2672.  * plane state.
  2673.  */
  2674. void __drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
  2675.                                              struct drm_plane_state *state)
  2676. {
  2677.         if (state->fb)
  2678.                 drm_framebuffer_unreference(state->fb);
  2679. }
  2680. EXPORT_SYMBOL(__drm_atomic_helper_plane_destroy_state);
  2681.  
  2682. /**
  2683.  * drm_atomic_helper_plane_destroy_state - default state destroy hook
  2684.  * @plane: drm plane
  2685.  * @state: plane state object to release
  2686.  *
  2687.  * Default plane state destroy hook for drivers which don't have their own
  2688.  * subclassed plane state structure.
  2689.  */
  2690. void drm_atomic_helper_plane_destroy_state(struct drm_plane *plane,
  2691.                                            struct drm_plane_state *state)
  2692. {
  2693.         __drm_atomic_helper_plane_destroy_state(plane, state);
  2694.         kfree(state);
  2695. }
  2696. EXPORT_SYMBOL(drm_atomic_helper_plane_destroy_state);
  2697.  
  2698. /**
  2699.  * __drm_atomic_helper_connector_reset - reset state on connector
  2700.  * @connector: drm connector
  2701.  * @conn_state: connector state to assign
  2702.  *
  2703.  * Initializes the newly allocated @conn_state and assigns it to
  2704.  * #connector ->state, usually required when initializing the drivers
  2705.  * or when called from the ->reset hook.
  2706.  *
  2707.  * This is useful for drivers that subclass the connector state.
  2708.  */
  2709. void
  2710. __drm_atomic_helper_connector_reset(struct drm_connector *connector,
  2711.                                     struct drm_connector_state *conn_state)
  2712. {
  2713.         if (conn_state)
  2714.                 conn_state->connector = connector;
  2715.  
  2716.         connector->state = conn_state;
  2717. }
  2718. EXPORT_SYMBOL(__drm_atomic_helper_connector_reset);
  2719.  
  2720. /**
  2721.  * drm_atomic_helper_connector_reset - default ->reset hook for connectors
  2722.  * @connector: drm connector
  2723.  *
  2724.  * Resets the atomic state for @connector by freeing the state pointer (which
  2725.  * might be NULL, e.g. at driver load time) and allocating a new empty state
  2726.  * object.
  2727.  */
  2728. void drm_atomic_helper_connector_reset(struct drm_connector *connector)
  2729. {
  2730.         struct drm_connector_state *conn_state =
  2731.                 kzalloc(sizeof(*conn_state), GFP_KERNEL);
  2732.  
  2733.         kfree(connector->state);
  2734.         __drm_atomic_helper_connector_reset(connector, conn_state);
  2735. }
  2736. EXPORT_SYMBOL(drm_atomic_helper_connector_reset);
  2737.  
  2738. /**
  2739.  * __drm_atomic_helper_connector_duplicate_state - copy atomic connector state
  2740.  * @connector: connector object
  2741.  * @state: atomic connector state
  2742.  *
  2743.  * Copies atomic state from a connector's current state. This is useful for
  2744.  * drivers that subclass the connector state.
  2745.  */
  2746. void
  2747. __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
  2748.                                             struct drm_connector_state *state)
  2749. {
  2750.         memcpy(state, connector->state, sizeof(*state));
  2751. }
  2752. EXPORT_SYMBOL(__drm_atomic_helper_connector_duplicate_state);
  2753.  
  2754. /**
  2755.  * drm_atomic_helper_connector_duplicate_state - default state duplicate hook
  2756.  * @connector: drm connector
  2757.  *
  2758.  * Default connector state duplicate hook for drivers which don't have their own
  2759.  * subclassed connector state structure.
  2760.  */
  2761. struct drm_connector_state *
  2762. drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector)
  2763. {
  2764.         struct drm_connector_state *state;
  2765.  
  2766.         if (WARN_ON(!connector->state))
  2767.                 return NULL;
  2768.  
  2769.         state = kmalloc(sizeof(*state), GFP_KERNEL);
  2770.         if (state)
  2771.                 __drm_atomic_helper_connector_duplicate_state(connector, state);
  2772.  
  2773.         return state;
  2774. }
  2775. EXPORT_SYMBOL(drm_atomic_helper_connector_duplicate_state);
  2776.  
  2777. /**
  2778.  * drm_atomic_helper_duplicate_state - duplicate an atomic state object
  2779.  * @dev: DRM device
  2780.  * @ctx: lock acquisition context
  2781.  *
  2782.  * Makes a copy of the current atomic state by looping over all objects and
  2783.  * duplicating their respective states. This is used for example by suspend/
  2784.  * resume support code to save the state prior to suspend such that it can
  2785.  * be restored upon resume.
  2786.  *
  2787.  * Note that this treats atomic state as persistent between save and restore.
  2788.  * Drivers must make sure that this is possible and won't result in confusion
  2789.  * or erroneous behaviour.
  2790.  *
  2791.  * Note that if callers haven't already acquired all modeset locks this might
  2792.  * return -EDEADLK, which must be handled by calling drm_modeset_backoff().
  2793.  *
  2794.  * Returns:
  2795.  * A pointer to the copy of the atomic state object on success or an
  2796.  * ERR_PTR()-encoded error code on failure.
  2797.  *
  2798.  * See also:
  2799.  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
  2800.  */
  2801. struct drm_atomic_state *
  2802. drm_atomic_helper_duplicate_state(struct drm_device *dev,
  2803.                                   struct drm_modeset_acquire_ctx *ctx)
  2804. {
  2805.         struct drm_atomic_state *state;
  2806.         struct drm_connector *conn;
  2807.         struct drm_plane *plane;
  2808.         struct drm_crtc *crtc;
  2809.         int err = 0;
  2810.  
  2811.         state = drm_atomic_state_alloc(dev);
  2812.         if (!state)
  2813.                 return ERR_PTR(-ENOMEM);
  2814.  
  2815.         state->acquire_ctx = ctx;
  2816.  
  2817.         drm_for_each_crtc(crtc, dev) {
  2818.                 struct drm_crtc_state *crtc_state;
  2819.  
  2820.                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
  2821.                 if (IS_ERR(crtc_state)) {
  2822.                         err = PTR_ERR(crtc_state);
  2823.                         goto free;
  2824.                 }
  2825.         }
  2826.  
  2827.         drm_for_each_plane(plane, dev) {
  2828.                 struct drm_plane_state *plane_state;
  2829.  
  2830.                 plane_state = drm_atomic_get_plane_state(state, plane);
  2831.                 if (IS_ERR(plane_state)) {
  2832.                         err = PTR_ERR(plane_state);
  2833.                         goto free;
  2834.                 }
  2835.         }
  2836.  
  2837.         drm_for_each_connector(conn, dev) {
  2838.                 struct drm_connector_state *conn_state;
  2839.  
  2840.                 conn_state = drm_atomic_get_connector_state(state, conn);
  2841.                 if (IS_ERR(conn_state)) {
  2842.                         err = PTR_ERR(conn_state);
  2843.                         goto free;
  2844.                 }
  2845.         }
  2846.  
  2847.         /* clear the acquire context so that it isn't accidentally reused */
  2848.         state->acquire_ctx = NULL;
  2849.  
  2850. free:
  2851.         if (err < 0) {
  2852.                 drm_atomic_state_free(state);
  2853.                 state = ERR_PTR(err);
  2854.         }
  2855.  
  2856.         return state;
  2857. }
  2858. EXPORT_SYMBOL(drm_atomic_helper_duplicate_state);
  2859.  
  2860. /**
  2861.  * __drm_atomic_helper_connector_destroy_state - release connector state
  2862.  * @connector: connector object
  2863.  * @state: connector state object to release
  2864.  *
  2865.  * Releases all resources stored in the connector state without actually
  2866.  * freeing the memory of the connector state. This is useful for drivers that
  2867.  * subclass the connector state.
  2868.  */
  2869. void
  2870. __drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
  2871.                                             struct drm_connector_state *state)
  2872. {
  2873.         /*
  2874.          * This is currently a placeholder so that drivers that subclass the
  2875.          * state will automatically do the right thing if code is ever added
  2876.          * to this function.
  2877.          */
  2878. }
  2879. EXPORT_SYMBOL(__drm_atomic_helper_connector_destroy_state);
  2880.  
  2881. /**
  2882.  * drm_atomic_helper_connector_destroy_state - default state destroy hook
  2883.  * @connector: drm connector
  2884.  * @state: connector state object to release
  2885.  *
  2886.  * Default connector state destroy hook for drivers which don't have their own
  2887.  * subclassed connector state structure.
  2888.  */
  2889. void drm_atomic_helper_connector_destroy_state(struct drm_connector *connector,
  2890.                                           struct drm_connector_state *state)
  2891. {
  2892.         __drm_atomic_helper_connector_destroy_state(connector, state);
  2893.         kfree(state);
  2894. }
  2895. EXPORT_SYMBOL(drm_atomic_helper_connector_destroy_state);
  2896.  
  2897. /**
  2898.  * drm_atomic_helper_legacy_gamma_set - set the legacy gamma correction table
  2899.  * @crtc: CRTC object
  2900.  * @red: red correction table
  2901.  * @green: green correction table
  2902.  * @blue: green correction table
  2903.  * @start:
  2904.  * @size: size of the tables
  2905.  *
  2906.  * Implements support for legacy gamma correction table for drivers
  2907.  * that support color management through the DEGAMMA_LUT/GAMMA_LUT
  2908.  * properties.
  2909.  */
  2910. void drm_atomic_helper_legacy_gamma_set(struct drm_crtc *crtc,
  2911.                                         u16 *red, u16 *green, u16 *blue,
  2912.                                         uint32_t start, uint32_t size)
  2913. {
  2914.         struct drm_device *dev = crtc->dev;
  2915.         struct drm_mode_config *config = &dev->mode_config;
  2916.         struct drm_atomic_state *state;
  2917.         struct drm_crtc_state *crtc_state;
  2918.         struct drm_property_blob *blob = NULL;
  2919.         struct drm_color_lut *blob_data;
  2920.         int i, ret = 0;
  2921.  
  2922.         state = drm_atomic_state_alloc(crtc->dev);
  2923.         if (!state)
  2924.                 return;
  2925.  
  2926.         blob = drm_property_create_blob(dev,
  2927.                                         sizeof(struct drm_color_lut) * size,
  2928.                                         NULL);
  2929.         if (IS_ERR(blob)) {
  2930.                 ret = PTR_ERR(blob);
  2931.                 blob = NULL;
  2932.                 goto fail;
  2933.         }
  2934.  
  2935.         /* Prepare GAMMA_LUT with the legacy values. */
  2936.         blob_data = (struct drm_color_lut *) blob->data;
  2937.         for (i = 0; i < size; i++) {
  2938.                 blob_data[i].red = red[i];
  2939.                 blob_data[i].green = green[i];
  2940.                 blob_data[i].blue = blue[i];
  2941.         }
  2942.  
  2943.         state->acquire_ctx = crtc->dev->mode_config.acquire_ctx;
  2944. retry:
  2945.         crtc_state = drm_atomic_get_crtc_state(state, crtc);
  2946.         if (IS_ERR(crtc_state)) {
  2947.                 ret = PTR_ERR(crtc_state);
  2948.                 goto fail;
  2949.         }
  2950.  
  2951.         /* Reset DEGAMMA_LUT and CTM properties. */
  2952.         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
  2953.                         config->degamma_lut_property, 0);
  2954.         if (ret)
  2955.                 goto fail;
  2956.  
  2957.         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
  2958.                         config->ctm_property, 0);
  2959.         if (ret)
  2960.                 goto fail;
  2961.  
  2962.         ret = drm_atomic_crtc_set_property(crtc, crtc_state,
  2963.                         config->gamma_lut_property, blob->base.id);
  2964.         if (ret)
  2965.                 goto fail;
  2966.  
  2967.         ret = drm_atomic_commit(state);
  2968.         if (ret)
  2969.                 goto fail;
  2970.  
  2971.         /* Driver takes ownership of state on successful commit. */
  2972.  
  2973.         drm_property_unreference_blob(blob);
  2974.  
  2975.         return;
  2976. fail:
  2977.         if (ret == -EDEADLK)
  2978.                 goto backoff;
  2979.  
  2980.         drm_atomic_state_free(state);
  2981.         drm_property_unreference_blob(blob);
  2982.  
  2983.         return;
  2984. backoff:
  2985.         drm_atomic_state_clear(state);
  2986.         drm_atomic_legacy_backoff(state);
  2987.  
  2988.         goto retry;
  2989. }
  2990. EXPORT_SYMBOL(drm_atomic_helper_legacy_gamma_set);
  2991.