drivers/gpu/drm/drm_crtc_helper.c

   1 /*
   2  * Copyright (c) 2006-2008 Intel Corporation
   3  * Copyright (c) 2007 Dave Airlie <[email protected]>
   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 <[email protected]>
  28  *      Dave Airlie <[email protected]>
  29  *      Jesse Barnes <[email protected]>
  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);