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.  
  29. #include <drm/drmP.h>
  30. #include <drm/drm_atomic.h>
  31. #include <drm/drm_mode.h>
  32. #include <drm/drm_plane_helper.h>
  33.  
  34. /**
  35.  * drm_atomic_state_default_release -
  36.  * release memory initialized by drm_atomic_state_init
  37.  * @state: atomic state
  38.  *
  39.  * Free all the memory allocated by drm_atomic_state_init.
  40.  * This is useful for drivers that subclass the atomic state.
  41.  */
  42. void drm_atomic_state_default_release(struct drm_atomic_state *state)
  43. {
  44.         kfree(state->connectors);
  45.         kfree(state->connector_states);
  46.         kfree(state->crtcs);
  47.         kfree(state->crtc_states);
  48.         kfree(state->planes);
  49.         kfree(state->plane_states);
  50. }
  51. EXPORT_SYMBOL(drm_atomic_state_default_release);
  52.  
  53. /**
  54.  * drm_atomic_state_init - init new atomic state
  55.  * @dev: DRM device
  56.  * @state: atomic state
  57.  *
  58.  * Default implementation for filling in a new atomic state.
  59.  * This is useful for drivers that subclass the atomic state.
  60.  */
  61. int
  62. drm_atomic_state_init(struct drm_device *dev, struct drm_atomic_state *state)
  63. {
  64.         /* TODO legacy paths should maybe do a better job about
  65.          * setting this appropriately?
  66.          */
  67.         state->allow_modeset = true;
  68.  
  69.         state->crtcs = kcalloc(dev->mode_config.num_crtc,
  70.                                sizeof(*state->crtcs), GFP_KERNEL);
  71.         if (!state->crtcs)
  72.                 goto fail;
  73.         state->crtc_states = kcalloc(dev->mode_config.num_crtc,
  74.                                      sizeof(*state->crtc_states), GFP_KERNEL);
  75.         if (!state->crtc_states)
  76.                 goto fail;
  77.         state->planes = kcalloc(dev->mode_config.num_total_plane,
  78.                                 sizeof(*state->planes), GFP_KERNEL);
  79.         if (!state->planes)
  80.                 goto fail;
  81.         state->plane_states = kcalloc(dev->mode_config.num_total_plane,
  82.                                       sizeof(*state->plane_states), GFP_KERNEL);
  83.         if (!state->plane_states)
  84.                 goto fail;
  85.  
  86.         state->dev = dev;
  87.  
  88.         DRM_DEBUG_ATOMIC("Allocated atomic state %p\n", state);
  89.  
  90.         return 0;
  91. fail:
  92.         drm_atomic_state_default_release(state);
  93.         return -ENOMEM;
  94. }
  95. EXPORT_SYMBOL(drm_atomic_state_init);
  96.  
  97. /**
  98.  * drm_atomic_state_alloc - allocate atomic state
  99.  * @dev: DRM device
  100.  *
  101.  * This allocates an empty atomic state to track updates.
  102.  */
  103. struct drm_atomic_state *
  104. drm_atomic_state_alloc(struct drm_device *dev)
  105. {
  106.         struct drm_mode_config *config = &dev->mode_config;
  107.         struct drm_atomic_state *state;
  108.  
  109.         if (!config->funcs->atomic_state_alloc) {
  110.                 state = kzalloc(sizeof(*state), GFP_KERNEL);
  111.                 if (!state)
  112.                         return NULL;
  113.                 if (drm_atomic_state_init(dev, state) < 0) {
  114.                         kfree(state);
  115.                         return NULL;
  116.                 }
  117.                 return state;
  118.         }
  119.  
  120.         return config->funcs->atomic_state_alloc(dev);
  121. }
  122. EXPORT_SYMBOL(drm_atomic_state_alloc);
  123.  
  124. /**
  125.  * drm_atomic_state_default_clear - clear base atomic state
  126.  * @state: atomic state
  127.  *
  128.  * Default implementation for clearing atomic state.
  129.  * This is useful for drivers that subclass the atomic state.
  130.  */
  131. void drm_atomic_state_default_clear(struct drm_atomic_state *state)
  132. {
  133.         struct drm_device *dev = state->dev;
  134.         struct drm_mode_config *config = &dev->mode_config;
  135.         int i;
  136.  
  137.         DRM_DEBUG_ATOMIC("Clearing atomic state %p\n", state);
  138.  
  139.         for (i = 0; i < state->num_connector; i++) {
  140.                 struct drm_connector *connector = state->connectors[i];
  141.  
  142.                 if (!connector || !connector->funcs)
  143.                         continue;
  144.  
  145.                 /*
  146.                  * FIXME: Async commits can race with connector unplugging and
  147.                  * there's currently nothing that prevents cleanup up state for
  148.                  * deleted connectors. As long as the callback doesn't look at
  149.                  * the connector we'll be fine though, so make sure that's the
  150.                  * case by setting all connector pointers to NULL.
  151.                  */
  152.                 state->connector_states[i]->connector = NULL;
  153.                 connector->funcs->atomic_destroy_state(NULL,
  154.                                                        state->connector_states[i]);
  155.                 state->connectors[i] = NULL;
  156.                 state->connector_states[i] = NULL;
  157.         }
  158.  
  159.         for (i = 0; i < config->num_crtc; i++) {
  160.                 struct drm_crtc *crtc = state->crtcs[i];
  161.  
  162.                 if (!crtc)
  163.                         continue;
  164.  
  165.                 crtc->funcs->atomic_destroy_state(crtc,
  166.                                                   state->crtc_states[i]);
  167.                 state->crtcs[i] = NULL;
  168.                 state->crtc_states[i] = NULL;
  169.         }
  170.  
  171.         for (i = 0; i < config->num_total_plane; i++) {
  172.                 struct drm_plane *plane = state->planes[i];
  173.  
  174.                 if (!plane)
  175.                         continue;
  176.  
  177.                 plane->funcs->atomic_destroy_state(plane,
  178.                                                    state->plane_states[i]);
  179.                 state->planes[i] = NULL;
  180.                 state->plane_states[i] = NULL;
  181.         }
  182. }
  183. EXPORT_SYMBOL(drm_atomic_state_default_clear);
  184.  
  185. /**
  186.  * drm_atomic_state_clear - clear state object
  187.  * @state: atomic state
  188.  *
  189.  * When the w/w mutex algorithm detects a deadlock we need to back off and drop
  190.  * all locks. So someone else could sneak in and change the current modeset
  191.  * configuration. Which means that all the state assembled in @state is no
  192.  * longer an atomic update to the current state, but to some arbitrary earlier
  193.  * state. Which could break assumptions the driver's ->atomic_check likely
  194.  * relies on.
  195.  *
  196.  * Hence we must clear all cached state and completely start over, using this
  197.  * function.
  198.  */
  199. void drm_atomic_state_clear(struct drm_atomic_state *state)
  200. {
  201.         struct drm_device *dev = state->dev;
  202.         struct drm_mode_config *config = &dev->mode_config;
  203.  
  204.         if (config->funcs->atomic_state_clear)
  205.                 config->funcs->atomic_state_clear(state);
  206.         else
  207.                 drm_atomic_state_default_clear(state);
  208. }
  209. EXPORT_SYMBOL(drm_atomic_state_clear);
  210.  
  211. /**
  212.  * drm_atomic_state_free - free all memory for an atomic state
  213.  * @state: atomic state to deallocate
  214.  *
  215.  * This frees all memory associated with an atomic state, including all the
  216.  * per-object state for planes, crtcs and connectors.
  217.  */
  218. void drm_atomic_state_free(struct drm_atomic_state *state)
  219. {
  220.         struct drm_device *dev;
  221.         struct drm_mode_config *config;
  222.  
  223.         if (!state)
  224.                 return;
  225.  
  226.         dev = state->dev;
  227.         config = &dev->mode_config;
  228.  
  229.         drm_atomic_state_clear(state);
  230.  
  231.         DRM_DEBUG_ATOMIC("Freeing atomic state %p\n", state);
  232.  
  233.         if (config->funcs->atomic_state_free) {
  234.                 config->funcs->atomic_state_free(state);
  235.         } else {
  236.                 drm_atomic_state_default_release(state);
  237.                 kfree(state);
  238.         }
  239. }
  240. EXPORT_SYMBOL(drm_atomic_state_free);
  241.  
  242. /**
  243.  * drm_atomic_get_crtc_state - get crtc state
  244.  * @state: global atomic state object
  245.  * @crtc: crtc to get state object for
  246.  *
  247.  * This function returns the crtc state for the given crtc, allocating it if
  248.  * needed. It will also grab the relevant crtc lock to make sure that the state
  249.  * is consistent.
  250.  *
  251.  * Returns:
  252.  *
  253.  * Either the allocated state or the error code encoded into the pointer. When
  254.  * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
  255.  * entire atomic sequence must be restarted. All other errors are fatal.
  256.  */
  257. struct drm_crtc_state *
  258. drm_atomic_get_crtc_state(struct drm_atomic_state *state,
  259.                           struct drm_crtc *crtc)
  260. {
  261.         int ret, index = drm_crtc_index(crtc);
  262.         struct drm_crtc_state *crtc_state;
  263.  
  264.         crtc_state = drm_atomic_get_existing_crtc_state(state, crtc);
  265.         if (crtc_state)
  266.                 return crtc_state;
  267.  
  268.         ret = drm_modeset_lock(&crtc->mutex, state->acquire_ctx);
  269.         if (ret)
  270.                 return ERR_PTR(ret);
  271.  
  272.         crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
  273.         if (!crtc_state)
  274.                 return ERR_PTR(-ENOMEM);
  275.  
  276.         state->crtc_states[index] = crtc_state;
  277.         state->crtcs[index] = crtc;
  278.         crtc_state->state = state;
  279.  
  280.         DRM_DEBUG_ATOMIC("Added [CRTC:%d:%s] %p state to %p\n",
  281.                          crtc->base.id, crtc->name, crtc_state, state);
  282.  
  283.         return crtc_state;
  284. }
  285. EXPORT_SYMBOL(drm_atomic_get_crtc_state);
  286.  
  287. /**
  288.  * drm_atomic_set_mode_for_crtc - set mode for CRTC
  289.  * @state: the CRTC whose incoming state to update
  290.  * @mode: kernel-internal mode to use for the CRTC, or NULL to disable
  291.  *
  292.  * Set a mode (originating from the kernel) on the desired CRTC state. Does
  293.  * not change any other state properties, including enable, active, or
  294.  * mode_changed.
  295.  *
  296.  * RETURNS:
  297.  * Zero on success, error code on failure. Cannot return -EDEADLK.
  298.  */
  299. int drm_atomic_set_mode_for_crtc(struct drm_crtc_state *state,
  300.                                  struct drm_display_mode *mode)
  301. {
  302.         struct drm_mode_modeinfo umode;
  303.  
  304.         /* Early return for no change. */
  305.         if (mode && memcmp(&state->mode, mode, sizeof(*mode)) == 0)
  306.                 return 0;
  307.  
  308.         drm_property_unreference_blob(state->mode_blob);
  309.         state->mode_blob = NULL;
  310.  
  311.         if (mode) {
  312.                 drm_mode_convert_to_umode(&umode, mode);
  313.                 state->mode_blob =
  314.                         drm_property_create_blob(state->crtc->dev,
  315.                                                  sizeof(umode),
  316.                                                  &umode);
  317.                 if (IS_ERR(state->mode_blob))
  318.                         return PTR_ERR(state->mode_blob);
  319.  
  320.                 drm_mode_copy(&state->mode, mode);
  321.                 state->enable = true;
  322.                 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
  323.                                  mode->name, state);
  324.         } else {
  325.                 memset(&state->mode, 0, sizeof(state->mode));
  326.                 state->enable = false;
  327.                 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
  328.                                  state);
  329.         }
  330.  
  331.         return 0;
  332. }
  333. EXPORT_SYMBOL(drm_atomic_set_mode_for_crtc);
  334.  
  335. /**
  336.  * drm_atomic_set_mode_prop_for_crtc - set mode for CRTC
  337.  * @state: the CRTC whose incoming state to update
  338.  * @blob: pointer to blob property to use for mode
  339.  *
  340.  * Set a mode (originating from a blob property) on the desired CRTC state.
  341.  * This function will take a reference on the blob property for the CRTC state,
  342.  * and release the reference held on the state's existing mode property, if any
  343.  * was set.
  344.  *
  345.  * RETURNS:
  346.  * Zero on success, error code on failure. Cannot return -EDEADLK.
  347.  */
  348. int drm_atomic_set_mode_prop_for_crtc(struct drm_crtc_state *state,
  349.                                       struct drm_property_blob *blob)
  350. {
  351.         if (blob == state->mode_blob)
  352.                 return 0;
  353.  
  354.         drm_property_unreference_blob(state->mode_blob);
  355.         state->mode_blob = NULL;
  356.  
  357.         memset(&state->mode, 0, sizeof(state->mode));
  358.  
  359.         if (blob) {
  360.                 if (blob->length != sizeof(struct drm_mode_modeinfo) ||
  361.                     drm_mode_convert_umode(&state->mode,
  362.                                            (const struct drm_mode_modeinfo *)
  363.                                             blob->data))
  364.                         return -EINVAL;
  365.  
  366.                 state->mode_blob = drm_property_reference_blob(blob);
  367.                 state->enable = true;
  368.                 DRM_DEBUG_ATOMIC("Set [MODE:%s] for CRTC state %p\n",
  369.                                  state->mode.name, state);
  370.         } else {
  371.                 state->enable = false;
  372.                 DRM_DEBUG_ATOMIC("Set [NOMODE] for CRTC state %p\n",
  373.                                  state);
  374.         }
  375.  
  376.         return 0;
  377. }
  378. EXPORT_SYMBOL(drm_atomic_set_mode_prop_for_crtc);
  379.  
  380. /**
  381.  * drm_atomic_replace_property_blob - replace a blob property
  382.  * @blob: a pointer to the member blob to be replaced
  383.  * @new_blob: the new blob to replace with
  384.  * @replaced: whether the blob has been replaced
  385.  *
  386.  * RETURNS:
  387.  * Zero on success, error code on failure
  388.  */
  389. static void
  390. drm_atomic_replace_property_blob(struct drm_property_blob **blob,
  391.                                  struct drm_property_blob *new_blob,
  392.                                  bool *replaced)
  393. {
  394.         struct drm_property_blob *old_blob = *blob;
  395.  
  396.         if (old_blob == new_blob)
  397.                 return;
  398.  
  399.         if (old_blob)
  400.                 drm_property_unreference_blob(old_blob);
  401.         if (new_blob)
  402.                 drm_property_reference_blob(new_blob);
  403.         *blob = new_blob;
  404.         *replaced = true;
  405.  
  406.         return;
  407. }
  408.  
  409. static int
  410. drm_atomic_replace_property_blob_from_id(struct drm_crtc *crtc,
  411.                                          struct drm_property_blob **blob,
  412.                                          uint64_t blob_id,
  413.                                          ssize_t expected_size,
  414.                                          bool *replaced)
  415. {
  416.         struct drm_device *dev = crtc->dev;
  417.         struct drm_property_blob *new_blob = NULL;
  418.  
  419.         if (blob_id != 0) {
  420.                 new_blob = drm_property_lookup_blob(dev, blob_id);
  421.                 if (new_blob == NULL)
  422.                         return -EINVAL;
  423.                 if (expected_size > 0 && expected_size != new_blob->length)
  424.                         return -EINVAL;
  425.         }
  426.  
  427.         drm_atomic_replace_property_blob(blob, new_blob, replaced);
  428.  
  429.         return 0;
  430. }
  431.  
  432. /**
  433.  * drm_atomic_crtc_set_property - set property on CRTC
  434.  * @crtc: the drm CRTC to set a property on
  435.  * @state: the state object to update with the new property value
  436.  * @property: the property to set
  437.  * @val: the new property value
  438.  *
  439.  * Use this instead of calling crtc->atomic_set_property directly.
  440.  * This function handles generic/core properties and calls out to
  441.  * driver's ->atomic_set_property() for driver properties.  To ensure
  442.  * consistent behavior you must call this function rather than the
  443.  * driver hook directly.
  444.  *
  445.  * RETURNS:
  446.  * Zero on success, error code on failure
  447.  */
  448. int drm_atomic_crtc_set_property(struct drm_crtc *crtc,
  449.                 struct drm_crtc_state *state, struct drm_property *property,
  450.                 uint64_t val)
  451. {
  452.         struct drm_device *dev = crtc->dev;
  453.         struct drm_mode_config *config = &dev->mode_config;
  454.         bool replaced = false;
  455.         int ret;
  456.  
  457.         if (property == config->prop_active)
  458.                 state->active = val;
  459.         else if (property == config->prop_mode_id) {
  460.                 struct drm_property_blob *mode =
  461.                         drm_property_lookup_blob(dev, val);
  462.                 ret = drm_atomic_set_mode_prop_for_crtc(state, mode);
  463.                 drm_property_unreference_blob(mode);
  464.                 return ret;
  465.         } else if (property == config->degamma_lut_property) {
  466.                 ret = drm_atomic_replace_property_blob_from_id(crtc,
  467.                                         &state->degamma_lut,
  468.                                         val,
  469.                                         -1,
  470.                                         &replaced);
  471.                 state->color_mgmt_changed = replaced;
  472.                 return ret;
  473.         } else if (property == config->ctm_property) {
  474.                 ret = drm_atomic_replace_property_blob_from_id(crtc,
  475.                                         &state->ctm,
  476.                                         val,
  477.                                         sizeof(struct drm_color_ctm),
  478.                                         &replaced);
  479.                 state->color_mgmt_changed = replaced;
  480.                 return ret;
  481.         } else if (property == config->gamma_lut_property) {
  482.                 ret = drm_atomic_replace_property_blob_from_id(crtc,
  483.                                         &state->gamma_lut,
  484.                                         val,
  485.                                         -1,
  486.                                         &replaced);
  487.                 state->color_mgmt_changed = replaced;
  488.                 return ret;
  489.         } else if (crtc->funcs->atomic_set_property)
  490.                 return crtc->funcs->atomic_set_property(crtc, state, property, val);
  491.         else
  492.                 return -EINVAL;
  493.  
  494.         return 0;
  495. }
  496. EXPORT_SYMBOL(drm_atomic_crtc_set_property);
  497.  
  498. /**
  499.  * drm_atomic_crtc_get_property - get property value from CRTC state
  500.  * @crtc: the drm CRTC to set a property on
  501.  * @state: the state object to get the property value from
  502.  * @property: the property to set
  503.  * @val: return location for the property value
  504.  *
  505.  * This function handles generic/core properties and calls out to
  506.  * driver's ->atomic_get_property() for driver properties.  To ensure
  507.  * consistent behavior you must call this function rather than the
  508.  * driver hook directly.
  509.  *
  510.  * RETURNS:
  511.  * Zero on success, error code on failure
  512.  */
  513. static int
  514. drm_atomic_crtc_get_property(struct drm_crtc *crtc,
  515.                 const struct drm_crtc_state *state,
  516.                 struct drm_property *property, uint64_t *val)
  517. {
  518.         struct drm_device *dev = crtc->dev;
  519.         struct drm_mode_config *config = &dev->mode_config;
  520.  
  521.         if (property == config->prop_active)
  522.                 *val = state->active;
  523.         else if (property == config->prop_mode_id)
  524.                 *val = (state->mode_blob) ? state->mode_blob->base.id : 0;
  525.         else if (property == config->degamma_lut_property)
  526.                 *val = (state->degamma_lut) ? state->degamma_lut->base.id : 0;
  527.         else if (property == config->ctm_property)
  528.                 *val = (state->ctm) ? state->ctm->base.id : 0;
  529.         else if (property == config->gamma_lut_property)
  530.                 *val = (state->gamma_lut) ? state->gamma_lut->base.id : 0;
  531.         else if (crtc->funcs->atomic_get_property)
  532.                 return crtc->funcs->atomic_get_property(crtc, state, property, val);
  533.         else
  534.                 return -EINVAL;
  535.  
  536.         return 0;
  537. }
  538.  
  539. /**
  540.  * drm_atomic_crtc_check - check crtc state
  541.  * @crtc: crtc to check
  542.  * @state: crtc state to check
  543.  *
  544.  * Provides core sanity checks for crtc state.
  545.  *
  546.  * RETURNS:
  547.  * Zero on success, error code on failure
  548.  */
  549. static int drm_atomic_crtc_check(struct drm_crtc *crtc,
  550.                 struct drm_crtc_state *state)
  551. {
  552.         /* NOTE: we explicitly don't enforce constraints such as primary
  553.          * layer covering entire screen, since that is something we want
  554.          * to allow (on hw that supports it).  For hw that does not, it
  555.          * should be checked in driver's crtc->atomic_check() vfunc.
  556.          *
  557.          * TODO: Add generic modeset state checks once we support those.
  558.          */
  559.  
  560.         if (state->active && !state->enable) {
  561.                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] active without enabled\n",
  562.                                  crtc->base.id, crtc->name);
  563.                 return -EINVAL;
  564.         }
  565.  
  566.         /* The state->enable vs. state->mode_blob checks can be WARN_ON,
  567.          * as this is a kernel-internal detail that userspace should never
  568.          * be able to trigger. */
  569.         if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
  570.             WARN_ON(state->enable && !state->mode_blob)) {
  571.                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] enabled without mode blob\n",
  572.                                  crtc->base.id, crtc->name);
  573.                 return -EINVAL;
  574.         }
  575.  
  576.         if (drm_core_check_feature(crtc->dev, DRIVER_ATOMIC) &&
  577.             WARN_ON(!state->enable && state->mode_blob)) {
  578.                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] disabled with mode blob\n",
  579.                                  crtc->base.id, crtc->name);
  580.                 return -EINVAL;
  581.         }
  582.  
  583.         /*
  584.          * Reject event generation for when a CRTC is off and stays off.
  585.          * It wouldn't be hard to implement this, but userspace has a track
  586.          * record of happily burning through 100% cpu (or worse, crash) when the
  587.          * display pipe is suspended. To avoid all that fun just reject updates
  588.          * that ask for events since likely that indicates a bug in the
  589.          * compositor's drawing loop. This is consistent with the vblank IOCTL
  590.          * and legacy page_flip IOCTL which also reject service on a disabled
  591.          * pipe.
  592.          */
  593.         if (state->event && !state->active && !crtc->state->active) {
  594.                 DRM_DEBUG_ATOMIC("[CRTC:%d] requesting event but off\n",
  595.                                  crtc->base.id);
  596.                 return -EINVAL;
  597.         }
  598.  
  599.         return 0;
  600. }
  601.  
  602. /**
  603.  * drm_atomic_get_plane_state - get plane state
  604.  * @state: global atomic state object
  605.  * @plane: plane to get state object for
  606.  *
  607.  * This function returns the plane state for the given plane, allocating it if
  608.  * needed. It will also grab the relevant plane lock to make sure that the state
  609.  * is consistent.
  610.  *
  611.  * Returns:
  612.  *
  613.  * Either the allocated state or the error code encoded into the pointer. When
  614.  * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
  615.  * entire atomic sequence must be restarted. All other errors are fatal.
  616.  */
  617. struct drm_plane_state *
  618. drm_atomic_get_plane_state(struct drm_atomic_state *state,
  619.                           struct drm_plane *plane)
  620. {
  621.         int ret, index = drm_plane_index(plane);
  622.         struct drm_plane_state *plane_state;
  623.  
  624.         plane_state = drm_atomic_get_existing_plane_state(state, plane);
  625.         if (plane_state)
  626.                 return plane_state;
  627.  
  628.         ret = drm_modeset_lock(&plane->mutex, state->acquire_ctx);
  629.         if (ret)
  630.                 return ERR_PTR(ret);
  631.  
  632.         plane_state = plane->funcs->atomic_duplicate_state(plane);
  633.         if (!plane_state)
  634.                 return ERR_PTR(-ENOMEM);
  635.  
  636.         state->plane_states[index] = plane_state;
  637.         state->planes[index] = plane;
  638.         plane_state->state = state;
  639.  
  640.         DRM_DEBUG_ATOMIC("Added [PLANE:%d:%s] %p state to %p\n",
  641.                          plane->base.id, plane->name, plane_state, state);
  642.  
  643.         if (plane_state->crtc) {
  644.                 struct drm_crtc_state *crtc_state;
  645.  
  646.                 crtc_state = drm_atomic_get_crtc_state(state,
  647.                                                        plane_state->crtc);
  648.                 if (IS_ERR(crtc_state))
  649.                         return ERR_CAST(crtc_state);
  650.         }
  651.  
  652.         return plane_state;
  653. }
  654. EXPORT_SYMBOL(drm_atomic_get_plane_state);
  655.  
  656. /**
  657.  * drm_atomic_plane_set_property - set property on plane
  658.  * @plane: the drm plane to set a property on
  659.  * @state: the state object to update with the new property value
  660.  * @property: the property to set
  661.  * @val: the new property value
  662.  *
  663.  * Use this instead of calling plane->atomic_set_property directly.
  664.  * This function handles generic/core properties and calls out to
  665.  * driver's ->atomic_set_property() for driver properties.  To ensure
  666.  * consistent behavior you must call this function rather than the
  667.  * driver hook directly.
  668.  *
  669.  * RETURNS:
  670.  * Zero on success, error code on failure
  671.  */
  672. int drm_atomic_plane_set_property(struct drm_plane *plane,
  673.                 struct drm_plane_state *state, struct drm_property *property,
  674.                 uint64_t val)
  675. {
  676.         struct drm_device *dev = plane->dev;
  677.         struct drm_mode_config *config = &dev->mode_config;
  678.  
  679.         if (property == config->prop_fb_id) {
  680.                 struct drm_framebuffer *fb = drm_framebuffer_lookup(dev, val);
  681.                 drm_atomic_set_fb_for_plane(state, fb);
  682.                 if (fb)
  683.                         drm_framebuffer_unreference(fb);
  684.         } else if (property == config->prop_crtc_id) {
  685.                 struct drm_crtc *crtc = drm_crtc_find(dev, val);
  686.                 return drm_atomic_set_crtc_for_plane(state, crtc);
  687.         } else if (property == config->prop_crtc_x) {
  688.                 state->crtc_x = U642I64(val);
  689.         } else if (property == config->prop_crtc_y) {
  690.                 state->crtc_y = U642I64(val);
  691.         } else if (property == config->prop_crtc_w) {
  692.                 state->crtc_w = val;
  693.         } else if (property == config->prop_crtc_h) {
  694.                 state->crtc_h = val;
  695.         } else if (property == config->prop_src_x) {
  696.                 state->src_x = val;
  697.         } else if (property == config->prop_src_y) {
  698.                 state->src_y = val;
  699.         } else if (property == config->prop_src_w) {
  700.                 state->src_w = val;
  701.         } else if (property == config->prop_src_h) {
  702.                 state->src_h = val;
  703.         } else if (property == config->rotation_property) {
  704.                 state->rotation = val;
  705.         } else if (plane->funcs->atomic_set_property) {
  706.                 return plane->funcs->atomic_set_property(plane, state,
  707.                                 property, val);
  708.         } else {
  709.                 return -EINVAL;
  710.         }
  711.  
  712.         return 0;
  713. }
  714. EXPORT_SYMBOL(drm_atomic_plane_set_property);
  715.  
  716. /**
  717.  * drm_atomic_plane_get_property - get property value from plane state
  718.  * @plane: the drm plane to set a property on
  719.  * @state: the state object to get the property value from
  720.  * @property: the property to set
  721.  * @val: return location for the property value
  722.  *
  723.  * This function handles generic/core properties and calls out to
  724.  * driver's ->atomic_get_property() for driver properties.  To ensure
  725.  * consistent behavior you must call this function rather than the
  726.  * driver hook directly.
  727.  *
  728.  * RETURNS:
  729.  * Zero on success, error code on failure
  730.  */
  731. static int
  732. drm_atomic_plane_get_property(struct drm_plane *plane,
  733.                 const struct drm_plane_state *state,
  734.                 struct drm_property *property, uint64_t *val)
  735. {
  736.         struct drm_device *dev = plane->dev;
  737.         struct drm_mode_config *config = &dev->mode_config;
  738.  
  739.         if (property == config->prop_fb_id) {
  740.                 *val = (state->fb) ? state->fb->base.id : 0;
  741.         } else if (property == config->prop_crtc_id) {
  742.                 *val = (state->crtc) ? state->crtc->base.id : 0;
  743.         } else if (property == config->prop_crtc_x) {
  744.                 *val = I642U64(state->crtc_x);
  745.         } else if (property == config->prop_crtc_y) {
  746.                 *val = I642U64(state->crtc_y);
  747.         } else if (property == config->prop_crtc_w) {
  748.                 *val = state->crtc_w;
  749.         } else if (property == config->prop_crtc_h) {
  750.                 *val = state->crtc_h;
  751.         } else if (property == config->prop_src_x) {
  752.                 *val = state->src_x;
  753.         } else if (property == config->prop_src_y) {
  754.                 *val = state->src_y;
  755.         } else if (property == config->prop_src_w) {
  756.                 *val = state->src_w;
  757.         } else if (property == config->prop_src_h) {
  758.                 *val = state->src_h;
  759.         } else if (property == config->rotation_property) {
  760.                 *val = state->rotation;
  761.         } else if (plane->funcs->atomic_get_property) {
  762.                 return plane->funcs->atomic_get_property(plane, state, property, val);
  763.         } else {
  764.                 return -EINVAL;
  765.         }
  766.  
  767.         return 0;
  768. }
  769.  
  770. static bool
  771. plane_switching_crtc(struct drm_atomic_state *state,
  772.                      struct drm_plane *plane,
  773.                      struct drm_plane_state *plane_state)
  774. {
  775.         if (!plane->state->crtc || !plane_state->crtc)
  776.                 return false;
  777.  
  778.         if (plane->state->crtc == plane_state->crtc)
  779.                 return false;
  780.  
  781.         /* This could be refined, but currently there's no helper or driver code
  782.          * to implement direct switching of active planes nor userspace to take
  783.          * advantage of more direct plane switching without the intermediate
  784.          * full OFF state.
  785.          */
  786.         return true;
  787. }
  788.  
  789. /**
  790.  * drm_atomic_plane_check - check plane state
  791.  * @plane: plane to check
  792.  * @state: plane state to check
  793.  *
  794.  * Provides core sanity checks for plane state.
  795.  *
  796.  * RETURNS:
  797.  * Zero on success, error code on failure
  798.  */
  799. static int drm_atomic_plane_check(struct drm_plane *plane,
  800.                 struct drm_plane_state *state)
  801. {
  802.         unsigned int fb_width, fb_height;
  803.         int ret;
  804.  
  805.         /* either *both* CRTC and FB must be set, or neither */
  806.         if (WARN_ON(state->crtc && !state->fb)) {
  807.                 DRM_DEBUG_ATOMIC("CRTC set but no FB\n");
  808.                 return -EINVAL;
  809.         } else if (WARN_ON(state->fb && !state->crtc)) {
  810.                 DRM_DEBUG_ATOMIC("FB set but no CRTC\n");
  811.                 return -EINVAL;
  812.         }
  813.  
  814.         /* if disabled, we don't care about the rest of the state: */
  815.         if (!state->crtc)
  816.                 return 0;
  817.  
  818.         /* Check whether this plane is usable on this CRTC */
  819.         if (!(plane->possible_crtcs & drm_crtc_mask(state->crtc))) {
  820.                 DRM_DEBUG_ATOMIC("Invalid crtc for plane\n");
  821.                 return -EINVAL;
  822.         }
  823.  
  824.         /* Check whether this plane supports the fb pixel format. */
  825.         ret = drm_plane_check_pixel_format(plane, state->fb->pixel_format);
  826.         if (ret) {
  827.                 DRM_DEBUG_ATOMIC("Invalid pixel format %s\n",
  828.                                  drm_get_format_name(state->fb->pixel_format));
  829.                 return ret;
  830.         }
  831.  
  832.         /* Give drivers some help against integer overflows */
  833.         if (state->crtc_w > INT_MAX ||
  834.             state->crtc_x > INT_MAX - (int32_t) state->crtc_w ||
  835.             state->crtc_h > INT_MAX ||
  836.             state->crtc_y > INT_MAX - (int32_t) state->crtc_h) {
  837.                 DRM_DEBUG_ATOMIC("Invalid CRTC coordinates %ux%u+%d+%d\n",
  838.                                  state->crtc_w, state->crtc_h,
  839.                                  state->crtc_x, state->crtc_y);
  840.                 return -ERANGE;
  841.         }
  842.  
  843.         fb_width = state->fb->width << 16;
  844.         fb_height = state->fb->height << 16;
  845.  
  846.         /* Make sure source coordinates are inside the fb. */
  847.         if (state->src_w > fb_width ||
  848.             state->src_x > fb_width - state->src_w ||
  849.             state->src_h > fb_height ||
  850.             state->src_y > fb_height - state->src_h) {
  851.                 DRM_DEBUG_ATOMIC("Invalid source coordinates "
  852.                                  "%u.%06ux%u.%06u+%u.%06u+%u.%06u\n",
  853.                                  state->src_w >> 16, ((state->src_w & 0xffff) * 15625) >> 10,
  854.                                  state->src_h >> 16, ((state->src_h & 0xffff) * 15625) >> 10,
  855.                                  state->src_x >> 16, ((state->src_x & 0xffff) * 15625) >> 10,
  856.                                  state->src_y >> 16, ((state->src_y & 0xffff) * 15625) >> 10);
  857.                 return -ENOSPC;
  858.         }
  859.  
  860.         if (plane_switching_crtc(state->state, plane, state)) {
  861.                 DRM_DEBUG_ATOMIC("[PLANE:%d:%s] switching CRTC directly\n",
  862.                                  plane->base.id, plane->name);
  863.                 return -EINVAL;
  864.         }
  865.  
  866.         return 0;
  867. }
  868.  
  869. /**
  870.  * drm_atomic_get_connector_state - get connector state
  871.  * @state: global atomic state object
  872.  * @connector: connector to get state object for
  873.  *
  874.  * This function returns the connector state for the given connector,
  875.  * allocating it if needed. It will also grab the relevant connector lock to
  876.  * make sure that the state is consistent.
  877.  *
  878.  * Returns:
  879.  *
  880.  * Either the allocated state or the error code encoded into the pointer. When
  881.  * the error is EDEADLK then the w/w mutex code has detected a deadlock and the
  882.  * entire atomic sequence must be restarted. All other errors are fatal.
  883.  */
  884. struct drm_connector_state *
  885. drm_atomic_get_connector_state(struct drm_atomic_state *state,
  886.                           struct drm_connector *connector)
  887. {
  888.         int ret, index;
  889.         struct drm_mode_config *config = &connector->dev->mode_config;
  890.         struct drm_connector_state *connector_state;
  891.  
  892.         ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
  893.         if (ret)
  894.                 return ERR_PTR(ret);
  895.  
  896.         index = drm_connector_index(connector);
  897.  
  898.         if (index >= state->num_connector) {
  899.                 struct drm_connector **c;
  900.                 struct drm_connector_state **cs;
  901.                 int alloc = max(index + 1, config->num_connector);
  902.  
  903.                 c = krealloc(state->connectors, alloc * sizeof(*state->connectors), GFP_KERNEL);
  904.                 if (!c)
  905.                         return ERR_PTR(-ENOMEM);
  906.  
  907.                 state->connectors = c;
  908.                 memset(&state->connectors[state->num_connector], 0,
  909.                        sizeof(*state->connectors) * (alloc - state->num_connector));
  910.  
  911.                 cs = krealloc(state->connector_states, alloc * sizeof(*state->connector_states), GFP_KERNEL);
  912.                 if (!cs)
  913.                         return ERR_PTR(-ENOMEM);
  914.  
  915.                 state->connector_states = cs;
  916.                 memset(&state->connector_states[state->num_connector], 0,
  917.                        sizeof(*state->connector_states) * (alloc - state->num_connector));
  918.                 state->num_connector = alloc;
  919.         }
  920.  
  921.         if (state->connector_states[index])
  922.                 return state->connector_states[index];
  923.  
  924.         connector_state = connector->funcs->atomic_duplicate_state(connector);
  925.         if (!connector_state)
  926.                 return ERR_PTR(-ENOMEM);
  927.  
  928.         state->connector_states[index] = connector_state;
  929.         state->connectors[index] = connector;
  930.         connector_state->state = state;
  931.  
  932.         DRM_DEBUG_ATOMIC("Added [CONNECTOR:%d] %p state to %p\n",
  933.                          connector->base.id, connector_state, state);
  934.  
  935.         if (connector_state->crtc) {
  936.                 struct drm_crtc_state *crtc_state;
  937.  
  938.                 crtc_state = drm_atomic_get_crtc_state(state,
  939.                                                        connector_state->crtc);
  940.                 if (IS_ERR(crtc_state))
  941.                         return ERR_CAST(crtc_state);
  942.         }
  943.  
  944.         return connector_state;
  945. }
  946. EXPORT_SYMBOL(drm_atomic_get_connector_state);
  947.  
  948. /**
  949.  * drm_atomic_connector_set_property - set property on connector.
  950.  * @connector: the drm connector to set a property on
  951.  * @state: the state object to update with the new property value
  952.  * @property: the property to set
  953.  * @val: the new property value
  954.  *
  955.  * Use this instead of calling connector->atomic_set_property directly.
  956.  * This function handles generic/core properties and calls out to
  957.  * driver's ->atomic_set_property() for driver properties.  To ensure
  958.  * consistent behavior you must call this function rather than the
  959.  * driver hook directly.
  960.  *
  961.  * RETURNS:
  962.  * Zero on success, error code on failure
  963.  */
  964. int drm_atomic_connector_set_property(struct drm_connector *connector,
  965.                 struct drm_connector_state *state, struct drm_property *property,
  966.                 uint64_t val)
  967. {
  968.         struct drm_device *dev = connector->dev;
  969.         struct drm_mode_config *config = &dev->mode_config;
  970.  
  971.         if (property == config->prop_crtc_id) {
  972.                 struct drm_crtc *crtc = drm_crtc_find(dev, val);
  973.                 return drm_atomic_set_crtc_for_connector(state, crtc);
  974.         } else if (property == config->dpms_property) {
  975.                 /* setting DPMS property requires special handling, which
  976.                  * is done in legacy setprop path for us.  Disallow (for
  977.                  * now?) atomic writes to DPMS property:
  978.                  */
  979.                 return -EINVAL;
  980.         } else if (connector->funcs->atomic_set_property) {
  981.                 return connector->funcs->atomic_set_property(connector,
  982.                                 state, property, val);
  983.         } else {
  984.                 return -EINVAL;
  985.         }
  986. }
  987. EXPORT_SYMBOL(drm_atomic_connector_set_property);
  988.  
  989. /**
  990.  * drm_atomic_connector_get_property - get property value from connector state
  991.  * @connector: the drm connector to set a property on
  992.  * @state: the state object to get the property value from
  993.  * @property: the property to set
  994.  * @val: return location for the property value
  995.  *
  996.  * This function handles generic/core properties and calls out to
  997.  * driver's ->atomic_get_property() for driver properties.  To ensure
  998.  * consistent behavior you must call this function rather than the
  999.  * driver hook directly.
  1000.  *
  1001.  * RETURNS:
  1002.  * Zero on success, error code on failure
  1003.  */
  1004. static int
  1005. drm_atomic_connector_get_property(struct drm_connector *connector,
  1006.                 const struct drm_connector_state *state,
  1007.                 struct drm_property *property, uint64_t *val)
  1008. {
  1009.         struct drm_device *dev = connector->dev;
  1010.         struct drm_mode_config *config = &dev->mode_config;
  1011.  
  1012.         if (property == config->prop_crtc_id) {
  1013.                 *val = (state->crtc) ? state->crtc->base.id : 0;
  1014.         } else if (property == config->dpms_property) {
  1015.                 *val = connector->dpms;
  1016.         } else if (connector->funcs->atomic_get_property) {
  1017.                 return connector->funcs->atomic_get_property(connector,
  1018.                                 state, property, val);
  1019.         } else {
  1020.                 return -EINVAL;
  1021.         }
  1022.  
  1023.         return 0;
  1024. }
  1025.  
  1026. int drm_atomic_get_property(struct drm_mode_object *obj,
  1027.                 struct drm_property *property, uint64_t *val)
  1028. {
  1029.         struct drm_device *dev = property->dev;
  1030.         int ret;
  1031.  
  1032.         switch (obj->type) {
  1033.         case DRM_MODE_OBJECT_CONNECTOR: {
  1034.                 struct drm_connector *connector = obj_to_connector(obj);
  1035.                 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  1036.                 ret = drm_atomic_connector_get_property(connector,
  1037.                                 connector->state, property, val);
  1038.                 break;
  1039.         }
  1040.         case DRM_MODE_OBJECT_CRTC: {
  1041.                 struct drm_crtc *crtc = obj_to_crtc(obj);
  1042.                 WARN_ON(!drm_modeset_is_locked(&crtc->mutex));
  1043.                 ret = drm_atomic_crtc_get_property(crtc,
  1044.                                 crtc->state, property, val);
  1045.                 break;
  1046.         }
  1047.         case DRM_MODE_OBJECT_PLANE: {
  1048.                 struct drm_plane *plane = obj_to_plane(obj);
  1049.                 WARN_ON(!drm_modeset_is_locked(&plane->mutex));
  1050.                 ret = drm_atomic_plane_get_property(plane,
  1051.                                 plane->state, property, val);
  1052.                 break;
  1053.         }
  1054.         default:
  1055.                 ret = -EINVAL;
  1056.                 break;
  1057.         }
  1058.  
  1059.         return ret;
  1060. }
  1061.  
  1062. /**
  1063.  * drm_atomic_set_crtc_for_plane - set crtc for plane
  1064.  * @plane_state: the plane whose incoming state to update
  1065.  * @crtc: crtc to use for the plane
  1066.  *
  1067.  * Changing the assigned crtc for a plane requires us to grab the lock and state
  1068.  * for the new crtc, as needed. This function takes care of all these details
  1069.  * besides updating the pointer in the state object itself.
  1070.  *
  1071.  * Returns:
  1072.  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
  1073.  * then the w/w mutex code has detected a deadlock and the entire atomic
  1074.  * sequence must be restarted. All other errors are fatal.
  1075.  */
  1076. int
  1077. drm_atomic_set_crtc_for_plane(struct drm_plane_state *plane_state,
  1078.                               struct drm_crtc *crtc)
  1079. {
  1080.         struct drm_plane *plane = plane_state->plane;
  1081.         struct drm_crtc_state *crtc_state;
  1082.  
  1083.         if (plane_state->crtc) {
  1084.                 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
  1085.                                                        plane_state->crtc);
  1086.                 if (WARN_ON(IS_ERR(crtc_state)))
  1087.                         return PTR_ERR(crtc_state);
  1088.  
  1089.                 crtc_state->plane_mask &= ~(1 << drm_plane_index(plane));
  1090.         }
  1091.  
  1092.         plane_state->crtc = crtc;
  1093.  
  1094.         if (crtc) {
  1095.                 crtc_state = drm_atomic_get_crtc_state(plane_state->state,
  1096.                                                        crtc);
  1097.                 if (IS_ERR(crtc_state))
  1098.                         return PTR_ERR(crtc_state);
  1099.                 crtc_state->plane_mask |= (1 << drm_plane_index(plane));
  1100.         }
  1101.  
  1102.         if (crtc)
  1103.                 DRM_DEBUG_ATOMIC("Link plane state %p to [CRTC:%d:%s]\n",
  1104.                                  plane_state, crtc->base.id, crtc->name);
  1105.         else
  1106.                 DRM_DEBUG_ATOMIC("Link plane state %p to [NOCRTC]\n",
  1107.                                  plane_state);
  1108.  
  1109.         return 0;
  1110. }
  1111. EXPORT_SYMBOL(drm_atomic_set_crtc_for_plane);
  1112.  
  1113. /**
  1114.  * drm_atomic_set_fb_for_plane - set framebuffer for plane
  1115.  * @plane_state: atomic state object for the plane
  1116.  * @fb: fb to use for the plane
  1117.  *
  1118.  * Changing the assigned framebuffer for a plane requires us to grab a reference
  1119.  * to the new fb and drop the reference to the old fb, if there is one. This
  1120.  * function takes care of all these details besides updating the pointer in the
  1121.  * state object itself.
  1122.  */
  1123. void
  1124. drm_atomic_set_fb_for_plane(struct drm_plane_state *plane_state,
  1125.                             struct drm_framebuffer *fb)
  1126. {
  1127.         if (plane_state->fb)
  1128.                 drm_framebuffer_unreference(plane_state->fb);
  1129.         if (fb)
  1130.                 drm_framebuffer_reference(fb);
  1131.         plane_state->fb = fb;
  1132.  
  1133.         if (fb)
  1134.                 DRM_DEBUG_ATOMIC("Set [FB:%d] for plane state %p\n",
  1135.                                  fb->base.id, plane_state);
  1136.         else
  1137.                 DRM_DEBUG_ATOMIC("Set [NOFB] for plane state %p\n",
  1138.                                  plane_state);
  1139. }
  1140. EXPORT_SYMBOL(drm_atomic_set_fb_for_plane);
  1141.  
  1142. /**
  1143.  * drm_atomic_set_crtc_for_connector - set crtc for connector
  1144.  * @conn_state: atomic state object for the connector
  1145.  * @crtc: crtc to use for the connector
  1146.  *
  1147.  * Changing the assigned crtc for a connector requires us to grab the lock and
  1148.  * state for the new crtc, as needed. This function takes care of all these
  1149.  * details besides updating the pointer in the state object itself.
  1150.  *
  1151.  * Returns:
  1152.  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
  1153.  * then the w/w mutex code has detected a deadlock and the entire atomic
  1154.  * sequence must be restarted. All other errors are fatal.
  1155.  */
  1156. int
  1157. drm_atomic_set_crtc_for_connector(struct drm_connector_state *conn_state,
  1158.                                   struct drm_crtc *crtc)
  1159. {
  1160.         struct drm_crtc_state *crtc_state;
  1161.  
  1162.         if (conn_state->crtc && conn_state->crtc != crtc) {
  1163.                 crtc_state = drm_atomic_get_existing_crtc_state(conn_state->state,
  1164.                                                                 conn_state->crtc);
  1165.  
  1166.                 crtc_state->connector_mask &=
  1167.                         ~(1 << drm_connector_index(conn_state->connector));
  1168.         }
  1169.  
  1170.         if (crtc) {
  1171.                 crtc_state = drm_atomic_get_crtc_state(conn_state->state, crtc);
  1172.                 if (IS_ERR(crtc_state))
  1173.                         return PTR_ERR(crtc_state);
  1174.  
  1175.                 crtc_state->connector_mask |=
  1176.                         1 << drm_connector_index(conn_state->connector);
  1177.         }
  1178.  
  1179.         conn_state->crtc = crtc;
  1180.  
  1181.         if (crtc)
  1182.                 DRM_DEBUG_ATOMIC("Link connector state %p to [CRTC:%d:%s]\n",
  1183.                                  conn_state, crtc->base.id, crtc->name);
  1184.         else
  1185.                 DRM_DEBUG_ATOMIC("Link connector state %p to [NOCRTC]\n",
  1186.                                  conn_state);
  1187.  
  1188.         return 0;
  1189. }
  1190. EXPORT_SYMBOL(drm_atomic_set_crtc_for_connector);
  1191.  
  1192. /**
  1193.  * drm_atomic_add_affected_connectors - add connectors for crtc
  1194.  * @state: atomic state
  1195.  * @crtc: DRM crtc
  1196.  *
  1197.  * This function walks the current configuration and adds all connectors
  1198.  * currently using @crtc to the atomic configuration @state. Note that this
  1199.  * function must acquire the connection mutex. This can potentially cause
  1200.  * unneeded seralization if the update is just for the planes on one crtc. Hence
  1201.  * drivers and helpers should only call this when really needed (e.g. when a
  1202.  * full modeset needs to happen due to some change).
  1203.  *
  1204.  * Returns:
  1205.  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
  1206.  * then the w/w mutex code has detected a deadlock and the entire atomic
  1207.  * sequence must be restarted. All other errors are fatal.
  1208.  */
  1209. int
  1210. drm_atomic_add_affected_connectors(struct drm_atomic_state *state,
  1211.                                    struct drm_crtc *crtc)
  1212. {
  1213.         struct drm_mode_config *config = &state->dev->mode_config;
  1214.         struct drm_connector *connector;
  1215.         struct drm_connector_state *conn_state;
  1216.         int ret;
  1217.  
  1218.         ret = drm_modeset_lock(&config->connection_mutex, state->acquire_ctx);
  1219.         if (ret)
  1220.                 return ret;
  1221.  
  1222.         DRM_DEBUG_ATOMIC("Adding all current connectors for [CRTC:%d:%s] to %p\n",
  1223.                          crtc->base.id, crtc->name, state);
  1224.  
  1225.         /*
  1226.          * Changed connectors are already in @state, so only need to look at the
  1227.          * current configuration.
  1228.          */
  1229.         drm_for_each_connector(connector, state->dev) {
  1230.                 if (connector->state->crtc != crtc)
  1231.                         continue;
  1232.  
  1233.                 conn_state = drm_atomic_get_connector_state(state, connector);
  1234.                 if (IS_ERR(conn_state))
  1235.                         return PTR_ERR(conn_state);
  1236.         }
  1237.  
  1238.         return 0;
  1239. }
  1240. EXPORT_SYMBOL(drm_atomic_add_affected_connectors);
  1241.  
  1242. /**
  1243.  * drm_atomic_add_affected_planes - add planes for crtc
  1244.  * @state: atomic state
  1245.  * @crtc: DRM crtc
  1246.  *
  1247.  * This function walks the current configuration and adds all planes
  1248.  * currently used by @crtc to the atomic configuration @state. This is useful
  1249.  * when an atomic commit also needs to check all currently enabled plane on
  1250.  * @crtc, e.g. when changing the mode. It's also useful when re-enabling a CRTC
  1251.  * to avoid special code to force-enable all planes.
  1252.  *
  1253.  * Since acquiring a plane state will always also acquire the w/w mutex of the
  1254.  * current CRTC for that plane (if there is any) adding all the plane states for
  1255.  * a CRTC will not reduce parallism of atomic updates.
  1256.  *
  1257.  * Returns:
  1258.  * 0 on success or can fail with -EDEADLK or -ENOMEM. When the error is EDEADLK
  1259.  * then the w/w mutex code has detected a deadlock and the entire atomic
  1260.  * sequence must be restarted. All other errors are fatal.
  1261.  */
  1262. int
  1263. drm_atomic_add_affected_planes(struct drm_atomic_state *state,
  1264.                                struct drm_crtc *crtc)
  1265. {
  1266.         struct drm_plane *plane;
  1267.  
  1268.         WARN_ON(!drm_atomic_get_existing_crtc_state(state, crtc));
  1269.  
  1270.         drm_for_each_plane_mask(plane, state->dev, crtc->state->plane_mask) {
  1271.                 struct drm_plane_state *plane_state =
  1272.                         drm_atomic_get_plane_state(state, plane);
  1273.  
  1274.                 if (IS_ERR(plane_state))
  1275.                         return PTR_ERR(plane_state);
  1276.         }
  1277.         return 0;
  1278. }
  1279. EXPORT_SYMBOL(drm_atomic_add_affected_planes);
  1280.  
  1281. /**
  1282.  * drm_atomic_legacy_backoff - locking backoff for legacy ioctls
  1283.  * @state: atomic state
  1284.  *
  1285.  * This function should be used by legacy entry points which don't understand
  1286.  * -EDEADLK semantics. For simplicity this one will grab all modeset locks after
  1287.  * the slowpath completed.
  1288.  */
  1289. void drm_atomic_legacy_backoff(struct drm_atomic_state *state)
  1290. {
  1291.         struct drm_device *dev = state->dev;
  1292.         unsigned crtc_mask = 0;
  1293.         struct drm_crtc *crtc;
  1294.         int ret;
  1295.         bool global = false;
  1296.  
  1297.         drm_for_each_crtc(crtc, dev) {
  1298.                 if (crtc->acquire_ctx != state->acquire_ctx)
  1299.                         continue;
  1300.  
  1301.                 crtc_mask |= drm_crtc_mask(crtc);
  1302.                 crtc->acquire_ctx = NULL;
  1303.         }
  1304.  
  1305.         if (WARN_ON(dev->mode_config.acquire_ctx == state->acquire_ctx)) {
  1306.                 global = true;
  1307.  
  1308.                 dev->mode_config.acquire_ctx = NULL;
  1309.         }
  1310.  
  1311. retry:
  1312.         drm_modeset_backoff(state->acquire_ctx);
  1313.  
  1314.         ret = drm_modeset_lock_all_ctx(dev, state->acquire_ctx);
  1315.         if (ret)
  1316.                 goto retry;
  1317.  
  1318.         drm_for_each_crtc(crtc, dev)
  1319.                 if (drm_crtc_mask(crtc) & crtc_mask)
  1320.                         crtc->acquire_ctx = state->acquire_ctx;
  1321.  
  1322.         if (global)
  1323.                 dev->mode_config.acquire_ctx = state->acquire_ctx;
  1324. }
  1325. EXPORT_SYMBOL(drm_atomic_legacy_backoff);
  1326.  
  1327. /**
  1328.  * drm_atomic_check_only - check whether a given config would work
  1329.  * @state: atomic configuration to check
  1330.  *
  1331.  * Note that this function can return -EDEADLK if the driver needed to acquire
  1332.  * more locks but encountered a deadlock. The caller must then do the usual w/w
  1333.  * backoff dance and restart. All other errors are fatal.
  1334.  *
  1335.  * Returns:
  1336.  * 0 on success, negative error code on failure.
  1337.  */
  1338. int drm_atomic_check_only(struct drm_atomic_state *state)
  1339. {
  1340.         struct drm_device *dev = state->dev;
  1341.         struct drm_mode_config *config = &dev->mode_config;
  1342.         struct drm_plane *plane;
  1343.         struct drm_plane_state *plane_state;
  1344.         struct drm_crtc *crtc;
  1345.         struct drm_crtc_state *crtc_state;
  1346.         int i, ret = 0;
  1347.  
  1348.         DRM_DEBUG_ATOMIC("checking %p\n", state);
  1349.  
  1350.         for_each_plane_in_state(state, plane, plane_state, i) {
  1351.                 ret = drm_atomic_plane_check(plane, plane_state);
  1352.                 if (ret) {
  1353.                         DRM_DEBUG_ATOMIC("[PLANE:%d:%s] atomic core check failed\n",
  1354.                                          plane->base.id, plane->name);
  1355.                         return ret;
  1356.                 }
  1357.         }
  1358.  
  1359.         for_each_crtc_in_state(state, crtc, crtc_state, i) {
  1360.                 ret = drm_atomic_crtc_check(crtc, crtc_state);
  1361.                 if (ret) {
  1362.                         DRM_DEBUG_ATOMIC("[CRTC:%d:%s] atomic core check failed\n",
  1363.                                          crtc->base.id, crtc->name);
  1364.                         return ret;
  1365.                 }
  1366.         }
  1367.  
  1368.         if (config->funcs->atomic_check)
  1369.                 ret = config->funcs->atomic_check(state->dev, state);
  1370.  
  1371.         if (!state->allow_modeset) {
  1372.                 for_each_crtc_in_state(state, crtc, crtc_state, i) {
  1373.                         if (drm_atomic_crtc_needs_modeset(crtc_state)) {
  1374.                                 DRM_DEBUG_ATOMIC("[CRTC:%d:%s] requires full modeset\n",
  1375.                                                  crtc->base.id, crtc->name);
  1376.                                 return -EINVAL;
  1377.                         }
  1378.                 }
  1379.         }
  1380.  
  1381.         return ret;
  1382. }
  1383. EXPORT_SYMBOL(drm_atomic_check_only);
  1384.  
  1385. /**
  1386.  * drm_atomic_commit - commit configuration atomically
  1387.  * @state: atomic configuration to check
  1388.  *
  1389.  * Note that this function can return -EDEADLK if the driver needed to acquire
  1390.  * more locks but encountered a deadlock. The caller must then do the usual w/w
  1391.  * backoff dance and restart. All other errors are fatal.
  1392.  *
  1393.  * Also note that on successful execution ownership of @state is transferred
  1394.  * from the caller of this function to the function itself. The caller must not
  1395.  * free or in any other way access @state. If the function fails then the caller
  1396.  * must clean up @state itself.
  1397.  *
  1398.  * Returns:
  1399.  * 0 on success, negative error code on failure.
  1400.  */
  1401. int drm_atomic_commit(struct drm_atomic_state *state)
  1402. {
  1403.         struct drm_mode_config *config = &state->dev->mode_config;
  1404.         int ret;
  1405.  
  1406.         ret = drm_atomic_check_only(state);
  1407.         if (ret)
  1408.                 return ret;
  1409.  
  1410.         DRM_DEBUG_ATOMIC("commiting %p\n", state);
  1411.  
  1412.         return config->funcs->atomic_commit(state->dev, state, false);
  1413. }
  1414. EXPORT_SYMBOL(drm_atomic_commit);
  1415.  
  1416. /**
  1417.  * drm_atomic_async_commit - atomic&async configuration commit
  1418.  * @state: atomic configuration to check
  1419.  *
  1420.  * Note that this function can return -EDEADLK if the driver needed to acquire
  1421.  * more locks but encountered a deadlock. The caller must then do the usual w/w
  1422.  * backoff dance and restart. All other errors are fatal.
  1423.  *
  1424.  * Also note that on successful execution ownership of @state is transferred
  1425.  * from the caller of this function to the function itself. The caller must not
  1426.  * free or in any other way access @state. If the function fails then the caller
  1427.  * must clean up @state itself.
  1428.  *
  1429.  * Returns:
  1430.  * 0 on success, negative error code on failure.
  1431.  */
  1432. int drm_atomic_async_commit(struct drm_atomic_state *state)
  1433. {
  1434.         struct drm_mode_config *config = &state->dev->mode_config;
  1435.         int ret;
  1436.  
  1437.         ret = drm_atomic_check_only(state);
  1438.         if (ret)
  1439.                 return ret;
  1440.  
  1441.         DRM_DEBUG_ATOMIC("commiting %p asynchronously\n", state);
  1442.  
  1443.         return config->funcs->atomic_commit(state->dev, state, true);
  1444. }
  1445. EXPORT_SYMBOL(drm_atomic_async_commit);
  1446.  
  1447. /*
  1448.  * The big monstor ioctl
  1449.  */
  1450.  
  1451. static struct drm_pending_vblank_event *create_vblank_event(
  1452.                 struct drm_device *dev, struct drm_file *file_priv, uint64_t user_data)
  1453. {
  1454.         struct drm_pending_vblank_event *e = NULL;
  1455.         int ret;
  1456.  
  1457.         e = kzalloc(sizeof *e, GFP_KERNEL);
  1458.         if (!e)
  1459.                 return NULL;
  1460.  
  1461.         e->event.base.type = DRM_EVENT_FLIP_COMPLETE;
  1462.         e->event.base.length = sizeof(e->event);
  1463.         e->event.user_data = user_data;
  1464.  
  1465.         ret = drm_event_reserve_init(dev, file_priv, &e->base, &e->event.base);
  1466.         if (ret) {
  1467.                 kfree(e);
  1468.                 return NULL;
  1469.         }
  1470.  
  1471.         return e;
  1472. }
  1473.  
  1474. static int atomic_set_prop(struct drm_atomic_state *state,
  1475.                 struct drm_mode_object *obj, struct drm_property *prop,
  1476.                 uint64_t prop_value)
  1477. {
  1478.         struct drm_mode_object *ref;
  1479.         int ret;
  1480.  
  1481.         if (!drm_property_change_valid_get(prop, prop_value, &ref))
  1482.                 return -EINVAL;
  1483.  
  1484.         switch (obj->type) {
  1485.         case DRM_MODE_OBJECT_CONNECTOR: {
  1486.                 struct drm_connector *connector = obj_to_connector(obj);
  1487.                 struct drm_connector_state *connector_state;
  1488.  
  1489.                 connector_state = drm_atomic_get_connector_state(state, connector);
  1490.                 if (IS_ERR(connector_state)) {
  1491.                         ret = PTR_ERR(connector_state);
  1492.                         break;
  1493.                 }
  1494.  
  1495.                 ret = drm_atomic_connector_set_property(connector,
  1496.                                 connector_state, prop, prop_value);
  1497.                 break;
  1498.         }
  1499.         case DRM_MODE_OBJECT_CRTC: {
  1500.                 struct drm_crtc *crtc = obj_to_crtc(obj);
  1501.                 struct drm_crtc_state *crtc_state;
  1502.  
  1503.                 crtc_state = drm_atomic_get_crtc_state(state, crtc);
  1504.                 if (IS_ERR(crtc_state)) {
  1505.                         ret = PTR_ERR(crtc_state);
  1506.                         break;
  1507.                 }
  1508.  
  1509.                 ret = drm_atomic_crtc_set_property(crtc,
  1510.                                 crtc_state, prop, prop_value);
  1511.                 break;
  1512.         }
  1513.         case DRM_MODE_OBJECT_PLANE: {
  1514.                 struct drm_plane *plane = obj_to_plane(obj);
  1515.                 struct drm_plane_state *plane_state;
  1516.  
  1517.                 plane_state = drm_atomic_get_plane_state(state, plane);
  1518.                 if (IS_ERR(plane_state)) {
  1519.                         ret = PTR_ERR(plane_state);
  1520.                         break;
  1521.                 }
  1522.  
  1523.                 ret = drm_atomic_plane_set_property(plane,
  1524.                                 plane_state, prop, prop_value);
  1525.                 break;
  1526.         }
  1527.         default:
  1528.                 ret = -EINVAL;
  1529.                 break;
  1530.         }
  1531.  
  1532.         drm_property_change_valid_put(prop, ref);
  1533.         return ret;
  1534. }
  1535.  
  1536. /**
  1537.  * drm_atomic_clean_old_fb -- Unset old_fb pointers and set plane->fb pointers.
  1538.  *
  1539.  * @dev: drm device to check.
  1540.  * @plane_mask: plane mask for planes that were updated.
  1541.  * @ret: return value, can be -EDEADLK for a retry.
  1542.  *
  1543.  * Before doing an update plane->old_fb is set to plane->fb,
  1544.  * but before dropping the locks old_fb needs to be set to NULL
  1545.  * and plane->fb updated. This is a common operation for each
  1546.  * atomic update, so this call is split off as a helper.
  1547.  */
  1548. void drm_atomic_clean_old_fb(struct drm_device *dev,
  1549.                              unsigned plane_mask,
  1550.                              int ret)
  1551. {
  1552.         struct drm_plane *plane;
  1553.  
  1554.         /* if succeeded, fixup legacy plane crtc/fb ptrs before dropping
  1555.          * locks (ie. while it is still safe to deref plane->state).  We
  1556.          * need to do this here because the driver entry points cannot
  1557.          * distinguish between legacy and atomic ioctls.
  1558.          */
  1559.         drm_for_each_plane_mask(plane, dev, plane_mask) {
  1560.                 if (ret == 0) {
  1561.                         struct drm_framebuffer *new_fb = plane->state->fb;
  1562.                         if (new_fb)
  1563.                                 drm_framebuffer_reference(new_fb);
  1564.                         plane->fb = new_fb;
  1565.                         plane->crtc = plane->state->crtc;
  1566.  
  1567.                         if (plane->old_fb)
  1568.                                 drm_framebuffer_unreference(plane->old_fb);
  1569.                 }
  1570.                 plane->old_fb = NULL;
  1571.         }
  1572. }
  1573. EXPORT_SYMBOL(drm_atomic_clean_old_fb);
  1574.