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         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1080         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1081 }
1082
1083 /**
1084  * drm_crtc_convert_to_umode - convert a modeinfo into a drm_display_mode
1085  * @out: drm_display_mode to return to the user
1086  * @in: drm_mode_modeinfo to use
1087  *
1088  * LOCKING:
1089  * None.
1090  *
1091  * Convert a drmo_mode_modeinfo into a drm_display_mode structure to return to
1092  * the caller.
1093  */
1094 void drm_crtc_convert_umode(struct drm_display_mode *out, struct drm_mode_modeinfo *in)
1095 {
1096         out->clock = in->clock;
1097         out->hdisplay = in->hdisplay;
1098         out->hsync_start = in->hsync_start;
1099         out->hsync_end = in->hsync_end;
1100         out->htotal = in->htotal;
1101         out->hskew = in->hskew;
1102         out->vdisplay = in->vdisplay;
1103         out->vsync_start = in->vsync_start;
1104         out->vsync_end = in->vsync_end;
1105         out->vtotal = in->vtotal;
1106         out->vscan = in->vscan;
1107         out->vrefresh = in->vrefresh;
1108         out->flags = in->flags;
1109         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1110         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1111 }
1112
1113 /**
1114  * drm_mode_getresources - get graphics configuration
1115  * @inode: inode from the ioctl
1116  * @filp: file * from the ioctl
1117  * @cmd: cmd from ioctl
1118  * @arg: arg from ioctl
1119  *
1120  * LOCKING:
1121  * Takes mode config lock.
1122  *
1123  * Construct a set of configuration description structures and return
1124  * them to the user, including CRTC, output and framebuffer configuration.
1125  *
1126  * Called by the user via ioctl.
1127  *
1128  * RETURNS:
1129  * Zero on success, errno on failure.
1130  */
1131 int drm_mode_getresources(struct drm_device *dev,
1132                           void *data, struct drm_file *file_priv)
1133 {
1134         struct drm_mode_card_res *card_res = data;
1135         struct list_head *lh;
1136         struct drm_framebuffer *fb;
1137         struct drm_output *output;
1138         struct drm_crtc *crtc;
1139         struct drm_mode_modeinfo u_mode;
1140         struct drm_display_mode *mode;
1141         int ret = 0;
1142         int mode_count= 0;
1143         int output_count = 0;
1144         int crtc_count = 0;
1145         int fb_count = 0;
1146         int copied = 0;
1147
1148         memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
1149
1150         mutex_lock(&dev->mode_config.mutex);
1151
1152         list_for_each(lh, &dev->mode_config.fb_list)
1153                 fb_count++;
1154
1155         list_for_each(lh, &dev->mode_config.crtc_list)
1156                 crtc_count++;
1157
1158         list_for_each_entry(output, &dev->mode_config.output_list,
1159                             head) {
1160                 output_count++;
1161                 list_for_each(lh, &output->modes)
1162                         mode_count++;
1163         }
1164         list_for_each(lh, &dev->mode_config.usermode_list)
1165                 mode_count++;
1166
1167         if (card_res->count_modes == 0) {
1168                 DRM_DEBUG("probing modes %dx%d\n", dev->mode_config.max_width, dev->mode_config.max_height);
1169                 drm_crtc_probe_output_modes(dev, dev->mode_config.max_width, dev->mode_config.max_height);
1170                 mode_count = 0;
1171                 list_for_each_entry(output, &dev->mode_config.output_list, head) {
1172                         list_for_each(lh, &output->modes)
1173                                 mode_count++;
1174                 }
1175                 list_for_each(lh, &dev->mode_config.usermode_list)
1176                         mode_count++;
1177         }
1178
1179         /* handle this in 4 parts */
1180         /* FBs */
1181         if (card_res->count_fbs >= fb_count) {
1182                 copied = 0;
1183                 list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
1184                         card_res->fb_id[copied++] = fb->id;
1185                 }
1186         }
1187         card_res->count_fbs = fb_count;
1188
1189         /* CRTCs */
1190         if (card_res->count_crtcs >= crtc_count) {
1191                 copied = 0;
1192                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head){
1193                         DRM_DEBUG("CRTC ID is %d\n", crtc->id);
1194                         card_res->crtc_id[copied++] = crtc->id;
1195                 }
1196         }
1197         card_res->count_crtcs = crtc_count;
1198
1199
1200         /* Outputs */
1201         if (card_res->count_outputs >= output_count) {
1202                 copied = 0;
1203                 list_for_each_entry(output, &dev->mode_config.output_list,
1204                                     head) {
1205                         DRM_DEBUG("OUTPUT ID is %d\n", output->id);
1206                         card_res->output_id[copied++] = output->id;
1207                 }
1208         }
1209         card_res->count_outputs = output_count;
1210
1211         /* Modes */
1212         if (card_res->count_modes >= mode_count) {
1213                 copied = 0;
1214                 list_for_each_entry(output, &dev->mode_config.output_list,
1215                                     head) {
1216                         list_for_each_entry(mode, &output->modes, head) {
1217                                 drm_crtc_convert_to_umode(&u_mode, mode);
1218                                 card_res->modes[copied++] = u_mode;
1219                         }
1220                 }
1221                 /* add in user modes */
1222                 list_for_each_entry(mode, &dev->mode_config.usermode_list, head) {
1223                         drm_crtc_convert_to_umode(&u_mode, mode);
1224                         card_res->modes[copied++] = u_mode;
1225                 }
1226         }
1227         card_res->count_modes = mode_count;
1228
1229         DRM_DEBUG("Counted %d %d %d\n", card_res->count_crtcs,
1230                   card_res->count_outputs,
1231                   card_res->count_modes);
1232
1233         mutex_unlock(&dev->mode_config.mutex);
1234         return ret;
1235 }
1236
1237 /**
1238  * drm_mode_getcrtc - get CRTC configuration
1239  * @inode: inode from the ioctl
1240  * @filp: file * from the ioctl
1241  * @cmd: cmd from ioctl
1242  * @arg: arg from ioctl
1243  *
1244  * LOCKING:
1245  * Caller? (FIXME)
1246  *
1247  * Construct a CRTC configuration structure to return to the user.
1248  *
1249  * Called by the user via ioctl.
1250  *
1251  * RETURNS:
1252  * Zero on success, errno on failure.
1253  */
1254 int drm_mode_getcrtc(struct drm_device *dev,
1255                      void *data, struct drm_file *file_priv)
1256 {
1257         struct drm_mode_crtc *crtc_resp = data;
1258         struct drm_crtc *crtc;
1259         struct drm_output *output;
1260         int ocount;
1261         int ret = 0;
1262
1263         mutex_lock(&dev->mode_config.mutex);
1264         crtc = idr_find(&dev->mode_config.crtc_idr, crtc_resp->crtc_id);
1265         if (!crtc || (crtc->id != crtc_resp->crtc_id)) {
1266                 ret = -EINVAL;
1267                 goto out;
1268         }
1269
1270         crtc_resp->x = crtc->x;
1271         crtc_resp->y = crtc->y;
1272         crtc_resp->fb_id = 1;
1273
1274         crtc_resp->outputs = 0;
1275         if (crtc->enabled) {
1276
1277                 crtc_resp->mode = crtc->mode.mode_id;
1278                 ocount = 0;
1279                 list_for_each_entry(output, &dev->mode_config.output_list, head) {
1280                         if (output->crtc == crtc)
1281                                 crtc_resp->outputs |= 1 << (ocount++);
1282                 }
1283         } else {
1284                 crtc_resp->mode = 0;
1285         }
1286
1287 out:
1288         mutex_unlock(&dev->mode_config.mutex);
1289         return ret;
1290 }
1291
1292 /**
1293  * drm_mode_getoutput - get output configuration
1294  * @inode: inode from the ioctl
1295  * @filp: file * from the ioctl
1296  * @cmd: cmd from ioctl
1297  * @arg: arg from ioctl
1298  *
1299  * LOCKING:
1300  * Caller? (FIXME)
1301  *
1302  * Construct a output configuration structure to return to the user.
1303  *
1304  * Called by the user via ioctl.
1305  *
1306  * RETURNS:
1307  * Zero on success, errno on failure.
1308  */
1309 int drm_mode_getoutput(struct drm_device *dev,
1310                        void *data, struct drm_file *file_priv)
1311 {
1312         struct drm_mode_get_output *out_resp = data;
1313         struct drm_output *output;
1314         struct drm_display_mode *mode;
1315         int mode_count = 0;
1316         int ret = 0;
1317         int copied = 0;
1318         int i;
1319
1320         DRM_DEBUG("output id %d:\n", out_resp->output);
1321
1322         mutex_lock(&dev->mode_config.mutex);
1323         output= idr_find(&dev->mode_config.crtc_idr, out_resp->output);
1324         if (!output || (output->id != out_resp->output)) {
1325                 ret = -EINVAL;
1326                 goto done;
1327         }
1328
1329         list_for_each_entry(mode, &output->modes, head)
1330                 mode_count++;
1331
1332         for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++)
1333                 if (output->user_mode_ids[i] != 0)
1334                         mode_count++;
1335
1336         strncpy(out_resp->name, output->name, DRM_OUTPUT_NAME_LEN);
1337         out_resp->name[DRM_OUTPUT_NAME_LEN-1] = 0;
1338
1339         out_resp->mm_width = output->mm_width;
1340         out_resp->mm_height = output->mm_height;
1341         out_resp->subpixel = output->subpixel_order;
1342         out_resp->connection = output->status;
1343         if (output->crtc)
1344                 out_resp->crtc = output->crtc->id;
1345         else
1346                 out_resp->crtc = 0;
1347
1348         if ((out_resp->count_modes >= mode_count) && mode_count) {
1349                 copied = 0;
1350                 list_for_each_entry(mode, &output->modes, head) {
1351                         out_resp->modes[copied++] = mode->mode_id;
1352                 }
1353                 for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
1354                         if (output->user_mode_ids[i] != 0)
1355                                 out_resp->modes[copied++] = output->user_mode_ids[i];
1356                 }
1357
1358         }
1359         out_resp->count_modes = mode_count;
1360
1361 done:
1362         mutex_unlock(&dev->mode_config.mutex);
1363         return ret;
1364 }
1365
1366 /**
1367  * drm_mode_setcrtc - set CRTC configuration
1368  * @inode: inode from the ioctl
1369  * @filp: file * from the ioctl
1370  * @cmd: cmd from ioctl
1371  * @arg: arg from ioctl
1372  *
1373  * LOCKING:
1374  * Caller? (FIXME)
1375  *
1376  * Build a new CRTC configuration based on user request.
1377  *
1378  * Called by the user via ioctl.
1379  *
1380  * RETURNS:
1381  * Zero on success, errno on failure.
1382  */
1383 int drm_mode_setcrtc(struct drm_device *dev,
1384                      void *data, struct drm_file *file_priv)
1385 {
1386         struct drm_mode_crtc *crtc_req = data;
1387         struct drm_crtc *crtc;
1388         struct drm_output **output_set = NULL, *output;
1389         struct drm_display_mode *mode;
1390         struct drm_framebuffer *fb = NULL;
1391         int ret = 0;
1392         int i;
1393
1394         mutex_lock(&dev->mode_config.mutex);
1395         crtc = idr_find(&dev->mode_config.crtc_idr, crtc_req->crtc_id);
1396         if (!crtc || (crtc->id != crtc_req->crtc_id)) {
1397                 DRM_DEBUG("Unknown CRTC ID %d\n", crtc_req->crtc_id);
1398                 ret = -EINVAL;
1399                 goto out;
1400         }
1401
1402         if (crtc_req->mode) {
1403                 /* if we have a mode we need a framebuffer */
1404                 if (crtc_req->fb_id) {
1405                         fb = idr_find(&dev->mode_config.crtc_idr, crtc_req->fb_id);
1406                         if (!fb || (fb->id != crtc_req->fb_id)) {
1407                                 DRM_DEBUG("Unknown FB ID%d\n", crtc_req->fb_id);
1408                                 ret = -EINVAL;
1409                                 goto out;
1410                         }
1411                 }
1412                 mode = idr_find(&dev->mode_config.crtc_idr, crtc_req->mode);
1413                 if (!mode || (mode->mode_id != crtc_req->mode)) {
1414                         struct drm_output *output;
1415
1416                         list_for_each_entry(output,
1417                                             &dev->mode_config.output_list,
1418                                             head) {
1419                                 list_for_each_entry(mode, &output->modes,
1420                                                     head) {
1421                                         drm_mode_debug_printmodeline(dev,
1422                                                                      mode);
1423                                 }
1424                         }
1425
1426                         DRM_DEBUG("Unknown mode id %d, %p\n", crtc_req->mode, mode);
1427                         ret = -EINVAL;
1428                         goto out;
1429                 }
1430         } else
1431                 mode = NULL;
1432
1433         if (crtc_req->count_outputs == 0 && mode) {
1434                 DRM_DEBUG("Count outputs is 0 but mode set\n");
1435                 ret = -EINVAL;
1436                 goto out;
1437         }
1438
1439         if (crtc_req->count_outputs > 0 && !mode && !fb) {
1440                 DRM_DEBUG("Count outputs is %d but no mode or fb set\n", crtc_req->count_outputs);
1441                 ret = -EINVAL;
1442                 goto out;
1443         }
1444
1445         if (crtc_req->count_outputs > 0) {
1446                 u32 out_id;
1447                 output_set = kmalloc(crtc_req->count_outputs *
1448                                      sizeof(struct drm_output *), GFP_KERNEL);
1449                 if (!output_set) {
1450                         ret = -ENOMEM;
1451                         goto out;
1452                 }
1453
1454                 for (i = 0; i < crtc_req->count_outputs; i++) {
1455                         if (get_user(out_id, &crtc_req->set_outputs[i])) {
1456                                 ret = -EFAULT;
1457                                 goto out;
1458                         }
1459
1460                         output = idr_find(&dev->mode_config.crtc_idr, out_id);
1461                         if (!output || (out_id != output->id)) {
1462                                 DRM_DEBUG("Output id %d unknown\n", out_id);
1463                                 ret = -EINVAL;
1464                                 goto out;
1465                         }
1466
1467                         output_set[i] = output;
1468                 }
1469         }
1470
1471         ret = drm_crtc_set_config(crtc, crtc_req, mode, output_set, fb);
1472
1473 out:
1474         mutex_unlock(&dev->mode_config.mutex);
1475         return ret;
1476 }
1477
1478 /**
1479  * drm_mode_addfb - add an FB to the graphics configuration
1480  * @inode: inode from the ioctl
1481  * @filp: file * from the ioctl
1482  * @cmd: cmd from ioctl
1483  * @arg: arg from ioctl
1484  *
1485  * LOCKING:
1486  * Takes mode config lock.
1487  *
1488  * Add a new FB to the specified CRTC, given a user request.
1489  *
1490  * Called by the user via ioctl.
1491  *
1492  * RETURNS:
1493  * Zero on success, errno on failure.
1494  */
1495 int drm_mode_addfb(struct drm_device *dev,
1496                    void *data, struct drm_file *file_priv)
1497 {
1498         struct drm_mode_fb_cmd *r = data;
1499         struct drm_mode_config *config = &dev->mode_config;
1500         struct drm_framebuffer *fb;
1501         struct drm_buffer_object *bo;
1502         struct drm_crtc *crtc;
1503         int ret = 0;
1504
1505         if ((config->min_width > r->width) || (r->width > config->max_width)) {
1506                 DRM_ERROR("mode new framebuffer width not within limits\n");
1507                 return -EINVAL;
1508         }
1509         if ((config->min_height > r->height) || (r->height > config->max_height)) {
1510                 DRM_ERROR("mode new framebuffer height not within limits\n");
1511                 return -EINVAL;
1512         }
1513
1514         mutex_lock(&dev->mode_config.mutex);
1515         /* TODO check limits are okay */
1516         ret = drm_get_buffer_object(dev, &bo, r->handle);
1517         if (ret || !bo) {
1518                 ret = -EINVAL;
1519                 goto out;
1520         }
1521
1522         /* TODO check buffer is sufficently large */
1523         /* TODO setup destructor callback */
1524
1525         fb = drm_framebuffer_create(dev);
1526         if (!fb) {
1527                 ret = -EINVAL;
1528                 goto out;
1529         }
1530
1531         fb->width = r->width;
1532         fb->height = r->height;
1533         fb->pitch = r->pitch;
1534         fb->bits_per_pixel = r->bpp;
1535         fb->depth = r->depth;
1536         fb->offset = bo->offset;
1537         fb->bo = bo;
1538
1539         r->buffer_id = fb->id;
1540
1541         list_add(&fb->filp_head, &file_priv->fbs);
1542
1543         /* FIXME: bind the fb to the right crtc */
1544         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
1545                 crtc->fb = fb;
1546                 dev->driver->fb_probe(dev, crtc);
1547         }
1548
1549 out:
1550         mutex_unlock(&dev->mode_config.mutex);
1551         return ret;
1552 }
1553
1554 /**
1555  * drm_mode_rmfb - remove an FB from the configuration
1556  * @inode: inode from the ioctl
1557  * @filp: file * from the ioctl
1558  * @cmd: cmd from ioctl
1559  * @arg: arg from ioctl
1560  *
1561  * LOCKING:
1562  * Takes mode config lock.
1563  *
1564  * Remove the FB specified by the user.
1565  *
1566  * Called by the user via ioctl.
1567  *
1568  * RETURNS:
1569  * Zero on success, errno on failure.
1570  */
1571 int drm_mode_rmfb(struct drm_device *dev,
1572                    void *data, struct drm_file *file_priv)
1573 {
1574         struct drm_framebuffer *fb = 0;
1575         uint32_t *id = data;
1576         int ret = 0;
1577
1578         fb = idr_find(&dev->mode_config.crtc_idr, *id);
1579         /* TODO check that we realy get a framebuffer back. */
1580         if (!fb || (*id != fb->id)) {
1581                 DRM_ERROR("mode invalid framebuffer id\n");
1582                 ret = -EINVAL;
1583                 goto out;
1584         }
1585
1586         /* TODO check if we own the buffer */
1587         /* TODO release all crtc connected to the framebuffer */
1588         /* bind the fb to the crtc for now */
1589         /* TODO unhock the destructor from the buffer object */
1590
1591         if (fb->bo->type != drm_bo_type_kernel)
1592                 drm_framebuffer_destroy(fb);
1593         else
1594                 dev->driver->fb_remove(dev, drm_crtc_from_fb(dev, fb));
1595
1596 out:
1597         mutex_unlock(&dev->mode_config.mutex);
1598         return ret;
1599 }
1600
1601 /**
1602  * drm_mode_getfb - get FB info
1603  * @inode: inode from the ioctl
1604  * @filp: file * from the ioctl
1605  * @cmd: cmd from ioctl
1606  * @arg: arg from ioctl
1607  *
1608  * LOCKING:
1609  * Caller? (FIXME)
1610  *
1611  * Lookup the FB given its ID and return info about it.
1612  *
1613  * Called by the user via ioctl.
1614  *
1615  * RETURNS:
1616  * Zero on success, errno on failure.
1617  */
1618 int drm_mode_getfb(struct drm_device *dev,
1619                    void *data, struct drm_file *file_priv)
1620 {
1621         struct drm_mode_fb_cmd *r = data;
1622         struct drm_framebuffer *fb;
1623         int ret = 0;
1624
1625         mutex_lock(&dev->mode_config.mutex);
1626         fb = idr_find(&dev->mode_config.crtc_idr, r->buffer_id);
1627         if (!fb || (r->buffer_id != fb->id)) {
1628                 DRM_ERROR("invalid framebuffer id\n");
1629                 ret = -EINVAL;
1630                 goto out;
1631         }
1632
1633         r->height = fb->height;
1634         r->width = fb->width;
1635         r->depth = fb->depth;
1636         r->bpp = fb->bits_per_pixel;
1637         r->handle = fb->bo->base.hash.key;
1638         r->pitch = fb->pitch;
1639
1640 out:
1641         mutex_unlock(&dev->mode_config.mutex);
1642         return ret;
1643 }
1644
1645 /**
1646  * drm_fb_release - remove and free the FBs on this file
1647  * @filp: file * from the ioctl
1648  *
1649  * LOCKING:
1650  * Takes mode config lock.
1651  *
1652  * Destroy all the FBs associated with @filp.
1653  *
1654  * Called by the user via ioctl.
1655  *
1656  * RETURNS:
1657  * Zero on success, errno on failure.
1658  */
1659 void drm_fb_release(struct file *filp)
1660 {
1661         struct drm_file *priv = filp->private_data;
1662         struct drm_device *dev = priv->head->dev;
1663         struct drm_framebuffer *fb, *tfb;
1664
1665         mutex_lock(&dev->mode_config.mutex);
1666         list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
1667                 list_del(&fb->filp_head);
1668                 if (fb->bo->type != drm_bo_type_kernel)
1669                         drm_framebuffer_destroy(fb);
1670                 else
1671                         dev->driver->fb_remove(dev, drm_crtc_from_fb(dev, fb));
1672         }
1673         mutex_unlock(&dev->mode_config.mutex);
1674 }
1675
1676 /**
1677  * drm_fb_newmode - adds a user defined mode
1678  * @inode: inode from the ioctl
1679  * @filp: file * from the ioctl
1680  * @cmd: cmd from ioctl
1681  * @arg: arg from ioctl
1682  *
1683  * Adds a user specified mode to the kernel.
1684  *
1685  * Called by the user via ioctl.
1686  *
1687  * RETURNS:
1688  * writes new mode id into arg.
1689  * Zero on success, errno on failure.
1690  */
1691 int drm_mode_addmode(struct drm_device *dev,
1692                      void *data, struct drm_file *file_priv)
1693 {
1694         struct drm_mode_modeinfo *new_mode = data;
1695         struct drm_display_mode *user_mode;
1696         int ret = 0;
1697
1698         mutex_lock(&dev->mode_config.mutex);
1699         user_mode = drm_mode_create(dev);
1700         if (!user_mode) {
1701                 ret = -ENOMEM;
1702                 goto out;
1703         }
1704
1705         drm_crtc_convert_umode(user_mode, new_mode);
1706         user_mode->type |= DRM_MODE_TYPE_USERDEF;
1707
1708         user_mode->output_count = 0;
1709
1710         list_add(&user_mode->head, &dev->mode_config.usermode_list);
1711
1712         new_mode->id = user_mode->mode_id;
1713
1714 out:
1715         mutex_unlock(&dev->mode_config.mutex);
1716         return ret;
1717 }
1718
1719 /**
1720  * drm_fb_rmmode - removes a user defined mode
1721  * @inode: inode from the ioctl
1722  * @filp: file * from the ioctl
1723  * @cmd: cmd from ioctl
1724  * @arg: arg from ioctl
1725  *
1726  * Remove the user defined mode specified by the user.
1727  *
1728  * Called by the user via ioctl
1729  *
1730  * RETURNS:
1731  * Zero on success, errno on failure.
1732  */
1733 int drm_mode_rmmode(struct drm_device *dev,
1734                     void *data, struct drm_file *file_priv)
1735 {
1736         uint32_t *id = data;
1737         struct drm_display_mode *mode, *t;
1738         int ret = -EINVAL;
1739
1740         mutex_lock(&dev->mode_config.mutex);
1741         mode = idr_find(&dev->mode_config.crtc_idr, *id);
1742         if (!mode || (*id != mode->mode_id)) {
1743                 ret = -EINVAL;
1744                 goto out;
1745         }
1746
1747         if (!(mode->type & DRM_MODE_TYPE_USERDEF)) {
1748                 ret = -EINVAL;
1749                 goto out;
1750         }
1751
1752         if (mode->output_count) {
1753                 ret = -EINVAL;
1754                 goto out;
1755         }
1756
1757         list_for_each_entry(t, &dev->mode_config.usermode_list, head) {
1758                 if (t == mode) {
1759                         list_del(&mode->head);
1760                         drm_mode_destroy(dev, mode);
1761                         ret = 0;
1762                         break;
1763                 }
1764         }
1765
1766 out:
1767         mutex_unlock(&dev->mode_config.mutex);
1768         return ret;
1769 }
1770
1771 /**
1772  * drm_fb_attachmode - Attach a user mode to an output
1773  * @inode: inode from the ioctl
1774  * @filp: file * from the ioctl
1775  * @cmd: cmd from ioctl
1776  * @arg: arg from ioctl
1777  *
1778  * This attaches a user specified mode to an output.
1779  * Called by the user via ioctl.
1780  *
1781  * RETURNS:
1782  * Zero on success, errno on failure.
1783  */
1784 int drm_mode_attachmode(struct drm_device *dev,
1785                         void *data, struct drm_file *file_priv)
1786 {
1787         struct drm_mode_mode_cmd *mode_cmd = data;
1788         struct drm_output *output;
1789         struct drm_display_mode *mode;
1790         int i, ret = 0;
1791
1792         mutex_lock(&dev->mode_config.mutex);
1793
1794         mode = idr_find(&dev->mode_config.crtc_idr, mode_cmd->mode_id);
1795         if (!mode || (mode->mode_id != mode_cmd->mode_id)) {
1796                 ret = -EINVAL;
1797                 goto out;
1798         }
1799
1800         output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
1801         if (!output || (output->id != mode_cmd->output_id)) {
1802                 ret = -EINVAL;
1803                 goto out;
1804         }
1805
1806         for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
1807                 if (output->user_mode_ids[i] == 0) {
1808                         output->user_mode_ids[i] = mode->mode_id;
1809                         mode->output_count++;
1810                         break;
1811                 }
1812         }
1813
1814         if (i == DRM_OUTPUT_MAX_UMODES)
1815                 ret = -ENOSPC;
1816
1817 out:
1818         mutex_unlock(&dev->mode_config.mutex);
1819         return ret;
1820 }
1821
1822
1823 /**
1824  * drm_fb_detachmode - Detach a user specified mode from an output
1825  * @inode: inode from the ioctl
1826  * @filp: file * from the ioctl
1827  * @cmd: cmd from ioctl
1828  * @arg: arg from ioctl
1829  *
1830  * Called by the user via ioctl.
1831  *
1832  * RETURNS:
1833  * Zero on success, errno on failure.
1834  */
1835 int drm_mode_detachmode(struct drm_device *dev,
1836                         void *data, struct drm_file *file_priv)
1837 {
1838         struct drm_mode_mode_cmd *mode_cmd = data;
1839         struct drm_output *output;
1840         struct drm_display_mode *mode;
1841         int i, found = 0, ret = 0;
1842
1843         mutex_lock(&dev->mode_config.mutex);
1844
1845         mode = idr_find(&dev->mode_config.crtc_idr, mode_cmd->mode_id);
1846         if (!mode || (mode->mode_id != mode_cmd->mode_id)) {
1847                 ret = -EINVAL;
1848                 goto out;
1849         }
1850
1851         output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
1852         if (!output || (output->id != mode_cmd->output_id)) {
1853                 ret = -EINVAL;
1854                 goto out;
1855         }
1856
1857
1858         for (i = 0; i < DRM_OUTPUT_MAX_UMODES; i++) {
1859                 if (output->user_mode_ids[i] == mode->mode_id) {
1860                         output->user_mode_ids[i] = 0;
1861                         mode->output_count--;
1862                         found = 1;
1863                 }
1864         }
1865
1866         if (!found)
1867                 ret = -EINVAL;
1868
1869 out:
1870         mutex_unlock(&dev->mode_config.mutex);
1871         return ret;
1872 }