LXR linux/include/drm/drm

   1/*
   2 * Copyright © 2006 Keith Packard
   3 * Copyright © 2007-2008 Dave Airlie
   4 * Copyright © 2007-2008 Intel Corporation
   5 *   Jesse Barnes <jesse.barnes@intel.com>
   6 *
   7 * Permission is hereby granted, free of charge, to any person obtaining a
   8 * copy of this software and associated documentation files (the "Software"),
   9 * to deal in the Software without restriction, including without limitation
  10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11 * and/or sell copies of the Software, and to permit persons to whom the
  12 * Software is furnished to do so, subject to the following conditions:
  13 *
  14 * The above copyright notice and this permission notice shall be included in
  15 * all copies or substantial portions of the Software.
  16 *
  17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20 * THE COPYRIGHT HOLDER(S) OR AUTHOR(S) BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23 * OTHER DEALINGS IN THE SOFTWARE.
  24 */
  25#ifndef __DRM_CRTC_H__
  26#define __DRM_CRTC_H__
  27
  28#include <linux/i2c.h>
  29#include <linux/spinlock.h>
  30#include <linux/types.h>
  31#include <linux/idr.h>
  32
  33#include <linux/fb.h>
  34
  35struct drm_device;
  36struct drm_mode_set;
  37struct drm_framebuffer;
  38
  39
  40#define DRM_MODE_OBJECT_CRTC 0xcccccccc
  41#define DRM_MODE_OBJECT_CONNECTOR 0xc0c0c0c0
  42#define DRM_MODE_OBJECT_ENCODER 0xe0e0e0e0
  43#define DRM_MODE_OBJECT_MODE 0xdededede
  44#define DRM_MODE_OBJECT_PROPERTY 0xb0b0b0b0
  45#define DRM_MODE_OBJECT_FB 0xfbfbfbfb
  46#define DRM_MODE_OBJECT_BLOB 0xbbbbbbbb
  47
  48struct drm_mode_object {
  49        uint32_t id;
  50        uint32_t type;
  51};
  52
  53/*
  54 * Note on terminology:  here, for brevity and convenience, we refer to connector
  55 * control chips as 'CRTCs'.  They can control any type of connector, VGA, LVDS,
  56 * DVI, etc.  And 'screen' refers to the whole of the visible display, which
  57 * may span multiple monitors (and therefore multiple CRTC and connector
  58 * structures).
  59 */
  60
  61enum drm_mode_status {
  62    MODE_OK     = 0,    /* Mode OK */
  63    MODE_HSYNC,         /* hsync out of range */
  64    MODE_VSYNC,         /* vsync out of range */
  65    MODE_H_ILLEGAL,     /* mode has illegal horizontal timings */
  66    MODE_V_ILLEGAL,     /* mode has illegal horizontal timings */
  67    MODE_BAD_WIDTH,     /* requires an unsupported linepitch */
  68    MODE_NOMODE,        /* no mode with a maching name */
  69    MODE_NO_INTERLACE,  /* interlaced mode not supported */
  70    MODE_NO_DBLESCAN,   /* doublescan mode not supported */
  71    MODE_NO_VSCAN,      /* multiscan mode not supported */
  72    MODE_MEM,           /* insufficient video memory */
  73    MODE_VIRTUAL_X,     /* mode width too large for specified virtual size */
  74    MODE_VIRTUAL_Y,     /* mode height too large for specified virtual size */
  75    MODE_MEM_VIRT,      /* insufficient video memory given virtual size */
  76    MODE_NOCLOCK,       /* no fixed clock available */
  77    MODE_CLOCK_HIGH,    /* clock required is too high */
  78    MODE_CLOCK_LOW,     /* clock required is too low */
  79    MODE_CLOCK_RANGE,   /* clock/mode isn't in a ClockRange */
  80    MODE_BAD_HVALUE,    /* horizontal timing was out of range */
  81    MODE_BAD_VVALUE,    /* vertical timing was out of range */
  82    MODE_BAD_VSCAN,     /* VScan value out of range */
  83    MODE_HSYNC_NARROW,  /* horizontal sync too narrow */
  84    MODE_HSYNC_WIDE,    /* horizontal sync too wide */
  85    MODE_HBLANK_NARROW, /* horizontal blanking too narrow */
  86    MODE_HBLANK_WIDE,   /* horizontal blanking too wide */
  87    MODE_VSYNC_NARROW,  /* vertical sync too narrow */
  88    MODE_VSYNC_WIDE,    /* vertical sync too wide */
  89    MODE_VBLANK_NARROW, /* vertical blanking too narrow */
  90    MODE_VBLANK_WIDE,   /* vertical blanking too wide */
  91    MODE_PANEL,         /* exceeds panel dimensions */
  92    MODE_INTERLACE_WIDTH, /* width too large for interlaced mode */
  93    MODE_ONE_WIDTH,     /* only one width is supported */
  94    MODE_ONE_HEIGHT,    /* only one height is supported */
  95    MODE_ONE_SIZE,      /* only one resolution is supported */
  96    MODE_NO_REDUCED,    /* monitor doesn't accept reduced blanking */
  97    MODE_UNVERIFIED = -3, /* mode needs to reverified */
  98    MODE_BAD = -2,      /* unspecified reason */
  99    MODE_ERROR  = -1    /* error condition */
 100};
 101
 102#define DRM_MODE_TYPE_CLOCK_CRTC_C (DRM_MODE_TYPE_CLOCK_C | \
 103                                    DRM_MODE_TYPE_CRTC_C)
 104
 105#define DRM_MODE(nm, t, c, hd, hss, hse, ht, hsk, vd, vss, vse, vt, vs, f) \
 106        .name = nm, .status = 0, .type = (t), .clock = (c), \
 107        .hdisplay = (hd), .hsync_start = (hss), .hsync_end = (hse), \
 108        .htotal = (ht), .hskew = (hsk), .vdisplay = (vd), \
 109        .vsync_start = (vss), .vsync_end = (vse), .vtotal = (vt), \
 110        .vscan = (vs), .flags = (f), .vrefresh = 0
 111
 112#define CRTC_INTERLACE_HALVE_V 0x1 /* halve V values for interlacing */
 113
 114struct drm_display_mode {
 115        /* Header */
 116        struct list_head head;
 117        struct drm_mode_object base;
 118
 119        char name[DRM_DISPLAY_MODE_LEN];
 120
 121        int connector_count;
 122        enum drm_mode_status status;
 123        int type;
 124
 125        /* Proposed mode values */
 126        int clock;
 127        int hdisplay;
 128        int hsync_start;
 129        int hsync_end;
 130        int htotal;
 131        int hskew;
 132        int vdisplay;
 133        int vsync_start;
 134        int vsync_end;
 135        int vtotal;
 136        int vscan;
 137        unsigned int flags;
 138
 139        /* Addressable image size (may be 0 for projectors, etc.) */
 140        int width_mm;
 141        int height_mm;
 142
 143        /* Actual mode we give to hw */
 144        int clock_index;
 145        int synth_clock;
 146        int crtc_hdisplay;
 147        int crtc_hblank_start;
 148        int crtc_hblank_end;
 149        int crtc_hsync_start;
 150        int crtc_hsync_end;
 151        int crtc_htotal;
 152        int crtc_hskew;
 153        int crtc_vdisplay;
 154        int crtc_vblank_start;
 155        int crtc_vblank_end;
 156        int crtc_vsync_start;
 157        int crtc_vsync_end;
 158        int crtc_vtotal;
 159        int crtc_hadjusted;
 160        int crtc_vadjusted;
 161
 162        /* Driver private mode info */
 163        int private_size;
 164        int *private;
 165        int private_flags;
 166
 167        int vrefresh;
 168        float hsync;
 169};
 170
 171enum drm_connector_status {
 172        connector_status_connected = 1,
 173        connector_status_disconnected = 2,
 174        connector_status_unknown = 3,
 175};
 176
 177enum subpixel_order {
 178        SubPixelUnknown = 0,
 179        SubPixelHorizontalRGB,
 180        SubPixelHorizontalBGR,
 181        SubPixelVerticalRGB,
 182        SubPixelVerticalBGR,
 183        SubPixelNone,
 184};
 185
 186
 187/*
 188 * Describes a given display (e.g. CRT or flat panel) and its limitations.
 189 */
 190struct drm_display_info {
 191        char name[DRM_DISPLAY_INFO_LEN];
 192        /* Input info */
 193        bool serration_vsync;
 194        bool sync_on_green;
 195        bool composite_sync;
 196        bool separate_syncs;
 197        bool blank_to_black;
 198        unsigned char video_level;
 199        bool digital;
 200        /* Physical size */
 201        unsigned int width_mm;
 202        unsigned int height_mm;
 203
 204        /* Display parameters */
 205        unsigned char gamma; /* FIXME: storage format */
 206        bool gtf_supported;
 207        bool standard_color;
 208        enum {
 209                monochrome = 0,
 210                rgb,
 211                other,
 212                unknown,
 213        } display_type;
 214        bool active_off_supported;
 215        bool suspend_supported;
 216        bool standby_supported;
 217
 218        /* Color info FIXME: storage format */
 219        unsigned short redx, redy;
 220        unsigned short greenx, greeny;
 221        unsigned short bluex, bluey;
 222        unsigned short whitex, whitey;
 223
 224        /* Clock limits FIXME: storage format */
 225        unsigned int min_vfreq, max_vfreq;
 226        unsigned int min_hfreq, max_hfreq;
 227        unsigned int pixel_clock;
 228
 229        /* White point indices FIXME: storage format */
 230        unsigned int wpx1, wpy1;
 231        unsigned int wpgamma1;
 232        unsigned int wpx2, wpy2;
 233        unsigned int wpgamma2;
 234
 235        enum subpixel_order subpixel_order;
 236
 237        char *raw_edid; /* if any */
 238};
 239
 240struct drm_framebuffer_funcs {
 241        void (*destroy)(struct drm_framebuffer *framebuffer);
 242        int (*create_handle)(struct drm_framebuffer *fb,
 243                             struct drm_file *file_priv,
 244                             unsigned int *handle);
 245};
 246
 247struct drm_framebuffer {
 248        struct drm_device *dev;
 249        struct list_head head;
 250        struct drm_mode_object base;
 251        const struct drm_framebuffer_funcs *funcs;
 252        unsigned int pitch;
 253        unsigned int width;
 254        unsigned int height;
 255        /* depth can be 15 or 16 */
 256        unsigned int depth;
 257        int bits_per_pixel;
 258        int flags;
 259        void *fbdev;
 260        u32 pseudo_palette[17];
 261        struct list_head filp_head;
 262};
 263
 264struct drm_property_blob {
 265        struct drm_mode_object base;
 266        struct list_head head;
 267        unsigned int length;
 268        void *data;
 269};
 270
 271struct drm_property_enum {
 272        uint64_t value;
 273        struct list_head head;
 274        char name[DRM_PROP_NAME_LEN];
 275};
 276
 277struct drm_property {
 278        struct list_head head;
 279        struct drm_mode_object base;
 280        uint32_t flags;
 281        char name[DRM_PROP_NAME_LEN];
 282        uint32_t num_values;
 283        uint64_t *values;
 284
 285        struct list_head enum_blob_list;
 286};
 287
 288struct drm_crtc;
 289struct drm_connector;
 290struct drm_encoder;
 291
 292/**
 293 * drm_crtc_funcs - control CRTCs for a given device
 294 * @dpms: control display power levels
 295 * @save: save CRTC state
 296 * @resore: restore CRTC state
 297 * @lock: lock the CRTC
 298 * @unlock: unlock the CRTC
 299 * @shadow_allocate: allocate shadow pixmap
 300 * @shadow_create: create shadow pixmap for rotation support
 301 * @shadow_destroy: free shadow pixmap
 302 * @mode_fixup: fixup proposed mode
 303 * @mode_set: set the desired mode on the CRTC
 304 * @gamma_set: specify color ramp for CRTC
 305 * @destroy: deinit and free object.
 306 *
 307 * The drm_crtc_funcs structure is the central CRTC management structure
 308 * in the DRM.  Each CRTC controls one or more connectors (note that the name
 309 * CRTC is simply historical, a CRTC may control LVDS, VGA, DVI, TV out, etc.
 310 * connectors, not just CRTs).
 311 *
 312 * Each driver is responsible for filling out this structure at startup time,
 313 * in addition to providing other modesetting features, like i2c and DDC
 314 * bus accessors.
 315 */
 316struct drm_crtc_funcs {
 317        /* Save CRTC state */
 318        void (*save)(struct drm_crtc *crtc); /* suspend? */
 319        /* Restore CRTC state */
 320        void (*restore)(struct drm_crtc *crtc); /* resume? */
 321
 322        /* cursor controls */
 323        int (*cursor_set)(struct drm_crtc *crtc, struct drm_file *file_priv,
 324                          uint32_t handle, uint32_t width, uint32_t height);
 325        int (*cursor_move)(struct drm_crtc *crtc, int x, int y);
 326
 327        /* Set gamma on the CRTC */
 328        void (*gamma_set)(struct drm_crtc *crtc, u16 *r, u16 *g, u16 *b,
 329                          uint32_t size);
 330        /* Object destroy routine */
 331        void (*destroy)(struct drm_crtc *crtc);
 332
 333        int (*set_config)(struct drm_mode_set *set);
 334};
 335
 336/**
 337 * drm_crtc - central CRTC control structure
 338 * @enabled: is this CRTC enabled?
 339 * @x: x position on screen
 340 * @y: y position on screen
 341 * @desired_mode: new desired mode
 342 * @desired_x: desired x for desired_mode
 343 * @desired_y: desired y for desired_mode
 344 * @funcs: CRTC control functions
 345 *
 346 * Each CRTC may have one or more connectors associated with it.  This structure
 347 * allows the CRTC to be controlled.
 348 */
 349struct drm_crtc {
 350        struct drm_device *dev;
 351        struct list_head head;
 352
 353        struct drm_mode_object base;
 354
 355        /* framebuffer the connector is currently bound to */
 356        struct drm_framebuffer *fb;
 357
 358        bool enabled;
 359
 360        struct drm_display_mode mode;
 361
 362        int x, y;
 363        struct drm_display_mode *desired_mode;
 364        int desired_x, desired_y;
 365        const struct drm_crtc_funcs *funcs;
 366
 367        /* CRTC gamma size for reporting to userspace */
 368        uint32_t gamma_size;
 369        uint16_t *gamma_store;
 370
 371        /* if you are using the helper */
 372        void *helper_private;
 373};
 374
 375
 376/**
 377 * drm_connector_funcs - control connectors on a given device
 378 * @dpms: set power state (see drm_crtc_funcs above)
 379 * @save: save connector state
 380 * @restore: restore connector state
 381 * @mode_valid: is this mode valid on the given connector?
 382 * @mode_fixup: try to fixup proposed mode for this connector
 383 * @mode_set: set this mode
 384 * @detect: is this connector active?
 385 * @get_modes: get mode list for this connector
 386 * @set_property: property for this connector may need update
 387 * @destroy: make object go away
 388 *
 389 * Each CRTC may have one or more connectors attached to it.  The functions
 390 * below allow the core DRM code to control connectors, enumerate available modes,
 391 * etc.
 392 */
 393struct drm_connector_funcs {
 394        void (*dpms)(struct drm_connector *connector, int mode);
 395        void (*save)(struct drm_connector *connector);
 396        void (*restore)(struct drm_connector *connector);
 397        enum drm_connector_status (*detect)(struct drm_connector *connector);
 398        int (*fill_modes)(struct drm_connector *connector, uint32_t max_width, uint32_t max_height);
 399        int (*set_property)(struct drm_connector *connector, struct drm_property *property,
 400                             uint64_t val);
 401        void (*destroy)(struct drm_connector *connector);
 402};
 403
 404struct drm_encoder_funcs {
 405        void (*destroy)(struct drm_encoder *encoder);
 406};
 407
 408#define DRM_CONNECTOR_MAX_UMODES 16
 409#define DRM_CONNECTOR_MAX_PROPERTY 16
 410#define DRM_CONNECTOR_LEN 32
 411#define DRM_CONNECTOR_MAX_ENCODER 2
 412
 413/**
 414 * drm_encoder - central DRM encoder structure
 415 */
 416struct drm_encoder {
 417        struct drm_device *dev;
 418        struct list_head head;
 419
 420        struct drm_mode_object base;
 421        int encoder_type;
 422        uint32_t possible_crtcs;
 423        uint32_t possible_clones;
 424
 425        struct drm_crtc *crtc;
 426        const struct drm_encoder_funcs *funcs;
 427        void *helper_private;
 428};
 429
 430/**
 431 * drm_connector - central DRM connector control structure
 432 * @crtc: CRTC this connector is currently connected to, NULL if none
 433 * @interlace_allowed: can this connector handle interlaced modes?
 434 * @doublescan_allowed: can this connector handle doublescan?
 435 * @available_modes: modes available on this connector (from get_modes() + user)
 436 * @initial_x: initial x position for this connector
 437 * @initial_y: initial y position for this connector
 438 * @status: connector connected?
 439 * @funcs: connector control functions
 440 *
 441 * Each connector may be connected to one or more CRTCs, or may be clonable by
 442 * another connector if they can share a CRTC.  Each connector also has a specific
 443 * position in the broader display (referred to as a 'screen' though it could
 444 * span multiple monitors).
 445 */
 446struct drm_connector {
 447        struct drm_device *dev;
 448        struct device kdev;
 449        struct device_attribute *attr;
 450        struct list_head head;
 451
 452        struct drm_mode_object base;
 453
 454        int connector_type;
 455        int connector_type_id;
 456        bool interlace_allowed;
 457        bool doublescan_allowed;
 458        struct list_head modes; /* list of modes on this connector */
 459
 460        int initial_x, initial_y;
 461        enum drm_connector_status status;
 462
 463        /* these are modes added by probing with DDC or the BIOS */
 464        struct list_head probed_modes;
 465
 466        struct drm_display_info display_info;
 467        const struct drm_connector_funcs *funcs;
 468
 469        struct list_head user_modes;
 470        struct drm_property_blob *edid_blob_ptr;
 471        u32 property_ids[DRM_CONNECTOR_MAX_PROPERTY];
 472        uint64_t property_values[DRM_CONNECTOR_MAX_PROPERTY];
 473
 474        /* requested DPMS state */
 475        int dpms;
 476
 477        void *helper_private;
 478
 479        uint32_t encoder_ids[DRM_CONNECTOR_MAX_ENCODER];
 480        uint32_t force_encoder_id;
 481        struct drm_encoder *encoder; /* currently active encoder */
 482};
 483
 484/**
 485 * struct drm_mode_set
 486 *
 487 * Represents a single crtc the connectors that it drives with what mode
 488 * and from which framebuffer it scans out from.
 489 *
 490 * This is used to set modes.
 491 */
 492struct drm_mode_set {
 493        struct list_head head;
 494
 495        struct drm_framebuffer *fb;
 496        struct drm_crtc *crtc;
 497        struct drm_display_mode *mode;
 498
 499        uint32_t x;
 500        uint32_t y;
 501
 502        struct drm_connector **connectors;
 503        size_t num_connectors;
 504};
 505
 506/**
 507 * struct drm_mode_config_funcs - configure CRTCs for a given screen layout
 508 * @resize: adjust CRTCs as necessary for the proposed layout
 509 *
 510 * Currently only a resize hook is available.  DRM will call back into the
 511 * driver with a new screen width and height.  If the driver can't support
 512 * the proposed size, it can return false.  Otherwise it should adjust
 513 * the CRTC<->connector mappings as needed and update its view of the screen.
 514 */
 515struct drm_mode_config_funcs {
 516        struct drm_framebuffer *(*fb_create)(struct drm_device *dev, struct drm_file *file_priv, struct drm_mode_fb_cmd *mode_cmd);
 517        int (*fb_changed)(struct drm_device *dev);
 518};
 519
 520struct drm_mode_group {
 521        uint32_t num_crtcs;
 522        uint32_t num_encoders;
 523        uint32_t num_connectors;
 524
 525        /* list of object IDs for this group */
 526        uint32_t *id_list;
 527};
 528
 529/**
 530 * drm_mode_config - Mode configuration control structure
 531 *
 532 */
 533struct drm_mode_config {
 534        struct mutex mutex; /* protects configuration (mode lists etc.) */
 535        struct mutex idr_mutex; /* for IDR management */
 536        struct idr crtc_idr; /* use this idr for all IDs, fb, crtc, connector, modes - just makes life easier */
 537        /* this is limited to one for now */
 538        int num_fb;
 539        struct list_head fb_list;
 540        int num_connector;
 541        struct list_head connector_list;
 542        int num_encoder;
 543        struct list_head encoder_list;
 544
 545        int num_crtc;
 546        struct list_head crtc_list;
 547
 548        struct list_head property_list;
 549
 550        /* in-kernel framebuffers - hung of filp_head in drm_framebuffer */
 551        struct list_head fb_kernel_list;
 552
 553        int min_width, min_height;
 554        int max_width, max_height;
 555        struct drm_mode_config_funcs *funcs;
 556        resource_size_t fb_base;
 557
 558        /* pointers to standard properties */
 559        struct list_head property_blob_list;
 560        struct drm_property *edid_property;
 561        struct drm_property *dpms_property;
 562
 563        /* DVI-I properties */
 564        struct drm_property *dvi_i_subconnector_property;
 565        struct drm_property *dvi_i_select_subconnector_property;
 566
 567        /* TV properties */
 568        struct drm_property *tv_subconnector_property;
 569        struct drm_property *tv_select_subconnector_property;
 570        struct drm_property *tv_mode_property;
 571        struct drm_property *tv_left_margin_property;
 572        struct drm_property *tv_right_margin_property;
 573        struct drm_property *tv_top_margin_property;
 574        struct drm_property *tv_bottom_margin_property;
 575
 576        /* Optional properties */
 577        struct drm_property *scaling_mode_property;
 578        struct drm_property *dithering_mode_property;
 579};
 580
 581#define obj_to_crtc(x) container_of(x, struct drm_crtc, base)
 582#define obj_to_connector(x) container_of(x, struct drm_connector, base)
 583#define obj_to_encoder(x) container_of(x, struct drm_encoder, base)
 584#define obj_to_mode(x) container_of(x, struct drm_display_mode, base)
 585#define obj_to_fb(x) container_of(x, struct drm_framebuffer, base)
 586#define obj_to_property(x) container_of(x, struct drm_property, base)
 587#define obj_to_blob(x) container_of(x, struct drm_property_blob, base)
 588
 589
 590extern void drm_crtc_init(struct drm_device *dev,
 591                          struct drm_crtc *crtc,
 592                          const struct drm_crtc_funcs *funcs);
 593extern void drm_crtc_cleanup(struct drm_crtc *crtc);
 594
 595extern void drm_connector_init(struct drm_device *dev,
 596                            struct drm_connector *connector,
 597                            const struct drm_connector_funcs *funcs,
 598                            int connector_type);
 599
 600extern void drm_connector_cleanup(struct drm_connector *connector);
 601
 602extern void drm_encoder_init(struct drm_device *dev,
 603                             struct drm_encoder *encoder,
 604                             const struct drm_encoder_funcs *funcs,
 605                             int encoder_type);
 606
 607extern void drm_encoder_cleanup(struct drm_encoder *encoder);
 608
 609extern char *drm_get_connector_name(struct drm_connector *connector);
 610extern char *drm_get_dpms_name(int val);
 611extern char *drm_get_dvi_i_subconnector_name(int val);
 612extern char *drm_get_dvi_i_select_name(int val);
 613extern char *drm_get_tv_subconnector_name(int val);
 614extern char *drm_get_tv_select_name(int val);
 615extern void drm_fb_release(struct drm_file *file_priv);
 616extern int drm_mode_group_init_legacy_group(struct drm_device *dev, struct drm_mode_group *group);
 617extern struct edid *drm_get_edid(struct drm_connector *connector,
 618                                 struct i2c_adapter *adapter);
 619extern int drm_do_probe_ddc_edid(struct i2c_adapter *adapter,
 620                                 unsigned char *buf, int len);
 621extern int drm_add_edid_modes(struct drm_connector *connector, struct edid *edid);
 622extern void drm_mode_probed_add(struct drm_connector *connector, struct drm_display_mode *mode);
 623extern void drm_mode_remove(struct drm_connector *connector, struct drm_display_mode *mode);
 624extern struct drm_display_mode *drm_mode_duplicate(struct drm_device *dev,
 625                                                   struct drm_display_mode *mode);
 626extern void drm_mode_debug_printmodeline(struct drm_display_mode *mode);
 627extern void drm_mode_config_init(struct drm_device *dev);
 628extern void drm_mode_config_cleanup(struct drm_device *dev);
 629extern void drm_mode_set_name(struct drm_display_mode *mode);
 630extern bool drm_mode_equal(struct drm_display_mode *mode1, struct drm_display_mode *mode2);
 631extern int drm_mode_width(struct drm_display_mode *mode);
 632extern int drm_mode_height(struct drm_display_mode *mode);
 633
 634/* for us by fb module */
 635extern int drm_mode_attachmode_crtc(struct drm_device *dev,
 636                                    struct drm_crtc *crtc,
 637                                    struct drm_display_mode *mode);
 638extern int drm_mode_detachmode_crtc(struct drm_device *dev, struct drm_display_mode *mode);
 639
 640extern struct drm_display_mode *drm_mode_create(struct drm_device *dev);
 641extern void drm_mode_destroy(struct drm_device *dev, struct drm_display_mode *mode);
 642extern void drm_mode_list_concat(struct list_head *head,
 643                                 struct list_head *new);
 644extern void drm_mode_validate_size(struct drm_device *dev,
 645                                   struct list_head *mode_list,
 646                                   int maxX, int maxY, int maxPitch);
 647extern void drm_mode_prune_invalid(struct drm_device *dev,
 648                                   struct list_head *mode_list, bool verbose);
 649extern void drm_mode_sort(struct list_head *mode_list);
 650extern int drm_mode_vrefresh(struct drm_display_mode *mode);
 651extern void drm_mode_set_crtcinfo(struct drm_display_mode *p,
 652                                  int adjust_flags);
 653extern void drm_mode_connector_list_update(struct drm_connector *connector);
 654extern int drm_mode_connector_update_edid_property(struct drm_connector *connector,
 655                                                struct edid *edid);
 656extern int drm_connector_property_set_value(struct drm_connector *connector,
 657                                         struct drm_property *property,
 658                                         uint64_t value);
 659extern int drm_connector_property_get_value(struct drm_connector *connector,
 660                                         struct drm_property *property,
 661                                         uint64_t *value);
 662extern struct drm_display_mode *drm_crtc_mode_create(struct drm_device *dev);
 663extern void drm_framebuffer_set_object(struct drm_device *dev,
 664                                       unsigned long handle);
 665extern int drm_framebuffer_init(struct drm_device *dev,
 666                                struct drm_framebuffer *fb,
 667                                const struct drm_framebuffer_funcs *funcs);
 668extern void drm_framebuffer_cleanup(struct drm_framebuffer *fb);
 669extern int drmfb_probe(struct drm_device *dev, struct drm_crtc *crtc);
 670extern int drmfb_remove(struct drm_device *dev, struct drm_framebuffer *fb);
 671extern void drm_crtc_probe_connector_modes(struct drm_device *dev, int maxX, int maxY);
 672extern bool drm_crtc_in_use(struct drm_crtc *crtc);
 673
 674extern int drm_connector_attach_property(struct drm_connector *connector,
 675                                      struct drm_property *property, uint64_t init_val);
 676extern struct drm_property *drm_property_create(struct drm_device *dev, int flags,
 677                                                const char *name, int num_values);
 678extern void drm_property_destroy(struct drm_device *dev, struct drm_property *property);
 679extern int drm_property_add_enum(struct drm_property *property, int index,
 680                                 uint64_t value, const char *name);
 681extern int drm_mode_create_dvi_i_properties(struct drm_device *dev);
 682extern int drm_mode_create_tv_properties(struct drm_device *dev, int num_formats,
 683                                     char *formats[]);
 684extern int drm_mode_create_scaling_mode_property(struct drm_device *dev);
 685extern int drm_mode_create_dithering_property(struct drm_device *dev);
 686extern char *drm_get_encoder_name(struct drm_encoder *encoder);
 687
 688extern int drm_mode_connector_attach_encoder(struct drm_connector *connector,
 689                                             struct drm_encoder *encoder);
 690extern void drm_mode_connector_detach_encoder(struct drm_connector *connector,
 691                                           struct drm_encoder *encoder);
 692extern bool drm_mode_crtc_set_gamma_size(struct drm_crtc *crtc,
 693                                         int gamma_size);
 694extern void *drm_mode_object_find(struct drm_device *dev, uint32_t id, uint32_t type);
 695/* IOCTLs */
 696extern int drm_mode_getresources(struct drm_device *dev,
 697                                 void *data, struct drm_file *file_priv);
 698
 699extern int drm_mode_getcrtc(struct drm_device *dev,
 700                            void *data, struct drm_file *file_priv);
 701extern int drm_mode_getconnector(struct drm_device *dev,
 702                              void *data, struct drm_file *file_priv);
 703extern int drm_mode_setcrtc(struct drm_device *dev,
 704                            void *data, struct drm_file *file_priv);
 705extern int drm_mode_cursor_ioctl(struct drm_device *dev,
 706                                void *data, struct drm_file *file_priv);
 707extern int drm_mode_addfb(struct drm_device *dev,
 708                          void *data, struct drm_file *file_priv);
 709extern int drm_mode_rmfb(struct drm_device *dev,
 710                         void *data, struct drm_file *file_priv);
 711extern int drm_mode_getfb(struct drm_device *dev,
 712                          void *data, struct drm_file *file_priv);
 713extern int drm_mode_addmode_ioctl(struct drm_device *dev,
 714                                  void *data, struct drm_file *file_priv);
 715extern int drm_mode_rmmode_ioctl(struct drm_device *dev,
 716                                 void *data, struct drm_file *file_priv);
 717extern int drm_mode_attachmode_ioctl(struct drm_device *dev,
 718                                     void *data, struct drm_file *file_priv);
 719extern int drm_mode_detachmode_ioctl(struct drm_device *dev,
 720                                     void *data, struct drm_file *file_priv);
 721
 722extern int drm_mode_getproperty_ioctl(struct drm_device *dev,
 723                                      void *data, struct drm_file *file_priv);
 724extern int drm_mode_getblob_ioctl(struct drm_device *dev,
 725                                  void *data, struct drm_file *file_priv);
 726extern int drm_mode_connector_property_set_ioctl(struct drm_device *dev,
 727                                              void *data, struct drm_file *file_priv);
 728extern int drm_mode_hotplug_ioctl(struct drm_device *dev,
 729                                  void *data, struct drm_file *file_priv);
 730extern int drm_mode_replacefb(struct drm_device *dev,
 731                              void *data, struct drm_file *file_priv);
 732extern int drm_mode_getencoder(struct drm_device *dev,
 733                               void *data, struct drm_file *file_priv);
 734extern int drm_mode_gamma_get_ioctl(struct drm_device *dev,
 735                                    void *data, struct drm_file *file_priv);
 736extern int drm_mode_gamma_set_ioctl(struct drm_device *dev,
 737                                    void *data, struct drm_file *file_priv);
 738extern bool drm_detect_hdmi_monitor(struct edid *edid);
 739#endif /* __DRM_CRTC_H__ */
 740