Subversion Repositories Kolibri OS

Rev

Rev 6084 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2006-2008 Intel Corporation
  3.  * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
  4.  *
  5.  * DRM core CRTC related functions
  6.  *
  7.  * Permission to use, copy, modify, distribute, and sell this software and its
  8.  * documentation for any purpose is hereby granted without fee, provided that
  9.  * the above copyright notice appear in all copies and that both that copyright
  10.  * notice and this permission notice appear in supporting documentation, and
  11.  * that the name of the copyright holders not be used in advertising or
  12.  * publicity pertaining to distribution of the software without specific,
  13.  * written prior permission.  The copyright holders make no representations
  14.  * about the suitability of this software for any purpose.  It is provided "as
  15.  * is" without express or implied warranty.
  16.  *
  17.  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  18.  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  19.  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  20.  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21.  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  22.  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  23.  * OF THIS SOFTWARE.
  24.  *
  25.  * Authors:
  26.  *      Keith Packard
  27.  *      Eric Anholt <eric@anholt.net>
  28.  *      Dave Airlie <airlied@linux.ie>
  29.  *      Jesse Barnes <jesse.barnes@intel.com>
  30.  */
  31.  
  32. #include <linux/kernel.h>
  33. #include <linux/export.h>
  34. #include <linux/moduleparam.h>
  35.  
  36. #include <drm/drmP.h>
  37. #include <drm/drm_atomic.h>
  38. #include <drm/drm_crtc.h>
  39. #include <drm/drm_fourcc.h>
  40. #include <drm/drm_crtc_helper.h>
  41. #include <drm/drm_fb_helper.h>
  42. #include <drm/drm_plane_helper.h>
  43. #include <drm/drm_atomic_helper.h>
  44. #include <drm/drm_edid.h>
  45.  
  46. /**
  47.  * DOC: overview
  48.  *
  49.  * The CRTC modeset helper library provides a default set_config implementation
  50.  * in drm_crtc_helper_set_config(). Plus a few other convenience functions using
  51.  * the same callbacks which drivers can use to e.g. restore the modeset
  52.  * configuration on resume with drm_helper_resume_force_mode().
  53.  *
  54.  * Note that this helper library doesn't track the current power state of CRTCs
  55.  * and encoders. It can call callbacks like ->dpms() even though the hardware is
  56.  * already in the desired state. This deficiency has been fixed in the atomic
  57.  * helpers.
  58.  *
  59.  * The driver callbacks are mostly compatible with the atomic modeset helpers,
  60.  * except for the handling of the primary plane: Atomic helpers require that the
  61.  * primary plane is implemented as a real standalone plane and not directly tied
  62.  * to the CRTC state. For easier transition this library provides functions to
  63.  * implement the old semantics required by the CRTC helpers using the new plane
  64.  * and atomic helper callbacks.
  65.  *
  66.  * Drivers are strongly urged to convert to the atomic helpers (by way of first
  67.  * converting to the plane helpers). New drivers must not use these functions
  68.  * but need to implement the atomic interface instead, potentially using the
  69.  * atomic helpers for that.
  70.  *
  71.  * These legacy modeset helpers use the same function table structures as
  72.  * all other modesetting helpers. See the documentation for struct
  73.  * &drm_crtc_helper_funcs, struct &drm_encoder_helper_funcs and struct
  74.  * &drm_connector_helper_funcs.
  75.  */
  76. MODULE_AUTHOR("David Airlie, Jesse Barnes");
  77. MODULE_DESCRIPTION("DRM KMS helper");
  78. MODULE_LICENSE("GPL and additional rights");
  79.  
  80. /**
  81.  * drm_helper_move_panel_connectors_to_head() - move panels to the front in the
  82.  *                                              connector list
  83.  * @dev: drm device to operate on
  84.  *
  85.  * Some userspace presumes that the first connected connector is the main
  86.  * display, where it's supposed to display e.g. the login screen. For
  87.  * laptops, this should be the main panel. Use this function to sort all
  88.  * (eDP/LVDS) panels to the front of the connector list, instead of
  89.  * painstakingly trying to initialize them in the right order.
  90.  */
  91. void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
  92. {
  93.         struct drm_connector *connector, *tmp;
  94.         struct list_head panel_list;
  95.  
  96.         INIT_LIST_HEAD(&panel_list);
  97.  
  98.         list_for_each_entry_safe(connector, tmp,
  99.                                  &dev->mode_config.connector_list, head) {
  100.                 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
  101.                     connector->connector_type == DRM_MODE_CONNECTOR_eDP)
  102.                         list_move_tail(&connector->head, &panel_list);
  103.         }
  104.  
  105.         list_splice(&panel_list, &dev->mode_config.connector_list);
  106. }
  107. EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
  108.  
  109. /**
  110.  * drm_helper_encoder_in_use - check if a given encoder is in use
  111.  * @encoder: encoder to check
  112.  *
  113.  * Checks whether @encoder is with the current mode setting output configuration
  114.  * in use by any connector. This doesn't mean that it is actually enabled since
  115.  * the DPMS state is tracked separately.
  116.  *
  117.  * Returns:
  118.  * True if @encoder is used, false otherwise.
  119.  */
  120. bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
  121. {
  122.         struct drm_connector *connector;
  123.         struct drm_device *dev = encoder->dev;
  124.  
  125.         /*
  126.          * We can expect this mutex to be locked if we are not panicking.
  127.          * Locking is currently fubar in the panic handler.
  128.          */
  129.         if (!oops_in_progress) {
  130.                 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
  131.                 WARN_ON(!drm_modeset_is_locked(&dev->mode_config.connection_mutex));
  132.         }
  133.  
  134.         drm_for_each_connector(connector, dev)
  135.                 if (connector->encoder == encoder)
  136.                         return true;
  137.         return false;
  138. }
  139. EXPORT_SYMBOL(drm_helper_encoder_in_use);
  140.  
  141. /**
  142.  * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
  143.  * @crtc: CRTC to check
  144.  *
  145.  * Checks whether @crtc is with the current mode setting output configuration
  146.  * in use by any connector. This doesn't mean that it is actually enabled since
  147.  * the DPMS state is tracked separately.
  148.  *
  149.  * Returns:
  150.  * True if @crtc is used, false otherwise.
  151.  */
  152. bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
  153. {
  154.         struct drm_encoder *encoder;
  155.         struct drm_device *dev = crtc->dev;
  156.  
  157.         /*
  158.          * We can expect this mutex to be locked if we are not panicking.
  159.          * Locking is currently fubar in the panic handler.
  160.          */
  161.         if (!oops_in_progress)
  162.                 WARN_ON(!mutex_is_locked(&dev->mode_config.mutex));
  163.  
  164.         drm_for_each_encoder(encoder, dev)
  165.                 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
  166.                         return true;
  167.         return false;
  168. }
  169. EXPORT_SYMBOL(drm_helper_crtc_in_use);
  170.  
  171. static void
  172. drm_encoder_disable(struct drm_encoder *encoder)
  173. {
  174.         const struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  175.  
  176.         drm_bridge_disable(encoder->bridge);
  177.  
  178.         if (encoder_funcs->disable)
  179.                 (*encoder_funcs->disable)(encoder);
  180.         else
  181.                 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
  182.  
  183.         drm_bridge_post_disable(encoder->bridge);
  184. }
  185.  
  186. static void __drm_helper_disable_unused_functions(struct drm_device *dev)
  187. {
  188.         struct drm_encoder *encoder;
  189.         struct drm_crtc *crtc;
  190.  
  191.         drm_warn_on_modeset_not_all_locked(dev);
  192.  
  193.         drm_for_each_encoder(encoder, dev) {
  194.                 if (!drm_helper_encoder_in_use(encoder)) {
  195.                         drm_encoder_disable(encoder);
  196.                         /* disconnect encoder from any connector */
  197.                         encoder->crtc = NULL;
  198.                 }
  199.         }
  200.  
  201.         drm_for_each_crtc(crtc, dev) {
  202.                 const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  203.                 crtc->enabled = drm_helper_crtc_in_use(crtc);
  204.                 if (!crtc->enabled) {
  205.                         if (crtc_funcs->disable)
  206.                                 (*crtc_funcs->disable)(crtc);
  207.                         else
  208.                                 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
  209.                         crtc->primary->fb = NULL;
  210.                 }
  211.         }
  212. }
  213.  
  214. /**
  215.  * drm_helper_disable_unused_functions - disable unused objects
  216.  * @dev: DRM device
  217.  *
  218.  * This function walks through the entire mode setting configuration of @dev. It
  219.  * will remove any CRTC links of unused encoders and encoder links of
  220.  * disconnected connectors. Then it will disable all unused encoders and CRTCs
  221.  * either by calling their disable callback if available or by calling their
  222.  * dpms callback with DRM_MODE_DPMS_OFF.
  223.  */
  224. void drm_helper_disable_unused_functions(struct drm_device *dev)
  225. {
  226.         drm_modeset_lock_all(dev);
  227.         __drm_helper_disable_unused_functions(dev);
  228.         drm_modeset_unlock_all(dev);
  229. }
  230. EXPORT_SYMBOL(drm_helper_disable_unused_functions);
  231.  
  232. /*
  233.  * Check the CRTC we're going to map each output to vs. its current
  234.  * CRTC.  If they don't match, we have to disable the output and the CRTC
  235.  * since the driver will have to re-route things.
  236.  */
  237. static void
  238. drm_crtc_prepare_encoders(struct drm_device *dev)
  239. {
  240.         const struct drm_encoder_helper_funcs *encoder_funcs;
  241.         struct drm_encoder *encoder;
  242.  
  243.         drm_for_each_encoder(encoder, dev) {
  244.                 encoder_funcs = encoder->helper_private;
  245.                 /* Disable unused encoders */
  246.                 if (encoder->crtc == NULL)
  247.                         drm_encoder_disable(encoder);
  248.                 /* Disable encoders whose CRTC is about to change */
  249.                 if (encoder_funcs->get_crtc &&
  250.                     encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
  251.                         drm_encoder_disable(encoder);
  252.         }
  253. }
  254.  
  255. /**
  256.  * drm_crtc_helper_set_mode - internal helper to set a mode
  257.  * @crtc: CRTC to program
  258.  * @mode: mode to use
  259.  * @x: horizontal offset into the surface
  260.  * @y: vertical offset into the surface
  261.  * @old_fb: old framebuffer, for cleanup
  262.  *
  263.  * Try to set @mode on @crtc.  Give @crtc and its associated connectors a chance
  264.  * to fixup or reject the mode prior to trying to set it. This is an internal
  265.  * helper that drivers could e.g. use to update properties that require the
  266.  * entire output pipe to be disabled and re-enabled in a new configuration. For
  267.  * example for changing whether audio is enabled on a hdmi link or for changing
  268.  * panel fitter or dither attributes. It is also called by the
  269.  * drm_crtc_helper_set_config() helper function to drive the mode setting
  270.  * sequence.
  271.  *
  272.  * Returns:
  273.  * True if the mode was set successfully, false otherwise.
  274.  */
  275. bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
  276.                               struct drm_display_mode *mode,
  277.                               int x, int y,
  278.                               struct drm_framebuffer *old_fb)
  279. {
  280.         struct drm_device *dev = crtc->dev;
  281.         struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
  282.         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  283.         const struct drm_encoder_helper_funcs *encoder_funcs;
  284.         int saved_x, saved_y;
  285.         bool saved_enabled;
  286.         struct drm_encoder *encoder;
  287.         bool ret = true;
  288.  
  289.         drm_warn_on_modeset_not_all_locked(dev);
  290.  
  291.         saved_enabled = crtc->enabled;
  292.         crtc->enabled = drm_helper_crtc_in_use(crtc);
  293.         if (!crtc->enabled)
  294.                 return true;
  295.  
  296.         adjusted_mode = drm_mode_duplicate(dev, mode);
  297.         if (!adjusted_mode) {
  298.                 crtc->enabled = saved_enabled;
  299.                 return false;
  300.         }
  301.  
  302.         saved_mode = crtc->mode;
  303.         saved_hwmode = crtc->hwmode;
  304.         saved_x = crtc->x;
  305.         saved_y = crtc->y;
  306.  
  307.         /* Update crtc values up front so the driver can rely on them for mode
  308.          * setting.
  309.          */
  310.         crtc->mode = *mode;
  311.         crtc->x = x;
  312.         crtc->y = y;
  313.  
  314.         /* Pass our mode to the connectors and the CRTC to give them a chance to
  315.          * adjust it according to limitations or connector properties, and also
  316.          * a chance to reject the mode entirely.
  317.          */
  318.         drm_for_each_encoder(encoder, dev) {
  319.  
  320.                 if (encoder->crtc != crtc)
  321.                         continue;
  322.  
  323.                 ret = drm_bridge_mode_fixup(encoder->bridge,
  324.                         mode, adjusted_mode);
  325.                 if (!ret) {
  326.                         DRM_DEBUG_KMS("Bridge fixup failed\n");
  327.                         goto done;
  328.                 }
  329.  
  330.                 encoder_funcs = encoder->helper_private;
  331.                 if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
  332.                                                       adjusted_mode))) {
  333.                         DRM_DEBUG_KMS("Encoder fixup failed\n");
  334.                         goto done;
  335.                 }
  336.         }
  337.  
  338.         if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
  339.                 DRM_DEBUG_KMS("CRTC fixup failed\n");
  340.                 goto done;
  341.         }
  342.         DRM_DEBUG_KMS("[CRTC:%d:%s]\n", crtc->base.id, crtc->name);
  343.  
  344.         crtc->hwmode = *adjusted_mode;
  345.  
  346.         /* Prepare the encoders and CRTCs before setting the mode. */
  347.         drm_for_each_encoder(encoder, dev) {
  348.  
  349.                 if (encoder->crtc != crtc)
  350.                         continue;
  351.  
  352.                 drm_bridge_disable(encoder->bridge);
  353.  
  354.                 encoder_funcs = encoder->helper_private;
  355.                 /* Disable the encoders as the first thing we do. */
  356.                 encoder_funcs->prepare(encoder);
  357.  
  358.                 drm_bridge_post_disable(encoder->bridge);
  359.         }
  360.  
  361.         drm_crtc_prepare_encoders(dev);
  362.  
  363.         crtc_funcs->prepare(crtc);
  364.  
  365.         /* Set up the DPLL and any encoders state that needs to adjust or depend
  366.          * on the DPLL.
  367.          */
  368.         ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
  369.         if (!ret)
  370.             goto done;
  371.  
  372.         drm_for_each_encoder(encoder, dev) {
  373.  
  374.                 if (encoder->crtc != crtc)
  375.                         continue;
  376.  
  377.                 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
  378.                         encoder->base.id, encoder->name,
  379.                         mode->base.id, mode->name);
  380.                 encoder_funcs = encoder->helper_private;
  381.                 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
  382.  
  383.                 drm_bridge_mode_set(encoder->bridge, mode, adjusted_mode);
  384.         }
  385.  
  386.         /* Now enable the clocks, plane, pipe, and connectors that we set up. */
  387.         crtc_funcs->commit(crtc);
  388.  
  389.         drm_for_each_encoder(encoder, dev) {
  390.  
  391.                 if (encoder->crtc != crtc)
  392.                         continue;
  393.  
  394.                 drm_bridge_pre_enable(encoder->bridge);
  395.  
  396.                 encoder_funcs = encoder->helper_private;
  397.                 encoder_funcs->commit(encoder);
  398.  
  399.                 drm_bridge_enable(encoder->bridge);
  400.         }
  401.  
  402.         /* Calculate and store various constants which
  403.          * are later needed by vblank and swap-completion
  404.          * timestamping. They are derived from true hwmode.
  405.          */
  406.         drm_calc_timestamping_constants(crtc, &crtc->hwmode);
  407.  
  408.         /* FIXME: add subpixel order */
  409. done:
  410.         drm_mode_destroy(dev, adjusted_mode);
  411.         if (!ret) {
  412.                 crtc->enabled = saved_enabled;
  413.                 crtc->mode = saved_mode;
  414.                 crtc->hwmode = saved_hwmode;
  415.                 crtc->x = saved_x;
  416.                 crtc->y = saved_y;
  417.         }
  418.  
  419.         return ret;
  420. }
  421. EXPORT_SYMBOL(drm_crtc_helper_set_mode);
  422.  
  423. static void
  424. drm_crtc_helper_disable(struct drm_crtc *crtc)
  425. {
  426.         struct drm_device *dev = crtc->dev;
  427.         struct drm_connector *connector;
  428.         struct drm_encoder *encoder;
  429.  
  430.         /* Decouple all encoders and their attached connectors from this crtc */
  431.         drm_for_each_encoder(encoder, dev) {
  432.                 if (encoder->crtc != crtc)
  433.                         continue;
  434.  
  435.                 drm_for_each_connector(connector, dev) {
  436.                         if (connector->encoder != encoder)
  437.                                 continue;
  438.  
  439.                         connector->encoder = NULL;
  440.  
  441.                         /*
  442.                          * drm_helper_disable_unused_functions() ought to be
  443.                          * doing this, but since we've decoupled the encoder
  444.                          * from the connector above, the required connection
  445.                          * between them is henceforth no longer available.
  446.                          */
  447.                         connector->dpms = DRM_MODE_DPMS_OFF;
  448.                 }
  449.         }
  450.  
  451.         __drm_helper_disable_unused_functions(dev);
  452. }
  453.  
  454. /**
  455.  * drm_crtc_helper_set_config - set a new config from userspace
  456.  * @set: mode set configuration
  457.  *
  458.  * The drm_crtc_helper_set_config() helper function implements the set_config
  459.  * callback of struct &drm_crtc_funcs for drivers using the legacy CRTC helpers.
  460.  *
  461.  * It first tries to locate the best encoder for each connector by calling the
  462.  * connector ->best_encoder() (struct &drm_connector_helper_funcs) helper
  463.  * operation.
  464.  *
  465.  * After locating the appropriate encoders, the helper function will call the
  466.  * mode_fixup encoder and CRTC helper operations to adjust the requested mode,
  467.  * or reject it completely in which case an error will be returned to the
  468.  * application. If the new configuration after mode adjustment is identical to
  469.  * the current configuration the helper function will return without performing
  470.  * any other operation.
  471.  *
  472.  * If the adjusted mode is identical to the current mode but changes to the
  473.  * frame buffer need to be applied, the drm_crtc_helper_set_config() function
  474.  * will call the CRTC ->mode_set_base() (struct &drm_crtc_helper_funcs) helper
  475.  * operation.
  476.  *
  477.  * If the adjusted mode differs from the current mode, or if the
  478.  * ->mode_set_base() helper operation is not provided, the helper function
  479.  * performs a full mode set sequence by calling the ->prepare(), ->mode_set()
  480.  * and ->commit() CRTC and encoder helper operations, in that order.
  481.  * Alternatively it can also use the dpms and disable helper operations. For
  482.  * details see struct &drm_crtc_helper_funcs and struct
  483.  * &drm_encoder_helper_funcs.
  484.  *
  485.  * This function is deprecated.  New drivers must implement atomic modeset
  486.  * support, for which this function is unsuitable. Instead drivers should use
  487.  * drm_atomic_helper_set_config().
  488.  *
  489.  * Returns:
  490.  * Returns 0 on success, negative errno numbers on failure.
  491.  */
  492. int drm_crtc_helper_set_config(struct drm_mode_set *set)
  493. {
  494.         struct drm_device *dev;
  495.         struct drm_crtc *new_crtc;
  496.         struct drm_encoder *save_encoders, *new_encoder, *encoder;
  497.         bool mode_changed = false; /* if true do a full mode set */
  498.         bool fb_changed = false; /* if true and !mode_changed just do a flip */
  499.         struct drm_connector *save_connectors, *connector;
  500.         int count = 0, ro, fail = 0;
  501.         const struct drm_crtc_helper_funcs *crtc_funcs;
  502.         struct drm_mode_set save_set;
  503.         int ret;
  504.         int i;
  505.  
  506.         DRM_DEBUG_KMS("\n");
  507.  
  508.         BUG_ON(!set);
  509.         BUG_ON(!set->crtc);
  510.         BUG_ON(!set->crtc->helper_private);
  511.  
  512.         /* Enforce sane interface api - has been abused by the fb helper. */
  513.         BUG_ON(!set->mode && set->fb);
  514.         BUG_ON(set->fb && set->num_connectors == 0);
  515.  
  516.         crtc_funcs = set->crtc->helper_private;
  517.  
  518.         if (!set->mode)
  519.                 set->fb = NULL;
  520.  
  521.         if (set->fb) {
  522.                 DRM_DEBUG_KMS("[CRTC:%d:%s] [FB:%d] #connectors=%d (x y) (%i %i)\n",
  523.                               set->crtc->base.id, set->crtc->name,
  524.                               set->fb->base.id,
  525.                                 (int)set->num_connectors, set->x, set->y);
  526.         } else {
  527.                 DRM_DEBUG_KMS("[CRTC:%d:%s] [NOFB]\n",
  528.                               set->crtc->base.id, set->crtc->name);
  529.                 drm_crtc_helper_disable(set->crtc);
  530.                 return 0;
  531.         }
  532.  
  533.         dev = set->crtc->dev;
  534.  
  535.         drm_warn_on_modeset_not_all_locked(dev);
  536.  
  537.         /*
  538.          * Allocate space for the backup of all (non-pointer) encoder and
  539.          * connector data.
  540.          */
  541.         save_encoders = kzalloc(dev->mode_config.num_encoder *
  542.                                 sizeof(struct drm_encoder), GFP_KERNEL);
  543.         if (!save_encoders)
  544.                 return -ENOMEM;
  545.  
  546.         save_connectors = kzalloc(dev->mode_config.num_connector *
  547.                                 sizeof(struct drm_connector), GFP_KERNEL);
  548.         if (!save_connectors) {
  549.                 kfree(save_encoders);
  550.                 return -ENOMEM;
  551.         }
  552.  
  553.         /*
  554.          * Copy data. Note that driver private data is not affected.
  555.          * Should anything bad happen only the expected state is
  556.          * restored, not the drivers personal bookkeeping.
  557.          */
  558.         count = 0;
  559.         drm_for_each_encoder(encoder, dev) {
  560.                 save_encoders[count++] = *encoder;
  561.         }
  562.  
  563.         count = 0;
  564.         drm_for_each_connector(connector, dev) {
  565.                 save_connectors[count++] = *connector;
  566.         }
  567.  
  568.         save_set.crtc = set->crtc;
  569.         save_set.mode = &set->crtc->mode;
  570.         save_set.x = set->crtc->x;
  571.         save_set.y = set->crtc->y;
  572.         save_set.fb = set->crtc->primary->fb;
  573.  
  574.         /* We should be able to check here if the fb has the same properties
  575.          * and then just flip_or_move it */
  576.         if (set->crtc->primary->fb != set->fb) {
  577.                 /* If we have no fb then treat it as a full mode set */
  578.                 if (set->crtc->primary->fb == NULL) {
  579.                         DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
  580.                         mode_changed = true;
  581.                 } else if (set->fb == NULL) {
  582.                         mode_changed = true;
  583.                 } else if (set->fb->pixel_format !=
  584.                            set->crtc->primary->fb->pixel_format) {
  585.                         mode_changed = true;
  586.                 } else
  587.                         fb_changed = true;
  588.         }
  589.  
  590.         if (set->x != set->crtc->x || set->y != set->crtc->y)
  591.                 fb_changed = true;
  592.  
  593.         if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
  594.                 DRM_DEBUG_KMS("modes are different, full mode set\n");
  595.                 drm_mode_debug_printmodeline(&set->crtc->mode);
  596.                 drm_mode_debug_printmodeline(set->mode);
  597.                 mode_changed = true;
  598.         }
  599.  
  600.         /* a) traverse passed in connector list and get encoders for them */
  601.         count = 0;
  602.         drm_for_each_connector(connector, dev) {
  603.                 const struct drm_connector_helper_funcs *connector_funcs =
  604.                         connector->helper_private;
  605.                 new_encoder = connector->encoder;
  606.                 for (ro = 0; ro < set->num_connectors; ro++) {
  607.                         if (set->connectors[ro] == connector) {
  608.                                 new_encoder = connector_funcs->best_encoder(connector);
  609.                                 /* if we can't get an encoder for a connector
  610.                                    we are setting now - then fail */
  611.                                 if (new_encoder == NULL)
  612.                                         /* don't break so fail path works correct */
  613.                                         fail = 1;
  614.  
  615.                                 if (connector->dpms != DRM_MODE_DPMS_ON) {
  616.                                         DRM_DEBUG_KMS("connector dpms not on, full mode switch\n");
  617.                                         mode_changed = true;
  618.                                 }
  619.  
  620.                                 break;
  621.                         }
  622.                 }
  623.  
  624.                 if (new_encoder != connector->encoder) {
  625.                         DRM_DEBUG_KMS("encoder changed, full mode switch\n");
  626.                         mode_changed = true;
  627.                         /* If the encoder is reused for another connector, then
  628.                          * the appropriate crtc will be set later.
  629.                          */
  630.                         if (connector->encoder)
  631.                                 connector->encoder->crtc = NULL;
  632.                         connector->encoder = new_encoder;
  633.                 }
  634.         }
  635.  
  636.         if (fail) {
  637.                 ret = -EINVAL;
  638.                 goto fail;
  639.         }
  640.  
  641.         count = 0;
  642.         drm_for_each_connector(connector, dev) {
  643.                 if (!connector->encoder)
  644.                         continue;
  645.  
  646.                 if (connector->encoder->crtc == set->crtc)
  647.                         new_crtc = NULL;
  648.                 else
  649.                         new_crtc = connector->encoder->crtc;
  650.  
  651.                 for (ro = 0; ro < set->num_connectors; ro++) {
  652.                         if (set->connectors[ro] == connector)
  653.                                 new_crtc = set->crtc;
  654.                 }
  655.  
  656.                 /* Make sure the new CRTC will work with the encoder */
  657.                 if (new_crtc &&
  658.                     !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
  659.                         ret = -EINVAL;
  660.                         goto fail;
  661.                 }
  662.                 if (new_crtc != connector->encoder->crtc) {
  663.                         DRM_DEBUG_KMS("crtc changed, full mode switch\n");
  664.                         mode_changed = true;
  665.                         connector->encoder->crtc = new_crtc;
  666.                 }
  667.                 if (new_crtc) {
  668.                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d:%s]\n",
  669.                                 connector->base.id, connector->name,
  670.                                       new_crtc->base.id, new_crtc->name);
  671.                 } else {
  672.                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
  673.                                 connector->base.id, connector->name);
  674.                 }
  675.         }
  676.  
  677.         /* mode_set_base is not a required function */
  678.         if (fb_changed && !crtc_funcs->mode_set_base)
  679.                 mode_changed = true;
  680.  
  681.         if (mode_changed) {
  682.                 if (drm_helper_crtc_in_use(set->crtc)) {
  683.                         DRM_DEBUG_KMS("attempting to set mode from"
  684.                                         " userspace\n");
  685.                         drm_mode_debug_printmodeline(set->mode);
  686.                         set->crtc->primary->fb = set->fb;
  687.                         if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
  688.                                                       set->x, set->y,
  689.                                                       save_set.fb)) {
  690.                                 DRM_ERROR("failed to set mode on [CRTC:%d:%s]\n",
  691.                                           set->crtc->base.id, set->crtc->name);
  692.                                 set->crtc->primary->fb = save_set.fb;
  693.                                 ret = -EINVAL;
  694.                                 goto fail;
  695.                         }
  696.                         DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
  697.                         for (i = 0; i < set->num_connectors; i++) {
  698.                                 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
  699.                                               set->connectors[i]->name);
  700.                                 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
  701.                         }
  702.                 }
  703.                 __drm_helper_disable_unused_functions(dev);
  704.         } else if (fb_changed) {
  705.                 set->crtc->x = set->x;
  706.                 set->crtc->y = set->y;
  707.                 set->crtc->primary->fb = set->fb;
  708.                 ret = crtc_funcs->mode_set_base(set->crtc,
  709.                                                 set->x, set->y, save_set.fb);
  710.                 if (ret != 0) {
  711.                         set->crtc->x = save_set.x;
  712.                         set->crtc->y = save_set.y;
  713.                         set->crtc->primary->fb = save_set.fb;
  714.                         goto fail;
  715.                 }
  716.         }
  717.  
  718.         kfree(save_connectors);
  719.         kfree(save_encoders);
  720.         return 0;
  721.  
  722. fail:
  723.         /* Restore all previous data. */
  724.         count = 0;
  725.         drm_for_each_encoder(encoder, dev) {
  726.                 *encoder = save_encoders[count++];
  727.         }
  728.  
  729.         count = 0;
  730.         drm_for_each_connector(connector, dev) {
  731.                 *connector = save_connectors[count++];
  732.         }
  733.  
  734.         /* Try to restore the config */
  735.         if (mode_changed &&
  736.             !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
  737.                                       save_set.y, save_set.fb))
  738.                 DRM_ERROR("failed to restore config after modeset failure\n");
  739.  
  740.         kfree(save_connectors);
  741.         kfree(save_encoders);
  742.         return ret;
  743. }
  744. EXPORT_SYMBOL(drm_crtc_helper_set_config);
  745.  
  746. static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
  747. {
  748.         int dpms = DRM_MODE_DPMS_OFF;
  749.         struct drm_connector *connector;
  750.         struct drm_device *dev = encoder->dev;
  751.  
  752.         drm_for_each_connector(connector, dev)
  753.                 if (connector->encoder == encoder)
  754.                         if (connector->dpms < dpms)
  755.                                 dpms = connector->dpms;
  756.         return dpms;
  757. }
  758.  
  759. /* Helper which handles bridge ordering around encoder dpms */
  760. static void drm_helper_encoder_dpms(struct drm_encoder *encoder, int mode)
  761. {
  762.         struct drm_bridge *bridge = encoder->bridge;
  763.         const struct drm_encoder_helper_funcs *encoder_funcs;
  764.  
  765.         if (mode == DRM_MODE_DPMS_ON)
  766.                 drm_bridge_pre_enable(bridge);
  767.         else
  768.                 drm_bridge_disable(bridge);
  769.  
  770.         encoder_funcs = encoder->helper_private;
  771.         if (encoder_funcs->dpms)
  772.                 encoder_funcs->dpms(encoder, mode);
  773.  
  774.         if (mode == DRM_MODE_DPMS_ON)
  775.                 drm_bridge_enable(bridge);
  776.         else
  777.                 drm_bridge_post_disable(bridge);
  778. }
  779.  
  780. static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
  781. {
  782.         int dpms = DRM_MODE_DPMS_OFF;
  783.         struct drm_connector *connector;
  784.         struct drm_device *dev = crtc->dev;
  785.  
  786.         drm_for_each_connector(connector, dev)
  787.                 if (connector->encoder && connector->encoder->crtc == crtc)
  788.                         if (connector->dpms < dpms)
  789.                                 dpms = connector->dpms;
  790.         return dpms;
  791. }
  792.  
  793. /**
  794.  * drm_helper_connector_dpms() - connector dpms helper implementation
  795.  * @connector: affected connector
  796.  * @mode: DPMS mode
  797.  *
  798.  * The drm_helper_connector_dpms() helper function implements the ->dpms()
  799.  * callback of struct &drm_connector_funcs for drivers using the legacy CRTC helpers.
  800.  *
  801.  * This is the main helper function provided by the CRTC helper framework for
  802.  * implementing the DPMS connector attribute. It computes the new desired DPMS
  803.  * state for all encoders and CRTCs in the output mesh and calls the ->dpms()
  804.  * callbacks provided by the driver in struct &drm_crtc_helper_funcs and struct
  805.  * &drm_encoder_helper_funcs appropriately.
  806.  *
  807.  * This function is deprecated.  New drivers must implement atomic modeset
  808.  * support, for which this function is unsuitable. Instead drivers should use
  809.  * drm_atomic_helper_connector_dpms().
  810.  *
  811.  * Returns:
  812.  * Always returns 0.
  813.  */
  814. int drm_helper_connector_dpms(struct drm_connector *connector, int mode)
  815. {
  816.         struct drm_encoder *encoder = connector->encoder;
  817.         struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
  818.         int old_dpms, encoder_dpms = DRM_MODE_DPMS_OFF;
  819.  
  820.         if (mode == connector->dpms)
  821.                 return 0;
  822.  
  823.         old_dpms = connector->dpms;
  824.         connector->dpms = mode;
  825.  
  826.         if (encoder)
  827.                 encoder_dpms = drm_helper_choose_encoder_dpms(encoder);
  828.  
  829.         /* from off to on, do crtc then encoder */
  830.         if (mode < old_dpms) {
  831.                 if (crtc) {
  832.                         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  833.                         if (crtc_funcs->dpms)
  834.                                 (*crtc_funcs->dpms) (crtc,
  835.                                                      drm_helper_choose_crtc_dpms(crtc));
  836.                 }
  837.                 if (encoder)
  838.                         drm_helper_encoder_dpms(encoder, encoder_dpms);
  839.         }
  840.  
  841.         /* from on to off, do encoder then crtc */
  842.         if (mode > old_dpms) {
  843.                 if (encoder)
  844.                         drm_helper_encoder_dpms(encoder, encoder_dpms);
  845.                 if (crtc) {
  846.                         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  847.                         if (crtc_funcs->dpms)
  848.                                 (*crtc_funcs->dpms) (crtc,
  849.                                                      drm_helper_choose_crtc_dpms(crtc));
  850.                 }
  851.         }
  852.  
  853.         return 0;
  854. }
  855. EXPORT_SYMBOL(drm_helper_connector_dpms);
  856.  
  857. /**
  858.  * drm_helper_mode_fill_fb_struct - fill out framebuffer metadata
  859.  * @fb: drm_framebuffer object to fill out
  860.  * @mode_cmd: metadata from the userspace fb creation request
  861.  *
  862.  * This helper can be used in a drivers fb_create callback to pre-fill the fb's
  863.  * metadata fields.
  864.  */
  865. void drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
  866.                                     const struct drm_mode_fb_cmd2 *mode_cmd)
  867. {
  868.         int i;
  869.  
  870.         fb->width = mode_cmd->width;
  871.         fb->height = mode_cmd->height;
  872.         for (i = 0; i < 4; i++) {
  873.                 fb->pitches[i] = mode_cmd->pitches[i];
  874.                 fb->offsets[i] = mode_cmd->offsets[i];
  875.                 fb->modifier[i] = mode_cmd->modifier[i];
  876.         }
  877.         drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
  878.                                     &fb->bits_per_pixel);
  879.         fb->pixel_format = mode_cmd->pixel_format;
  880.         fb->flags = mode_cmd->flags;
  881. }
  882. EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
  883.  
  884. /**
  885.  * drm_helper_resume_force_mode - force-restore mode setting configuration
  886.  * @dev: drm_device which should be restored
  887.  *
  888.  * Drivers which use the mode setting helpers can use this function to
  889.  * force-restore the mode setting configuration e.g. on resume or when something
  890.  * else might have trampled over the hw state (like some overzealous old BIOSen
  891.  * tended to do).
  892.  *
  893.  * This helper doesn't provide a error return value since restoring the old
  894.  * config should never fail due to resource allocation issues since the driver
  895.  * has successfully set the restored configuration already. Hence this should
  896.  * boil down to the equivalent of a few dpms on calls, which also don't provide
  897.  * an error code.
  898.  *
  899.  * Drivers where simply restoring an old configuration again might fail (e.g.
  900.  * due to slight differences in allocating shared resources when the
  901.  * configuration is restored in a different order than when userspace set it up)
  902.  * need to use their own restore logic.
  903.  *
  904.  * This function is deprecated. New drivers should implement atomic mode-
  905.  * setting and use the atomic suspend/resume helpers.
  906.  *
  907.  * See also:
  908.  * drm_atomic_helper_suspend(), drm_atomic_helper_resume()
  909.  */
  910. void drm_helper_resume_force_mode(struct drm_device *dev)
  911. {
  912.         struct drm_crtc *crtc;
  913.         struct drm_encoder *encoder;
  914.         const struct drm_crtc_helper_funcs *crtc_funcs;
  915.         int encoder_dpms;
  916.         bool ret;
  917.  
  918.         drm_modeset_lock_all(dev);
  919.         drm_for_each_crtc(crtc, dev) {
  920.  
  921.                 if (!crtc->enabled)
  922.                         continue;
  923.  
  924.                 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
  925.                                                crtc->x, crtc->y, crtc->primary->fb);
  926.  
  927.                 /* Restoring the old config should never fail! */
  928.                 if (ret == false)
  929.                         DRM_ERROR("failed to set mode on crtc %p\n", crtc);
  930.  
  931.                 /* Turn off outputs that were already powered off */
  932.                 if (drm_helper_choose_crtc_dpms(crtc)) {
  933.                         drm_for_each_encoder(encoder, dev) {
  934.  
  935.                                 if(encoder->crtc != crtc)
  936.                                         continue;
  937.  
  938.                                 encoder_dpms = drm_helper_choose_encoder_dpms(
  939.                                                         encoder);
  940.  
  941.                                 drm_helper_encoder_dpms(encoder, encoder_dpms);
  942.                         }
  943.  
  944.                         crtc_funcs = crtc->helper_private;
  945.                         if (crtc_funcs->dpms)
  946.                                 (*crtc_funcs->dpms) (crtc,
  947.                                                      drm_helper_choose_crtc_dpms(crtc));
  948.                 }
  949.         }
  950.  
  951.         /* disable the unused connectors while restoring the modesetting */
  952.         __drm_helper_disable_unused_functions(dev);
  953.         drm_modeset_unlock_all(dev);
  954. }
  955. EXPORT_SYMBOL(drm_helper_resume_force_mode);
  956.  
  957. /**
  958.  * drm_helper_crtc_mode_set - mode_set implementation for atomic plane helpers
  959.  * @crtc: DRM CRTC
  960.  * @mode: DRM display mode which userspace requested
  961.  * @adjusted_mode: DRM display mode adjusted by ->mode_fixup callbacks
  962.  * @x: x offset of the CRTC scanout area on the underlying framebuffer
  963.  * @y: y offset of the CRTC scanout area on the underlying framebuffer
  964.  * @old_fb: previous framebuffer
  965.  *
  966.  * This function implements a callback useable as the ->mode_set callback
  967.  * required by the CRTC helpers. Besides the atomic plane helper functions for
  968.  * the primary plane the driver must also provide the ->mode_set_nofb callback
  969.  * to set up the CRTC.
  970.  *
  971.  * This is a transitional helper useful for converting drivers to the atomic
  972.  * interfaces.
  973.  */
  974. int drm_helper_crtc_mode_set(struct drm_crtc *crtc, struct drm_display_mode *mode,
  975.                              struct drm_display_mode *adjusted_mode, int x, int y,
  976.                              struct drm_framebuffer *old_fb)
  977. {
  978.         struct drm_crtc_state *crtc_state;
  979.         const struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  980.         int ret;
  981.  
  982.         if (crtc->funcs->atomic_duplicate_state)
  983.                 crtc_state = crtc->funcs->atomic_duplicate_state(crtc);
  984.         else {
  985.                 if (!crtc->state)
  986.                         drm_atomic_helper_crtc_reset(crtc);
  987.  
  988.                 crtc_state = drm_atomic_helper_crtc_duplicate_state(crtc);
  989.         }
  990.  
  991.         if (!crtc_state)
  992.                 return -ENOMEM;
  993.  
  994.         crtc_state->planes_changed = true;
  995.         crtc_state->mode_changed = true;
  996.         ret = drm_atomic_set_mode_for_crtc(crtc_state, mode);
  997.         if (ret)
  998.                 goto out;
  999.         drm_mode_copy(&crtc_state->adjusted_mode, adjusted_mode);
  1000.  
  1001.         if (crtc_funcs->atomic_check) {
  1002.                 ret = crtc_funcs->atomic_check(crtc, crtc_state);
  1003.                 if (ret)
  1004.                         goto out;
  1005.         }
  1006.  
  1007.         swap(crtc->state, crtc_state);
  1008.  
  1009.         crtc_funcs->mode_set_nofb(crtc);
  1010.  
  1011.         ret = drm_helper_crtc_mode_set_base(crtc, x, y, old_fb);
  1012.  
  1013. out:
  1014.         if (crtc_state) {
  1015.                 if (crtc->funcs->atomic_destroy_state)
  1016.                         crtc->funcs->atomic_destroy_state(crtc, crtc_state);
  1017.                 else
  1018.                         drm_atomic_helper_crtc_destroy_state(crtc, crtc_state);
  1019.         }
  1020.  
  1021.         return ret;
  1022. }
  1023. EXPORT_SYMBOL(drm_helper_crtc_mode_set);
  1024.  
  1025. /**
  1026.  * drm_helper_crtc_mode_set_base - mode_set_base implementation for atomic plane helpers
  1027.  * @crtc: DRM CRTC
  1028.  * @x: x offset of the CRTC scanout area on the underlying framebuffer
  1029.  * @y: y offset of the CRTC scanout area on the underlying framebuffer
  1030.  * @old_fb: previous framebuffer
  1031.  *
  1032.  * This function implements a callback useable as the ->mode_set_base used
  1033.  * required by the CRTC helpers. The driver must provide the atomic plane helper
  1034.  * functions for the primary plane.
  1035.  *
  1036.  * This is a transitional helper useful for converting drivers to the atomic
  1037.  * interfaces.
  1038.  */
  1039. int drm_helper_crtc_mode_set_base(struct drm_crtc *crtc, int x, int y,
  1040.                                   struct drm_framebuffer *old_fb)
  1041. {
  1042.         struct drm_plane_state *plane_state;
  1043.         struct drm_plane *plane = crtc->primary;
  1044.  
  1045.         if (plane->funcs->atomic_duplicate_state)
  1046.                 plane_state = plane->funcs->atomic_duplicate_state(plane);
  1047.         else if (plane->state)
  1048.                 plane_state = drm_atomic_helper_plane_duplicate_state(plane);
  1049.         else
  1050.                 plane_state = kzalloc(sizeof(*plane_state), GFP_KERNEL);
  1051.         if (!plane_state)
  1052.                 return -ENOMEM;
  1053.         plane_state->plane = plane;
  1054.  
  1055.         plane_state->crtc = crtc;
  1056.         drm_atomic_set_fb_for_plane(plane_state, crtc->primary->fb);
  1057.         plane_state->crtc_x = 0;
  1058.         plane_state->crtc_y = 0;
  1059.         plane_state->crtc_h = crtc->mode.vdisplay;
  1060.         plane_state->crtc_w = crtc->mode.hdisplay;
  1061.         plane_state->src_x = x << 16;
  1062.         plane_state->src_y = y << 16;
  1063.         plane_state->src_h = crtc->mode.vdisplay << 16;
  1064.         plane_state->src_w = crtc->mode.hdisplay << 16;
  1065.  
  1066.         return drm_plane_helper_commit(plane, plane_state, old_fb);
  1067. }
  1068. EXPORT_SYMBOL(drm_helper_crtc_mode_set_base);
  1069.