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 struct drm_prop_enum_list {
  37         int type;
  38         char *name;
  39 };
  40
  41 /*
  42  * Global properties
  43  */
  44 static struct drm_prop_enum_list drm_dpms_enum_list[] =
  45 { { DPMSModeOn, "On" },
  46   { DPMSModeStandby, "Standby" },
  47   { DPMSModeSuspend, "Suspend" },
  48   { DPMSModeOff, "Off" }
  49 };
  50 static struct drm_prop_enum_list drm_conn_enum_list[] =
  51 { { ConnectorUnknown, "Unknown" },
  52   { ConnectorVGA, "VGA" },
  53   { ConnectorDVII, "DVI-I" },
  54   { ConnectorDVID, "DVI-D" },
  55   { ConnectorDVIA, "DVI-A" },
  56   { ConnectorComposite, "Composite" },
  57   { ConnectorSVIDEO, "SVIDEO" },
  58   { ConnectorLVDS, "LVDS" },
  59   { ConnectorComponent, "Component" },
  60   { Connector9PinDIN, "9-pin DIN" },
  61   { ConnectorDisplayPort, "DisplayPort" },
  62   { ConnectorHDMIA, "HDMI Type A" },
  63   { ConnectorHDMIB, "HDMI Type B" },
  64 };
  65 static struct drm_prop_enum_list drm_output_enum_list[] =
  66 { { DRM_MODE_OUTPUT_NONE, "None" },
  67   { DRM_MODE_OUTPUT_DAC, "DAC" },
  68   { DRM_MODE_OUTPUT_TMDS, "TMDS" },
  69   { DRM_MODE_OUTPUT_LVDS, "LVDS" },
  70   { DRM_MODE_OUTPUT_TVDAC, "TV" },
  71 };
  72
  73 char *drm_get_output_name(struct drm_output *output)
  74 {
  75         static char buf[32];
  76
  77         snprintf(buf, 32, "%s-%d", drm_output_enum_list[output->output_type].name,
  78                  output->output_type_id);
  79         return buf;
  80 }
  81
  82 /**
  83  * drm_idr_get - allocate a new identifier
  84  * @dev: DRM device
  85  * @ptr: object pointer, used to generate unique ID
  86  *
  87  * LOCKING:
  88  * Caller must hold DRM mode_config lock.
  89  *
  90  * Create a unique identifier based on @ptr in @dev's identifier space.  Used
  91  * for tracking modes, CRTCs and outputs.
  92  *
  93  * RETURNS:
  94  * New unique (relative to other objects in @dev) integer identifier for the
  95  * object.
  96  */
  97 int drm_idr_get(struct drm_device *dev, void *ptr)
  98 {
  99         int new_id = 0;
 100         int ret;
 101 again:
 102         if (idr_pre_get(&dev->mode_config.crtc_idr, GFP_KERNEL) == 0) {
 103                 DRM_ERROR("Ran out memory getting a mode number\n");
 104                 return 0;
 105         }
 106
 107         ret = idr_get_new_above(&dev->mode_config.crtc_idr, ptr, 1, &new_id);
 108         if (ret == -EAGAIN)
 109                 goto again;
 110
 111         return new_id;
 112 }
 113
 114 /**
 115  * drm_idr_put - free an identifer
 116  * @dev: DRM device
 117  * @id: ID to free
 118  *
 119  * LOCKING:
 120  * Caller must hold DRM mode_config lock.
 121  *
 122  * Free @id from @dev's unique identifier pool.
 123  */
 124 void drm_idr_put(struct drm_device *dev, int id)
 125 {
 126         idr_remove(&dev->mode_config.crtc_idr, id);
 127 }
 128
 129 /**
 130  * drm_crtc_from_fb - find the CRTC structure associated with an fb
 131  * @dev: DRM device
 132  * @fb: framebuffer in question
 133  *
 134  * LOCKING:
 135  * Caller must hold mode_config lock.
 136  *
 137  * Find CRTC in the mode_config structure that matches @fb.
 138  *
 139  * RETURNS:
 140  * Pointer to the CRTC or NULL if it wasn't found.
 141  */
 142 struct drm_crtc *drm_crtc_from_fb(struct drm_device *dev,
 143                                   struct drm_framebuffer *fb)
 144 {
 145         struct drm_crtc *crtc;
 146
 147         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 148                 if (crtc->fb == fb)
 149                         return crtc;
 150         }
 151         return NULL;
 152 }
 153
 154 /**
 155  * drm_framebuffer_create - create a new framebuffer object
 156  * @dev: DRM device
 157  *
 158  * LOCKING:
 159  * Caller must hold mode config lock.
 160  *
 161  * Creates a new framebuffer objects and adds it to @dev's DRM mode_config.
 162  *
 163  * RETURNS:
 164  * Pointer to new framebuffer or NULL on error.
 165  */
 166 struct drm_framebuffer *drm_framebuffer_create(struct drm_device *dev)
 167 {
 168         struct drm_framebuffer *fb;
 169
 170         fb = kzalloc(sizeof(struct drm_framebuffer), GFP_KERNEL);
 171         if (!fb)
 172                 return NULL;
 173
 174         fb->id = drm_idr_get(dev, fb);
 175         fb->dev = dev;
 176         dev->mode_config.num_fb++;
 177         list_add(&fb->head, &dev->mode_config.fb_list);
 178
 179         return fb;
 180 }
 181 EXPORT_SYMBOL(drm_framebuffer_create);
 182
 183 /**
 184  * drm_framebuffer_destroy - remove a framebuffer object
 185  * @fb: framebuffer to remove
 186  *
 187  * LOCKING:
 188  * Caller must hold mode config lock.
 189  *
 190  * Scans all the CRTCs in @dev's mode_config.  If they're using @fb, removes
 191  * it, setting it to NULL.
 192  */
 193 void drm_framebuffer_destroy(struct drm_framebuffer *fb)
 194 {
 195         struct drm_device *dev = fb->dev;
 196         struct drm_crtc *crtc;
 197
 198         /* remove from any CRTC */
 199         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 200                 if (crtc->fb == fb)
 201                         crtc->fb = NULL;
 202         }
 203
 204         drm_idr_put(dev, fb->id);
 205         list_del(&fb->head);
 206         dev->mode_config.num_fb--;
 207
 208         kfree(fb);
 209 }
 210 EXPORT_SYMBOL(drm_framebuffer_destroy);
 211
 212 /**
 213  * drm_crtc_create - create a new CRTC object
 214  * @dev: DRM device
 215  * @funcs: callbacks for the new CRTC
 216  *
 217  * LOCKING:
 218  * Caller must hold mode config lock.
 219  *
 220  * Creates a new CRTC object and adds it to @dev's mode_config structure.
 221  *
 222  * RETURNS:
 223  * Pointer to new CRTC object or NULL on error.
 224  */
 225 struct drm_crtc *drm_crtc_create(struct drm_device *dev,
 226                                  const struct drm_crtc_funcs *funcs)
 227 {
 228         struct drm_crtc *crtc;
 229
 230         crtc = kzalloc(sizeof(struct drm_crtc), GFP_KERNEL);
 231         if (!crtc)
 232                 return NULL;
 233
 234         crtc->dev = dev;
 235         crtc->funcs = funcs;
 236
 237         crtc->id = drm_idr_get(dev, crtc);
 238
 239         list_add_tail(&crtc->head, &dev->mode_config.crtc_list);
 240         dev->mode_config.num_crtc++;
 241
 242         return crtc;
 243 }
 244 EXPORT_SYMBOL(drm_crtc_create);
 245
 246 /**
 247  * drm_crtc_destroy - remove a CRTC object
 248  * @crtc: CRTC to remove
 249  *
 250  * LOCKING:
 251  * Caller must hold mode config lock.
 252  *
 253  * Cleanup @crtc.  Calls @crtc's cleanup function, then removes @crtc from
 254  * its associated DRM device's mode_config.  Frees it afterwards.
 255  */
 256 void drm_crtc_destroy(struct drm_crtc *crtc)
 257 {
 258         struct drm_device *dev = crtc->dev;
 259
 260         if (crtc->funcs->cleanup)
 261                 (*crtc->funcs->cleanup)(crtc);
 262
 263         drm_idr_put(dev, crtc->id);
 264         list_del(&crtc->head);
 265         dev->mode_config.num_crtc--;
 266         kfree(crtc);
 267 }
 268 EXPORT_SYMBOL(drm_crtc_destroy);
 269
 270 /**
 271  * drm_crtc_in_use - check if a given CRTC is in a mode_config
 272  * @crtc: CRTC to check
 273  *
 274  * LOCKING:
 275  * Caller must hold mode config lock.
 276  *
 277  * Walk @crtc's DRM device's mode_config and see if it's in use.
 278  *
 279  * RETURNS:
 280  * True if @crtc is part of the mode_config, false otherwise.
 281  */
 282 bool drm_crtc_in_use(struct drm_crtc *crtc)
 283 {
 284         struct drm_output *output;
 285         struct drm_device *dev = crtc->dev;
 286         /* FIXME: Locking around list access? */
 287         list_for_each_entry(output, &dev->mode_config.output_list, head)
 288                 if (output->crtc == crtc)
 289                         return true;
 290         return false;
 291 }
 292 EXPORT_SYMBOL(drm_crtc_in_use);
 293
 294 /*
 295  * Detailed mode info for a standard 640x480@60Hz monitor
 296  */
 297 static struct drm_display_mode std_mode[] = {
 298         { DRM_MODE("640x480", DRM_MODE_TYPE_DEFAULT, 25200, 640, 656,
 299                    752, 800, 0, 480, 490, 492, 525, 0,
 300                    V_NHSYNC | V_NVSYNC) }, /* 640x480@60Hz */
 301 };
 302
 303 /**
 304  * drm_crtc_probe_output_modes - get complete set of display modes
 305  * @dev: DRM device
 306  * @maxX: max width for modes
 307  * @maxY: max height for modes
 308  *
 309  * LOCKING:
 310  * Caller must hold mode config lock.
 311  *
 312  * Based on @dev's mode_config layout, scan all the outputs and try to detect
 313  * modes on them.  Modes will first be added to the output's probed_modes
 314  * list, then culled (based on validity and the @maxX, @maxY parameters) and
 315  * put into the normal modes list.
 316  *
 317  * Intended to be used either at bootup time or when major configuration
 318  * changes have occurred.
 319  *
 320  * FIXME: take into account monitor limits
 321  */
 322 void drm_crtc_probe_single_output_modes(struct drm_output *output, int maxX, int maxY)
 323 {
 324         struct drm_device *dev = output->dev;
 325         struct drm_display_mode *mode, *t;
 326         int ret;
 327         //if (maxX == 0 || maxY == 0)
 328         // TODO
 329
 330         /* set all modes to the unverified state */
 331         list_for_each_entry_safe(mode, t, &output->modes, head)
 332                 mode->status = MODE_UNVERIFIED;
 333
 334         output->status = (*output->funcs->detect)(output);
 335
 336         if (output->status == output_status_disconnected) {
 337                 DRM_DEBUG("%s is disconnected\n", drm_get_output_name(output));
 338                 /* TODO set EDID to NULL */
 339                 return;
 340         }
 341
 342         ret = (*output->funcs->get_modes)(output);
 343
 344         if (ret) {
 345                 drm_mode_output_list_update(output);
 346         }
 347
 348         if (maxX && maxY)
 349                 drm_mode_validate_size(dev, &output->modes, maxX,
 350                                        maxY, 0);
 351         list_for_each_entry_safe(mode, t, &output->modes, head) {
 352                 if (mode->status == MODE_OK)
 353                         mode->status = (*output->funcs->mode_valid)(output,mode);
 354         }
 355
 356
 357         drm_mode_prune_invalid(dev, &output->modes, TRUE);
 358
 359         if (list_empty(&output->modes)) {
 360                 struct drm_display_mode *stdmode;
 361
 362                 DRM_DEBUG("No valid modes on %s\n", drm_get_output_name(output));
 363
 364                 /* Should we do this here ???
 365                  * When no valid EDID modes are available we end up
 366                  * here and bailed in the past, now we add a standard
 367                  * 640x480@60Hz mode and carry on.
 368                  */
 369                 stdmode = drm_mode_duplicate(dev, &std_mode[0]);
 370                 drm_mode_probed_add(output, stdmode);
 371                 drm_mode_list_concat(&output->probed_modes,
 372                                      &output->modes);
 373
 374                 DRM_DEBUG("Adding standard 640x480 @ 60Hz to %s\n",
 375                           drm_get_output_name(output));
 376         }
 377
 378         drm_mode_sort(&output->modes);
 379
 380         DRM_DEBUG("Probed modes for %s\n", drm_get_output_name(output));
 381         list_for_each_entry_safe(mode, t, &output->modes, head) {
 382                 mode->vrefresh = drm_mode_vrefresh(mode);
 383
 384                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
 385                 drm_mode_debug_printmodeline(dev, mode);
 386         }
 387 }
 388
 389 void drm_crtc_probe_output_modes(struct drm_device *dev, int maxX, int maxY)
 390 {
 391         struct drm_output *output;
 392
 393         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 394                 drm_crtc_probe_single_output_modes(output, maxX, maxY);
 395         }
 396 }
 397 EXPORT_SYMBOL(drm_crtc_probe_output_modes);
 398
 399 /**
 400  * drm_crtc_set_mode - set a mode
 401  * @crtc: CRTC to program
 402  * @mode: mode to use
 403  * @x: width of mode
 404  * @y: height of mode
 405  *
 406  * LOCKING:
 407  * Caller must hold mode config lock.
 408  *
 409  * Try to set @mode on @crtc.  Give @crtc and its associated outputs a chance
 410  * to fixup or reject the mode prior to trying to set it.
 411  *
 412  * RETURNS:
 413  * True if the mode was set successfully, or false otherwise.
 414  */
 415 bool drm_crtc_set_mode(struct drm_crtc *crtc, struct drm_display_mode *mode,
 416                        int x, int y)
 417 {
 418         struct drm_device *dev = crtc->dev;
 419         struct drm_display_mode *adjusted_mode, saved_mode;
 420         int saved_x, saved_y;
 421         bool didLock = false;
 422         struct drm_output *output;
 423
 424         adjusted_mode = drm_mode_duplicate(dev, mode);
 425
 426         crtc->enabled = drm_crtc_in_use(crtc);
 427
 428         if (!crtc->enabled) {
 429                 return true;
 430         }
 431
 432         didLock = crtc->funcs->lock(crtc);
 433
 434         saved_mode = crtc->mode;
 435         saved_x = crtc->x;
 436         saved_y = crtc->y;
 437
 438         /* Update crtc values up front so the driver can rely on them for mode
 439          * setting.
 440          */
 441         crtc->mode = *mode;
 442         crtc->x = x;
 443         crtc->y = y;
 444
 445         if (drm_mode_equal(&saved_mode, &crtc->mode)) {
 446                 if (saved_x != crtc->x || saved_y != crtc->y) {
 447                         crtc->funcs->mode_set_base(crtc, crtc->x, crtc->y);
 448                         goto done;
 449                 }
 450         }
 451
 452         /* Pass our mode to the outputs and the CRTC to give them a chance to
 453          * adjust it according to limitations or output properties, and also
 454          * a chance to reject the mode entirely.
 455          */
 456         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 457
 458                 if (output->crtc != crtc)
 459                         continue;
 460
 461                 if (!(ret = output->funcs->mode_fixup(output, mode, adjusted_mode))) {
 462                         goto done;
 463                 }
 464         }
 465
 466         if (!(ret = crtc->funcs->mode_fixup(crtc, mode, adjusted_mode))) {
 467                 goto done;
 468         }
 469
 470         /* Prepare the outputs and CRTCs before setting the mode. */
 471         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 472
 473                 if (output->crtc != crtc)
 474                         continue;
 475
 476                 /* Disable the output as the first thing we do. */
 477                 output->funcs->prepare(output);
 478         }
 479
 480         crtc->funcs->prepare(crtc);
 481
 482         /* Set up the DPLL and any output state that needs to adjust or depend
 483          * on the DPLL.
 484          */
 485         crtc->funcs->mode_set(crtc, mode, adjusted_mode, x, y);
 486
 487         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 488
 489                 if (output->crtc != crtc)
 490                         continue;
 491
 492                 DRM_INFO("%s: set mode %s %x\n", drm_get_output_name(output), mode->name, mode->mode_id);
 493
 494                 output->funcs->mode_set(output, mode, adjusted_mode);
 495         }
 496
 497         /* Now, enable the clocks, plane, pipe, and outputs that we set up. */
 498         crtc->funcs->commit(crtc);
 499
 500         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 501
 502                 if (output->crtc != crtc)
 503                         continue;
 504
 505                 output->funcs->commit(output);
 506
 507 #if 0 // TODO def RANDR_12_INTERFACE
 508                 if (output->randr_output)
 509                         RRPostPendingProperties (output->randr_output);
 510 #endif
 511         }
 512
 513         /* XXX free adjustedmode */
 514         drm_mode_destroy(dev, adjusted_mode);
 515         /* TODO */
 516 //      if (scrn->pScreen)
 517 //              drm_crtc_set_screen_sub_pixel_order(dev);
 518
 519 done:
 520         if (!ret) {
 521                 crtc->mode = saved_mode;
 522                 crtc->x = saved_x;
 523                 crtc->y = saved_y;
 524         }
 525
 526         if (didLock)
 527                 crtc->funcs->unlock (crtc);
 528
 529         return ret;
 530 }
 531 EXPORT_SYMBOL(drm_crtc_set_mode);
 532
 533 /**
 534  * drm_disable_unused_functions - disable unused objects
 535  * @dev: DRM device
 536  *
 537  * LOCKING:
 538  * Caller must hold mode config lock.
 539  *
 540  * If an output or CRTC isn't part of @dev's mode_config, it can be disabled
 541  * by calling its dpms function, which should power it off.
 542  */
 543 void drm_disable_unused_functions(struct drm_device *dev)
 544 {
 545         struct drm_output *output;
 546         struct drm_crtc *crtc;
 547
 548         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 549                 if (!output->crtc)
 550                         (*output->funcs->dpms)(output, DPMSModeOff);
 551         }
 552
 553         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 554                 if (!crtc->enabled)
 555                         crtc->funcs->dpms(crtc, DPMSModeOff);
 556         }
 557 }
 558 EXPORT_SYMBOL(drm_disable_unused_functions);
 559
 560 /**
 561  * drm_mode_probed_add - add a mode to the specified output's probed mode list
 562  * @output: output the new mode
 563  * @mode: mode data
 564  *
 565  * LOCKING:
 566  * Caller must hold mode config lock.
 567  *
 568  * Add @mode to @output's mode list for later use.
 569  */
 570 void drm_mode_probed_add(struct drm_output *output,
 571                          struct drm_display_mode *mode)
 572 {
 573         list_add(&mode->head, &output->probed_modes);
 574 }
 575 EXPORT_SYMBOL(drm_mode_probed_add);
 576
 577 /**
 578  * drm_mode_remove - remove and free a mode
 579  * @output: output list to modify
 580  * @mode: mode to remove
 581  *
 582  * LOCKING:
 583  * Caller must hold mode config lock.
 584  *
 585  * Remove @mode from @output's mode list, then free it.
 586  */
 587 void drm_mode_remove(struct drm_output *output, struct drm_display_mode *mode)
 588 {
 589         list_del(&mode->head);
 590         kfree(mode);
 591 }
 592 EXPORT_SYMBOL(drm_mode_remove);
 593
 594 /**
 595  * drm_output_create - create a new output
 596  * @dev: DRM device
 597  * @funcs: callbacks for this output
 598  * @name: user visible name of the output
 599  *
 600  * LOCKING:
 601  * Caller must hold @dev's mode_config lock.
 602  *
 603  * Creates a new drm_output structure and adds it to @dev's mode_config
 604  * structure.
 605  *
 606  * RETURNS:
 607  * Pointer to the new output or NULL on error.
 608  */
 609 struct drm_output *drm_output_create(struct drm_device *dev,
 610                                      const struct drm_output_funcs *funcs,
 611                                      int output_type)
 612 {
 613         struct drm_output *output = NULL;
 614
 615         output = kzalloc(sizeof(struct drm_output), GFP_KERNEL);
 616         if (!output)
 617                 return NULL;
 618
 619         output->dev = dev;
 620         output->funcs = funcs;
 621         output->id = drm_idr_get(dev, output);
 622         output->output_type = output_type;
 623         output->output_type_id = 1; /* TODO */
 624         output->subpixel_order = SubPixelUnknown;
 625         INIT_LIST_HEAD(&output->user_modes);
 626         INIT_LIST_HEAD(&output->probed_modes);
 627         INIT_LIST_HEAD(&output->modes);
 628         /* randr_output? */
 629         /* output_set_monitor(output)? */
 630         /* check for output_ignored(output)? */
 631
 632         mutex_lock(&dev->mode_config.mutex);
 633         list_add_tail(&output->head, &dev->mode_config.output_list);
 634         dev->mode_config.num_output++;
 635
 636         drm_output_attach_property(output, dev->mode_config.edid_property, 0);
 637
 638         drm_output_attach_property(output, dev->mode_config.dpms_property, 0);
 639
 640         mutex_unlock(&dev->mode_config.mutex);
 641
 642         return output;
 643
 644 }
 645 EXPORT_SYMBOL(drm_output_create);
 646
 647 /**
 648  * drm_output_destroy - remove an output
 649  * @output: output to remove
 650  *
 651  * LOCKING:
 652  * Caller must hold @dev's mode_config lock.
 653  *
 654  * Call @output's cleanup function, then remove the output from the DRM
 655  * mode_config after freeing @output's modes.
 656  */
 657 void drm_output_destroy(struct drm_output *output)
 658 {
 659         struct drm_device *dev = output->dev;
 660         struct drm_display_mode *mode, *t;
 661
 662         if (*output->funcs->cleanup)
 663                 (*output->funcs->cleanup)(output);
 664
 665         list_for_each_entry_safe(mode, t, &output->probed_modes, head)
 666                 drm_mode_remove(output, mode);
 667
 668         list_for_each_entry_safe(mode, t, &output->modes, head)
 669                 drm_mode_remove(output, mode);
 670
 671         list_for_each_entry_safe(mode, t, &output->user_modes, head)
 672                 drm_mode_remove(output, mode);
 673
 674         mutex_lock(&dev->mode_config.mutex);
 675         drm_idr_put(dev, output->id);
 676         list_del(&output->head);
 677         mutex_unlock(&dev->mode_config.mutex);
 678         kfree(output);
 679 }
 680 EXPORT_SYMBOL(drm_output_destroy);
 681
 682
 683 /**
 684  * drm_mode_create - create a new display mode
 685  * @dev: DRM device
 686  *
 687  * LOCKING:
 688  * None.
 689  *
 690  * Create a new drm_display_mode, give it an ID, and return it.
 691  *
 692  * RETURNS:
 693  * Pointer to new mode on success, NULL on error.
 694  */
 695 struct drm_display_mode *drm_mode_create(struct drm_device *dev)
 696 {
 697         struct drm_display_mode *nmode;
 698
 699         nmode = kzalloc(sizeof(struct drm_display_mode), GFP_KERNEL);
 700         if (!nmode)
 701                 return NULL;
 702
 703         nmode->mode_id = drm_idr_get(dev, nmode);
 704         return nmode;
 705 }
 706 EXPORT_SYMBOL(drm_mode_create);
 707
 708 /**
 709  * drm_mode_destroy - remove a mode
 710  * @dev: DRM device
 711  * @mode: mode to remove
 712  *
 713  * LOCKING:
 714  * Caller must hold mode config lock.
 715  *
 716  * Free @mode's unique identifier, then free it.
 717  */
 718 void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode)
 719 {
 720         drm_idr_put(dev, mode->mode_id);
 721
 722         kfree(mode);
 723 }
 724 EXPORT_SYMBOL(drm_mode_destroy);
 725
 726 static int drm_mode_create_standard_output_properties(struct drm_device *dev)
 727 {
 728         int i;
 729
 730         /*
 731          * Standard properties (apply to all outputs)
 732          */
 733         dev->mode_config.edid_property =
 734                 drm_property_create(dev, DRM_MODE_PROP_BLOB | DRM_MODE_PROP_IMMUTABLE,
 735                                     "EDID", 0);
 736
 737         dev->mode_config.dpms_property =
 738                 drm_property_create(dev, DRM_MODE_PROP_ENUM, "DPMS", 4);
 739
 740         for (i = 0; i < ARRAY_SIZE(drm_dpms_enum_list); i++)
 741                 drm_property_add_enum(dev->mode_config.dpms_property, i, drm_dpms_enum_list[i].type, drm_dpms_enum_list[i].name);
 742
 743         dev->mode_config.connector_type_property =
 744                 drm_property_create(dev, DRM_MODE_PROP_ENUM | DRM_MODE_PROP_IMMUTABLE,
 745                                     "Connector Type", 10);
 746         for (i = 0; i < ARRAY_SIZE(drm_conn_enum_list); i++)
 747                 drm_property_add_enum(dev->mode_config.connector_type_property, i, drm_conn_enum_list[i].type, drm_conn_enum_list[i].name);
 748
 749         dev->mode_config.connector_num_property =
 750                 drm_property_create(dev, DRM_MODE_PROP_RANGE | DRM_MODE_PROP_IMMUTABLE,
 751                                     "Connector ID", 2);
 752         dev->mode_config.connector_num_property->values[0] = 0;
 753         dev->mode_config.connector_num_property->values[1] = 20;
 754
 755         /*
 756          * TV specific properties
 757          */
 758         dev->mode_config.tv_left_margin_property =
 759                 drm_property_create(dev, DRM_MODE_PROP_RANGE |
 760                                     DRM_MODE_PROP_IMMUTABLE,
 761                                     "left margin", 2);
 762         dev->mode_config.tv_left_margin_property->values[0] = 0;
 763         dev->mode_config.tv_left_margin_property->values[1] = 100;
 764
 765         dev->mode_config.tv_right_margin_property =
 766                 drm_property_create(dev, DRM_MODE_PROP_RANGE |
 767                                     DRM_MODE_PROP_IMMUTABLE,
 768                                     "right margin", 2);
 769         dev->mode_config.tv_right_margin_property->values[0] = 0;
 770         dev->mode_config.tv_right_margin_property->values[1] = 100;
 771
 772         dev->mode_config.tv_top_margin_property =
 773                 drm_property_create(dev, DRM_MODE_PROP_RANGE |
 774                                     DRM_MODE_PROP_IMMUTABLE,
 775                                     "top margin", 2);
 776         dev->mode_config.tv_top_margin_property->values[0] = 0;
 777         dev->mode_config.tv_top_margin_property->values[1] = 100;
 778
 779         dev->mode_config.tv_bottom_margin_property =
 780                 drm_property_create(dev, DRM_MODE_PROP_RANGE |
 781                                     DRM_MODE_PROP_IMMUTABLE,
 782                                     "bottom margin", 2);
 783         dev->mode_config.tv_bottom_margin_property->values[0] = 0;
 784         dev->mode_config.tv_bottom_margin_property->values[1] = 100;
 785
 786
 787         return 0;
 788 }
 789
 790 /**
 791  * drm_mode_config_init - initialize DRM mode_configuration structure
 792  * @dev: DRM device
 793  *
 794  * LOCKING:
 795  * None, should happen single threaded at init time.
 796  *
 797  * Initialize @dev's mode_config structure, used for tracking the graphics
 798  * configuration of @dev.
 799  */
 800 void drm_mode_config_init(struct drm_device *dev)
 801 {
 802         mutex_init(&dev->mode_config.mutex);
 803         INIT_LIST_HEAD(&dev->mode_config.fb_list);
 804         INIT_LIST_HEAD(&dev->mode_config.crtc_list);
 805         INIT_LIST_HEAD(&dev->mode_config.output_list);
 806         INIT_LIST_HEAD(&dev->mode_config.property_list);
 807         INIT_LIST_HEAD(&dev->mode_config.property_blob_list);
 808         idr_init(&dev->mode_config.crtc_idr);
 809
 810         drm_mode_create_standard_output_properties(dev);
 811
 812         /* Just to be sure */
 813         dev->mode_config.num_fb = 0;
 814         dev->mode_config.num_output = 0;
 815         dev->mode_config.num_crtc = 0;
 816         dev->mode_config.hotplug_counter = 0;
 817 }
 818 EXPORT_SYMBOL(drm_mode_config_init);
 819
 820 /**
 821  * drm_get_buffer_object - find the buffer object for a given handle
 822  * @dev: DRM device
 823  * @bo: pointer to caller's buffer_object pointer
 824  * @handle: handle to lookup
 825  *
 826  * LOCKING:
 827  * Must take @dev's struct_mutex to protect buffer object lookup.
 828  *
 829  * Given @handle, lookup the buffer object in @dev and put it in the caller's
 830  * @bo pointer.
 831  *
 832  * RETURNS:
 833  * Zero on success, -EINVAL if the handle couldn't be found.
 834  */
 835 static int drm_get_buffer_object(struct drm_device *dev, struct drm_buffer_object **bo, unsigned long handle)
 836 {
 837         struct drm_user_object *uo;
 838         struct drm_hash_item *hash;
 839         int ret;
 840
 841         *bo = NULL;
 842
 843         mutex_lock(&dev->struct_mutex);
 844         ret = drm_ht_find_item(&dev->object_hash, handle, &hash);
 845         if (ret) {
 846                 DRM_ERROR("Couldn't find handle.\n");
 847                 ret = -EINVAL;
 848                 goto out_err;
 849         }
 850
 851         uo = drm_hash_entry(hash, struct drm_user_object, hash);
 852         if (uo->type != drm_buffer_type) {
 853                 ret = -EINVAL;
 854                 goto out_err;
 855         }
 856
 857         *bo = drm_user_object_entry(uo, struct drm_buffer_object, base);
 858         ret = 0;
 859 out_err:
 860         mutex_unlock(&dev->struct_mutex);
 861         return ret;
 862 }
 863
 864 /**
 865  * drm_pick_crtcs - pick crtcs for output devices
 866  * @dev: DRM device
 867  *
 868  * LOCKING:
 869  * Caller must hold mode config lock.
 870  */
 871 static void drm_pick_crtcs (struct drm_device *dev)
 872 {
 873         int c, o, assigned;
 874         struct drm_output *output, *output_equal;
 875         struct drm_crtc   *crtc;
 876         struct drm_display_mode *des_mode = NULL, *modes, *modes_equal;
 877         int found;
 878
 879         list_for_each_entry(output, &dev->mode_config.output_list, head) {
 880                 output->crtc = NULL;
 881
 882                 /* Don't hook up outputs that are disconnected ??
 883                  *
 884                  * This is debateable. Do we want fixed /dev/fbX or
 885                  * dynamic on hotplug (need mode code for that though) ?
 886                  *
 887                  * If we don't hook up outputs now, then we only create
 888                  * /dev/fbX for the output that's enabled, that's good as
 889                  * the users console will be on that output.
 890                  *
 891                  * If we do hook up outputs that are disconnected now, then
 892                  * the user may end up having to muck about with the fbcon
 893                  * map flags to assign his console to the enabled output. Ugh.
 894                  */
 895                 if (output->status != output_status_connected)
 896                         continue;
 897
 898                 if (list_empty(&output->modes))
 899                         continue;
 900
 901                 des_mode = NULL;
 902                 found = 0;
 903                 list_for_each_entry(des_mode, &output->modes, head) {
 904                         if (des_mode->type & DRM_MODE_TYPE_PREFERRED) {
 905                                 found = 1;
 906                                 break;
 907                         }
 908                 }
 909
 910                 /* No preferred mode, let's just select the first available */
 911                 if (!found) {
 912                         des_mode = NULL;
 913                         list_for_each_entry(des_mode, &output->modes, head) {
 914                                 break;
 915                         }
 916                 }
 917
 918                 c = -1;
 919                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
 920                         assigned = 0;
 921
 922                         c++;
 923                         if ((output->possible_crtcs & (1 << c)) == 0)
 924                                 continue;
 925
 926                         list_for_each_entry(output_equal, &dev->mode_config.output_list, head) {
 927                                 if (output->id == output_equal->id)
 928                                         continue;
 929
 930                                 /* Find out if crtc has been assigned before */
 931                                 if (output_equal->crtc == crtc)
 932                                         assigned = 1;
 933                         }
 934
 935 #if 1 /* continue for now */
 936                         if (assigned)
 937                                 continue;
 938 #endif
 939
 940                         o = -1;
 941                         list_for_each_entry(output_equal, &dev->mode_config.output_list, head) {
 942                                 o++;
 943                                 if (output->id == output_equal->id)
 944                                         continue;
 945
 946                                 list_for_each_entry(modes, &output->modes, head) {
 947                                         list_for_each_entry(modes_equal, &output_equal->modes, head) {
 948                                                 if (drm_mode_equal (modes, modes_equal)) {
 949                                                         if ((output->possible_clones & output_equal->possible_clones) && (output_equal->crtc == crtc)) {
 950                                                                 printk("Cloning %s (0x%lx) to %s (0x%lx)\n",drm_get_output_name(output),output->possible_clones,drm_get_output_name(output_equal),output_equal->possible_clones);
 951                                                                 assigned = 0;
 952                                                                 goto clone;
 953                                                         }
 954                                                 }
 955                                         }
 956                                 }
 957                         }
 958
 959 clone:
 960                         /* crtc has been assigned skip it */
 961                         if (assigned)
 962                                 continue;
 963
 964                         /* Found a CRTC to attach to, do it ! */
 965                         output->crtc = crtc;
 966                         output->crtc->desired_mode = des_mode;
 967                         output->initial_x = 0;
 968                         output->initial_y = 0;
 969                         DRM_DEBUG("Desired mode for CRTC %d is 0x%x:%s\n",c,des_mode->mode_id, des_mode->name);
 970                         break;
 971                 }
 972         }
 973 }
 974 EXPORT_SYMBOL(drm_pick_crtcs);
 975
 976 /**
 977  * drm_initial_config - setup a sane initial output configuration
 978  * @dev: DRM device
 979  * @can_grow: this configuration is growable
 980  *
 981  * LOCKING:
 982  * Called at init time, must take mode config lock.
 983  *
 984  * Scan the CRTCs and outputs and try to put together an initial setup.
 985  * At the moment, this is a cloned configuration across all heads with
 986  * a new framebuffer object as the backing store.
 987  *
 988  * RETURNS:
 989  * Zero if everything went ok, nonzero otherwise.
 990  */
 991 bool drm_initial_config(struct drm_device *dev, bool can_grow)
 992 {
 993         struct drm_output *output;
 994         struct drm_crtc *crtc;
 995         int ret = false;
 996
 997         mutex_lock(&dev->mode_config.mutex);
 998
 999         drm_crtc_probe_output_modes(dev, 2048, 2048);
1000
1001         drm_pick_crtcs(dev);
1002
1003         list_for_each_entry(crtc, &dev->mode_config.crtc_list, head) {
1004
1005                 /* can't setup the crtc if there's no assigned mode */
1006                 if (!crtc->desired_mode)
1007                         continue;
1008
1009                 /* Now setup the fbdev for attached crtcs */
1010                 dev->driver->fb_probe(dev, crtc);
1011         }
1012
1013         /* This is a little screwy, as we've already walked the outputs
1014          * above, but it's a little bit of magic too. There's the potential
1015          * for things not to get setup above if an existing device gets
1016          * re-assigned thus confusing the hardware. By walking the outputs
1017          * this fixes up their crtc's.
1018          */
1019         list_for_each_entry(output, &dev->mode_config.output_list, head) {
1020
1021                 /* can't setup the output if there's no assigned mode */
1022                 if (!output->crtc || !output->crtc->desired_mode)
1023                         continue;
1024
1025                 /* and needs an attached fb */
1026                 if (output->crtc->fb)
1027                         drm_crtc_set_mode(output->crtc, output->crtc->desired_mode, 0, 0);
1028         }
1029
1030         drm_disable_unused_functions(dev);
1031
1032         mutex_unlock(&dev->mode_config.mutex);
1033         return ret;
1034 }
1035 EXPORT_SYMBOL(drm_initial_config);
1036
1037 /**
1038  * drm_mode_config_cleanup - free up DRM mode_config info
1039  * @dev: DRM device
1040  *
1041  * LOCKING:
1042  * Caller must hold mode config lock.
1043  *
1044  * Free up all the outputs and CRTCs associated with this DRM device, then
1045  * free up the framebuffers and associated buffer objects.
1046  *
1047  * FIXME: cleanup any dangling user buffer objects too
1048  */
1049 void drm_mode_config_cleanup(struct drm_device *dev)
1050 {
1051         struct drm_output *output, *ot;
1052         struct drm_crtc *crtc, *ct;
1053         struct drm_framebuffer *fb, *fbt;
1054         struct drm_property *property, *pt;
1055
1056         list_for_each_entry_safe(output, ot, &dev->mode_config.output_list, head) {
1057                 drm_output_destroy(output);
1058         }
1059
1060         list_for_each_entry_safe(property, pt, &dev->mode_config.property_list, head) {
1061                 drm_property_destroy(dev, property);
1062         }
1063
1064         list_for_each_entry_safe(fb, fbt, &dev->mode_config.fb_list, head) {
1065                 /* there should only be bo of kernel type left */
1066                 if (fb->bo->type != drm_bo_type_kernel)
1067                         drm_framebuffer_destroy(fb);
1068                 else
1069                         dev->driver->fb_remove(dev, drm_crtc_from_fb(dev, fb));
1070         }
1071
1072         list_for_each_entry_safe(crtc, ct, &dev->mode_config.crtc_list, head) {
1073                 drm_crtc_destroy(crtc);
1074         }
1075
1076 }
1077 EXPORT_SYMBOL(drm_mode_config_cleanup);
1078
1079 /**
1080  * drm_crtc_set_config - set a new config from userspace
1081  * @crtc: CRTC to setup
1082  * @crtc_info: user provided configuration
1083  * @new_mode: new mode to set
1084  * @output_set: set of outputs for the new config
1085  * @fb: new framebuffer
1086  *
1087  * LOCKING:
1088  * Caller must hold mode config lock.
1089  *
1090  * Setup a new configuration, provided by the user in @crtc_info, and enable
1091  * it.
1092  *
1093  * RETURNS:
1094  * Zero. (FIXME)
1095  */
1096 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)
1097 {
1098         struct drm_device *dev = crtc->dev;
1099         struct drm_crtc **save_crtcs, *new_crtc;
1100         bool save_enabled = crtc->enabled;
1101         bool changed = false;
1102         bool flip_or_move = false;
1103         struct drm_output *output;
1104         int count = 0, ro;
1105
1106         /* this is meant to be num_output not num_crtc */
1107         save_crtcs = kzalloc(dev->mode_config.num_output * sizeof(struct drm_crtc *), GFP_KERNEL);
1108         if (!save_crtcs)
1109                 return -ENOMEM;
1110
1111         /* We should be able to check here if the fb has the same properties
1112          * and then just flip_or_move it */
1113         if (crtc->fb != fb)
1114                 changed = true;
1115
1116         if (crtc_info->x != crtc->x || crtc_info->y != crtc->y)
1117                 flip_or_move = true;
1118
1119         if (new_mode && !drm_mode_equal(new_mode, &crtc->mode))
1120                 changed = true;
1121
1122         list_for_each_entry(output, &dev->mode_config.output_list, head) {
1123                 save_crtcs[count++] = output->crtc;
1124
1125                 if (output->crtc == crtc)
1126                         new_crtc = NULL;
1127                 else
1128                         new_crtc = output->crtc;
1129
1130                 for (ro = 0; ro < crtc_info->count_outputs; ro++) {
1131                         if (output_set[ro] == output)
1132                                 new_crtc = crtc;
1133                 }
1134                 if (new_crtc != output->crtc) {
1135                         changed = true;
1136                         output->crtc = new_crtc;
1137                 }
1138         }
1139
1140         /* mode_set_base is not a required function */
1141         if (flip_or_move && !crtc->funcs->mode_set_base)
1142                 changed = true;
1143
1144         if (changed) {
1145                 crtc->fb = fb;
1146                 crtc->enabled = (new_mode != NULL);
1147                 if (new_mode != NULL) {
1148                         DRM_DEBUG("attempting to set mode from userspace\n");
1149                         drm_mode_debug_printmodeline(dev, new_mode);
1150                         if (!drm_crtc_set_mode(crtc, new_mode, crtc_info->x,
1151                                                crtc_info->y)) {
1152                                 crtc->enabled = save_enabled;
1153                                 count = 0;
1154                                 list_for_each_entry(output, &dev->mode_config.output_list, head)
1155                                         output->crtc = save_crtcs[count++];
1156                                 kfree(save_crtcs);
1157                                 return -EINVAL;
1158                         }
1159                         crtc->desired_x = crtc_info->x;
1160                         crtc->desired_y = crtc_info->y;
1161                         crtc->desired_mode = new_mode;
1162                 }
1163                 drm_disable_unused_functions(dev);
1164         } else if (flip_or_move) {
1165                 crtc->funcs->mode_set_base(crtc, crtc_info->x, crtc_info->y);
1166         }
1167
1168         kfree(save_crtcs);
1169         return 0;
1170 }
1171
1172 /**
1173  * drm_hotplug_stage_two
1174  * @dev DRM device
1175  * @output hotpluged output
1176  *
1177  * LOCKING.
1178  * Caller must hold mode config lock, function might grap struct lock.
1179  *
1180  * Stage two of a hotplug.
1181  *
1182  * RETURNS:
1183  * Zero on success, errno on failure.
1184  */
1185 int drm_hotplug_stage_two(struct drm_device *dev, struct drm_output *output,
1186                           bool connected)
1187 {
1188         int has_config = 0;
1189
1190         /* We might want to do something more here */
1191         if (!connected) {
1192                 DRM_DEBUG("not connected\n");
1193                 dev->mode_config.hotplug_counter++;
1194                 return 0;
1195         }
1196
1197         if (output->crtc && output->crtc->desired_mode) {
1198                 DRM_DEBUG("drm thinks that the output already has a config\n");
1199                 has_config = 1;
1200         }
1201
1202         drm_crtc_probe_output_modes(dev, 2048, 2048);
1203
1204         if (!has_config)
1205                 drm_pick_crtcs(dev);
1206
1207         if (!output->crtc || !output->crtc->desired_mode) {
1208                 DRM_DEBUG("could not find a desired mode or crtc for output\n");
1209                 goto out_err;
1210         }
1211
1212         /* We should realy check if there is a fb using this crtc */
1213         if (!has_config)
1214                 dev->driver->fb_probe(dev, output->crtc);
1215         else {
1216                 dev->driver->fb_resize(dev, output->crtc);
1217
1218                 if (!drm_crtc_set_mode(output->crtc, output->crtc->desired_mode, 0, 0))
1219                         DRM_ERROR("failed to set mode after hotplug\n");
1220         }
1221
1222         drm_disable_unused_functions(dev);
1223
1224         dev->mode_config.hotplug_counter++;
1225         return 0;
1226
1227 out_err:
1228         dev->mode_config.hotplug_counter++;
1229         return 1;
1230 }
1231 EXPORT_SYMBOL(drm_hotplug_stage_two);
1232
1233 int drm_mode_hotplug_ioctl(struct drm_device *dev,
1234                            void *data, struct drm_file *file_priv)
1235 {
1236         struct drm_mode_hotplug *arg = data;
1237
1238         arg->counter = dev->mode_config.hotplug_counter;
1239
1240         return 0;
1241 }
1242
1243 /**
1244  * drm_crtc_convert_to_umode - convert a drm_display_mode into a modeinfo
1245  * @out: drm_mode_modeinfo struct to return to the user
1246  * @in: drm_display_mode to use
1247  *
1248  * LOCKING:
1249  * None.
1250  *
1251  * Convert a drm_display_mode into a drm_mode_modeinfo structure to return to
1252  * the user.
1253  */
1254 void drm_crtc_convert_to_umode(struct drm_mode_modeinfo *out, struct drm_display_mode *in)
1255 {
1256         out->clock = in->clock;
1257         out->hdisplay = in->hdisplay;
1258         out->hsync_start = in->hsync_start;
1259         out->hsync_end = in->hsync_end;
1260         out->htotal = in->htotal;
1261         out->hskew = in->hskew;
1262         out->vdisplay = in->vdisplay;
1263         out->vsync_start = in->vsync_start;
1264         out->vsync_end = in->vsync_end;
1265         out->vtotal = in->vtotal;
1266         out->vscan = in->vscan;
1267         out->vrefresh = in->vrefresh;
1268         out->flags = in->flags;
1269         out->type = in->type;
1270         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1271         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1272 }
1273
1274 /**
1275  * drm_crtc_convert_to_umode - convert a modeinfo into a drm_display_mode
1276  * @out: drm_display_mode to return to the user
1277  * @in: drm_mode_modeinfo to use
1278  *
1279  * LOCKING:
1280  * None.
1281  *
1282  * Convert a drmo_mode_modeinfo into a drm_display_mode structure to return to
1283  * the caller.
1284  */
1285 void drm_crtc_convert_umode(struct drm_display_mode *out, struct drm_mode_modeinfo *in)
1286 {
1287         out->clock = in->clock;
1288         out->hdisplay = in->hdisplay;
1289         out->hsync_start = in->hsync_start;
1290         out->hsync_end = in->hsync_end;
1291         out->htotal = in->htotal;
1292         out->hskew = in->hskew;
1293         out->vdisplay = in->vdisplay;
1294         out->vsync_start = in->vsync_start;
1295         out->vsync_end = in->vsync_end;
1296         out->vtotal = in->vtotal;
1297         out->vscan = in->vscan;
1298         out->vrefresh = in->vrefresh;
1299         out->flags = in->flags;
1300         out->type = in->type;
1301         strncpy(out->name, in->name, DRM_DISPLAY_MODE_LEN);
1302         out->name[DRM_DISPLAY_MODE_LEN-1] = 0;
1303 }
1304
1305 /**
1306  * drm_mode_getresources - get graphics configuration
1307  * @inode: inode from the ioctl
1308  * @filp: file * from the ioctl
1309  * @cmd: cmd from ioctl
1310  * @arg: arg from ioctl
1311  *
1312  * LOCKING:
1313  * Takes mode config lock.
1314  *
1315  * Construct a set of configuration description structures and return
1316  * them to the user, including CRTC, output and framebuffer configuration.
1317  *
1318  * Called by the user via ioctl.
1319  *
1320  * RETURNS:
1321  * Zero on success, errno on failure.
1322  */
1323 int drm_mode_getresources(struct drm_device *dev,
1324                           void *data, struct drm_file *file_priv)
1325 {
1326         struct drm_mode_card_res *card_res = data;
1327         struct list_head *lh;
1328         struct drm_framebuffer *fb;
1329         struct drm_output *output;
1330         struct drm_crtc *crtc;
1331         int ret = 0;
1332         int output_count = 0;
1333         int crtc_count = 0;
1334         int fb_count = 0;
1335         int copied = 0;
1336         uint32_t __user *fb_id;
1337         uint32_t __user *crtc_id;
1338         uint32_t __user *output_id;
1339
1340         mutex_lock(&dev->mode_config.mutex);
1341
1342         list_for_each(lh, &dev->mode_config.fb_list)
1343                 fb_count++;
1344
1345         list_for_each(lh, &dev->mode_config.crtc_list)
1346                 crtc_count++;
1347
1348         list_for_each(lh, &dev->mode_config.output_list)
1349                 output_count++;
1350
1351         card_res->max_height = dev->mode_config.max_height;
1352         card_res->min_height = dev->mode_config.min_height;
1353         card_res->max_width = dev->mode_config.max_width;
1354         card_res->min_width = dev->mode_config.min_width;
1355
1356         /* handle this in 4 parts */
1357         /* FBs */
1358         if (card_res->count_fbs >= fb_count) {
1359                 copied = 0;
1360                 fb_id = (uint32_t *)(unsigned long)card_res->fb_id_ptr;
1361                 list_for_each_entry(fb, &dev->mode_config.fb_list, head) {
1362                         if (put_user(fb->id, fb_id + copied)) {
1363                                 ret = -EFAULT;
1364                                 goto out;
1365                         }
1366                         copied++;
1367                 }
1368         }
1369         card_res->count_fbs = fb_count;
1370
1371         /* CRTCs */
1372         if (card_res->count_crtcs >= crtc_count) {
1373                 copied = 0;
1374                 crtc_id = (uint32_t *)(unsigned long)card_res->crtc_id_ptr;
1375                 list_for_each_entry(crtc, &dev->mode_config.crtc_list, head){
1376                         DRM_DEBUG("CRTC ID is %d\n", crtc->id);
1377                         if (put_user(crtc->id, crtc_id + copied)) {
1378                                 ret = -EFAULT;
1379                                 goto out;
1380                         }
1381                         copied++;
1382                 }
1383         }
1384         card_res->count_crtcs = crtc_count;
1385
1386
1387         /* Outputs */
1388         if (card_res->count_outputs >= output_count) {
1389                 copied = 0;
1390                 output_id = (uint32_t *)(unsigned long)card_res->output_id_ptr;
1391                 list_for_each_entry(output, &dev->mode_config.output_list,
1392                                     head) {
1393                         DRM_DEBUG("OUTPUT ID is %d\n", output->id);
1394                         if (put_user(output->id, output_id + copied)) {
1395                                 ret = -EFAULT;
1396                                 goto out;
1397                         }
1398                         copied++;
1399                 }
1400         }
1401         card_res->count_outputs = output_count;
1402
1403         DRM_DEBUG("Counted %d %d\n", card_res->count_crtcs,
1404                   card_res->count_outputs);
1405
1406 out:
1407         mutex_unlock(&dev->mode_config.mutex);
1408         return ret;
1409 }
1410
1411 /**
1412  * drm_mode_getcrtc - get CRTC configuration
1413  * @inode: inode from the ioctl
1414  * @filp: file * from the ioctl
1415  * @cmd: cmd from ioctl
1416  * @arg: arg from ioctl
1417  *
1418  * LOCKING:
1419  * Caller? (FIXME)
1420  *
1421  * Construct a CRTC configuration structure to return to the user.
1422  *
1423  * Called by the user via ioctl.
1424  *
1425  * RETURNS:
1426  * Zero on success, errno on failure.
1427  */
1428 int drm_mode_getcrtc(struct drm_device *dev,
1429                      void *data, struct drm_file *file_priv)
1430 {
1431         struct drm_mode_crtc *crtc_resp = data;
1432         struct drm_crtc *crtc;
1433         struct drm_output *output;
1434         int ocount;
1435         int ret = 0;
1436
1437         mutex_lock(&dev->mode_config.mutex);
1438         crtc = idr_find(&dev->mode_config.crtc_idr, crtc_resp->crtc_id);
1439         if (!crtc || (crtc->id != crtc_resp->crtc_id)) {
1440                 ret = -EINVAL;
1441                 goto out;
1442         }
1443
1444         crtc_resp->x = crtc->x;
1445         crtc_resp->y = crtc->y;
1446
1447         if (crtc->fb)
1448                 crtc_resp->fb_id = crtc->fb->id;
1449         else
1450                 crtc_resp->fb_id = 0;
1451
1452         crtc_resp->outputs = 0;
1453         if (crtc->enabled) {
1454
1455                 drm_crtc_convert_to_umode(&crtc_resp->mode, &crtc->mode);
1456                 crtc_resp->mode_valid = 1;
1457                 ocount = 0;
1458                 list_for_each_entry(output, &dev->mode_config.output_list, head) {
1459                         if (output->crtc == crtc)
1460                                 crtc_resp->outputs |= 1 << (ocount++);
1461                 }
1462
1463         } else {
1464                 crtc_resp->mode_valid = 0;
1465         }
1466
1467 out:
1468         mutex_unlock(&dev->mode_config.mutex);
1469         return ret;
1470 }
1471
1472 /**
1473  * drm_mode_getoutput - get output configuration
1474  * @inode: inode from the ioctl
1475  * @filp: file * from the ioctl
1476  * @cmd: cmd from ioctl
1477  * @arg: arg from ioctl
1478  *
1479  * LOCKING:
1480  * Caller? (FIXME)
1481  *
1482  * Construct a output configuration structure to return to the user.
1483  *
1484  * Called by the user via ioctl.
1485  *
1486  * RETURNS:
1487  * Zero on success, errno on failure.
1488  */
1489 int drm_mode_getoutput(struct drm_device *dev,
1490                        void *data, struct drm_file *file_priv)
1491 {
1492         struct drm_mode_get_output *out_resp = data;
1493         struct drm_output *output;
1494         struct drm_display_mode *mode;
1495         int mode_count = 0;
1496         int props_count = 0;
1497         int ret = 0;
1498         int copied = 0;
1499         int i;
1500         struct drm_mode_modeinfo u_mode;
1501         struct drm_mode_modeinfo __user *mode_ptr;
1502         uint32_t __user *prop_ptr;
1503         uint64_t __user *prop_values;
1504
1505         memset(&u_mode, 0, sizeof(struct drm_mode_modeinfo));
1506
1507         DRM_DEBUG("output id %d:\n", out_resp->output);
1508
1509         mutex_lock(&dev->mode_config.mutex);
1510         output= idr_find(&dev->mode_config.crtc_idr, out_resp->output);
1511         if (!output || (output->id != out_resp->output)) {
1512                 ret = -EINVAL;
1513                 goto out;
1514         }
1515
1516         list_for_each_entry(mode, &output->modes, head)
1517                 mode_count++;
1518
1519         for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
1520                 if (output->property_ids[i] != 0) {
1521                         props_count++;
1522                 }
1523         }
1524
1525         if (out_resp->count_modes == 0) {
1526                 drm_crtc_probe_single_output_modes(output, dev->mode_config.max_width, dev->mode_config.max_height);
1527         }
1528
1529         out_resp->output_type = output->output_type;
1530         out_resp->output_type_id = output->output_type_id;
1531         out_resp->mm_width = output->mm_width;
1532         out_resp->mm_height = output->mm_height;
1533         out_resp->subpixel = output->subpixel_order;
1534         out_resp->connection = output->status;
1535         if (output->crtc)
1536                 out_resp->crtc = output->crtc->id;
1537         else
1538                 out_resp->crtc = 0;
1539
1540         out_resp->crtcs = output->possible_crtcs;
1541         out_resp->clones = output->possible_clones;
1542
1543         if ((out_resp->count_modes >= mode_count) && mode_count) {
1544                 copied = 0;
1545                 mode_ptr = (struct drm_mode_modeinfo *)(unsigned long)out_resp->modes_ptr;
1546                 list_for_each_entry(mode, &output->modes, head) {
1547                         drm_crtc_convert_to_umode(&u_mode, mode);
1548                         if (copy_to_user(mode_ptr + copied,
1549                                          &u_mode, sizeof(u_mode))) {
1550                                 ret = -EFAULT;
1551                                 goto out;
1552                         }
1553                         copied++;
1554
1555                 }
1556         }
1557         out_resp->count_modes = mode_count;
1558
1559         if ((out_resp->count_props >= props_count) && props_count) {
1560                 copied = 0;
1561                 prop_ptr = (uint32_t *)(unsigned long)(out_resp->props_ptr);
1562                 prop_values = (uint64_t *)(unsigned long)(out_resp->prop_values_ptr);
1563                 for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
1564                         if (output->property_ids[i] != 0) {
1565                                 if (put_user(output->property_ids[i], prop_ptr + copied)) {
1566                                         ret = -EFAULT;
1567                                         goto out;
1568                                 }
1569
1570                                 if (put_user(output->property_values[i], prop_values + copied)) {
1571                                         ret = -EFAULT;
1572                                         goto out;
1573                                 }
1574                                 copied++;
1575                         }
1576                 }
1577         }
1578         out_resp->count_props = props_count;
1579
1580 out:
1581         mutex_unlock(&dev->mode_config.mutex);
1582         return ret;
1583 }
1584
1585 /**
1586  * drm_mode_setcrtc - set CRTC configuration
1587  * @inode: inode from the ioctl
1588  * @filp: file * from the ioctl
1589  * @cmd: cmd from ioctl
1590  * @arg: arg from ioctl
1591  *
1592  * LOCKING:
1593  * Caller? (FIXME)
1594  *
1595  * Build a new CRTC configuration based on user request.
1596  *
1597  * Called by the user via ioctl.
1598  *
1599  * RETURNS:
1600  * Zero on success, errno on failure.
1601  */
1602 int drm_mode_setcrtc(struct drm_device *dev,
1603                      void *data, struct drm_file *file_priv)
1604 {
1605         struct drm_mode_crtc *crtc_req = data;
1606         struct drm_crtc *crtc, *crtcfb;
1607         struct drm_output **output_set = NULL, *output;
1608         struct drm_framebuffer *fb = NULL;
1609         struct drm_display_mode *mode = NULL;
1610         uint32_t __user *set_outputs_ptr;
1611         int ret = 0;
1612         int i;
1613
1614         mutex_lock(&dev->mode_config.mutex);
1615         crtc = idr_find(&dev->mode_config.crtc_idr, crtc_req->crtc_id);
1616         if (!crtc || (crtc->id != crtc_req->crtc_id)) {
1617                 DRM_DEBUG("Unknown CRTC ID %d\n", crtc_req->crtc_id);
1618                 ret = -EINVAL;
1619                 goto out;
1620         }
1621
1622         if (crtc_req->mode_valid) {
1623                 /* If we have a mode we need a framebuffer. */
1624                 /* If we pass -1, set the mode with the currently bound fb */
1625                 if (crtc_req->fb_id == -1) {
1626                         list_for_each_entry(crtcfb, &dev->mode_config.crtc_list, head) {
1627                                 if (crtcfb == crtc) {
1628                                         DRM_DEBUG("Using current fb for setmode\n");
1629                                         fb = crtc->fb;
1630                                 }
1631                         }
1632                 } else {
1633                         fb = idr_find(&dev->mode_config.crtc_idr, crtc_req->fb_id);
1634                         if (!fb || (fb->id != crtc_req->fb_id)) {
1635                                 DRM_DEBUG("Unknown FB ID%d\n", crtc_req->fb_id);
1636                                 ret = -EINVAL;
1637                                 goto out;
1638                         }
1639                 }
1640
1641                 mode = drm_mode_create(dev);
1642                 drm_crtc_convert_umode(mode, &crtc_req->mode);
1643                 drm_mode_set_crtcinfo(mode, CRTC_INTERLACE_HALVE_V);
1644         }
1645
1646         if (crtc_req->count_outputs == 0 && mode) {
1647                 DRM_DEBUG("Count outputs is 0 but mode set\n");
1648                 ret = -EINVAL;
1649                 goto out;
1650         }
1651
1652         if (crtc_req->count_outputs > 0 && !mode && !fb) {
1653                 DRM_DEBUG("Count outputs is %d but no mode or fb set\n", crtc_req->count_outputs);
1654                 ret = -EINVAL;
1655                 goto out;
1656         }
1657
1658         if (crtc_req->count_outputs > 0) {
1659                 u32 out_id;
1660                 /* Maybe we should check that count_outputs is a sensible value. */
1661                 output_set = kmalloc(crtc_req->count_outputs *
1662                                      sizeof(struct drm_output *), GFP_KERNEL);
1663                 if (!output_set) {
1664                         ret = -ENOMEM;
1665                         goto out;
1666                 }
1667
1668                 for (i = 0; i < crtc_req->count_outputs; i++) {
1669                         set_outputs_ptr = (uint32_t *)(unsigned long)crtc_req->set_outputs_ptr;
1670                         if (get_user(out_id, &set_outputs_ptr[i])) {
1671                                 ret = -EFAULT;
1672                                 goto out;
1673                         }
1674
1675                         output = idr_find(&dev->mode_config.crtc_idr, out_id);
1676                         if (!output || (out_id != output->id)) {
1677                                 DRM_DEBUG("Output id %d unknown\n", out_id);
1678                                 ret = -EINVAL;
1679                                 goto out;
1680                         }
1681
1682                         output_set[i] = output;
1683                 }
1684         }
1685
1686         ret = drm_crtc_set_config(crtc, crtc_req, mode, output_set, fb);
1687
1688 out:
1689         kfree(output_set);
1690         mutex_unlock(&dev->mode_config.mutex);
1691         return ret;
1692 }
1693
1694 int drm_mode_cursor_ioctl(struct drm_device *dev,
1695                         void *data, struct drm_file *file_priv)
1696 {
1697         struct drm_mode_cursor *req = data;
1698         struct drm_crtc *crtc;
1699         struct drm_buffer_object *bo = NULL; /* must be set */
1700         int ret = 0;
1701
1702         DRM_DEBUG("\n");
1703
1704         if (!req->flags) {
1705                 DRM_ERROR("no operation set\n");
1706                 return -EINVAL;
1707         }
1708
1709         mutex_lock(&dev->mode_config.mutex);
1710         crtc = idr_find(&dev->mode_config.crtc_idr, req->crtc);
1711         if (!crtc || (crtc->id != req->crtc)) {
1712                 DRM_DEBUG("Unknown CRTC ID %d\n", req->crtc);
1713                 ret = -EINVAL;
1714                 goto out;
1715         }
1716
1717         if (req->flags & DRM_MODE_CURSOR_BO) {
1718                 /* Turn of the cursor if handle is 0 */
1719                 if (req->handle)
1720                         ret = drm_get_buffer_object(dev, &bo, req->handle);
1721
1722                 if (ret) {
1723                         DRM_ERROR("invalid buffer id\n");
1724                         ret = -EINVAL;
1725                         goto out;
1726                 }
1727
1728                 if (crtc->funcs->cursor_set) {
1729                         ret = crtc->funcs->cursor_set(crtc, bo, req->width, req->height);
1730                 } else {
1731                         DRM_ERROR("crtc does not support cursor\n");
1732                         ret = -EFAULT;
1733                         goto out;
1734                 }
1735         }
1736
1737         if (req->flags & DRM_MODE_CURSOR_MOVE) {
1738                 if (crtc->funcs->cursor_move) {
1739                         ret = crtc->funcs->cursor_move(crtc, req->x, req->y);
1740                 } else {
1741                         DRM_ERROR("crtc does not support cursor\n");
1742                         ret = -EFAULT;
1743                         goto out;
1744                 }
1745         }
1746 out:
1747         mutex_unlock(&dev->mode_config.mutex);
1748         return ret;
1749 }
1750
1751 /**
1752  * drm_mode_addfb - add an FB to the graphics configuration
1753  * @inode: inode from the ioctl
1754  * @filp: file * from the ioctl
1755  * @cmd: cmd from ioctl
1756  * @arg: arg from ioctl
1757  *
1758  * LOCKING:
1759  * Takes mode config lock.
1760  *
1761  * Add a new FB to the specified CRTC, given a user request.
1762  *
1763  * Called by the user via ioctl.
1764  *
1765  * RETURNS:
1766  * Zero on success, errno on failure.
1767  */
1768 int drm_mode_addfb(struct drm_device *dev,
1769                    void *data, struct drm_file *file_priv)
1770 {
1771         struct drm_mode_fb_cmd *r = data;
1772         struct drm_mode_config *config = &dev->mode_config;
1773         struct drm_framebuffer *fb;
1774         struct drm_buffer_object *bo;
1775         int ret = 0;
1776
1777         if ((config->min_width > r->width) || (r->width > config->max_width)) {
1778                 DRM_ERROR("mode new framebuffer width not within limits\n");
1779                 return -EINVAL;
1780         }
1781         if ((config->min_height > r->height) || (r->height > config->max_height)) {
1782                 DRM_ERROR("mode new framebuffer height not within limits\n");
1783                 return -EINVAL;
1784         }
1785
1786         mutex_lock(&dev->mode_config.mutex);
1787         /* TODO check limits are okay */
1788         ret = drm_get_buffer_object(dev, &bo, r->handle);
1789         if (ret || !bo) {
1790                 DRM_ERROR("BO handle not valid\n");
1791                 ret = -EINVAL;
1792                 goto out;
1793         }
1794
1795         /* TODO check buffer is sufficently large */
1796         /* TODO setup destructor callback */
1797
1798         fb = drm_framebuffer_create(dev);
1799         if (!fb) {
1800                 DRM_ERROR("could not create framebuffer\n");
1801                 ret = -EINVAL;
1802                 goto out;
1803         }
1804
1805         fb->width = r->width;
1806         fb->height = r->height;
1807         fb->pitch = r->pitch;
1808         fb->bits_per_pixel = r->bpp;
1809         fb->depth = r->depth;
1810         fb->bo = bo;
1811
1812         r->buffer_id = fb->id;
1813
1814         list_add(&fb->filp_head, &file_priv->fbs);
1815
1816 out:
1817         mutex_unlock(&dev->mode_config.mutex);
1818         return ret;
1819 }
1820
1821 /**
1822  * drm_mode_rmfb - remove an FB from the configuration
1823  * @inode: inode from the ioctl
1824  * @filp: file * from the ioctl
1825  * @cmd: cmd from ioctl
1826  * @arg: arg from ioctl
1827  *
1828  * LOCKING:
1829  * Takes mode config lock.
1830  *
1831  * Remove the FB specified by the user.
1832  *
1833  * Called by the user via ioctl.
1834  *
1835  * RETURNS:
1836  * Zero on success, errno on failure.
1837  */
1838 int drm_mode_rmfb(struct drm_device *dev,
1839                    void *data, struct drm_file *file_priv)
1840 {
1841         struct drm_framebuffer *fb = 0;
1842         struct drm_framebuffer *fbl = 0;
1843         uint32_t *id = data;
1844         int ret = 0;
1845         int found = 0;
1846
1847         mutex_lock(&dev->mode_config.mutex);
1848         fb = idr_find(&dev->mode_config.crtc_idr, *id);
1849         /* TODO check that we realy get a framebuffer back. */
1850         if (!fb || (*id != fb->id)) {
1851                 DRM_ERROR("mode invalid framebuffer id\n");
1852                 ret = -EINVAL;
1853                 goto out;
1854         }
1855
1856         list_for_each_entry(fbl, &file_priv->fbs, filp_head)
1857                 if (fb == fbl)
1858                         found = 1;
1859
1860         if (!found) {
1861                 DRM_ERROR("tried to remove a fb that we didn't own\n");
1862                 ret = -EINVAL;
1863                 goto out;
1864         }
1865
1866         /* TODO release all crtc connected to the framebuffer */
1867         /* TODO unhock the destructor from the buffer object */
1868
1869         if (fb->bo->type == drm_bo_type_kernel)
1870                 DRM_ERROR("the bo type should not be of kernel type\n");
1871
1872         list_del(&fb->filp_head);
1873         drm_framebuffer_destroy(fb);
1874
1875 out:
1876         mutex_unlock(&dev->mode_config.mutex);
1877         return ret;
1878 }
1879
1880 /**
1881  * drm_mode_getfb - get FB info
1882  * @inode: inode from the ioctl
1883  * @filp: file * from the ioctl
1884  * @cmd: cmd from ioctl
1885  * @arg: arg from ioctl
1886  *
1887  * LOCKING:
1888  * Caller? (FIXME)
1889  *
1890  * Lookup the FB given its ID and return info about it.
1891  *
1892  * Called by the user via ioctl.
1893  *
1894  * RETURNS:
1895  * Zero on success, errno on failure.
1896  */
1897 int drm_mode_getfb(struct drm_device *dev,
1898                    void *data, struct drm_file *file_priv)
1899 {
1900         struct drm_mode_fb_cmd *r = data;
1901         struct drm_framebuffer *fb;
1902         int ret = 0;
1903
1904         mutex_lock(&dev->mode_config.mutex);
1905         fb = idr_find(&dev->mode_config.crtc_idr, r->buffer_id);
1906         if (!fb || (r->buffer_id != fb->id)) {
1907                 DRM_ERROR("invalid framebuffer id\n");
1908                 ret = -EINVAL;
1909                 goto out;
1910         }
1911
1912         r->height = fb->height;
1913         r->width = fb->width;
1914         r->depth = fb->depth;
1915         r->bpp = fb->bits_per_pixel;
1916         r->handle = fb->bo->base.hash.key;
1917         r->pitch = fb->pitch;
1918
1919 out:
1920         mutex_unlock(&dev->mode_config.mutex);
1921         return ret;
1922 }
1923
1924 /**
1925  * drm_fb_release - remove and free the FBs on this file
1926  * @filp: file * from the ioctl
1927  *
1928  * LOCKING:
1929  * Takes mode config lock.
1930  *
1931  * Destroy all the FBs associated with @filp.
1932  *
1933  * Called by the user via ioctl.
1934  *
1935  * RETURNS:
1936  * Zero on success, errno on failure.
1937  */
1938 void drm_fb_release(struct file *filp)
1939 {
1940         struct drm_file *priv = filp->private_data;
1941         struct drm_device *dev = priv->minor->dev;
1942         struct drm_framebuffer *fb, *tfb;
1943
1944         mutex_lock(&dev->mode_config.mutex);
1945         list_for_each_entry_safe(fb, tfb, &priv->fbs, filp_head) {
1946                 list_del(&fb->filp_head);
1947                 if (fb->bo->type == drm_bo_type_kernel)
1948                         DRM_ERROR("the bo type should not be of kernel_type, the kernel will probably explode, why Dave\n");
1949
1950                 drm_framebuffer_destroy(fb);
1951         }
1952         mutex_unlock(&dev->mode_config.mutex);
1953 }
1954
1955 /*
1956  *
1957  */
1958
1959 static int drm_mode_attachmode(struct drm_device *dev,
1960                                struct drm_output *output,
1961                                struct drm_display_mode *mode)
1962 {
1963         int ret = 0;
1964
1965         list_add_tail(&mode->head, &output->user_modes);
1966         return ret;
1967 }
1968
1969 int drm_mode_attachmode_crtc(struct drm_device *dev, struct drm_crtc *crtc,
1970                              struct drm_display_mode *mode)
1971 {
1972         struct drm_output *output;
1973         int ret = 0;
1974         struct drm_display_mode *dup_mode;
1975         int need_dup = 0;
1976         list_for_each_entry(output, &dev->mode_config.output_list, head) {
1977                 if (output->crtc == crtc) {
1978                         if (need_dup)
1979                                 dup_mode = drm_mode_duplicate(dev, mode);
1980                         else
1981                                 dup_mode = mode;
1982                         ret = drm_mode_attachmode(dev, output, dup_mode);
1983                         if (ret)
1984                                 return ret;
1985                         need_dup = 1;
1986                 }
1987         }
1988         return 0;
1989 }
1990 EXPORT_SYMBOL(drm_mode_attachmode_crtc);
1991
1992 static int drm_mode_detachmode(struct drm_device *dev,
1993                                struct drm_output *output,
1994                                struct drm_display_mode *mode)
1995 {
1996         int found = 0;
1997         int ret = 0;
1998         struct drm_display_mode *match_mode, *t;
1999
2000         list_for_each_entry_safe(match_mode, t, &output->user_modes, head) {
2001                 if (drm_mode_equal(match_mode, mode)) {
2002                         list_del(&match_mode->head);
2003                         drm_mode_destroy(dev, match_mode);
2004                         found = 1;
2005                         break;
2006                 }
2007         }
2008
2009         if (!found)
2010                 ret = -EINVAL;
2011
2012         return ret;
2013 }
2014
2015 int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode)
2016 {
2017         struct drm_output *output;
2018
2019         list_for_each_entry(output, &dev->mode_config.output_list, head) {
2020                 drm_mode_detachmode(dev, output, mode);
2021         }
2022         return 0;
2023 }
2024 EXPORT_SYMBOL(drm_mode_detachmode_crtc);
2025
2026 /**
2027  * drm_fb_attachmode - Attach a user mode to an output
2028  * @inode: inode from the ioctl
2029  * @filp: file * from the ioctl
2030  * @cmd: cmd from ioctl
2031  * @arg: arg from ioctl
2032  *
2033  * This attaches a user specified mode to an output.
2034  * Called by the user via ioctl.
2035  *
2036  * RETURNS:
2037  * Zero on success, errno on failure.
2038  */
2039 int drm_mode_attachmode_ioctl(struct drm_device *dev,
2040                               void *data, struct drm_file *file_priv)
2041 {
2042         struct drm_mode_mode_cmd *mode_cmd = data;
2043         struct drm_output *output;
2044         struct drm_display_mode *mode;
2045         struct drm_mode_modeinfo *umode = &mode_cmd->mode;
2046         int ret = 0;
2047
2048         mutex_lock(&dev->mode_config.mutex);
2049
2050         output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
2051         if (!output || (output->id != mode_cmd->output_id)) {
2052                 ret = -EINVAL;
2053                 goto out;
2054         }
2055
2056         mode = drm_mode_create(dev);
2057         if (!mode) {
2058                 ret = -ENOMEM;
2059                 goto out;
2060         }
2061
2062         drm_crtc_convert_umode(mode, umode);
2063
2064         ret = drm_mode_attachmode(dev, output, mode);
2065 out:
2066         mutex_unlock(&dev->mode_config.mutex);
2067         return ret;
2068 }
2069
2070
2071 /**
2072  * drm_fb_detachmode - Detach a user specified mode from an output
2073  * @inode: inode from the ioctl
2074  * @filp: file * from the ioctl
2075  * @cmd: cmd from ioctl
2076  * @arg: arg from ioctl
2077  *
2078  * Called by the user via ioctl.
2079  *
2080  * RETURNS:
2081  * Zero on success, errno on failure.
2082  */
2083 int drm_mode_detachmode_ioctl(struct drm_device *dev,
2084                               void *data, struct drm_file *file_priv)
2085 {
2086         struct drm_mode_mode_cmd *mode_cmd = data;
2087         struct drm_output *output;
2088         struct drm_display_mode mode;
2089         struct drm_mode_modeinfo *umode = &mode_cmd->mode;
2090         int ret = 0;
2091
2092         mutex_lock(&dev->mode_config.mutex);
2093
2094         output = idr_find(&dev->mode_config.crtc_idr, mode_cmd->output_id);
2095         if (!output || (output->id != mode_cmd->output_id)) {
2096                 ret = -EINVAL;
2097                 goto out;
2098         }
2099
2100         drm_crtc_convert_umode(&mode, umode);
2101         ret = drm_mode_detachmode(dev, output, &mode);
2102 out:
2103         mutex_unlock(&dev->mode_config.mutex);
2104         return ret;
2105 }
2106
2107 struct drm_property *drm_property_create(struct drm_device *dev, int flags,
2108                                          const char *name, int num_values)
2109 {
2110         struct drm_property *property = NULL;
2111
2112         property = kzalloc(sizeof(struct drm_property), GFP_KERNEL);
2113         if (!property)
2114                 return NULL;
2115
2116         if (num_values) {
2117                 property->values = kzalloc(sizeof(uint64_t)*num_values, GFP_KERNEL);
2118                 if (!property->values)
2119                         goto fail;
2120         }
2121
2122         property->id = drm_idr_get(dev, property);
2123         property->flags = flags;
2124         property->num_values = num_values;
2125         INIT_LIST_HEAD(&property->enum_blob_list);
2126
2127         if (name)
2128                 strncpy(property->name, name, DRM_PROP_NAME_LEN);
2129
2130         list_add_tail(&property->head, &dev->mode_config.property_list);
2131         return property;
2132 fail:
2133         kfree(property);
2134         return NULL;
2135 }
2136 EXPORT_SYMBOL(drm_property_create);
2137
2138 int drm_property_add_enum(struct drm_property *property, int index,
2139                           uint64_t value, const char *name)
2140 {
2141         struct drm_property_enum *prop_enum;
2142
2143         if (!(property->flags & DRM_MODE_PROP_ENUM))
2144                 return -EINVAL;
2145
2146         if (!list_empty(&property->enum_blob_list)) {
2147                 list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
2148                         if (prop_enum->value == value) {
2149                                 strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
2150                                 prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
2151                                 return 0;
2152                         }
2153                 }
2154         }
2155
2156         prop_enum = kzalloc(sizeof(struct drm_property_enum), GFP_KERNEL);
2157         if (!prop_enum)
2158                 return -ENOMEM;
2159
2160         strncpy(prop_enum->name, name, DRM_PROP_NAME_LEN);
2161         prop_enum->name[DRM_PROP_NAME_LEN-1] = '\0';
2162         prop_enum->value = value;
2163
2164         property->values[index] = value;
2165         list_add_tail(&prop_enum->head, &property->enum_blob_list);
2166         return 0;
2167 }
2168 EXPORT_SYMBOL(drm_property_add_enum);
2169
2170 void drm_property_destroy(struct drm_device *dev, struct drm_property *property)
2171 {
2172         struct drm_property_enum *prop_enum, *pt;
2173
2174         list_for_each_entry_safe(prop_enum, pt, &property->enum_blob_list, head) {
2175                 list_del(&prop_enum->head);
2176                 kfree(prop_enum);
2177         }
2178
2179         if (property->num_values)
2180                 kfree(property->values);
2181         drm_idr_put(dev, property->id);
2182         list_del(&property->head);
2183         kfree(property);
2184 }
2185 EXPORT_SYMBOL(drm_property_destroy);
2186
2187 int drm_output_attach_property(struct drm_output *output,
2188                                struct drm_property *property, uint64_t init_val)
2189 {
2190         int i;
2191
2192         for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
2193                 if (output->property_ids[i] == 0) {
2194                         output->property_ids[i] = property->id;
2195                         output->property_values[i] = init_val;
2196                         break;
2197                 }
2198         }
2199
2200         if (i == DRM_OUTPUT_MAX_PROPERTY)
2201                 return -EINVAL;
2202         return 0;
2203 }
2204 EXPORT_SYMBOL(drm_output_attach_property);
2205
2206 int drm_output_property_set_value(struct drm_output *output,
2207                                   struct drm_property *property, uint64_t value)
2208 {
2209         int i;
2210
2211         for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
2212                 if (output->property_ids[i] == property->id) {
2213                         output->property_values[i] = value;
2214                         break;
2215                 }
2216         }
2217
2218         if (i == DRM_OUTPUT_MAX_PROPERTY)
2219                 return -EINVAL;
2220         return 0;
2221 }
2222 EXPORT_SYMBOL(drm_output_property_set_value);
2223
2224 int drm_mode_getproperty_ioctl(struct drm_device *dev,
2225                                void *data, struct drm_file *file_priv)
2226 {
2227         struct drm_mode_get_property *out_resp = data;
2228         struct drm_property *property;
2229         int enum_count = 0;
2230         int blob_count = 0;
2231         int value_count = 0;
2232         int ret = 0, i;
2233         int copied;
2234         struct drm_property_enum *prop_enum;
2235         struct drm_mode_property_enum __user *enum_ptr;
2236         struct drm_property_blob *prop_blob;
2237         uint32_t *blob_id_ptr;
2238         uint64_t __user *values_ptr;
2239         uint32_t __user *blob_length_ptr;
2240
2241         mutex_lock(&dev->mode_config.mutex);
2242         property = idr_find(&dev->mode_config.crtc_idr, out_resp->prop_id);
2243         if (!property || (property->id != out_resp->prop_id)) {
2244                 ret = -EINVAL;
2245                 goto done;
2246         }
2247
2248         if (property->flags & DRM_MODE_PROP_ENUM) {
2249                 list_for_each_entry(prop_enum, &property->enum_blob_list, head)
2250                         enum_count++;
2251         } else if (property->flags & DRM_MODE_PROP_BLOB) {
2252                 list_for_each_entry(prop_blob, &property->enum_blob_list, head)
2253                         blob_count++;
2254         }
2255
2256         value_count = property->num_values;
2257
2258         strncpy(out_resp->name, property->name, DRM_PROP_NAME_LEN);
2259         out_resp->name[DRM_PROP_NAME_LEN-1] = 0;
2260         out_resp->flags = property->flags;
2261
2262         if ((out_resp->count_values >= value_count) && value_count) {
2263                 values_ptr = (uint64_t *)(unsigned long)out_resp->values_ptr;
2264                 for (i = 0; i < value_count; i++) {
2265                         if (copy_to_user(values_ptr + i, &property->values[i], sizeof(uint64_t))) {
2266                                 ret = -EFAULT;
2267                                 goto done;
2268                         }
2269                 }
2270         }
2271         out_resp->count_values = value_count;
2272
2273         if (property->flags & DRM_MODE_PROP_ENUM) {
2274
2275                 if ((out_resp->count_enum_blobs >= enum_count) && enum_count) {
2276                         copied = 0;
2277                         enum_ptr = (struct drm_mode_property_enum *)(unsigned long)out_resp->enum_blob_ptr;
2278                         list_for_each_entry(prop_enum, &property->enum_blob_list, head) {
2279
2280                                 if (copy_to_user(&enum_ptr[copied].value, &prop_enum->value, sizeof(uint64_t))) {
2281                                         ret = -EFAULT;
2282                                         goto done;
2283                                 }
2284
2285                                 if (copy_to_user(&enum_ptr[copied].name,
2286                                                  &prop_enum->name, DRM_PROP_NAME_LEN)) {
2287                                         ret = -EFAULT;
2288                                         goto done;
2289                                 }
2290                                 copied++;
2291                         }
2292                 }
2293                 out_resp->count_enum_blobs = enum_count;
2294         }
2295
2296         if (property->flags & DRM_MODE_PROP_BLOB) {
2297                 if ((out_resp->count_enum_blobs >= blob_count) && blob_count) {
2298                         copied = 0;
2299                         blob_id_ptr = (uint32_t *)(unsigned long)out_resp->enum_blob_ptr;
2300                         blob_length_ptr = (uint32_t *)(unsigned long)out_resp->values_ptr;
2301
2302                         list_for_each_entry(prop_blob, &property->enum_blob_list, head) {
2303                                 if (put_user(prop_blob->id, blob_id_ptr + copied)) {
2304                                         ret = -EFAULT;
2305                                         goto done;
2306                                 }
2307
2308                                 if (put_user(prop_blob->length, blob_length_ptr + copied)) {
2309                                         ret = -EFAULT;
2310                                         goto done;
2311                                 }
2312
2313                                 copied++;
2314                         }
2315                 }
2316                 out_resp->count_enum_blobs = enum_count;
2317         }
2318 done:
2319         mutex_unlock(&dev->mode_config.mutex);
2320         return ret;
2321 }
2322
2323 static struct drm_property_blob *drm_property_create_blob(struct drm_device *dev, int length,
2324                                                           void *data)
2325 {
2326         struct drm_property_blob *blob;
2327
2328         if (!length || !data)
2329                 return NULL;
2330
2331         blob = kzalloc(sizeof(struct drm_property_blob)+length, GFP_KERNEL);
2332         if (!blob)
2333                 return NULL;
2334
2335         blob->data = (void *)((char *)blob + sizeof(struct drm_property_blob));
2336         blob->length = length;
2337
2338         memcpy(blob->data, data, length);
2339
2340         blob->id = drm_idr_get(dev, blob);
2341
2342         list_add_tail(&blob->head, &dev->mode_config.property_blob_list);
2343         return blob;
2344 }
2345
2346 static void drm_property_destroy_blob(struct drm_device *dev,
2347                                struct drm_property_blob *blob)
2348 {
2349         drm_idr_put(dev, blob->id);
2350         list_del(&blob->head);
2351         kfree(blob);
2352 }
2353
2354 int drm_mode_getblob_ioctl(struct drm_device *dev,
2355                            void *data, struct drm_file *file_priv)
2356 {
2357         struct drm_mode_get_blob *out_resp = data;
2358         struct drm_property_blob *blob;
2359         int ret = 0;
2360         void *blob_ptr;
2361
2362         mutex_lock(&dev->mode_config.mutex);
2363
2364         blob = idr_find(&dev->mode_config.crtc_idr, out_resp->blob_id);
2365         if (!blob || (blob->id != out_resp->blob_id)) {
2366                 ret = -EINVAL;
2367                 goto done;
2368         }
2369
2370         if (out_resp->length == blob->length) {
2371                 blob_ptr = (void *)(unsigned long)out_resp->data;
2372                 if (copy_to_user(blob_ptr, blob->data, blob->length)){
2373                         ret = -EFAULT;
2374                         goto done;
2375                 }
2376         }
2377         out_resp->length = blob->length;
2378
2379 done:
2380         mutex_unlock(&dev->mode_config.mutex);
2381         return ret;
2382 }
2383
2384 int drm_mode_output_update_edid_property(struct drm_output *output, struct edid *edid)
2385 {
2386         struct drm_device *dev = output->dev;
2387         int ret = 0;
2388         if (output->edid_blob_ptr)
2389                 drm_property_destroy_blob(dev, output->edid_blob_ptr);
2390
2391         output->edid_blob_ptr = drm_property_create_blob(output->dev, 128, edid);
2392
2393         ret = drm_output_property_set_value(output, dev->mode_config.edid_property, output->edid_blob_ptr->id);
2394         return ret;
2395 }
2396 EXPORT_SYMBOL(drm_mode_output_update_edid_property);
2397
2398 int drm_mode_output_property_set_ioctl(struct drm_device *dev,
2399                                        void *data, struct drm_file *file_priv)
2400 {
2401         struct drm_mode_output_set_property *out_resp = data;
2402         struct drm_property *property;
2403         struct drm_output *output;
2404         int ret = -EINVAL;
2405         int i;
2406
2407         mutex_lock(&dev->mode_config.mutex);
2408         output = idr_find(&dev->mode_config.crtc_idr, out_resp->output_id);
2409         if (!output || (output->id != out_resp->output_id)) {
2410                 goto out;
2411         }
2412
2413         for (i = 0; i < DRM_OUTPUT_MAX_PROPERTY; i++) {
2414                 if (output->property_ids[i] == out_resp->prop_id)
2415                         break;
2416         }
2417
2418         if (i == DRM_OUTPUT_MAX_PROPERTY) {
2419                 goto out;
2420         }
2421
2422         property = idr_find(&dev->mode_config.crtc_idr, out_resp->prop_id);
2423         if (!property || (property->id != out_resp->prop_id)) {
2424                 goto out;
2425         }
2426
2427         if (property->flags & DRM_MODE_PROP_IMMUTABLE)
2428                 goto out;
2429
2430         if (property->flags & DRM_MODE_PROP_RANGE) {
2431                 if (out_resp->value < property->values[0])
2432                         goto out;
2433
2434                 if (out_resp->value > property->values[1])
2435                         goto out;
2436         } else {
2437                 int found = 0;
2438                 for (i = 0; i < property->num_values; i++) {
2439                         if (property->values[i] == out_resp->value) {
2440                                 found = 1;
2441                                 break;
2442                         }
2443                 }
2444                 if (!found) {
2445                         goto out;
2446                 }
2447         }
2448
2449         if (output->funcs->set_property)
2450                 ret = output->funcs->set_property(output, property, out_resp->value);
2451
2452 out:
2453         mutex_unlock(&dev->mode_config.mutex);
2454         return ret;
2455 }
2456