drivers/gpu/drm/drm_mode_config.c

   1 /*
   2  * Copyright (c) 2016 Intel Corporation
   3  *
   4  * Permission to use, copy, modify, distribute, and sell this software and its
   5  * documentation for any purpose is hereby granted without fee, provided that
   6  * the above copyright notice appear in all copies and that both that copyright
   7  * notice and this permission notice appear in supporting documentation, and
   8  * that the name of the copyright holders not be used in advertising or
   9  * publicity pertaining to distribution of the software without specific,
  10  * written prior permission.  The copyright holders make no representations
  11  * about the suitability of this software for any purpose.  It is provided "as
  12  * is" without express or implied warranty.
  13  *
  14  * THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
  15  * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
  16  * EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
  17  * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  18  * DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
  19  * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
  20  * OF THIS SOFTWARE.
  21  */
  22
  23 #include <linux/uaccess.h>
  24
  25 #include <drm/drm_drv.h>
  26 #include <drm/drm_encoder.h>
  27 #include <drm/drm_file.h>
  28 #include <drm/drm_framebuffer.h>
  29 #include <drm/drm_managed.h>
  30 #include <drm/drm_mode_config.h>
  31 #include <drm/drm_print.h>
  32 #include <linux/dma-resv.h>
  33
  34 #include "drm_crtc_internal.h"
  35 #include "drm_internal.h"
  36
  37 int drm_modeset_register_all(struct drm_device *dev)
  38 {
  39         int ret;
  40
  41         ret = drm_plane_register_all(dev);
  42         if (ret)
  43                 goto err_plane;
  44
  45         ret = drm_crtc_register_all(dev);
  46         if  (ret)
  47                 goto err_crtc;
  48
  49         ret = drm_encoder_register_all(dev);
  50         if (ret)
  51                 goto err_encoder;
  52
  53         ret = drm_connector_register_all(dev);
  54         if (ret)
  55                 goto err_connector;
  56
  57         return 0;
  58
  59 err_connector:
  60         drm_encoder_unregister_all(dev);
  61 err_encoder:
  62         drm_crtc_unregister_all(dev);
  63 err_crtc:
  64         drm_plane_unregister_all(dev);
  65 err_plane:
  66         return ret;
  67 }
  68
  69 void drm_modeset_unregister_all(struct drm_device *dev)
  70 {
  71         drm_connector_unregister_all(dev);
  72         drm_encoder_unregister_all(dev);
  73         drm_crtc_unregister_all(dev);
  74         drm_plane_unregister_all(dev);
  75 }
  76
  77 /**
  78  * drm_mode_getresources - get graphics configuration
  79  * @dev: drm device for the ioctl
  80  * @data: data pointer for the ioctl
  81  * @file_priv: drm file for the ioctl call
  82  *
  83  * Construct a set of configuration description structures and return
  84  * them to the user, including CRTC, connector and framebuffer configuration.
  85  *
  86  * Called by the user via ioctl.
  87  *
  88  * Returns:
  89  * Zero on success, negative errno on failure.
  90  */
  91 int drm_mode_getresources(struct drm_device *dev, void *data,
  92                           struct drm_file *file_priv)
  93 {
  94         struct drm_mode_card_res *card_res = data;
  95         struct drm_framebuffer *fb;
  96         struct drm_connector *connector;
  97         struct drm_crtc *crtc;
  98         struct drm_encoder *encoder;
  99         int count, ret = 0;
 100         uint32_t __user *fb_id;
 101         uint32_t __user *crtc_id;
 102         uint32_t __user *connector_id;
 103         uint32_t __user *encoder_id;
 104         struct drm_connector_list_iter conn_iter;
 105
 106         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 107                 return -EOPNOTSUPP;
 108
 109         mutex_lock(&file_priv->fbs_lock);
 110         count = 0;
 111         fb_id = u64_to_user_ptr(card_res->fb_id_ptr);
 112         list_for_each_entry(fb, &file_priv->fbs, filp_head) {
 113                 if (count < card_res->count_fbs &&
 114                     put_user(fb->base.id, fb_id + count)) {
 115                         mutex_unlock(&file_priv->fbs_lock);
 116                         return -EFAULT;
 117                 }
 118                 count++;
 119         }
 120         card_res->count_fbs = count;
 121         mutex_unlock(&file_priv->fbs_lock);
 122
 123         card_res->max_height = dev->mode_config.max_height;
 124         card_res->min_height = dev->mode_config.min_height;
 125         card_res->max_width = dev->mode_config.max_width;
 126         card_res->min_width = dev->mode_config.min_width;
 127
 128         count = 0;
 129         crtc_id = u64_to_user_ptr(card_res->crtc_id_ptr);
 130         drm_for_each_crtc(crtc, dev) {
 131                 if (drm_lease_held(file_priv, crtc->base.id)) {
 132                         if (count < card_res->count_crtcs &&
 133                             put_user(crtc->base.id, crtc_id + count))
 134                                 return -EFAULT;
 135                         count++;
 136                 }
 137         }
 138         card_res->count_crtcs = count;
 139
 140         count = 0;
 141         encoder_id = u64_to_user_ptr(card_res->encoder_id_ptr);
 142         drm_for_each_encoder(encoder, dev) {
 143                 if (count < card_res->count_encoders &&
 144                     put_user(encoder->base.id, encoder_id + count))
 145                         return -EFAULT;
 146                 count++;
 147         }
 148         card_res->count_encoders = count;
 149
 150         drm_connector_list_iter_begin(dev, &conn_iter);
 151         count = 0;
 152         connector_id = u64_to_user_ptr(card_res->connector_id_ptr);
 153         drm_for_each_connector_iter(connector, &conn_iter) {
 154                 if (connector->registration_state != DRM_CONNECTOR_REGISTERED)
 155                         continue;
 156
 157                 /* only expose writeback connectors if userspace understands them */
 158                 if (!file_priv->writeback_connectors &&
 159                     (connector->connector_type == DRM_MODE_CONNECTOR_WRITEBACK))
 160                         continue;
 161
 162                 if (drm_lease_held(file_priv, connector->base.id)) {
 163                         if (count < card_res->count_connectors &&
 164                             put_user(connector->base.id, connector_id + count)) {
 165                                 drm_connector_list_iter_end(&conn_iter);
 166                                 return -EFAULT;
 167                         }
 168                         count++;
 169                 }
 170         }
 171         card_res->count_connectors = count;
 172         drm_connector_list_iter_end(&conn_iter);
 173
 174         return ret;
 175 }
 176
 177 /**
 178  * drm_mode_config_reset - call ->reset callbacks
 179  * @dev: drm device
 180  *
 181  * This functions calls all the crtc's, encoder's and connector's ->reset
 182  * callback. Drivers can use this in e.g. their driver load or resume code to
 183  * reset hardware and software state.
 184  */
 185 void drm_mode_config_reset(struct drm_device *dev)
 186 {
 187         struct drm_crtc *crtc;
 188         struct drm_plane *plane;
 189         struct drm_encoder *encoder;
 190         struct drm_connector *connector;
 191         struct drm_connector_list_iter conn_iter;
 192
 193         drm_for_each_plane(plane, dev)
 194                 if (plane->funcs->reset)
 195                         plane->funcs->reset(plane);
 196
 197         drm_for_each_crtc(crtc, dev)
 198                 if (crtc->funcs->reset)
 199                         crtc->funcs->reset(crtc);
 200
 201         drm_for_each_encoder(encoder, dev)
 202                 if (encoder->funcs && encoder->funcs->reset)
 203                         encoder->funcs->reset(encoder);
 204
 205         drm_connector_list_iter_begin(dev, &conn_iter);
 206         drm_for_each_connector_iter(connector, &conn_iter)
 207                 if (connector->funcs->reset)
 208                         connector->funcs->reset(connector);
 209         drm_connector_list_iter_end(&conn_iter);
 210 }
 211 EXPORT_SYMBOL(drm_mode_config_reset);
 212
 213 /*
 214  * Global properties
 215  */
 216 static const struct drm_prop_enum_list drm_plane_type_enum_list[] = {
 217         { DRM_PLANE_TYPE_OVERLAY, "Overlay" },
 218         { DRM_PLANE_TYPE_PRIMARY, "Primary" },
 219         { DRM_PLANE_TYPE_CURSOR, "Cursor" },
 220 };
 221
 222 static int drm_mode_create_standard_properties(struct drm_device *dev)
 223 {
 224         struct drm_property *prop;
 225         int ret;
 226
 227         ret = drm_connector_create_standard_properties(dev);
 228         if (ret)
 229                 return ret;
 230
 231         prop = drm_property_create_enum(dev, DRM_MODE_PROP_IMMUTABLE,
 232                                         "type", drm_plane_type_enum_list,
 233                                         ARRAY_SIZE(drm_plane_type_enum_list));
 234         if (!prop)
 235                 return -ENOMEM;
 236         dev->mode_config.plane_type_property = prop;
 237
 238         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 239                         "SRC_X", 0, UINT_MAX);
 240         if (!prop)
 241                 return -ENOMEM;
 242         dev->mode_config.prop_src_x = prop;
 243
 244         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 245                         "SRC_Y", 0, UINT_MAX);
 246         if (!prop)
 247                 return -ENOMEM;
 248         dev->mode_config.prop_src_y = prop;
 249
 250         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 251                         "SRC_W", 0, UINT_MAX);
 252         if (!prop)
 253                 return -ENOMEM;
 254         dev->mode_config.prop_src_w = prop;
 255
 256         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 257                         "SRC_H", 0, UINT_MAX);
 258         if (!prop)
 259                 return -ENOMEM;
 260         dev->mode_config.prop_src_h = prop;
 261
 262         prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
 263                         "CRTC_X", INT_MIN, INT_MAX);
 264         if (!prop)
 265                 return -ENOMEM;
 266         dev->mode_config.prop_crtc_x = prop;
 267
 268         prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
 269                         "CRTC_Y", INT_MIN, INT_MAX);
 270         if (!prop)
 271                 return -ENOMEM;
 272         dev->mode_config.prop_crtc_y = prop;
 273
 274         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 275                         "CRTC_W", 0, INT_MAX);
 276         if (!prop)
 277                 return -ENOMEM;
 278         dev->mode_config.prop_crtc_w = prop;
 279
 280         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 281                         "CRTC_H", 0, INT_MAX);
 282         if (!prop)
 283                 return -ENOMEM;
 284         dev->mode_config.prop_crtc_h = prop;
 285
 286         prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
 287                         "FB_ID", DRM_MODE_OBJECT_FB);
 288         if (!prop)
 289                 return -ENOMEM;
 290         dev->mode_config.prop_fb_id = prop;
 291
 292         prop = drm_property_create_signed_range(dev, DRM_MODE_PROP_ATOMIC,
 293                         "IN_FENCE_FD", -1, INT_MAX);
 294         if (!prop)
 295                 return -ENOMEM;
 296         dev->mode_config.prop_in_fence_fd = prop;
 297
 298         prop = drm_property_create_range(dev, DRM_MODE_PROP_ATOMIC,
 299                         "OUT_FENCE_PTR", 0, U64_MAX);
 300         if (!prop)
 301                 return -ENOMEM;
 302         dev->mode_config.prop_out_fence_ptr = prop;
 303
 304         prop = drm_property_create_object(dev, DRM_MODE_PROP_ATOMIC,
 305                         "CRTC_ID", DRM_MODE_OBJECT_CRTC);
 306         if (!prop)
 307                 return -ENOMEM;
 308         dev->mode_config.prop_crtc_id = prop;
 309
 310         prop = drm_property_create(dev,
 311                         DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
 312                         "FB_DAMAGE_CLIPS", 0);
 313         if (!prop)
 314                 return -ENOMEM;
 315         dev->mode_config.prop_fb_damage_clips = prop;
 316
 317         prop = drm_property_create_bool(dev, DRM_MODE_PROP_ATOMIC,
 318                         "ACTIVE");
 319         if (!prop)
 320                 return -ENOMEM;
 321         dev->mode_config.prop_active = prop;
 322
 323         prop = drm_property_create(dev,
 324                         DRM_MODE_PROP_ATOMIC | DRM_MODE_PROP_BLOB,
 325                         "MODE_ID", 0);
 326         if (!prop)
 327                 return -ENOMEM;
 328         dev->mode_config.prop_mode_id = prop;
 329
 330         prop = drm_property_create_bool(dev, 0,
 331                         "VRR_ENABLED");
 332         if (!prop)
 333                 return -ENOMEM;
 334         dev->mode_config.prop_vrr_enabled = prop;
 335
 336         prop = drm_property_create(dev,
 337                         DRM_MODE_PROP_BLOB,
 338                         "DEGAMMA_LUT", 0);
 339         if (!prop)
 340                 return -ENOMEM;
 341         dev->mode_config.degamma_lut_property = prop;
 342
 343         prop = drm_property_create_range(dev,
 344                         DRM_MODE_PROP_IMMUTABLE,
 345                         "DEGAMMA_LUT_SIZE", 0, UINT_MAX);
 346         if (!prop)
 347                 return -ENOMEM;
 348         dev->mode_config.degamma_lut_size_property = prop;
 349
 350         prop = drm_property_create(dev,
 351                         DRM_MODE_PROP_BLOB,
 352                         "CTM", 0);
 353         if (!prop)
 354                 return -ENOMEM;
 355         dev->mode_config.ctm_property = prop;
 356
 357         prop = drm_property_create(dev,
 358                         DRM_MODE_PROP_BLOB,
 359                         "GAMMA_LUT", 0);
 360         if (!prop)
 361                 return -ENOMEM;
 362         dev->mode_config.gamma_lut_property = prop;
 363
 364         prop = drm_property_create_range(dev,
 365                         DRM_MODE_PROP_IMMUTABLE,
 366                         "GAMMA_LUT_SIZE", 0, UINT_MAX);
 367         if (!prop)
 368                 return -ENOMEM;
 369         dev->mode_config.gamma_lut_size_property = prop;
 370
 371         prop = drm_property_create(dev,
 372                                    DRM_MODE_PROP_IMMUTABLE | DRM_MODE_PROP_BLOB,
 373                                    "IN_FORMATS", 0);
 374         if (!prop)
 375                 return -ENOMEM;
 376         dev->mode_config.modifiers_property = prop;
 377
 378         return 0;
 379 }
 380
 381 static void drm_mode_config_init_release(struct drm_device *dev, void *ptr)
 382 {
 383         drm_mode_config_cleanup(dev);
 384 }
 385
 386 /**
 387  * drmm_mode_config_init - managed DRM mode_configuration structure
 388  *      initialization
 389  * @dev: DRM device
 390  *
 391  * Initialize @dev's mode_config structure, used for tracking the graphics
 392  * configuration of @dev.
 393  *
 394  * Since this initializes the modeset locks, no locking is possible. Which is no
 395  * problem, since this should happen single threaded at init time. It is the
 396  * driver's problem to ensure this guarantee.
 397  *
 398  * Cleanup is automatically handled through registering drm_mode_config_cleanup
 399  * with drmm_add_action().
 400  *
 401  * Returns: 0 on success, negative error value on failure.
 402  */
 403 int drmm_mode_config_init(struct drm_device *dev)
 404 {
 405         mutex_init(&dev->mode_config.mutex);
 406         drm_modeset_lock_init(&dev->mode_config.connection_mutex);
 407         mutex_init(&dev->mode_config.idr_mutex);
 408         mutex_init(&dev->mode_config.fb_lock);
 409         mutex_init(&dev->mode_config.blob_lock);
 410         INIT_LIST_HEAD(&dev->mode_config.fb_list);
 411         INIT_LIST_HEAD(&dev->mode_config.crtc_list);
 412         INIT_LIST_HEAD(&dev->mode_config.connector_list);
 413         INIT_LIST_HEAD(&dev->mode_config.encoder_list);
 414         INIT_LIST_HEAD(&dev->mode_config.property_list);
 415         INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
 416         INIT_LIST_HEAD(&dev->mode_config.plane_list);
 417         INIT_LIST_HEAD(&dev->mode_config.privobj_list);
 418         idr_init_base(&dev->mode_config.object_idr, 1);
 419         idr_init_base(&dev->mode_config.tile_idr, 1);
 420         ida_init(&dev->mode_config.connector_ida);
 421         spin_lock_init(&dev->mode_config.connector_list_lock);
 422
 423         init_llist_head(&dev->mode_config.connector_free_list);
 424         INIT_WORK(&dev->mode_config.connector_free_work, drm_connector_free_work_fn);
 425
 426         drm_mode_create_standard_properties(dev);
 427
 428         /* Just to be sure */
 429         dev->mode_config.num_fb = 0;
 430         dev->mode_config.num_connector = 0;
 431         dev->mode_config.num_crtc = 0;
 432         dev->mode_config.num_encoder = 0;
 433         dev->mode_config.num_total_plane = 0;
 434
 435         if (IS_ENABLED(CONFIG_LOCKDEP)) {
 436                 struct drm_modeset_acquire_ctx modeset_ctx;
 437                 struct ww_acquire_ctx resv_ctx;
 438                 struct dma_resv resv;
 439                 int ret;
 440
 441                 dma_resv_init(&resv);
 442
 443                 drm_modeset_acquire_init(&modeset_ctx, 0);
 444                 ret = drm_modeset_lock(&dev->mode_config.connection_mutex,
 445                                        &modeset_ctx);
 446                 if (ret == -EDEADLK)
 447                         ret = drm_modeset_backoff(&modeset_ctx);
 448
 449                 ww_acquire_init(&resv_ctx, &reservation_ww_class);
 450                 ret = dma_resv_lock(&resv, &resv_ctx);
 451                 if (ret == -EDEADLK)
 452                         dma_resv_lock_slow(&resv, &resv_ctx);
 453
 454                 dma_resv_unlock(&resv);
 455                 ww_acquire_fini(&resv_ctx);
 456
 457                 drm_modeset_drop_locks(&modeset_ctx);
 458                 drm_modeset_acquire_fini(&modeset_ctx);
 459                 dma_resv_fini(&resv);
 460         }
 461
 462         return drmm_add_action_or_reset(dev, drm_mode_config_init_release,
 463                                         NULL);
 464 }
 465 EXPORT_SYMBOL(drmm_mode_config_init);
 466
 467 /**
 468  * drm_mode_config_cleanup - free up DRM mode_config info
 469  * @dev: DRM device
 470  *
 471  * Free up all the connectors and CRTCs associated with this DRM device, then
 472  * free up the framebuffers and associated buffer objects.
 473  *
 474  * Note that since this /should/ happen single-threaded at driver/device
 475  * teardown time, no locking is required. It's the driver's job to ensure that
 476  * this guarantee actually holds true.
 477  *
 478  * FIXME: With the managed drmm_mode_config_init() it is no longer necessary for
 479  * drivers to explicitly call this function.
 480  */
 481 void drm_mode_config_cleanup(struct drm_device *dev)
 482 {
 483         struct drm_connector *connector;
 484         struct drm_connector_list_iter conn_iter;
 485         struct drm_crtc *crtc, *ct;
 486         struct drm_encoder *encoder, *enct;
 487         struct drm_framebuffer *fb, *fbt;
 488         struct drm_property *property, *pt;
 489         struct drm_property_blob *blob, *bt;
 490         struct drm_plane *plane, *plt;
 491
 492         list_for_each_entry_safe(encoder, enct, &dev->mode_config.encoder_list,
 493                                  head) {
 494                 encoder->funcs->destroy(encoder);
 495         }
 496
 497         drm_connector_list_iter_begin(dev, &conn_iter);
 498         drm_for_each_connector_iter(connector, &conn_iter) {
 499                 /* drm_connector_list_iter holds an full reference to the
 500                  * current connector itself, which means it is inherently safe
 501                  * against unreferencing the current connector - but not against
 502                  * deleting it right away. */
 503                 drm_connector_put(connector);
 504         }
 505         drm_connector_list_iter_end(&conn_iter);
 506         /* connector_iter drops references in a work item. */
 507         flush_work(&dev->mode_config.connector_free_work);
 508         if (WARN_ON(!list_empty(&dev->mode_config.connector_list))) {
 509                 drm_connector_list_iter_begin(dev, &conn_iter);
 510                 drm_for_each_connector_iter(connector, &conn_iter)
 511                         DRM_ERROR("connector %s leaked!\n", connector->name);
 512                 drm_connector_list_iter_end(&conn_iter);
 513         }
 514
 515         list_for_each_entry_safe(property, pt, &dev->mode_config.property_list,
 516                                  head) {
 517                 drm_property_destroy(dev, property);
 518         }
 519
 520         list_for_each_entry_safe(plane, plt, &dev->mode_config.plane_list,
 521                                  head) {
 522                 plane->funcs->destroy(plane);
 523         }
 524
 525         list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
 526                 crtc->funcs->destroy(crtc);
 527         }
 528
 529         list_for_each_entry_safe(blob, bt, &dev->mode_config.property_blob_list,
 530                                  head_global) {
 531                 drm_property_blob_put(blob);
 532         }
 533
 534         /*
 535          * Single-threaded teardown context, so it's not required to grab the
 536          * fb_lock to protect against concurrent fb_list access. Contrary, it
 537          * would actually deadlock with the drm_framebuffer_cleanup function.
 538          *
 539          * Also, if there are any framebuffers left, that's a driver leak now,
 540          * so politely WARN about this.
 541          */
 542         WARN_ON(!list_empty(&dev->mode_config.fb_list));
 543         list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
 544                 struct drm_printer p = drm_debug_printer("[leaked fb]");
 545
 546                 drm_printf(&p, "framebuffer[%u]:\n", fb->base.id);
 547                 drm_framebuffer_print_info(&p, 1, fb);
 548                 drm_framebuffer_free(&fb->base.refcount);
 549         }
 550
 551         ida_destroy(&dev->mode_config.connector_ida);
 552         idr_destroy(&dev->mode_config.tile_idr);
 553         idr_destroy(&dev->mode_config.object_idr);
 554         drm_modeset_lock_fini(&dev->mode_config.connection_mutex);
 555 }
 556 EXPORT_SYMBOL(drm_mode_config_cleanup);
 557
 558 static u32 full_encoder_mask(struct drm_device *dev)
 559 {
 560         struct drm_encoder *encoder;
 561         u32 encoder_mask = 0;
 562
 563         drm_for_each_encoder(encoder, dev)
 564                 encoder_mask |= drm_encoder_mask(encoder);
 565
 566         return encoder_mask;
 567 }
 568
 569 /*
 570  * For some reason we want the encoder itself included in
 571  * possible_clones. Make life easy for drivers by allowing them
 572  * to leave possible_clones unset if no cloning is possible.
 573  */
 574 static void fixup_encoder_possible_clones(struct drm_encoder *encoder)
 575 {
 576         if (encoder->possible_clones == 0)
 577                 encoder->possible_clones = drm_encoder_mask(encoder);
 578 }
 579
 580 static void validate_encoder_possible_clones(struct drm_encoder *encoder)
 581 {
 582         struct drm_device *dev = encoder->dev;
 583         u32 encoder_mask = full_encoder_mask(dev);
 584         struct drm_encoder *other;
 585
 586         drm_for_each_encoder(other, dev) {
 587                 WARN(!!(encoder->possible_clones & drm_encoder_mask(other)) !=
 588                      !!(other->possible_clones & drm_encoder_mask(encoder)),
 589                      "possible_clones mismatch: "
 590                      "[ENCODER:%d:%s] mask=0x%x possible_clones=0x%x vs. "
 591                      "[ENCODER:%d:%s] mask=0x%x possible_clones=0x%x\n",
 592                      encoder->base.id, encoder->name,
 593                      drm_encoder_mask(encoder), encoder->possible_clones,
 594                      other->base.id, other->name,
 595                      drm_encoder_mask(other), other->possible_clones);
 596         }
 597
 598         WARN((encoder->possible_clones & drm_encoder_mask(encoder)) == 0 ||
 599              (encoder->possible_clones & ~encoder_mask) != 0,
 600              "Bogus possible_clones: "
 601              "[ENCODER:%d:%s] possible_clones=0x%x (full encoder mask=0x%x)\n",
 602              encoder->base.id, encoder->name,
 603              encoder->possible_clones, encoder_mask);
 604 }
 605
 606 static u32 full_crtc_mask(struct drm_device *dev)
 607 {
 608         struct drm_crtc *crtc;
 609         u32 crtc_mask = 0;
 610
 611         drm_for_each_crtc(crtc, dev)
 612                 crtc_mask |= drm_crtc_mask(crtc);
 613
 614         return crtc_mask;
 615 }
 616
 617 static void validate_encoder_possible_crtcs(struct drm_encoder *encoder)
 618 {
 619         u32 crtc_mask = full_crtc_mask(encoder->dev);
 620
 621         WARN((encoder->possible_crtcs & crtc_mask) == 0 ||
 622              (encoder->possible_crtcs & ~crtc_mask) != 0,
 623              "Bogus possible_crtcs: "
 624              "[ENCODER:%d:%s] possible_crtcs=0x%x (full crtc mask=0x%x)\n",
 625              encoder->base.id, encoder->name,
 626              encoder->possible_crtcs, crtc_mask);
 627 }
 628
 629 void drm_mode_config_validate(struct drm_device *dev)
 630 {
 631         struct drm_encoder *encoder;
 632         struct drm_crtc *crtc;
 633         struct drm_plane *plane;
 634         u32 primary_with_crtc = 0, cursor_with_crtc = 0;
 635         unsigned int num_primary = 0;
 636
 637         if (!drm_core_check_feature(dev, DRIVER_MODESET))
 638                 return;
 639
 640         drm_for_each_encoder(encoder, dev)
 641                 fixup_encoder_possible_clones(encoder);
 642
 643         drm_for_each_encoder(encoder, dev) {
 644                 validate_encoder_possible_clones(encoder);
 645                 validate_encoder_possible_crtcs(encoder);
 646         }
 647
 648         drm_for_each_crtc(crtc, dev) {
 649                 WARN(!crtc->primary, "Missing primary plane on [CRTC:%d:%s]\n",
 650                      crtc->base.id, crtc->name);
 651
 652                 WARN(crtc->cursor && crtc->funcs->cursor_set,
 653                      "[CRTC:%d:%s] must not have both a cursor plane and a cursor_set func",
 654                      crtc->base.id, crtc->name);
 655                 WARN(crtc->cursor && crtc->funcs->cursor_set2,
 656                      "[CRTC:%d:%s] must not have both a cursor plane and a cursor_set2 func",
 657                      crtc->base.id, crtc->name);
 658                 WARN(crtc->cursor && crtc->funcs->cursor_move,
 659                      "[CRTC:%d:%s] must not have both a cursor plane and a cursor_move func",
 660                      crtc->base.id, crtc->name);
 661
 662                 if (crtc->primary) {
 663                         WARN(!(crtc->primary->possible_crtcs & drm_crtc_mask(crtc)),
 664                              "Bogus primary plane possible_crtcs: [PLANE:%d:%s] must be compatible with [CRTC:%d:%s]\n",
 665                              crtc->primary->base.id, crtc->primary->name,
 666                              crtc->base.id, crtc->name);
 667                         WARN(primary_with_crtc & drm_plane_mask(crtc->primary),
 668                              "Primary plane [PLANE:%d:%s] used for multiple CRTCs",
 669                              crtc->primary->base.id, crtc->primary->name);
 670                         primary_with_crtc |= drm_plane_mask(crtc->primary);
 671                 }
 672                 if (crtc->cursor) {
 673                         WARN(!(crtc->cursor->possible_crtcs & drm_crtc_mask(crtc)),
 674                              "Bogus cursor plane possible_crtcs: [PLANE:%d:%s] must be compatible with [CRTC:%d:%s]\n",
 675                              crtc->cursor->base.id, crtc->cursor->name,
 676                              crtc->base.id, crtc->name);
 677                         WARN(cursor_with_crtc & drm_plane_mask(crtc->cursor),
 678                              "Cursor plane [PLANE:%d:%s] used for multiple CRTCs",
 679                              crtc->cursor->base.id, crtc->cursor->name);
 680                         cursor_with_crtc |= drm_plane_mask(crtc->cursor);
 681                 }
 682         }
 683
 684         drm_for_each_plane(plane, dev) {
 685                 if (plane->type == DRM_PLANE_TYPE_PRIMARY)
 686                         num_primary++;
 687         }
 688
 689         WARN(num_primary != dev->mode_config.num_crtc,
 690              "Must have as many primary planes as there are CRTCs, but have %u primary planes and %u CRTCs",
 691              num_primary, dev->mode_config.num_crtc);
 692 }