Subversion Repositories Kolibri OS

Rev

Rev 3746 | Rev 4075 | 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/export.h>
  33. #include <linux/moduleparam.h>
  34.  
  35. #include <drm/drmP.h>
  36. #include <drm/drm_crtc.h>
  37. #include <drm/drm_fourcc.h>
  38. #include <drm/drm_crtc_helper.h>
  39. #include <drm/drm_fb_helper.h>
  40. #include <drm/drm_edid.h>
  41.  
  42. /**
  43.  * drm_helper_move_panel_connectors_to_head() - move panels to the front in the
  44.  *                                              connector list
  45.  * @dev: drm device to operate on
  46.  *
  47.  * Some userspace presumes that the first connected connector is the main
  48.  * display, where it's supposed to display e.g. the login screen. For
  49.  * laptops, this should be the main panel. Use this function to sort all
  50.  * (eDP/LVDS) panels to the front of the connector list, instead of
  51.  * painstakingly trying to initialize them in the right order.
  52.  */
  53. void drm_helper_move_panel_connectors_to_head(struct drm_device *dev)
  54. {
  55.         struct drm_connector *connector, *tmp;
  56.         struct list_head panel_list;
  57.  
  58.         INIT_LIST_HEAD(&panel_list);
  59.  
  60.         list_for_each_entry_safe(connector, tmp,
  61.                                  &dev->mode_config.connector_list, head) {
  62.                 if (connector->connector_type == DRM_MODE_CONNECTOR_LVDS ||
  63.                     connector->connector_type == DRM_MODE_CONNECTOR_eDP)
  64.                         list_move_tail(&connector->head, &panel_list);
  65.         }
  66.  
  67.         list_splice(&panel_list, &dev->mode_config.connector_list);
  68. }
  69. EXPORT_SYMBOL(drm_helper_move_panel_connectors_to_head);
  70.  
  71. static bool drm_kms_helper_poll = true;
  72. module_param_named(poll, drm_kms_helper_poll, bool, 0600);
  73.  
  74. static void drm_mode_validate_flag(struct drm_connector *connector,
  75.                                    int flags)
  76. {
  77.         struct drm_display_mode *mode;
  78.  
  79.         if (flags == (DRM_MODE_FLAG_DBLSCAN | DRM_MODE_FLAG_INTERLACE))
  80.                 return;
  81.  
  82.         list_for_each_entry(mode, &connector->modes, head) {
  83.                 if ((mode->flags & DRM_MODE_FLAG_INTERLACE) &&
  84.                                 !(flags & DRM_MODE_FLAG_INTERLACE))
  85.                         mode->status = MODE_NO_INTERLACE;
  86.                 if ((mode->flags & DRM_MODE_FLAG_DBLSCAN) &&
  87.                                 !(flags & DRM_MODE_FLAG_DBLSCAN))
  88.                         mode->status = MODE_NO_DBLESCAN;
  89.         }
  90.  
  91.         return;
  92. }
  93.  
  94. /**
  95.  * drm_helper_probe_single_connector_modes - get complete set of display modes
  96.  * @connector: connector to probe
  97.  * @maxX: max width for modes
  98.  * @maxY: max height for modes
  99.  *
  100.  * LOCKING:
  101.  * Caller must hold mode config lock.
  102.  *
  103.  * Based on the helper callbacks implemented by @connector try to detect all
  104.  * valid modes.  Modes will first be added to the connector's probed_modes list,
  105.  * then culled (based on validity and the @maxX, @maxY parameters) and put into
  106.  * the normal modes list.
  107.  *
  108.  * Intended to be use as a generic implementation of the ->probe() @connector
  109.  * callback for drivers that use the crtc helpers for output mode filtering and
  110.  * detection.
  111.  *
  112.  * RETURNS:
  113.  * Number of modes found on @connector.
  114.  */
  115. int drm_helper_probe_single_connector_modes(struct drm_connector *connector,
  116.                                             uint32_t maxX, uint32_t maxY)
  117. {
  118.         struct drm_device *dev = connector->dev;
  119.         struct drm_display_mode *mode;
  120.         struct drm_connector_helper_funcs *connector_funcs =
  121.                 connector->helper_private;
  122.         int count = 0;
  123.         int mode_flags = 0;
  124.         bool verbose_prune = true;
  125.  
  126.         DRM_DEBUG_KMS("[CONNECTOR:%d:%s]\n", connector->base.id,
  127.                         drm_get_connector_name(connector));
  128.         /* set all modes to the unverified state */
  129.         list_for_each_entry(mode, &connector->modes, head)
  130.                 mode->status = MODE_UNVERIFIED;
  131.  
  132.         if (connector->force) {
  133.                 if (connector->force == DRM_FORCE_ON)
  134.                         connector->status = connector_status_connected;
  135.                 else
  136.                         connector->status = connector_status_disconnected;
  137.                 if (connector->funcs->force)
  138.                         connector->funcs->force(connector);
  139.         } else {
  140.                 connector->status = connector->funcs->detect(connector, true);
  141.         }
  142.  
  143.         /* Re-enable polling in case the global poll config changed. */
  144.         if (drm_kms_helper_poll != dev->mode_config.poll_running)
  145.                 drm_kms_helper_poll_enable(dev);
  146.  
  147.         dev->mode_config.poll_running = drm_kms_helper_poll;
  148.  
  149.         if (connector->status == connector_status_disconnected) {
  150.                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] disconnected\n",
  151.                         connector->base.id, drm_get_connector_name(connector));
  152.                 drm_mode_connector_update_edid_property(connector, NULL);
  153.                 verbose_prune = false;
  154.                 goto prune;
  155.         }
  156.  
  157. #ifdef CONFIG_DRM_LOAD_EDID_FIRMWARE
  158.         count = drm_load_edid_firmware(connector);
  159.         if (count == 0)
  160. #endif
  161.         count = (*connector_funcs->get_modes)(connector);
  162.  
  163.         if (count == 0 && connector->status == connector_status_connected)
  164.                 count = drm_add_modes_noedid(connector, 1024, 768);
  165.         if (count == 0)
  166.                 goto prune;
  167.  
  168.         drm_mode_connector_list_update(connector);
  169.  
  170.         if (maxX && maxY)
  171.                 drm_mode_validate_size(dev, &connector->modes, maxX,
  172.                                        maxY, 0);
  173.  
  174.         if (connector->interlace_allowed)
  175.                 mode_flags |= DRM_MODE_FLAG_INTERLACE;
  176.         if (connector->doublescan_allowed)
  177.                 mode_flags |= DRM_MODE_FLAG_DBLSCAN;
  178.         drm_mode_validate_flag(connector, mode_flags);
  179.  
  180.         list_for_each_entry(mode, &connector->modes, head) {
  181.                 if (mode->status == MODE_OK)
  182.                         mode->status = connector_funcs->mode_valid(connector,
  183.                                                                    mode);
  184.         }
  185.  
  186. prune:
  187.         drm_mode_prune_invalid(dev, &connector->modes, verbose_prune);
  188.  
  189.         if (list_empty(&connector->modes))
  190.                 return 0;
  191.  
  192.         drm_mode_sort(&connector->modes);
  193.  
  194.         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] probed modes :\n", connector->base.id,
  195.                                 drm_get_connector_name(connector));
  196.         list_for_each_entry(mode, &connector->modes, head) {
  197.                 mode->vrefresh = drm_mode_vrefresh(mode);
  198.  
  199.                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
  200.                 drm_mode_debug_printmodeline(mode);
  201.         }
  202.  
  203.         return count;
  204. }
  205. EXPORT_SYMBOL(drm_helper_probe_single_connector_modes);
  206.  
  207. /**
  208.  * drm_helper_encoder_in_use - check if a given encoder is in use
  209.  * @encoder: encoder to check
  210.  *
  211.  * LOCKING:
  212.  * Caller must hold mode config lock.
  213.  *
  214.  * Walk @encoders's DRM device's mode_config and see if it's in use.
  215.  *
  216.  * RETURNS:
  217.  * True if @encoder is part of the mode_config, false otherwise.
  218.  */
  219. bool drm_helper_encoder_in_use(struct drm_encoder *encoder)
  220. {
  221.         struct drm_connector *connector;
  222.         struct drm_device *dev = encoder->dev;
  223.         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
  224.                 if (connector->encoder == encoder)
  225.                         return true;
  226.         return false;
  227. }
  228. EXPORT_SYMBOL(drm_helper_encoder_in_use);
  229.  
  230. /**
  231.  * drm_helper_crtc_in_use - check if a given CRTC is in a mode_config
  232.  * @crtc: CRTC to check
  233.  *
  234.  * LOCKING:
  235.  * Caller must hold mode config lock.
  236.  *
  237.  * Walk @crtc's DRM device's mode_config and see if it's in use.
  238.  *
  239.  * RETURNS:
  240.  * True if @crtc is part of the mode_config, false otherwise.
  241.  */
  242. bool drm_helper_crtc_in_use(struct drm_crtc *crtc)
  243. {
  244.         struct drm_encoder *encoder;
  245.         struct drm_device *dev = crtc->dev;
  246.         /* FIXME: Locking around list access? */
  247.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head)
  248.                 if (encoder->crtc == crtc && drm_helper_encoder_in_use(encoder))
  249.                         return true;
  250.         return false;
  251. }
  252. EXPORT_SYMBOL(drm_helper_crtc_in_use);
  253.  
  254. static void
  255. drm_encoder_disable(struct drm_encoder *encoder)
  256. {
  257.         struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  258.  
  259.         if (encoder_funcs->disable)
  260.                 (*encoder_funcs->disable)(encoder);
  261.         else
  262.                 (*encoder_funcs->dpms)(encoder, DRM_MODE_DPMS_OFF);
  263. }
  264.  
  265. /**
  266.  * drm_helper_disable_unused_functions - disable unused objects
  267.  * @dev: DRM device
  268.  *
  269.  * LOCKING:
  270.  * Caller must hold mode config lock.
  271.  *
  272.  * If an connector or CRTC isn't part of @dev's mode_config, it can be disabled
  273.  * by calling its dpms function, which should power it off.
  274.  */
  275. void drm_helper_disable_unused_functions(struct drm_device *dev)
  276. {
  277.         struct drm_encoder *encoder;
  278.         struct drm_connector *connector;
  279.         struct drm_crtc *crtc;
  280.  
  281.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  282.                 if (!connector->encoder)
  283.                         continue;
  284.                 if (connector->status == connector_status_disconnected)
  285.                         connector->encoder = NULL;
  286.         }
  287.  
  288.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  289.                 if (!drm_helper_encoder_in_use(encoder)) {
  290.                         drm_encoder_disable(encoder);
  291.                         /* disconnector encoder from any connector */
  292.                         encoder->crtc = NULL;
  293.                 }
  294.         }
  295.  
  296.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
  297.                 struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  298.                 crtc->enabled = drm_helper_crtc_in_use(crtc);
  299.                 if (!crtc->enabled) {
  300.                         if (crtc_funcs->disable)
  301.                                 (*crtc_funcs->disable)(crtc);
  302.                         else
  303.                                 (*crtc_funcs->dpms)(crtc, DRM_MODE_DPMS_OFF);
  304.                         crtc->fb = NULL;
  305.                 }
  306.         }
  307. }
  308. EXPORT_SYMBOL(drm_helper_disable_unused_functions);
  309.  
  310. /**
  311.  * drm_encoder_crtc_ok - can a given crtc drive a given encoder?
  312.  * @encoder: encoder to test
  313.  * @crtc: crtc to test
  314.  *
  315.  * Return false if @encoder can't be driven by @crtc, true otherwise.
  316.  */
  317. static bool drm_encoder_crtc_ok(struct drm_encoder *encoder,
  318.                                 struct drm_crtc *crtc)
  319. {
  320.         struct drm_device *dev;
  321.         struct drm_crtc *tmp;
  322.         int crtc_mask = 1;
  323.  
  324.         WARN(!crtc, "checking null crtc?\n");
  325.  
  326.         dev = crtc->dev;
  327.  
  328.         list_for_each_entry(tmp, &dev->mode_config.crtc_list, head) {
  329.                 if (tmp == crtc)
  330.                         break;
  331.                 crtc_mask <<= 1;
  332.         }
  333.  
  334.         if (encoder->possible_crtcs & crtc_mask)
  335.                 return true;
  336.         return false;
  337. }
  338.  
  339. /*
  340.  * Check the CRTC we're going to map each output to vs. its current
  341.  * CRTC.  If they don't match, we have to disable the output and the CRTC
  342.  * since the driver will have to re-route things.
  343.  */
  344. static void
  345. drm_crtc_prepare_encoders(struct drm_device *dev)
  346. {
  347.         struct drm_encoder_helper_funcs *encoder_funcs;
  348.         struct drm_encoder *encoder;
  349.  
  350.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  351.                 encoder_funcs = encoder->helper_private;
  352.                 /* Disable unused encoders */
  353.                 if (encoder->crtc == NULL)
  354.                         drm_encoder_disable(encoder);
  355.                 /* Disable encoders whose CRTC is about to change */
  356.                 if (encoder_funcs->get_crtc &&
  357.                     encoder->crtc != (*encoder_funcs->get_crtc)(encoder))
  358.                         drm_encoder_disable(encoder);
  359.         }
  360. }
  361.  
  362. /**
  363.  * drm_crtc_helper_set_mode - internal helper to set a mode
  364.  * @crtc: CRTC to program
  365.  * @mode: mode to use
  366.  * @x: horizontal offset into the surface
  367.  * @y: vertical offset into the surface
  368.  * @old_fb: old framebuffer, for cleanup
  369.  *
  370.  * LOCKING:
  371.  * Caller must hold mode config lock.
  372.  *
  373.  * Try to set @mode on @crtc.  Give @crtc and its associated connectors a chance
  374.  * to fixup or reject the mode prior to trying to set it. This is an internal
  375.  * helper that drivers could e.g. use to update properties that require the
  376.  * entire output pipe to be disabled and re-enabled in a new configuration. For
  377.  * example for changing whether audio is enabled on a hdmi link or for changing
  378.  * panel fitter or dither attributes. It is also called by the
  379.  * drm_crtc_helper_set_config() helper function to drive the mode setting
  380.  * sequence.
  381.  *
  382.  * RETURNS:
  383.  * True if the mode was set successfully, or false otherwise.
  384.  */
  385. bool drm_crtc_helper_set_mode(struct drm_crtc *crtc,
  386.                               struct drm_display_mode *mode,
  387.                               int x, int y,
  388.                               struct drm_framebuffer *old_fb)
  389. {
  390.         struct drm_device *dev = crtc->dev;
  391.         struct drm_display_mode *adjusted_mode, saved_mode, saved_hwmode;
  392.         struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  393.         struct drm_encoder_helper_funcs *encoder_funcs;
  394.         int saved_x, saved_y;
  395.         struct drm_encoder *encoder;
  396.         bool ret = true;
  397.  
  398.         crtc->enabled = drm_helper_crtc_in_use(crtc);
  399.         if (!crtc->enabled)
  400.                 return true;
  401.  
  402.         adjusted_mode = drm_mode_duplicate(dev, mode);
  403.         if (!adjusted_mode)
  404.                 return false;
  405.  
  406.         saved_hwmode = crtc->hwmode;
  407.         saved_mode = crtc->mode;
  408.         saved_x = crtc->x;
  409.         saved_y = crtc->y;
  410.  
  411.         /* Update crtc values up front so the driver can rely on them for mode
  412.          * setting.
  413.          */
  414.         crtc->mode = *mode;
  415.         crtc->x = x;
  416.         crtc->y = y;
  417.  
  418.         /* Pass our mode to the connectors and the CRTC to give them a chance to
  419.          * adjust it according to limitations or connector properties, and also
  420.          * a chance to reject the mode entirely.
  421.          */
  422.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  423.  
  424.                 if (encoder->crtc != crtc)
  425.                         continue;
  426.                 encoder_funcs = encoder->helper_private;
  427.                 if (!(ret = encoder_funcs->mode_fixup(encoder, mode,
  428.                                                       adjusted_mode))) {
  429.                         DRM_DEBUG_KMS("Encoder fixup failed\n");
  430.                         goto done;
  431.                 }
  432.         }
  433.  
  434.         if (!(ret = crtc_funcs->mode_fixup(crtc, mode, adjusted_mode))) {
  435.                 DRM_DEBUG_KMS("CRTC fixup failed\n");
  436.                 goto done;
  437.         }
  438.         DRM_DEBUG_KMS("[CRTC:%d]\n", crtc->base.id);
  439.  
  440.         /* Prepare the encoders and CRTCs before setting the mode. */
  441.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  442.  
  443.                 if (encoder->crtc != crtc)
  444.                         continue;
  445.                 encoder_funcs = encoder->helper_private;
  446.                 /* Disable the encoders as the first thing we do. */
  447.                 encoder_funcs->prepare(encoder);
  448.         }
  449.  
  450.         drm_crtc_prepare_encoders(dev);
  451.  
  452.         crtc_funcs->prepare(crtc);
  453.  
  454.         /* Set up the DPLL and any encoders state that needs to adjust or depend
  455.          * on the DPLL.
  456.          */
  457.         ret = !crtc_funcs->mode_set(crtc, mode, adjusted_mode, x, y, old_fb);
  458.         if (!ret)
  459.             goto done;
  460.  
  461.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  462.  
  463.                 if (encoder->crtc != crtc)
  464.                         continue;
  465.  
  466.                 DRM_DEBUG_KMS("[ENCODER:%d:%s] set [MODE:%d:%s]\n",
  467.                         encoder->base.id, drm_get_encoder_name(encoder),
  468.                         mode->base.id, mode->name);
  469.                 encoder_funcs = encoder->helper_private;
  470.                 encoder_funcs->mode_set(encoder, mode, adjusted_mode);
  471.         }
  472.  
  473.         /* Now enable the clocks, plane, pipe, and connectors that we set up. */
  474.         crtc_funcs->commit(crtc);
  475.  
  476.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  477.  
  478.                 if (encoder->crtc != crtc)
  479.                         continue;
  480.  
  481.                 encoder_funcs = encoder->helper_private;
  482.                 encoder_funcs->commit(encoder);
  483.  
  484.         }
  485.  
  486.         /* Store real post-adjustment hardware mode. */
  487.         crtc->hwmode = *adjusted_mode;
  488.  
  489.         /* Calculate and store various constants which
  490.          * are later needed by vblank and swap-completion
  491.          * timestamping. They are derived from true hwmode.
  492.          */
  493.         drm_calc_timestamping_constants(crtc);
  494.  
  495.         /* FIXME: add subpixel order */
  496. done:
  497.         drm_mode_destroy(dev, adjusted_mode);
  498.         if (!ret) {
  499.                 crtc->hwmode = saved_hwmode;
  500.                 crtc->mode = saved_mode;
  501.                 crtc->x = saved_x;
  502.                 crtc->y = saved_y;
  503.         }
  504.  
  505.         return ret;
  506. }
  507. EXPORT_SYMBOL(drm_crtc_helper_set_mode);
  508.  
  509.  
  510. static int
  511. drm_crtc_helper_disable(struct drm_crtc *crtc)
  512. {
  513.         struct drm_device *dev = crtc->dev;
  514.         struct drm_connector *connector;
  515.         struct drm_encoder *encoder;
  516.  
  517.         /* Decouple all encoders and their attached connectors from this crtc */
  518.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  519.                 if (encoder->crtc != crtc)
  520.                         continue;
  521.  
  522.                 list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  523.                         if (connector->encoder != encoder)
  524.                                 continue;
  525.  
  526.                         connector->encoder = NULL;
  527.                 }
  528.         }
  529.  
  530.         drm_helper_disable_unused_functions(dev);
  531.         return 0;
  532. }
  533.  
  534. /**
  535.  * drm_crtc_helper_set_config - set a new config from userspace
  536.  * @set: mode set configuration
  537.  *
  538.  * LOCKING:
  539.  * Caller must hold mode config lock.
  540.  *
  541.  * Setup a new configuration, provided by the upper layers (either an ioctl call
  542.  * from userspace or internally e.g. from the fbdev suppport code) in @set, and
  543.  * enable it. This is the main helper functions for drivers that implement
  544.  * kernel mode setting with the crtc helper functions and the assorted
  545.  * ->prepare(), ->modeset() and ->commit() helper callbacks.
  546.  *
  547.  * RETURNS:
  548.  * Returns 0 on success, -ERRNO on failure.
  549.  */
  550. int drm_crtc_helper_set_config(struct drm_mode_set *set)
  551. {
  552.         struct drm_device *dev;
  553.         struct drm_crtc *save_crtcs, *new_crtc, *crtc;
  554.         struct drm_encoder *save_encoders, *new_encoder, *encoder;
  555.         struct drm_framebuffer *old_fb = NULL;
  556.         bool mode_changed = false; /* if true do a full mode set */
  557.         bool fb_changed = false; /* if true and !mode_changed just do a flip */
  558.         struct drm_connector *save_connectors, *connector;
  559.         int count = 0, ro, fail = 0;
  560.         struct drm_crtc_helper_funcs *crtc_funcs;
  561.         struct drm_mode_set save_set;
  562.         int ret;
  563.         int i;
  564.  
  565.         DRM_DEBUG_KMS("\n");
  566.  
  567.         if (!set)
  568.                 return -EINVAL;
  569.  
  570.         if (!set->crtc)
  571.                 return -EINVAL;
  572.  
  573.         if (!set->crtc->helper_private)
  574.                 return -EINVAL;
  575.  
  576.         crtc_funcs = set->crtc->helper_private;
  577.  
  578.         if (!set->mode)
  579.                 set->fb = NULL;
  580.  
  581.         if (set->fb) {
  582.                 DRM_DEBUG_KMS("[CRTC:%d] [FB:%d] #connectors=%d (x y) (%i %i)\n",
  583.                                 set->crtc->base.id, set->fb->base.id,
  584.                   (int)set->num_connectors, set->x, set->y);
  585.         } else {
  586.                 DRM_DEBUG_KMS("[CRTC:%d] [NOFB]\n", set->crtc->base.id);
  587.                 return drm_crtc_helper_disable(set->crtc);
  588.         }
  589.  
  590.         dev = set->crtc->dev;
  591.  
  592.         /* Allocate space for the backup of all (non-pointer) crtc, encoder and
  593.          * connector data. */
  594.         save_crtcs = kzalloc(dev->mode_config.num_crtc *
  595.                              sizeof(struct drm_crtc), GFP_KERNEL);
  596.         if (!save_crtcs)
  597.                 return -ENOMEM;
  598.  
  599.         save_encoders = kzalloc(dev->mode_config.num_encoder *
  600.                                 sizeof(struct drm_encoder), GFP_KERNEL);
  601.         if (!save_encoders) {
  602.                 kfree(save_crtcs);
  603.                 return -ENOMEM;
  604.         }
  605.  
  606.         save_connectors = kzalloc(dev->mode_config.num_connector *
  607.                                 sizeof(struct drm_connector), GFP_KERNEL);
  608.         if (!save_connectors) {
  609.                 kfree(save_crtcs);
  610.                 kfree(save_encoders);
  611.                 return -ENOMEM;
  612.         }
  613.  
  614.         /* Copy data. Note that driver private data is not affected.
  615.          * Should anything bad happen only the expected state is
  616.          * restored, not the drivers personal bookkeeping.
  617.          */
  618.         count = 0;
  619.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
  620.                 save_crtcs[count++] = *crtc;
  621.         }
  622.  
  623.         count = 0;
  624.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  625.                 save_encoders[count++] = *encoder;
  626.         }
  627.  
  628.         count = 0;
  629.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  630.                 save_connectors[count++] = *connector;
  631.         }
  632.  
  633.         save_set.crtc = set->crtc;
  634.         save_set.mode = &set->crtc->mode;
  635.         save_set.x = set->crtc->x;
  636.         save_set.y = set->crtc->y;
  637.         save_set.fb = set->crtc->fb;
  638.  
  639.         /* We should be able to check here if the fb has the same properties
  640.          * and then just flip_or_move it */
  641.         if (set->crtc->fb != set->fb) {
  642.                 /* If we have no fb then treat it as a full mode set */
  643.                 if (set->crtc->fb == NULL) {
  644.                         DRM_DEBUG_KMS("crtc has no fb, full mode set\n");
  645.                         mode_changed = true;
  646.                 } else if (set->fb == NULL) {
  647.                         mode_changed = true;
  648.                 } else if (set->fb->depth != set->crtc->fb->depth) {
  649.                         mode_changed = true;
  650.                 } else if (set->fb->bits_per_pixel !=
  651.                            set->crtc->fb->bits_per_pixel) {
  652.                         mode_changed = true;
  653.                 } else if (set->fb->pixel_format !=
  654.                            set->crtc->fb->pixel_format) {
  655.                         mode_changed = true;
  656.                 } else
  657.                         fb_changed = true;
  658.         }
  659.  
  660.         if (set->x != set->crtc->x || set->y != set->crtc->y)
  661.                 fb_changed = true;
  662.  
  663.         if (set->mode && !drm_mode_equal(set->mode, &set->crtc->mode)) {
  664.                 DRM_DEBUG_KMS("modes are different, full mode set\n");
  665.                 drm_mode_debug_printmodeline(&set->crtc->mode);
  666.                 drm_mode_debug_printmodeline(set->mode);
  667.                 mode_changed = true;
  668.         }
  669.  
  670.         /* a) traverse passed in connector list and get encoders for them */
  671.         count = 0;
  672.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  673.                 struct drm_connector_helper_funcs *connector_funcs =
  674.                         connector->helper_private;
  675.                 new_encoder = connector->encoder;
  676.                 for (ro = 0; ro < set->num_connectors; ro++) {
  677.                         if (set->connectors[ro] == connector) {
  678.                                 new_encoder = connector_funcs->best_encoder(connector);
  679.                                 /* if we can't get an encoder for a connector
  680.                                    we are setting now - then fail */
  681.                                 if (new_encoder == NULL)
  682.                                         /* don't break so fail path works correct */
  683.                                         fail = 1;
  684.                                 break;
  685.                         }
  686.                 }
  687.  
  688.                 if (new_encoder != connector->encoder) {
  689.                         DRM_DEBUG_KMS("encoder changed, full mode switch\n");
  690.                         mode_changed = true;
  691.                         /* If the encoder is reused for another connector, then
  692.                          * the appropriate crtc will be set later.
  693.                          */
  694.                         if (connector->encoder)
  695.                                 connector->encoder->crtc = NULL;
  696.                         connector->encoder = new_encoder;
  697.                 }
  698.         }
  699.  
  700.         if (fail) {
  701.                 ret = -EINVAL;
  702.                 goto fail;
  703.         }
  704.  
  705.         count = 0;
  706.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  707.                 if (!connector->encoder)
  708.                         continue;
  709.  
  710.                 if (connector->encoder->crtc == set->crtc)
  711.                         new_crtc = NULL;
  712.                 else
  713.                         new_crtc = connector->encoder->crtc;
  714.  
  715.                 for (ro = 0; ro < set->num_connectors; ro++) {
  716.                         if (set->connectors[ro] == connector)
  717.                                 new_crtc = set->crtc;
  718.                 }
  719.  
  720.                 /* Make sure the new CRTC will work with the encoder */
  721.                 if (new_crtc &&
  722.                     !drm_encoder_crtc_ok(connector->encoder, new_crtc)) {
  723.                         ret = -EINVAL;
  724.                         goto fail;
  725.                 }
  726.                 if (new_crtc != connector->encoder->crtc) {
  727.                         DRM_DEBUG_KMS("crtc changed, full mode switch\n");
  728.                         mode_changed = true;
  729.                         connector->encoder->crtc = new_crtc;
  730.                 }
  731.                 if (new_crtc) {
  732.                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [CRTC:%d]\n",
  733.                                 connector->base.id, drm_get_connector_name(connector),
  734.                                 new_crtc->base.id);
  735.                 } else {
  736.                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] to [NOCRTC]\n",
  737.                                 connector->base.id, drm_get_connector_name(connector));
  738.                 }
  739.         }
  740.  
  741.         /* mode_set_base is not a required function */
  742.         if (fb_changed && !crtc_funcs->mode_set_base)
  743.                 mode_changed = true;
  744.  
  745.         if (mode_changed) {
  746.                 set->crtc->enabled = drm_helper_crtc_in_use(set->crtc);
  747.                 if (set->crtc->enabled) {
  748.                         DRM_DEBUG_KMS("attempting to set mode from"
  749.                                         " userspace\n");
  750.                         drm_mode_debug_printmodeline(set->mode);
  751.                         old_fb = set->crtc->fb;
  752.                         set->crtc->fb = set->fb;
  753.                         if (!drm_crtc_helper_set_mode(set->crtc, set->mode,
  754.                                                       set->x, set->y,
  755.                                                       old_fb)) {
  756.                                 DRM_ERROR("failed to set mode on [CRTC:%d]\n",
  757.                                           set->crtc->base.id);
  758.                                 set->crtc->fb = old_fb;
  759.                                 ret = -EINVAL;
  760.                                 goto fail;
  761.                         }
  762.                         DRM_DEBUG_KMS("Setting connector DPMS state to on\n");
  763.                         for (i = 0; i < set->num_connectors; i++) {
  764.                                 DRM_DEBUG_KMS("\t[CONNECTOR:%d:%s] set DPMS on\n", set->connectors[i]->base.id,
  765.                                               drm_get_connector_name(set->connectors[i]));
  766.                                 set->connectors[i]->funcs->dpms(set->connectors[i], DRM_MODE_DPMS_ON);
  767.                         }
  768.                 }
  769.                 drm_helper_disable_unused_functions(dev);
  770.         } else if (fb_changed) {
  771.                 set->crtc->x = set->x;
  772.                 set->crtc->y = set->y;
  773.  
  774.                 old_fb = set->crtc->fb;
  775.                 if (set->crtc->fb != set->fb)
  776.                         set->crtc->fb = set->fb;
  777.                 ret = crtc_funcs->mode_set_base(set->crtc,
  778.                                                 set->x, set->y, old_fb);
  779.                 if (ret != 0) {
  780.                         set->crtc->fb = old_fb;
  781.                         goto fail;
  782.         }
  783.         }
  784.  
  785.         kfree(save_connectors);
  786.         kfree(save_encoders);
  787.         kfree(save_crtcs);
  788.         return 0;
  789.  
  790. fail:
  791.         /* Restore all previous data. */
  792.         count = 0;
  793.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
  794.                 *crtc = save_crtcs[count++];
  795.         }
  796.  
  797.         count = 0;
  798.         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  799.                 *encoder = save_encoders[count++];
  800.         }
  801.  
  802.         count = 0;
  803.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  804.                 *connector = save_connectors[count++];
  805.         }
  806.  
  807.         /* Try to restore the config */
  808.         if (mode_changed &&
  809.             !drm_crtc_helper_set_mode(save_set.crtc, save_set.mode, save_set.x,
  810.                                       save_set.y, save_set.fb))
  811.                 DRM_ERROR("failed to restore config after modeset failure\n");
  812.  
  813.         kfree(save_connectors);
  814.         kfree(save_encoders);
  815.         kfree(save_crtcs);
  816.         return ret;
  817. }
  818. EXPORT_SYMBOL(drm_crtc_helper_set_config);
  819.  
  820. static int drm_helper_choose_encoder_dpms(struct drm_encoder *encoder)
  821. {
  822.         int dpms = DRM_MODE_DPMS_OFF;
  823.         struct drm_connector *connector;
  824.         struct drm_device *dev = encoder->dev;
  825.  
  826.         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
  827.                 if (connector->encoder == encoder)
  828.                         if (connector->dpms < dpms)
  829.                                 dpms = connector->dpms;
  830.         return dpms;
  831. }
  832.  
  833. static int drm_helper_choose_crtc_dpms(struct drm_crtc *crtc)
  834. {
  835.         int dpms = DRM_MODE_DPMS_OFF;
  836.         struct drm_connector *connector;
  837.         struct drm_device *dev = crtc->dev;
  838.  
  839.         list_for_each_entry(connector, &dev->mode_config.connector_list, head)
  840.                 if (connector->encoder && connector->encoder->crtc == crtc)
  841.                         if (connector->dpms < dpms)
  842.                                 dpms = connector->dpms;
  843.         return dpms;
  844. }
  845.  
  846. /**
  847.  * drm_helper_connector_dpms() - connector dpms helper implementation
  848.  * @connector: affected connector
  849.  * @mode: DPMS mode
  850.  *
  851.  * This is the main helper function provided by the crtc helper framework for
  852.  * implementing the DPMS connector attribute. It computes the new desired DPMS
  853.  * state for all encoders and crtcs in the output mesh and calls the ->dpms()
  854.  * callback provided by the driver appropriately.
  855.  */
  856. void drm_helper_connector_dpms(struct drm_connector *connector, int mode)
  857. {
  858.         struct drm_encoder *encoder = connector->encoder;
  859.         struct drm_crtc *crtc = encoder ? encoder->crtc : NULL;
  860.         int old_dpms;
  861.  
  862.         if (mode == connector->dpms)
  863.                 return;
  864.  
  865.         old_dpms = connector->dpms;
  866.         connector->dpms = mode;
  867.  
  868.         /* from off to on, do crtc then encoder */
  869.         if (mode < old_dpms) {
  870.                 if (crtc) {
  871.                         struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  872.                         if (crtc_funcs->dpms)
  873.                                 (*crtc_funcs->dpms) (crtc,
  874.                                                      drm_helper_choose_crtc_dpms(crtc));
  875.                 }
  876.                 if (encoder) {
  877.                         struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  878.                         if (encoder_funcs->dpms)
  879.                                 (*encoder_funcs->dpms) (encoder,
  880.                                                         drm_helper_choose_encoder_dpms(encoder));
  881.                 }
  882.         }
  883.  
  884.         /* from on to off, do encoder then crtc */
  885.         if (mode > old_dpms) {
  886.                 if (encoder) {
  887.                         struct drm_encoder_helper_funcs *encoder_funcs = encoder->helper_private;
  888.                         if (encoder_funcs->dpms)
  889.                                 (*encoder_funcs->dpms) (encoder,
  890.                                                         drm_helper_choose_encoder_dpms(encoder));
  891.                 }
  892.                 if (crtc) {
  893.                         struct drm_crtc_helper_funcs *crtc_funcs = crtc->helper_private;
  894.                         if (crtc_funcs->dpms)
  895.                                 (*crtc_funcs->dpms) (crtc,
  896.                                                      drm_helper_choose_crtc_dpms(crtc));
  897.                 }
  898.         }
  899.  
  900.         return;
  901. }
  902. EXPORT_SYMBOL(drm_helper_connector_dpms);
  903.  
  904. int drm_helper_mode_fill_fb_struct(struct drm_framebuffer *fb,
  905.                                    struct drm_mode_fb_cmd2 *mode_cmd)
  906. {
  907.         int i;
  908.  
  909.         fb->width = mode_cmd->width;
  910.         fb->height = mode_cmd->height;
  911.         for (i = 0; i < 4; i++) {
  912.                 fb->pitches[i] = mode_cmd->pitches[i];
  913.                 fb->offsets[i] = mode_cmd->offsets[i];
  914.         }
  915.         drm_fb_get_bpp_depth(mode_cmd->pixel_format, &fb->depth,
  916.                                     &fb->bits_per_pixel);
  917.         fb->pixel_format = mode_cmd->pixel_format;
  918.  
  919.         return 0;
  920. }
  921. EXPORT_SYMBOL(drm_helper_mode_fill_fb_struct);
  922.  
  923. int drm_helper_resume_force_mode(struct drm_device *dev)
  924. {
  925.         struct drm_crtc *crtc;
  926.         struct drm_encoder *encoder;
  927.         struct drm_encoder_helper_funcs *encoder_funcs;
  928.         struct drm_crtc_helper_funcs *crtc_funcs;
  929.         int ret;
  930.  
  931.         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
  932.  
  933.        if (!crtc->enabled)
  934.            continue;
  935.  
  936.                 ret = drm_crtc_helper_set_mode(crtc, &crtc->mode,
  937.                                                crtc->x, crtc->y, crtc->fb);
  938.  
  939.                 if (ret == false)
  940.                         DRM_ERROR("failed to set mode on crtc %p\n", crtc);
  941.  
  942.                 /* Turn off outputs that were already powered off */
  943.                 if (drm_helper_choose_crtc_dpms(crtc)) {
  944.                         list_for_each_entry(encoder, &dev->mode_config.encoder_list, head) {
  945.  
  946.                                 if(encoder->crtc != crtc)
  947.                                         continue;
  948.  
  949.                                 encoder_funcs = encoder->helper_private;
  950.                                 if (encoder_funcs->dpms)
  951.                                         (*encoder_funcs->dpms) (encoder,
  952.                                                                 drm_helper_choose_encoder_dpms(encoder));
  953.                         }
  954.  
  955.                                 crtc_funcs = crtc->helper_private;
  956.                                 if (crtc_funcs->dpms)
  957.                                         (*crtc_funcs->dpms) (crtc,
  958.                                                              drm_helper_choose_crtc_dpms(crtc));
  959.                         }
  960.                 }
  961.         /* disable the unused connectors while restoring the modesetting */
  962.         drm_helper_disable_unused_functions(dev);
  963.         return 0;
  964. }
  965. EXPORT_SYMBOL(drm_helper_resume_force_mode);
  966.  
  967. void drm_kms_helper_hotplug_event(struct drm_device *dev)
  968. {
  969.         /* send a uevent + call fbdev */
  970.     if (dev->mode_config.funcs->output_poll_changed)
  971.                 dev->mode_config.funcs->output_poll_changed(dev);
  972. }
  973. EXPORT_SYMBOL(drm_kms_helper_hotplug_event);
  974.  
  975. #define DRM_OUTPUT_POLL_PERIOD (10*HZ)
  976. static void output_poll_execute(struct work_struct *work)
  977. {
  978.         struct delayed_work *delayed_work = to_delayed_work(work);
  979.         struct drm_device *dev = container_of(delayed_work, struct drm_device, mode_config.output_poll_work);
  980.         struct drm_connector *connector;
  981.         enum drm_connector_status old_status;
  982.         bool repoll = false, changed = false;
  983.  
  984.         if (!drm_kms_helper_poll)
  985.                 return;
  986.  
  987.         mutex_lock(&dev->mode_config.mutex);
  988.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  989.  
  990.                 /* Ignore forced connectors. */
  991.                 if (connector->force)
  992.                         continue;
  993.  
  994.                 /* Ignore HPD capable connectors and connectors where we don't
  995.                  * want any hotplug detection at all for polling. */
  996.                 if (!connector->polled || connector->polled == DRM_CONNECTOR_POLL_HPD)
  997.                         continue;
  998.  
  999.                         repoll = true;
  1000.  
  1001.                 old_status = connector->status;
  1002.                 /* if we are connected and don't want to poll for disconnect
  1003.                    skip it */
  1004.                 if (old_status == connector_status_connected &&
  1005.                     !(connector->polled & DRM_CONNECTOR_POLL_DISCONNECT))
  1006.                         continue;
  1007.  
  1008.                 connector->status = connector->funcs->detect(connector, false);
  1009.                 if (old_status != connector->status) {
  1010.                         const char *old, *new;
  1011.  
  1012.                         old = drm_get_connector_status_name(old_status);
  1013.                         new = drm_get_connector_status_name(connector->status);
  1014.  
  1015.                         DRM_DEBUG_KMS("[CONNECTOR:%d:%s] "
  1016.                                       "status updated from %s to %s\n",
  1017.                               connector->base.id,
  1018.                               drm_get_connector_name(connector),
  1019.                                       old, new);
  1020.  
  1021.                         changed = true;
  1022.         }
  1023.         }
  1024.  
  1025.         mutex_unlock(&dev->mode_config.mutex);
  1026.  
  1027.         if (changed)
  1028.                 drm_kms_helper_hotplug_event(dev);
  1029.  
  1030. //   if (repoll)
  1031. //       schedule_delayed_work(delayed_work, DRM_OUTPUT_POLL_PERIOD);
  1032. }
  1033.  
  1034. void drm_kms_helper_poll_disable(struct drm_device *dev)
  1035. {
  1036.         if (!dev->mode_config.poll_enabled)
  1037.                 return;
  1038. //   cancel_delayed_work_sync(&dev->mode_config.output_poll_work);
  1039. }
  1040. EXPORT_SYMBOL(drm_kms_helper_poll_disable);
  1041.  
  1042. void drm_kms_helper_poll_enable(struct drm_device *dev)
  1043. {
  1044.         bool poll = false;
  1045.         struct drm_connector *connector;
  1046.  
  1047.         if (!dev->mode_config.poll_enabled || !drm_kms_helper_poll)
  1048.                 return;
  1049.  
  1050.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1051.                 if (connector->polled & (DRM_CONNECTOR_POLL_CONNECT |
  1052.                                          DRM_CONNECTOR_POLL_DISCONNECT))
  1053.                         poll = true;
  1054.         }
  1055.  
  1056. //   if (poll)
  1057. //       schedule_delayed_work(&dev->mode_config.output_poll_work, DRM_OUTPUT_POLL_PERIOD);
  1058. }
  1059. EXPORT_SYMBOL(drm_kms_helper_poll_enable);
  1060.  
  1061. void drm_kms_helper_poll_init(struct drm_device *dev)
  1062. {
  1063.         INIT_DELAYED_WORK(&dev->mode_config.output_poll_work, output_poll_execute);
  1064.         dev->mode_config.poll_enabled = true;
  1065.  
  1066.         drm_kms_helper_poll_enable(dev);
  1067. }
  1068. EXPORT_SYMBOL(drm_kms_helper_poll_init);
  1069.  
  1070. void drm_kms_helper_poll_fini(struct drm_device *dev)
  1071. {
  1072.         drm_kms_helper_poll_disable(dev);
  1073. }
  1074. EXPORT_SYMBOL(drm_kms_helper_poll_fini);
  1075.  
  1076. void drm_helper_hpd_irq_event(struct drm_device *dev)
  1077. {
  1078.         struct drm_connector *connector;
  1079.         enum drm_connector_status old_status;
  1080.         bool changed = false;
  1081.  
  1082.         if (!dev->mode_config.poll_enabled)
  1083.                 return;
  1084.  
  1085.         mutex_lock(&dev->mode_config.mutex);
  1086.         list_for_each_entry(connector, &dev->mode_config.connector_list, head) {
  1087.  
  1088.                 /* Only handle HPD capable connectors. */
  1089.                 if (!(connector->polled & DRM_CONNECTOR_POLL_HPD))
  1090.                         continue;
  1091.  
  1092.                 old_status = connector->status;
  1093.  
  1094.                 connector->status = connector->funcs->detect(connector, false);
  1095.                 DRM_DEBUG_KMS("[CONNECTOR:%d:%s] status updated from %s to %s\n",
  1096.                               connector->base.id,
  1097.                               drm_get_connector_name(connector),
  1098.                               drm_get_connector_status_name(old_status),
  1099.                               drm_get_connector_status_name(connector->status));
  1100.                 if (old_status != connector->status)
  1101.                         changed = true;
  1102.         }
  1103.  
  1104.         mutex_unlock(&dev->mode_config.mutex);
  1105.  
  1106.         if (changed)
  1107.                 drm_kms_helper_hotplug_event(dev);
  1108. }
  1109. EXPORT_SYMBOL(drm_helper_hpd_irq_event);
  1110.