linux-core/drm_crtc.c

   1 /*
   2  * Copyright (c) 2006-2007 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 #include <linux/list.h>
  32 #include "drm.h"
  33 #include "drmP.h"
  34 #include "drm_crtc.h"
  35
  36 /**
  37  * drm_idr_get - allocate a new identifier
  38  * @dev: DRM device
  39  * @ptr: object pointer, used to generate unique ID
  40  *
  41  * LOCKING:
  42  * Caller must hold DRM mode_config lock.
  43  *
  44  * Create a unique identifier based on @ptr in @dev's identifier space.  Used
  45  * for tracking modes, CRTCs and outputs.
  46  *
  47  * RETURNS:
  48  * New unique (relative to other objects in @dev) integer identifier for the
  49  * object.
  50  */
  51 int drm_idr_get(struct drm_device *dev, void *ptr)
  52 {
  53         int new_id = 0;
  54         int ret;
  55 again:
  56         if (idr_pre_get(&dev->mode_config.crtc_idr, GFP_KERNEL) == 0) {
  57                 DRM_ERROR("Ran out memory getting a mode number\n");
  58                 return 0;
  59         }
  60
  61         ret = idr_get_new_above(&dev->mode_config.crtc_idr, ptr, 1, &new_id);
  62         if (ret == -EAGAIN)
  63                 goto again;
  64
  65         return new_id;
  66 }
  67
  68 /**
  69  * drm_idr_put - free an identifer
  70  * @dev: DRM device
  71  * @id: ID to free
  72  *
  73  * LOCKING:
  74  * Caller must hold DRM mode_config lock.
  75  *
  76  * Free @id from @dev's unique identifier pool.
  77  */
  78 void drm_idr_put(struct drm_device *dev, int id)
  79 {
  80         idr_remove(&dev->mode_config.crtc_idr, id);
  81 }
  82
  83 /**
  84  * drm_crtc_from_fb - find the CRTC structure associated with an fb
  85  * @dev: DRM device
  86  * @fb: framebuffer in question
  87  *
  88  * LOCKING:
  89  * Caller must hold mode_config lock.
  90  *
  91  * Find CRTC in the mode_config structure that matches @fb.
  92  *
  93  * RETURNS:
  94  * Pointer to the CRTC or NULL if it wasn't found.
  95  */
  96 struct drm_crtc *drm_crtc_from_fb(struct drm_device *dev,
  97                                   struct drm_framebuffer *fb)
  98 {
  99         struct drm_crtc *crtc;
 100
 101         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 102                 if (crtc->fb == fb)
 103                         return crtc;
 104         }
 105         return NULL;
 106 }
 107
 108 /**
 109  * drm_framebuffer_create - create a new framebuffer object
 110  * @dev: DRM device
 111  *
 112  * LOCKING:
 113  * Caller must hold mode config lock.
 114  *
 115  * Creates a new framebuffer objects and adds it to @dev's DRM mode_config.
 116  *
 117  * RETURNS:
 118  * Pointer to new framebuffer or NULL on error.
 119  */
 120 struct drm_framebuffer *drm_framebuffer_create(struct drm_device *dev)
 121 {
 122         struct drm_framebuffer *fb;
 123
 124         /* Limit to single framebuffer for now */
 125         if (dev->mode_config.num_fb > 1) {
 126                 mutex_unlock(&dev->mode_config.mutex);
 127                 DRM_ERROR("Attempt to add multiple framebuffers failed\n");
 128                 return NULL;
 129         }
 130
 131         fb = kzalloc(sizeof(struct drm_framebuffer), GFP_KERNEL);
 132         if (!fb)
 133                 return NULL;
 134
 135         fb->id = drm_idr_get(dev, fb);
 136         fb->dev = dev;
 137         dev->mode_config.num_fb++;
 138         list_add(&fb->head, &dev->mode_config.fb_list);
 139
 140         return fb;
 141 }
 142 EXPORT_SYMBOL(drm_framebuffer_create);
 143
 144 /**
 145  * drm_framebuffer_destroy - remove a framebuffer object
 146  * @fb: framebuffer to remove
 147  *
 148  * LOCKING:
 149  * Caller must hold mode config lock.
 150  *
 151  * Scans all the CRTCs in @dev's mode_config.  If they're using @fb, removes
 152  * it, setting it to NULL.
 153  */
 154 void drm_framebuffer_destroy(struct drm_framebuffer *fb)
 155 {
 156         struct drm_device *dev = fb->dev;
 157         struct drm_crtc *crtc;
 158
 159         /* remove from any CRTC */
 160         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 161                 if (crtc->fb == fb)
 162                         crtc->fb = NULL;
 163         }
 164
 165         drm_idr_put(dev, fb->id);
 166         list_del(&fb->head);
 167         dev->mode_config.num_fb--;
 168
 169         kfree(fb);
 170 }
 171 EXPORT_SYMBOL(drm_framebuffer_destroy);
 172
 173 /**
 174  * drm_crtc_create - create a new CRTC object
 175  * @dev: DRM device
 176  * @funcs: callbacks for the new CRTC
 177  *
 178  * LOCKING:
 179  * Caller must hold mode config lock.
 180  *
 181  * Creates a new CRTC object and adds it to @dev's mode_config structure.
 182  *
 183  * RETURNS:
 184  * Pointer to new CRTC object or NULL on error.
 185  */
 186 struct drm_crtc *drm_crtc_create(struct drm_device *dev,
 187                                  const struct drm_crtc_funcs *funcs)
 188 {
 189         struct drm_crtc *crtc;
 190
 191         crtc = kzalloc(sizeof(struct drm_crtc), GFP_KERNEL);
 192         if (!crtc)
 193                 return NULL;
 194
 195         crtc->dev = dev;
 196         crtc->funcs = funcs;
 197
 198         crtc->id = drm_idr_get(dev, crtc);
 199
 200         list_add_tail(&crtc->head, &dev->mode_config.crtc_list);
 201         dev->mode_config.num_crtc++;
 202
 203         return crtc;
 204 }
 205 EXPORT_SYMBOL(drm_crtc_create);
 206
 207 /**
 208  * drm_crtc_destroy - remove a CRTC object
 209  * @crtc: CRTC to remove
 210  *
 211  * LOCKING:
 212  * Caller must hold mode config lock.
 213  *
 214  * Cleanup @crtc.  Calls @crtc's cleanup function, then removes @crtc from
 215  * its associated DRM device's mode_config.  Frees it afterwards.
 216  */
 217 void drm_crtc_destroy(struct drm_crtc *crtc)
 218 {
 219         struct drm_device *dev = crtc->dev;
 220
 221         if (crtc->funcs->cleanup)
 222                 (*crtc->funcs->cleanup)(crtc);
 223
 224         drm_idr_put(dev, crtc->id);
 225         list_del(&crtc->head);
 226         dev->mode_config.num_crtc--;
 227         kfree(crtc);
 228 }
 229 EXPORT_SYMBOL(drm_crtc_destroy);
 230
 231 /**
 232  * drm_crtc_in_use - check if a given CRTC is in a mode_config
 233  * @crtc: CRTC to check
 234  *
 235  * LOCKING:
 236  * Caller must hold mode config lock.
 237  *
 238  * Walk @crtc's DRM device's mode_config and see if it's in use.
 239  *
 240  * RETURNS:
 241  * True if @crtc is part of the mode_config, false otherwise.
 242  */
 243 bool drm_crtc_in_use(struct drm_crtc *crtc)
 244 {
 245         struct drm_output *output;
 246         struct drm_device *dev = crtc->dev;
 247         /* FIXME: Locking around list access? */
 248         list_for_each_entry(output, &dev->mode_config.output_list, head)
 249                 if (output->crtc == crtc)
 250                         return true;
 251         return false;
 252 }
 253 EXPORT_SYMBOL(drm_crtc_in_use);
 254
 255 /*
 256  * Detailed mode info for a standard 640x480@60Hz monitor
 257  */
 258 static struct drm_display_mode std_mode[] = {
 259         { DRM_MODE("640x480", DRM_MODE_TYPE_DEFAULT, 25200, 640, 656,
 260                    752, 800, 0, 480, 490, 492, 525, 0,
 261                    V_NHSYNC | V_NVSYNC) }, /* 640x480@60Hz */
 262 };
 263
 264 /**
 265  * drm_crtc_probe_output_modes - get complete set of display modes
 266  * @dev: DRM device
 267  * @maxX: max width for modes
 268  * @maxY: max height for modes
 269  *
 270  * LOCKING:
 271  * Caller must hold mode config lock.
 272  *
 273  * Based on @dev's mode_config layout, scan all the outputs and try to detect
 274  * modes on them.  Modes will first be added to the output's probed_modes
 275  * list, then culled (based on validity and the @maxX, @maxY parameters) and
 276  * put into the normal modes list.
 277  *
 278  * Intended to be used either at bootup time or when major configuration
 279  * changes have occurred.
 280  *
 281  * FIXME: take into account monitor limits
 282  */
 283 void drm_crtc_probe_output_modes(struct drm_device *dev, int maxX, int maxY)
 284 {
 285         struct drm_output *output;
 286         struct drm_display_mode *mode, *t;
 287         int ret;
 288         //if (maxX == 0 || maxY == 0)
 289         // TODO
 290
 291         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 292
 293                 /* set all modes to the unverified state */
 294                 list_for_each_entry_safe(mode, t, &output->modes, head)
 295                         mode->status = MODE_UNVERIFIED;
 296
 297                 output->status = (*output->funcs->detect)(output);
 298
 299                 if (output->status == output_status_disconnected) {
 300                         DRM_DEBUG("%s is disconnected\n", output->name);
 301                         /* TODO set EDID to NULL */
 302                         continue;
 303                 }
 304
 305                 ret = (*output->funcs->get_modes)(output);
 306
 307                 if (ret) {
 308                         drm_mode_output_list_update(output);
 309                 }
 310
 311                 if (maxX && maxY)
 312                         drm_mode_validate_size(dev, &output->modes, maxX,
 313                                                maxY, 0);
 314                 list_for_each_entry_safe(mode, t, &output->modes, head) {
 315                         if (mode->status == MODE_OK)
 316                                 mode->status = (*output->funcs->mode_valid)(output,mode);
 317                 }
 318
 319
 320                 drm_mode_prune_invalid(dev, &output->modes, TRUE);
 321
 322                 if (list_empty(&output->modes)) {
 323                         struct drm_display_mode *stdmode;
 324
 325                         DRM_DEBUG("No valid modes on %s\n", output->name);
 326
 327                         /* Should we do this here ???
 328                          * When no valid EDID modes are available we end up
 329                          * here and bailed in the past, now we add a standard
 330                          * 640x480@60Hz mode and carry on.
 331                          */
 332                         stdmode = drm_mode_duplicate(dev, &std_mode[0]);
 333                         drm_mode_probed_add(output, stdmode);
 334                         drm_mode_list_concat(&output->probed_modes,
 335                                              &output->modes);
 336
 337                         DRM_DEBUG("Adding standard 640x480 @ 60Hz to %s\n",
 338                                                                 output->name);
 339                 }
 340
 341                 drm_mode_sort(&output->modes);
 342
 343                 DRM_DEBUG("Probed modes for %s\n", output->name);
 344                 list_for_each_entry_safe(mode, t, &output->modes, head) {
 345                         mode->vrefresh = drm_mode_vrefresh(mode);
 346
 347                         drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 348                         drm_mode_debug_printmodeline(dev, mode);
 349                 }
 350         }
 351 }
 352
 353 /**
 354  * drm_crtc_set_mode - set a mode
 355  * @crtc: CRTC to program
 356  * @mode: mode to use
 357  * @x: width of mode
 358  * @y: height of mode
 359  *
 360  * LOCKING:
 361  * Caller must hold mode config lock.
 362  *
 363  * Try to set @mode on @crtc.  Give @crtc and its associated outputs a chance
 364  * to fixup or reject the mode prior to trying to set it.
 365  *
 366  * RETURNS:
 367  * True if the mode was set successfully, or false otherwise.
 368  */
 369 bool drm_crtc_set_mode(struct drm_crtc *crtc, struct drm_display_mode *mode,
 370                        int x, int y)
 371 {
 372         struct drm_device *dev = crtc->dev;
 373         struct drm_display_mode *adjusted_mode, saved_mode;
 374         int saved_x, saved_y;
 375         bool didLock = false;
 376         bool ret = false;
 377         struct drm_output *output;
 378
 379         adjusted_mode = drm_mode_duplicate(dev, mode);
 380
 381         crtc->enabled = drm_crtc_in_use(crtc);
 382
 383         if (!crtc->enabled) {
 384                 return true;
 385         }
 386
 387         didLock = crtc->funcs->lock(crtc);
 388
 389         saved_mode = crtc->mode;
 390         saved_x = crtc->x;
 391         saved_y = crtc->y;
 392
 393         /* Update crtc values up front so the driver can rely on them for mode
 394          * setting.
 395          */
 396         crtc->mode = *mode;
 397         crtc->x = x;
 398         crtc->y = y;
 399
 400         /* XXX short-circuit changes to base location only */
 401
 402         /* Pass our mode to the outputs and the CRTC to give them a chance to
 403          * adjust it according to limitations or output properties, and also
 404          * a chance to reject the mode entirely.
 405          */
 406         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 407
 408                 if (output->crtc != crtc)
 409                         continue;
 410
 411                 if (!output->funcs->mode_fixup(output, mode, adjusted_mode)) {
 412                         goto done;
 413                 }
 414         }
 415
 416         if (!crtc->funcs->mode_fixup(crtc, mode, adjusted_mode)) {
 417                 goto done;
 418         }
 419
 420         /* Prepare the outputs and CRTCs before setting the mode. */
 421         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 422
 423                 if (output->crtc != crtc)
 424                         continue;
 425
 426                 /* Disable the output as the first thing we do. */
 427                 output->funcs->prepare(output);
 428         }
 429
 430         crtc->funcs->prepare(crtc);
 431
 432         /* Set up the DPLL and any output state that needs to adjust or depend
 433          * on the DPLL.
 434          */
 435         crtc->funcs->mode_set(crtc, mode, adjusted_mode, x, y);
 436
 437         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 438
 439                 if (output->crtc != crtc)
 440                         continue;
 441
 442                 DRM_INFO("%s: set mode %s\n", output->name, mode->name);
 443
 444                 output->funcs->mode_set(output, mode, adjusted_mode);
 445         }
 446
 447         /* Now, enable the clocks, plane, pipe, and outputs that we set up. */
 448         crtc->funcs->commit(crtc);
 449
 450         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 451
 452                 if (output->crtc != crtc)
 453                         continue;
 454
 455                 output->funcs->commit(output);
 456
 457 #if 0 // TODO def RANDR_12_INTERFACE
 458                 if (output->randr_output)
 459                         RRPostPendingProperties (output->randr_output);
 460 #endif
 461         }
 462
 463         /* XXX free adjustedmode */
 464         drm_mode_destroy(dev, adjusted_mode);
 465         ret = TRUE;
 466         /* TODO */
 467 //      if (scrn->pScreen)
 468 //              drm_crtc_set_screen_sub_pixel_order(dev);
 469
 470 done:
 471         if (!ret) {
 472                 crtc->x = saved_x;
 473                 crtc->y = saved_y;
 474                 crtc->mode = saved_mode;
 475         }
 476
 477         if (didLock)
 478                 crtc->funcs->unlock (crtc);
 479
 480         return ret;
 481 }
 482 EXPORT_SYMBOL(drm_crtc_set_mode);
 483
 484 /**
 485  * drm_disable_unused_functions - disable unused objects
 486  * @dev: DRM device
 487  *
 488  * LOCKING:
 489  * Caller must hold mode config lock.
 490  *
 491  * If an output or CRTC isn't part of @dev's mode_config, it can be disabled
 492  * by calling its dpms function, which should power it off.
 493  */
 494 void drm_disable_unused_functions(struct drm_device *dev)
 495 {
 496         struct drm_output *output;
 497         struct drm_crtc *crtc;
 498
 499         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 500                 if (!output->crtc)
 501                         (*output->funcs->dpms)(output, DPMSModeOff);
 502         }
 503
 504         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 505                 if (!crtc->enabled)
 506                         crtc->funcs->dpms(crtc, DPMSModeOff);
 507         }
 508 }
 509
 510 /**
 511  * drm_mode_probed_add - add a mode to the specified output's probed mode list
 512  * @output: output the new mode
 513  * @mode: mode data
 514  *
 515  * LOCKING:
 516  * Caller must hold mode config lock.
 517  *
 518  * Add @mode to @output's mode list for later use.
 519  */
 520 void drm_mode_probed_add(struct drm_output *output,
 521                          struct drm_display_mode *mode)
 522 {
 523         list_add(&mode->head, &output->probed_modes);
 524 }
 525 EXPORT_SYMBOL(drm_mode_probed_add);
 526
 527 /**
 528  * drm_mode_remove - remove and free a mode
 529  * @output: output list to modify
 530  * @mode: mode to remove
 531  *
 532  * LOCKING:
 533  * Caller must hold mode config lock.
 534  *
 535  * Remove @mode from @output's mode list, then free it.
 536  */
 537 void drm_mode_remove(struct drm_output *output, struct drm_display_mode *mode)
 538 {
 539         list_del(&mode->head);
 540         kfree(mode);
 541 }
 542 EXPORT_SYMBOL(drm_mode_remove);
 543
 544 /**
 545  * drm_output_create - create a new output
 546  * @dev: DRM device
 547  * @funcs: callbacks for this output
 548  * @name: user visible name of the output
 549  *
 550  * LOCKING:
 551  * Caller must hold @dev's mode_config lock.
 552  *
 553  * Creates a new drm_output structure and adds it to @dev's mode_config
 554  * structure.
 555  *
 556  * RETURNS:
 557  * Pointer to the new output or NULL on error.
 558  */
 559 struct drm_output *drm_output_create(struct drm_device *dev,
 560                                      const struct drm_output_funcs *funcs,
 561                                      const char *name)
 562 {
 563         struct drm_output *output = NULL;
 564
 565         output = kzalloc(sizeof(struct drm_output), GFP_KERNEL);
 566         if (!output)
 567                 return NULL;
 568
 569         output->dev = dev;
 570         output->funcs = funcs;
 571         output->id = drm_idr_get(dev, output);
 572         if (name)
 573                 strncpy(output->name, name, DRM_OUTPUT_LEN);
 574         output->name[DRM_OUTPUT_LEN - 1] = 0;
 575         output->subpixel_order = SubPixelUnknown;
 576         INIT_LIST_HEAD(&output->probed_modes);
 577         INIT_LIST_HEAD(&output->modes);
 578         /* randr_output? */
 579         /* output_set_monitor(output)? */
 580         /* check for output_ignored(output)? */
 581
 582         mutex_lock(&dev->mode_config.mutex);
 583         list_add_tail(&output->head, &dev->mode_config.output_list);
 584         dev->mode_config.num_output++;
 585
 586         mutex_unlock(&dev->mode_config.mutex);
 587
 588         return output;
 589
 590 }
 591 EXPORT_SYMBOL(drm_output_create);
 592
 593 /**
 594  * drm_output_destroy - remove an output
 595  * @output: output to remove
 596  *
 597  * LOCKING:
 598  * Caller must hold @dev's mode_config lock.
 599  *
 600  * Call @output's cleanup function, then remove the output from the DRM
 601  * mode_config after freeing @output's modes.
 602  */
 603 void drm_output_destroy(struct drm_output *output)
 604 {
 605         struct drm_device *dev = output->dev;
 606         struct drm_display_mode *mode, *t;
 607
 608         if (*output->funcs->cleanup)
 609                 (*output->funcs->cleanup)(output);
 610
 611         list_for_each_entry_safe(mode, t, &output->probed_modes, head)
 612                 drm_mode_remove(output, mode);
 613
 614         list_for_each_entry_safe(mode, t, &output->modes, head)
 615                 drm_mode_remove(output, mode);
 616
 617         mutex_lock(&dev->mode_config.mutex);
 618         drm_idr_put(dev, output->id);
 619         list_del(&output->head);
 620         mutex_unlock(&dev->mode_config.mutex);
 621         kfree(output);
 622 }
 623 EXPORT_SYMBOL(drm_output_destroy);
 624
 625 /**
 626  * drm_output_rename - rename an output
 627  * @output: output to rename
 628  * @name: new user visible name
 629  *
 630  * LOCKING:
 631  * None.
 632  *
 633  * Simply stuff a new name into @output's name field, based on @name.
 634  *
 635  * RETURNS:
 636  * True if the name was changed, false otherwise.
 637  */
 638 bool drm_output_rename(struct drm_output *output, const char *name)
 639 {
 640         if (!name)
 641                 return false;
 642
 643         strncpy(output->name, name, DRM_OUTPUT_LEN);
 644         output->name[DRM_OUTPUT_LEN - 1] = 0;
 645
 646         DRM_DEBUG("Changed name to %s\n", output->name);
 647 //      drm_output_set_monitor(output);
 648 //      if (drm_output_ignored(output))
 649 //              return FALSE;
 650
 651         return TRUE;
 652 }
 653 EXPORT_SYMBOL(drm_output_rename);
 654
 655 /**
 656  * drm_mode_create - create a new display mode
 657  * @dev: DRM device
 658  *
 659  * LOCKING:
 660  * None.
 661  *
 662  * Create a new drm_display_mode, give it an ID, and return it.
 663  *
 664  * RETURNS:
 665  * Pointer to new mode on success, NULL on error.
 666  */
 667 struct drm_display_mode *drm_mode_create(struct drm_device *dev)
 668 {
 669         struct drm_display_mode *nmode;
 670
 671         nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);
 672         if (!nmode)
 673                 return NULL;
 674
 675         nmode->mode_id = drm_idr_get(dev, nmode);
 676         return nmode;
 677 }
 678 EXPORT_SYMBOL(drm_mode_create);
 679
 680 /**
 681  * drm_mode_destroy - remove a mode
 682  * @dev: DRM device
 683  * @mode: mode to remove
 684  *
 685  * LOCKING:
 686  * Caller must hold mode config lock.
 687  *
 688  * Free @mode's unique identifier, then free it.
 689  */
 690 void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
 691 {
 692         drm_idr_put(dev, mode->mode_id);
 693
 694         kfree(mode);
 695 }
 696 EXPORT_SYMBOL(drm_mode_destroy);
 697
 698 /**
 699  * drm_mode_config_init - initialize DRM mode_configuration structure
 700  * @dev: DRM device
 701  *
 702  * LOCKING:
 703  * None, should happen single threaded at init time.
 704  *
 705  * Initialize @dev's mode_config structure, used for tracking the graphics
 706  * configuration of @dev.
 707  */
 708 void drm_mode_config_init(struct drm_device *dev)
 709 {
 710         mutex_init(&dev->mode_config.mutex);
 711         INIT_LIST_HEAD(&dev->mode_config.fb_list);
 712         INIT_LIST_HEAD(&dev->mode_config.crtc_list);
 713         INIT_LIST_HEAD(&dev->mode_config.output_list);
 714         INIT_LIST_HEAD(&dev->mode_config.usermode_list);
 715         idr_init(&dev->mode_config.crtc_idr);
 716 }
 717 EXPORT_SYMBOL(drm_mode_config_init);
 718
 719 /**
 720  * drm_get_buffer_object - find the buffer object for a given handle
 721  * @dev: DRM device
 722  * @bo: pointer to caller's buffer_object pointer
 723  * @handle: handle to lookup
 724  *
 725  * LOCKING:
 726  * Must take @dev's struct_mutex to protect buffer object lookup.
 727  *
 728  * Given @handle, lookup the buffer object in @dev and put it in the caller's
 729  * @bo pointer.
 730  *
 731  * RETURNS:
 732  * Zero on success, -EINVAL if the handle couldn't be found.
 733  */
 734 static int drm_get_buffer_object(struct drm_device *dev, struct drm_buffer_object **bo, unsigned long handle)
 735 {
 736         struct drm_user_object *uo;
 737         struct drm_hash_item *hash;
 738         int ret;
 739
 740         *bo = NULL;
 741
 742         mutex_lock(&dev->struct_mutex);
 743         ret = drm_ht_find_item(&dev->object_hash, handle, &hash);
 744         if (ret) {
 745                 DRM_ERROR("Couldn't find handle.\n");
 746                 ret = -EINVAL;
 747                 goto out_err;
 748         }
 749
 750         uo = drm_hash_entry(hash, struct drm_user_object, hash);
 751         if (uo->type != drm_buffer_type) {
 752                 ret = -EINVAL;
 753                 goto out_err;
 754         }
 755
 756         *bo = drm_user_object_entry(uo, struct drm_buffer_object, base);
 757         ret = 0;
 758 out_err:
 759         mutex_unlock(&dev->struct_mutex);
 760         return ret;
 761 }
 762
 763 /**
 764  * drm_pick_crtcs - pick crtcs for output devices
 765  * @dev: DRM device
 766  *
 767  * LOCKING:
 768  * Caller must hold mode config lock.
 769  */
 770 static void drm_pick_crtcs (struct drm_device *dev)
 771 {
 772         int c, o, assigned;
 773         struct drm_output *output, *output_equal;
 774         struct drm_crtc   *crtc;
 775         struct drm_display_mode *des_mode = NULL, *modes, *modes_equal;
 776
 777         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 778                 output->crtc = NULL;
 779
 780                 /* Don't hook up outputs that are disconnected ??
 781                  *
 782                  * This is debateable. Do we want fixed /dev/fbX or
 783                  * dynamic on hotplug (need mode code for that though) ?
 784                  *
 785                  * If we don't hook up outputs now, then we only create
 786                  * /dev/fbX for the output that's enabled, that's good as
 787                  * the users console will be on that output.
 788                  *
 789                  * If we do hook up outputs that are disconnected now, then
 790                  * the user may end up having to muck about with the fbcon
 791                  * map flags to assign his console to the enabled output. Ugh.
 792                  */
 793                 if (output->status != output_status_connected)
 794                         continue;
 795
 796                 des_mode = NULL;
 797                 list_for_each_entry(des_mode, &output->modes, head) {
 798                         if (des_mode->type & DRM_MODE_TYPE_PREFERRED)
 799                                 break;
 800                 }
 801
 802                 /* No preferred mode, let's just select the first available */
 803                 if (!des_mode || !(des_mode->type & DRM_MODE_TYPE_PREFERRED)) {
 804                         list_for_each_entry(des_mode, &output->modes, head) {
 805                                 if (des_mode)
 806                                         break;
 807                         }
 808                 }
 809
 810                 c = -1;
 811                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 812                         assigned = 0;
 813
 814                         c++;
 815                         if ((output->possible_crtcs & (1 << c)) == 0)
 816                                 continue;
 817
 818                         list_for_each_entry(output_equal, &dev->mode_config.output_list, head) {
 819                                 if (output->id == output_equal->id)
 820                                         continue;
 821
 822                                 /* Find out if crtc has been assigned before */
 823                                 if (output_equal->crtc == crtc)
 824                                         assigned = 1;
 825                         }
 826
 827 #if 1 /* continue for now */
 828                         if (assigned)
 829                                 continue;
 830 #endif
 831
 832                         o = -1;
 833                         list_for_each_entry(output_equal, &dev->mode_config.output_list, head) {
 834                                 o++;
 835                                 if (output->id == output_equal->id)
 836                                         continue;
 837
 838                                 list_for_each_entry(modes, &output->modes, head) {
 839                                         list_for_each_entry(modes_equal, &output_equal->modes, head) {
 840                                                 if (drm_mode_equal (modes, modes_equal)) {
 841                                                         if ((output->possible_clones & output_equal->possible_clones) && (output_equal->crtc == crtc)) {
 842                                                                 printk("Cloning %s (0x%lx) to %s (0x%lx)\n",output->name,output->possible_clones,output_equal->name,output_equal->possible_clones);
 843                                                                 assigned = 0;
 844                                                                 goto clone;
 845                                                         }
 846                                                 }
 847                                         }
 848                                 }
 849                         }
 850
 851 clone:
 852                         /* crtc has been assigned skip it */
 853                         if (assigned)
 854                                 continue;
 855
 856                         /* Found a CRTC to attach to, do it ! */
 857                         output->crtc = crtc;
 858                         output->crtc->desired_mode = des_mode;
 859                         output->initial_x = 0;
 860                         output->initial_y = 0;
 861                         DRM_DEBUG("Desired mode for CRTC %d is %s\n",c,des_mode->name);
 862                         break;
 863                 }
 864         }
 865 }
 866
 867
 868 /**
 869  * drm_initial_config - setup a sane initial output configuration
 870  * @dev: DRM device
 871  * @can_grow: this configuration is growable
 872  *
 873  * LOCKING:
 874  * Called at init time, must take mode config lock.
 875  *
 876  * Scan the CRTCs and outputs and try to put together an initial setup.
 877  * At the moment, this is a cloned configuration across all heads with
 878  * a new framebuffer object as the backing store.
 879  *
 880  * RETURNS:
 881  * Zero if everything went ok, nonzero otherwise.
 882  */
 883 bool drm_initial_config(struct drm_device *dev, bool can_grow)
 884 {
 885         struct drm_output *output;
 886         struct drm_crtc *crtc;
 887         int ret = false;
 888
 889         mutex_lock(&dev->mode_config.mutex);
 890
 891         drm_crtc_probe_output_modes(dev, 2048, 2048);
 892
 893         drm_pick_crtcs(dev);
 894
 895         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 896
 897                 /* can't setup the crtc if there's no assigned mode */
 898                 if (!crtc->desired_mode)
 899                         continue;
 900
 901                 /* Now setup the fbdev for attached crtcs */
 902                 dev->driver->fb_probe(dev, crtc);
 903         }
 904
 905         /* This is a little screwy, as we've already walked the outputs
 906          * above, but it's a little bit of magic too. There's the potential
 907          * for things not to get setup above if an existing device gets
 908          * re-assigned thus confusing the hardware. By walking the outputs
 909          * this fixes up their crtc's.
 910          */
 911         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 912
 913                 /* can't setup the output if there's no assigned mode */
 914                 if (!output->crtc || !output->crtc->desired_mode)
 915                         continue;
 916
 917                 /* and needs an attached fb */
 918                 if (output->crtc->fb)
 919                         drm_crtc_set_mode(output->crtc, output->crtc->desired_mode, 0, 0);
 920         }
 921
 922         drm_disable_unused_functions(dev);
 923
 924         mutex_unlock(&dev->mode_config.mutex);
 925         return ret;
 926 }
 927 EXPORT_SYMBOL(drm_initial_config);
 928
 929 /**
 930  * drm_mode_config_cleanup - free up DRM mode_config info
 931  * @dev: DRM device
 932  *
 933  * LOCKING:
 934  * Caller must hold mode config lock.
 935  *
 936  * Free up all the outputs and CRTCs associated with this DRM device, then
 937  * free up the framebuffers and associated buffer objects.
 938  *
 939  * FIXME: cleanup any dangling user buffer objects too
 940  */
 941 void drm_mode_config_cleanup(struct drm_device *dev)
 942 {
 943         struct drm_output *output, *ot;
 944         struct drm_crtc *crtc, *ct;
 945         struct drm_framebuffer *fb, *fbt;
 946         struct drm_display_mode *mode, *mt;
 947         list_for_each_entry_safe(output, ot, &dev->mode_config.output_list, head) {
 948                 drm_output_destroy(output);
 949         }
 950
 951         list_for_each_entry_safe(mode, mt, &dev->mode_config.usermode_list, head) {
 952                 drm_mode_destroy(dev, mode);
 953         }
 954
 955         list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
 956                 if (fb->bo->type != drm_bo_type_kernel)
 957                         drm_framebuffer_destroy(fb);
 958                 else
 959                         dev->driver->fb_remove(dev, drm_crtc_from_fb(dev, fb));
 960         }
 961
 962         list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
 963                 drm_crtc_destroy(crtc);
 964         }
 965
 966 }
 967 EXPORT_SYMBOL(drm_mode_config_cleanup);
 968
 969 /**
 970  * drm_crtc_set_config - set a new config from userspace
 971  * @crtc: CRTC to setup
 972  * @crtc_info: user provided configuration
 973  * @new_mode: new mode to set
 974  * @output_set: set of outputs for the new config
 975  * @fb: new framebuffer
 976  *
 977  * LOCKING:
 978  * Caller must hold mode config lock.
 979  *
 980  * Setup a new configuration, provided by the user in @crtc_info, and enable
 981  * it.
 982  *
 983  * RETURNS:
 984  * Zero. (FIXME)
 985  */
 986 int drm_crtc_set_config(struct drm_crtc *crtc, struct drm_mode_crtc *crtc_info, struct drm_display_mode *new_mode, struct drm_output **output_set, struct drm_framebuffer *fb)
 987 {
 988         struct drm_device *dev = crtc->dev;
 989         struct drm_crtc **save_crtcs, *new_crtc;
 990         bool save_enabled = crtc->enabled;
 991         bool changed;
 992         struct drm_output *output;
 993         int count = 0, ro;
 994
 995         save_crtcs = kzalloc(dev->mode_config.num_crtc * sizeof(struct drm_crtc *), GFP_KERNEL);
 996         if (!save_crtcs)
 997                 return -ENOMEM;
 998
 999         if (crtc->fb != fb)
1000                 changed = true;
1001
1002         if (crtc_info->x != crtc->x || crtc_info->y != crtc->y)
1003                 changed = true;
1004
1005         if (new_mode && (crtc->mode.mode_id != new_mode->mode_id))
1006                 changed = true;
1007
1008         list_for_each_entry(output, &dev->mode_config.output_list, head) {
1009                 save_crtcs[count++] = output->crtc;
1010
1011                 if (output->crtc == crtc)
1012                         new_crtc = NULL;
1013                 else
1014                         new_crtc = output->crtc;
1015
1016                 for (ro = 0; ro < crtc_info->count_outputs; ro++) {
1017                         if (output_set[ro] == output)
1018                                 new_crtc = crtc;
1019                 }
1020                 if (new_crtc != output->crtc) {
1021                         changed = true;
1022                         output->crtc = new_crtc;
1023                 }
1024         }
1025
1026         if (changed) {
1027                 crtc->fb = fb;
1028                 crtc->enabled = (new_mode != NULL);
1029                 if (new_mode != NULL) {
1030                         DRM_DEBUG("attempting to set mode from userspace\n");
1031                         drm_mode_debug_printmodeline(dev, new_mode);
1032                         if (!drm_crtc_set_mode(crtc, new_mode, crtc_info->x,
1033                                                crtc_info->y)) {
1034                                 crtc->enabled = save_enabled;
1035                                 count = 0;
1036                                 list_for_each_entry(output, &dev->mode_config.output_list, head)
1037                                         output->crtc = save_crtcs[count++];
1038                                 kfree(save_crtcs);
1039                                 return -EINVAL;
1040                         }
1041                         crtc->desired_x = crtc_info->x;
1042                         crtc->desired_y = crtc_info->y;
1043                         crtc->desired_mode = new_mode;
1044                 }
1045                 drm_disable_unused_functions(dev);
1046         }
1047         kfree(save_crtcs);
1048         return 0;
1049 }
1050
1051 /**
1052  * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
1053  * @out: drm_mode_modeinfo struct to return to the user
1054  * @in: drm_display_mode to use
1055  *
1056  * LOCKING:
1057  * None.
1058  *
1059  * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to
1060  * the user.
1061  */
1062 void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, struct drm_display_mode *in)
1063 {
1064
1065         out->id = in->mode_id;
1066         out->clock = in->clock;
1067         out->hdisplay = in->hdisplay;
1068         out->hsync_start = in->hsync_start;
1069         out->hsync_end = in->hsync_end;
1070         out->htotal = in->htotal;
1071         out->hskew = in->hskew;
1072         out->vdisplay = in->vdisplay;
1073         out->vsync_start = in->vsync_start;
1074         out->vsync_end = in->vsync_end;
1075         out->vtotal = in->vtotal;
1076         out->vscan = in->vscan;
1077         out->vrefresh = in->vrefresh;
1078         out->flags = in->flags;
1079         out->type = in->type;
1080         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1081         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1082 }
1083
1084 /**
1085  * drm_crtc_convert_to_umode - convert a modeinfo into a drm_display_mode
1086  * @out: drm_display_mode to return to the user
1087  * @in: drm_mode_modeinfo to use
1088  *
1089  * LOCKING:
1090  * None.
1091  *
1092  * Convert a drmo_mode_modeinfo into a drm_display_mode structure to return to
1093  * the caller.
1094  */
1095 void drm_crtc_convert_umode(struct drm_display_mode *out, struct drm_mode_modeinfo *in)
1096 {
1097         out->clock = in->clock;
1098         out->hdisplay = in->hdisplay;
1099         out->hsync_start = in->hsync_start;
1100         out->hsync_end = in->hsync_end;
1101         out->htotal = in->htotal;
1102         out->hskew = in->hskew;
1103         out->vdisplay = in->vdisplay;
1104         out->vsync_start = in->vsync_start;
1105         out->vsync_end = in->vsync_end;
1106         out->vtotal = in->vtotal;
1107         out->vscan = in->vscan;
1108         out->vrefresh = in->vrefresh;
1109         out->flags = in->flags;
1110         out->type = in->type;
1111         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1112         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1113 }
1114
1115 /**
1116  * drm_mode_getresources - get graphics configuration
1117  * @inode: inode from the ioctl
1118  * @filp: file * from the ioctl
1119  * @cmd: cmd from ioctl
1120  * @arg: arg from ioctl
1121  *
1122  * LOCKING:
1123  * Takes mode config lock.
1124  *
1125  * Construct a set of configuration description structures and return
1126  * them to the user, including CRTC, output and framebuffer configuration.
1127  *
1128  * Called by the user via ioctl.
1129  *
1130  * RETURNS:
1131  * Zero on success, errno on failure.
1132  */
1133 int drm_mode_getresources(struct drm_device *dev,
1134                           void *data, struct drm_file *file_priv)
1135 {
1136         struct drm_mode_card_res *card_res = data;
1137         struct list_head *lh;
1138         struct drm_framebuffer *fb;
1139         struct drm_output *output;
1140         struct drm_crtc *crtc;
1141         struct drm_mode_modeinfo u_mode;
1142         struct drm_display_mode *mode;
1143         int ret = 0;
1144         int mode_count= 0;
1145         int output_count = 0;
1146         int crtc_count = 0;
1147         int fb_count = 0;
1148         int copied = 0;
1149
1150         memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
1151
1152         mutex_lock(&dev->mode_config.mutex);
1153
1154         list_for_each(lh, &dev->mode_config.fb_list)
1155                 fb_count++;
1156
1157         list_for_each(lh, &dev->mode_config.crtc_list)
1158                 crtc_count++;
1159
1160         list_for_each_entry(output, &dev->mode_config.output_list,
1161                             head) {
1162                 output_count++;
1163                 list_for_each(lh, &output->modes)
1164                         mode_count++;
1165         }
1166         list_for_each(lh, &dev->mode_config.usermode_list)
1167                 mode_count++;
1168
1169         if (card_res->count_modes == 0) {
1170                 DRM_DEBUG("probing modes %dx%d\n", dev->mode_config.max_width, dev->mode_config.max_height);
1171                 drm_crtc_probe_output_modes(dev, dev->mode_config.max_width, dev->mode_config.max_height);
1172                 mode_count = 0;
1173                 list_for_each_entry(output, &dev->mode_config.output_list, head) {
1174                         list_for_each(lh, &output->modes)
1175                                 mode_count++;
1176                 }
1177                 list_for_each(lh, &dev->mode_config.usermode_list)
1178                         mode_count++;
1179         }
1180
1181         /* handle this in 4 parts */
1182         /* FBs */
1183         if (card_res->count_fbs >= fb_count) {
1184                 copied = 0;
1185                 list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
1186                         card_res->fb_id[copied++] = fb->id;
1187                 }
1188         }
1189         card_res->count_fbs = fb_count;
1190
1191         /* CRTCs */
1192         if (card_res->count_crtcs >= crtc_count) {
1193                 copied = 0;
1194                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head){
1195                         DRM_DEBUG("CRTC ID is %d\n", crtc->id);
1196                         card_res->crtc_id[copied++] = crtc->id;
1197                 }
1198         }
1199         card_res->count_crtcs = crtc_count;
1200
1201
1202         /* Outputs */
1203         if (card_res->count_outputs >= output_count) {
1204                 copied = 0;
1205                 list_for_each_entry(output, &dev->mode_config.output_list,
1206                                     head) {
1207                         DRM_DEBUG("OUTPUT ID is %d\n", output->id);
1208                         card_res->output_id[copied++] = output->id;
1209                 }
1210         }
1211         card_res->count_outputs = output_count;
1212
1213         /* Modes */
1214         if (card_res->count_modes >= mode_count) {
1215                 copied = 0;
1216                 list_for_each_entry(output, &dev->mode_config.output_list,
1217                                     head) {
1218                         list_for_each_entry(mode, &output->modes, head) {
1219                                 drm_crtc_convert_to_umode(&u_mode, mode);
1220                                 card_res->modes[copied++] = u_mode;
1221                         }
1222                 }
1223                 /* add in user modes */
1224                 list_for_each_entry(mode, &dev->mode_config.usermode_list, head) {
1225                         drm_crtc_convert_to_umode(&u_mode, mode);
1226                         card_res->modes[copied++] = u_mode;
1227                 }
1228         }
1229         card_res->count_modes = mode_count;
1230
1231         DRM_DEBUG("Counted %d %d %d\n", card_res->count_crtcs,
1232                   card_res->count_outputs,
1233                   card_res->count_modes);
1234
1235         mutex_unlock(&dev->mode_config.mutex);
1236         return ret;
1237 }
1238
1239 /**
1240  * drm_mode_getcrtc - get CRTC configuration
1241  * @inode: inode from the ioctl
1242  * @filp: file * from the ioctl
1243  * @cmd: cmd from ioctl
1244  * @arg: arg from ioctl
1245  *
1246  * LOCKING:
1247  * Caller? (FIXME)
1248  *
1249  * Construct a CRTC configuration structure to return to the user.
1250  *
1251  * Called by the user via ioctl.
1252  *
1253  * RETURNS:
1254  * Zero on success, errno on failure.
1255  */
1256 int drm_mode_getcrtc(struct drm_device *dev,
1257                      void *data, struct drm_file *file_priv)
1258 {
1259         struct drm_mode_crtc *crtc_resp = data;
1260         struct drm_crtc *crtc;
1261         struct drm_output *output;
1262         int ocount;
1263         int ret = 0;
1264
1265         mutex_lock(&dev->mode_config.mutex);
1266         crtc = idr_find(&dev->mode_config.crtc_idr, crtc_resp->crtc_id);
1267         if (!crtc || (crtc->id != crtc_resp->crtc_id)) {
1268                 ret = -EINVAL;
1269                 goto out;
1270         }
1271
1272         crtc_resp->x = crtc->x;
1273         crtc_resp->y = crtc->y;
1274
1275         if (crtc->fb)
1276                 crtc_resp->fb_id = crtc->fb->id;
1277         else
1278                 crtc_resp->fb_id = 0;
1279
1280         crtc_resp->outputs = 0;
1281         if (crtc->enabled) {
1282
1283                 crtc_resp->mode = crtc->mode.mode_id;
1284                 ocount = 0;
1285                 list_for_each_entry(output, &dev->mode_config.output_list, head) {
1286                         if (output->crtc == crtc)
1287                                 crtc_resp->outputs |= 1 << (ocount++);
1288                 }
1289         } else {
1290                 crtc_resp->mode = 0;
1291         }
1292
1293 out:
1294         mutex_unlock(&dev->mode_config.mutex);
1295         return ret;
1296 }
1297
1298 /**
1299  * drm_mode_getoutput - get output configuration
1300  * @inode: inode from the ioctl
1301  * @filp: file * from the ioctl
1302  * @cmd: cmd from ioctl
1303  * @arg: arg from ioctl
1304  *
1305  * LOCKING:
1306  * Caller? (FIXME)
1307  *
1308  * Construct a output configuration structure to return to the user.
1309  *
1310  * Called by the user via ioctl.
1311  *
1312  * RETURNS:
1313  * Zero on success, errno on failure.
1314  */
1315 int drm_mode_getoutput(struct drm_device *dev,
1316                        void *data, struct drm_file *file_priv)
1317 {
1318         struct drm_mode_get_output *out_resp = data;
1319         struct drm_output *output;
1320         struct drm_display_mode *mode;
1321         int mode_count = 0;
1322         int ret = 0;
1323         int copied = 0;
1324         int i;
1325
1326         DRM_DEBUG("output id %d:\n", out_resp->output);
1327
1328         mutex_lock(&dev->mode_config.mutex);
1329         output= idr_find(&dev->mode_config.crtc_idr, out_resp->output);
1330         if (!output || (output->id != out_resp->output)) {
1331                 ret = -EINVAL;
1332                 goto done;
1333         }
1334
1335         list_for_each_entry(mode, &output->modes, head)
1336                 mode_count++;
1337
1338         for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++)
1339                 if (output->user_mode_ids[i] != 0)
1340                         mode_count++;
1341
1342         strncpy(out_resp->name, output->name, DRM_OUTPUT_NAME_LEN);
1343         out_resp->name[DRM_OUTPUT_NAME_LEN-1] = 0;
1344
1345         out_resp->mm_width = output->mm_width;
1346         out_resp->mm_height = output->mm_height;
1347         out_resp->subpixel = output->subpixel_order;
1348         out_resp->connection = output->status;
1349         if (output->crtc)
1350                 out_resp->crtc = output->crtc->id;
1351         else
1352                 out_resp->crtc = 0;
1353
1354         out_resp->crtcs = output->possible_crtcs;
1355         out_resp->clones = output->possible_clones;
1356         if ((out_resp->count_modes >= mode_count) && mode_count) {
1357                 copied = 0;
1358                 list_for_each_entry(mode, &output->modes, head) {
1359                         out_resp->modes[copied++] = mode->mode_id;
1360                 }
1361                 for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
1362                         if (output->user_mode_ids[i] != 0)
1363                                 out_resp->modes[copied++] = output->user_mode_ids[i];
1364                 }
1365
1366         }
1367         out_resp->count_modes = mode_count;
1368
1369 done:
1370         mutex_unlock(&dev->mode_config.mutex);
1371         return ret;
1372 }
1373
1374 /**
1375  * drm_mode_setcrtc - set CRTC configuration
1376  * @inode: inode from the ioctl
1377  * @filp: file * from the ioctl
1378  * @cmd: cmd from ioctl
1379  * @arg: arg from ioctl
1380  *
1381  * LOCKING:
1382  * Caller? (FIXME)
1383  *
1384  * Build a new CRTC configuration based on user request.
1385  *
1386  * Called by the user via ioctl.
1387  *
1388  * RETURNS:
1389  * Zero on success, errno on failure.
1390  */
1391 int drm_mode_setcrtc(struct drm_device *dev,
1392                      void *data, struct drm_file *file_priv)
1393 {
1394         struct drm_mode_crtc *crtc_req = data;
1395         struct drm_crtc *crtc;
1396         struct drm_output **output_set = NULL, *output;
1397         struct drm_display_mode *mode;
1398         struct drm_framebuffer *fb = NULL;
1399         int ret = 0;
1400         int i;
1401
1402         mutex_lock(&dev->mode_config.mutex);
1403         crtc = idr_find(&dev->mode_config.crtc_idr, crtc_req->crtc_id);
1404         if (!crtc || (crtc->id != crtc_req->crtc_id)) {
1405                 DRM_DEBUG("Unknown CRTC ID %d\n", crtc_req->crtc_id);
1406                 ret = -EINVAL;
1407                 goto out;
1408         }
1409
1410         if (crtc_req->mode) {
1411                 /* if we have a mode we need a framebuffer */
1412                 if (crtc_req->fb_id) {
1413                         fb = idr_find(&dev->mode_config.crtc_idr, crtc_req->fb_id);
1414                         if (!fb || (fb->id != crtc_req->fb_id)) {
1415                                 DRM_DEBUG("Unknown FB ID%d\n", crtc_req->fb_id);
1416                                 ret = -EINVAL;
1417                                 goto out;
1418                         }
1419                 }
1420                 mode = idr_find(&dev->mode_config.crtc_idr, crtc_req->mode);
1421                 if (!mode || (mode->mode_id != crtc_req->mode)) {
1422                         struct drm_output *output;
1423
1424                         list_for_each_entry(output,
1425                                             &dev->mode_config.output_list,
1426                                             head) {
1427                                 list_for_each_entry(mode, &output->modes,
1428                                                     head) {
1429                                         drm_mode_debug_printmodeline(dev,
1430                                                                      mode);
1431                                 }
1432                         }
1433
1434                         DRM_DEBUG("Unknown mode id %d, %p\n", crtc_req->mode, mode);
1435                         ret = -EINVAL;
1436                         goto out;
1437                 }
1438         } else
1439                 mode = NULL;
1440
1441         if (crtc_req->count_outputs == 0 && mode) {
1442                 DRM_DEBUG("Count outputs is 0 but mode set\n");
1443                 ret = -EINVAL;
1444                 goto out;
1445         }
1446
1447         if (crtc_req->count_outputs > 0 && !mode && !fb) {
1448                 DRM_DEBUG("Count outputs is %d but no mode or fb set\n", crtc_req->count_outputs);
1449                 ret = -EINVAL;
1450                 goto out;
1451         }
1452
1453         if (crtc_req->count_outputs > 0) {
1454                 u32 out_id;
1455                 output_set = kmalloc(crtc_req->count_outputs *
1456                                      sizeof(struct drm_output *), GFP_KERNEL);
1457                 if (!output_set) {
1458                         ret = -ENOMEM;
1459                         goto out;
1460                 }
1461
1462                 for (i = 0; i < crtc_req->count_outputs; i++) {
1463                         if (get_user(out_id, &crtc_req->set_outputs[i])) {
1464                                 ret = -EFAULT;
1465                                 goto out;
1466                         }
1467
1468                         output = idr_find(&dev->mode_config.crtc_idr, out_id);
1469                         if (!output || (out_id != output->id)) {
1470                                 DRM_DEBUG("Output id %d unknown\n", out_id);
1471                                 ret = -EINVAL;
1472                                 goto out;
1473                         }
1474
1475                         output_set[i] = output;
1476                 }
1477         }
1478
1479         ret = drm_crtc_set_config(crtc, crtc_req, mode, output_set, fb);
1480
1481 out:
1482         mutex_unlock(&dev->mode_config.mutex);
1483         return ret;
1484 }
1485
1486 /**
1487  * drm_mode_addfb - add an FB to the graphics configuration
1488  * @inode: inode from the ioctl
1489  * @filp: file * from the ioctl
1490  * @cmd: cmd from ioctl
1491  * @arg: arg from ioctl
1492  *
1493  * LOCKING:
1494  * Takes mode config lock.
1495  *
1496  * Add a new FB to the specified CRTC, given a user request.
1497  *
1498  * Called by the user via ioctl.
1499  *
1500  * RETURNS:
1501  * Zero on success, errno on failure.
1502  */
1503 int drm_mode_addfb(struct drm_device *dev,
1504                    void *data, struct drm_file *file_priv)
1505 {
1506         struct drm_mode_fb_cmd *r = data;
1507         struct drm_mode_config *config = &dev->mode_config;
1508         struct drm_framebuffer *fb;
1509         struct drm_buffer_object *bo;
1510         struct drm_crtc *crtc;
1511         int ret = 0;
1512
1513         if ((config->min_width > r->width) || (r->width > config->max_width)) {
1514                 DRM_ERROR("mode new framebuffer width not within limits\n");
1515                 return -EINVAL;
1516         }
1517         if ((config->min_height > r->height) || (r->height > config->max_height)) {
1518                 DRM_ERROR("mode new framebuffer height not within limits\n");
1519                 return -EINVAL;
1520         }
1521
1522         mutex_lock(&dev->mode_config.mutex);
1523         /* TODO check limits are okay */
1524         ret = drm_get_buffer_object(dev, &bo, r->handle);
1525         if (ret || !bo) {
1526                 ret = -EINVAL;
1527                 goto out;
1528         }
1529
1530         /* TODO check buffer is sufficently large */
1531         /* TODO setup destructor callback */
1532
1533         fb = drm_framebuffer_create(dev);
1534         if (!fb) {
1535                 ret = -EINVAL;
1536                 goto out;
1537         }
1538
1539         fb->width = r->width;
1540         fb->height = r->height;
1541         fb->pitch = r->pitch;
1542         fb->bits_per_pixel = r->bpp;
1543         fb->depth = r->depth;
1544         fb->offset = bo->offset;
1545         fb->bo = bo;
1546
1547         r->buffer_id = fb->id;
1548
1549         list_add(&fb->filp_head, &file_priv->fbs);
1550
1551         /* FIXME: bind the fb to the right crtc */
1552         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
1553                 crtc->fb = fb;
1554                 dev->driver->fb_probe(dev, crtc);
1555         }
1556
1557 out:
1558         mutex_unlock(&dev->mode_config.mutex);
1559         return ret;
1560 }
1561
1562 /**
1563  * drm_mode_rmfb - remove an FB from the configuration
1564  * @inode: inode from the ioctl
1565  * @filp: file * from the ioctl
1566  * @cmd: cmd from ioctl
1567  * @arg: arg from ioctl
1568  *
1569  * LOCKING:
1570  * Takes mode config lock.
1571  *
1572  * Remove the FB specified by the user.
1573  *
1574  * Called by the user via ioctl.
1575  *
1576  * RETURNS:
1577  * Zero on success, errno on failure.
1578  */
1579 int drm_mode_rmfb(struct drm_device *dev,
1580                    void *data, struct drm_file *file_priv)
1581 {
1582         struct drm_framebuffer *fb = 0;
1583         uint32_t *id = data;
1584         int ret = 0;
1585
1586         mutex_lock(&dev->mode_config.mutex);
1587         fb = idr_find(&dev->mode_config.crtc_idr, *id);
1588         /* TODO check that we realy get a framebuffer back. */
1589         if (!fb || (*id != fb->id)) {
1590                 DRM_ERROR("mode invalid framebuffer id\n");
1591                 ret = -EINVAL;
1592                 goto out;
1593         }
1594
1595         /* TODO check if we own the buffer */
1596         /* TODO release all crtc connected to the framebuffer */
1597         /* bind the fb to the crtc for now */
1598         /* TODO unhock the destructor from the buffer object */
1599
1600         if (fb->bo->type != drm_bo_type_kernel)
1601                 drm_framebuffer_destroy(fb);
1602         else
1603                 dev->driver->fb_remove(dev, drm_crtc_from_fb(dev, fb));
1604
1605 out:
1606         mutex_unlock(&dev->mode_config.mutex);
1607         return ret;
1608 }
1609
1610 /**
1611  * drm_mode_getfb - get FB info
1612  * @inode: inode from the ioctl
1613  * @filp: file * from the ioctl
1614  * @cmd: cmd from ioctl
1615  * @arg: arg from ioctl
1616  *
1617  * LOCKING:
1618  * Caller? (FIXME)
1619  *
1620  * Lookup the FB given its ID and return info about it.
1621  *
1622  * Called by the user via ioctl.
1623  *
1624  * RETURNS:
1625  * Zero on success, errno on failure.
1626  */
1627 int drm_mode_getfb(struct drm_device *dev,
1628                    void *data, struct drm_file *file_priv)
1629 {
1630         struct drm_mode_fb_cmd *r = data;
1631         struct drm_framebuffer *fb;
1632         int ret = 0;
1633
1634         mutex_lock(&dev->mode_config.mutex);
1635         fb = idr_find(&dev->mode_config.crtc_idr, r->buffer_id);
1636         if (!fb || (r->buffer_id != fb->id)) {
1637                 DRM_ERROR("invalid framebuffer id\n");
1638                 ret = -EINVAL;
1639                 goto out;
1640         }
1641
1642         r->height = fb->height;
1643         r->width = fb->width;
1644         r->depth = fb->depth;
1645         r->bpp = fb->bits_per_pixel;
1646         r->handle = fb->bo->base.hash.key;
1647         r->pitch = fb->pitch;
1648
1649 out:
1650         mutex_unlock(&dev->mode_config.mutex);
1651         return ret;
1652 }
1653
1654 /**
1655  * drm_fb_release - remove and free the FBs on this file
1656  * @filp: file * from the ioctl
1657  *
1658  * LOCKING:
1659  * Takes mode config lock.
1660  *
1661  * Destroy all the FBs associated with @filp.
1662  *
1663  * Called by the user via ioctl.
1664  *
1665  * RETURNS:
1666  * Zero on success, errno on failure.
1667  */
1668 void drm_fb_release(struct file *filp)
1669 {
1670         struct drm_file *priv = filp->private_data;
1671         struct drm_device *dev = priv->head->dev;
1672         struct drm_framebuffer *fb, *tfb;
1673
1674         mutex_lock(&dev->mode_config.mutex);
1675         list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
1676                 list_del(&fb->filp_head);
1677                 if (fb->bo->type != drm_bo_type_kernel)
1678                         drm_framebuffer_destroy(fb);
1679                 else
1680                         dev->driver->fb_remove(dev, drm_crtc_from_fb(dev, fb));
1681         }
1682         mutex_unlock(&dev->mode_config.mutex);
1683 }
1684
1685 /**
1686  * drm_fb_newmode - adds a user defined mode
1687  * @inode: inode from the ioctl
1688  * @filp: file * from the ioctl
1689  * @cmd: cmd from ioctl
1690  * @arg: arg from ioctl
1691  *
1692  * Adds a user specified mode to the kernel.
1693  *
1694  * Called by the user via ioctl.
1695  *
1696  * RETURNS:
1697  * writes new mode id into arg.
1698  * Zero on success, errno on failure.
1699  */
1700 int drm_mode_addmode(struct drm_device *dev,
1701                      void *data, struct drm_file *file_priv)
1702 {
1703         struct drm_mode_modeinfo *new_mode = data;
1704         struct drm_display_mode *user_mode;
1705         int ret = 0;
1706
1707         mutex_lock(&dev->mode_config.mutex);
1708         user_mode = drm_mode_create(dev);
1709         if (!user_mode) {
1710                 ret = -ENOMEM;
1711                 goto out;
1712         }
1713
1714         drm_crtc_convert_umode(user_mode, new_mode);
1715         user_mode->type |= DRM_MODE_TYPE_USERDEF;
1716
1717         user_mode->output_count = 0;
1718
1719         list_add(&user_mode->head, &dev->mode_config.usermode_list);
1720
1721         new_mode->id = user_mode->mode_id;
1722
1723 out:
1724         mutex_unlock(&dev->mode_config.mutex);
1725         return ret;
1726 }
1727
1728 /**
1729  * drm_fb_rmmode - removes a user defined mode
1730  * @inode: inode from the ioctl
1731  * @filp: file * from the ioctl
1732  * @cmd: cmd from ioctl
1733  * @arg: arg from ioctl
1734  *
1735  * Remove the user defined mode specified by the user.
1736  *
1737  * Called by the user via ioctl
1738  *
1739  * RETURNS:
1740  * Zero on success, errno on failure.
1741  */
1742 int drm_mode_rmmode(struct drm_device *dev,
1743                     void *data, struct drm_file *file_priv)
1744 {
1745         uint32_t *id = data;
1746         struct drm_display_mode *mode, *t;
1747         int ret = -EINVAL;
1748
1749         mutex_lock(&dev->mode_config.mutex);
1750         mode = idr_find(&dev->mode_config.crtc_idr, *id);
1751         if (!mode || (*id != mode->mode_id)) {
1752                 ret = -EINVAL;
1753                 goto out;
1754         }
1755
1756         if (!(mode->type & DRM_MODE_TYPE_USERDEF)) {
1757                 ret = -EINVAL;
1758                 goto out;
1759         }
1760
1761         if (mode->output_count) {
1762                 ret = -EINVAL;
1763                 goto out;
1764         }
1765
1766         list_for_each_entry(t, &dev->mode_config.usermode_list, head) {
1767                 if (t == mode) {
1768                         list_del(&mode->head);
1769                         drm_mode_destroy(dev, mode);
1770                         ret = 0;
1771                         break;
1772                 }
1773         }
1774
1775 out:
1776         mutex_unlock(&dev->mode_config.mutex);
1777         return ret;
1778 }
1779
1780 /**
1781  * drm_fb_attachmode - Attach a user mode to an output
1782  * @inode: inode from the ioctl
1783  * @filp: file * from the ioctl
1784  * @cmd: cmd from ioctl
1785  * @arg: arg from ioctl
1786  *
1787  * This attaches a user specified mode to an output.
1788  * Called by the user via ioctl.
1789  *
1790  * RETURNS:
1791  * Zero on success, errno on failure.
1792  */
1793 int drm_mode_attachmode(struct drm_device *dev,
1794                         void *data, struct drm_file *file_priv)
1795 {
1796         struct drm_mode_mode_cmd *mode_cmd = data;
1797         struct drm_output *output;
1798         struct drm_display_mode *mode;
1799         int i, ret = 0;
1800
1801         mutex_lock(&dev->mode_config.mutex);
1802
1803         mode = idr_find(&dev->mode_config.crtc_idr, mode_cmd->mode_id);
1804         if (!mode || (mode->mode_id != mode_cmd->mode_id)) {
1805                 ret = -EINVAL;
1806                 goto out;
1807         }
1808
1809         output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
1810         if (!output || (output->id != mode_cmd->output_id)) {
1811                 ret = -EINVAL;
1812                 goto out;
1813         }
1814
1815         for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
1816                 if (output->user_mode_ids[i] == 0) {
1817                         output->user_mode_ids[i] = mode->mode_id;
1818                         mode->output_count++;
1819                         break;
1820                 }
1821         }
1822
1823         if (i == DRM_OUTPUT_MAX_UMODES)
1824                 ret = -ENOSPC;
1825
1826 out:
1827         mutex_unlock(&dev->mode_config.mutex);
1828         return ret;
1829 }
1830
1831
1832 /**
1833  * drm_fb_detachmode - Detach a user specified mode from an output
1834  * @inode: inode from the ioctl
1835  * @filp: file * from the ioctl
1836  * @cmd: cmd from ioctl
1837  * @arg: arg from ioctl
1838  *
1839  * Called by the user via ioctl.
1840  *
1841  * RETURNS:
1842  * Zero on success, errno on failure.
1843  */
1844 int drm_mode_detachmode(struct drm_device *dev,
1845                         void *data, struct drm_file *file_priv)
1846 {
1847         struct drm_mode_mode_cmd *mode_cmd = data;
1848         struct drm_output *output;
1849         struct drm_display_mode *mode;
1850         int i, found = 0, ret = 0;
1851
1852         mutex_lock(&dev->mode_config.mutex);
1853
1854         mode = idr_find(&dev->mode_config.crtc_idr, mode_cmd->mode_id);
1855         if (!mode || (mode->mode_id != mode_cmd->mode_id)) {
1856                 ret = -EINVAL;
1857                 goto out;
1858         }
1859
1860         output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
1861         if (!output || (output->id != mode_cmd->output_id)) {
1862                 ret = -EINVAL;
1863                 goto out;
1864         }
1865
1866
1867         for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
1868                 if (output->user_mode_ids[i] == mode->mode_id) {
1869                         output->user_mode_ids[i] = 0;
1870                         mode->output_count--;
1871                         found = 1;
1872                 }
1873         }
1874
1875         if (!found)
1876                 ret = -EINVAL;
1877
1878 out:
1879         mutex_unlock(&dev->mode_config.mutex);
1880         return ret;
1881 }