drivers/gpu/drm/drm_crtc_helper.c

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