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