drm: kill drm_agp_chipset_flush
[linux-2.6.git] / include / drm / drm_mode.h
index 601d2bd..0fc7397 100644 (file)
 #ifndef _DRM_MODE_H
 #define _DRM_MODE_H
 
-#if !defined(__KERNEL__) && !defined(_KERNEL)
-#include <stdint.h>
-#else
-#include <linux/kernel.h>
-#endif
-
 #define DRM_DISPLAY_INFO_LEN   32
 #define DRM_CONNECTOR_NAME_LEN 32
 #define DRM_DISPLAY_MODE_LEN   32
 #define DRM_MODE_DPMS_OFF      3
 
 /* Scaling mode options */
-#define DRM_MODE_SCALE_NON_GPU         0
-#define DRM_MODE_SCALE_FULLSCREEN      1
-#define DRM_MODE_SCALE_NO_SCALE                2
-#define DRM_MODE_SCALE_ASPECT          3
+#define DRM_MODE_SCALE_NONE            0 /* Unmodified timing (display or
+                                            software can still scale) */
+#define DRM_MODE_SCALE_FULLSCREEN      1 /* Full screen, ignore aspect */
+#define DRM_MODE_SCALE_CENTER          2 /* Centered, no scaling */
+#define DRM_MODE_SCALE_ASPECT          3 /* Full screen, preserve aspect */
 
 /* Dithering mode options */
 #define DRM_MODE_DITHERING_OFF 0
 #define DRM_MODE_DITHERING_ON  1
+#define DRM_MODE_DITHERING_AUTO 2
+
+/* Dirty info options */
+#define DRM_MODE_DIRTY_OFF      0
+#define DRM_MODE_DIRTY_ON       1
+#define DRM_MODE_DIRTY_ANNOTATE 2
 
 struct drm_mode_modeinfo {
-       uint32_t clock;
-       uint16_t hdisplay, hsync_start, hsync_end, htotal, hskew;
-       uint16_t vdisplay, vsync_start, vsync_end, vtotal, vscan;
+       __u32 clock;
+       __u16 hdisplay, hsync_start, hsync_end, htotal, hskew;
+       __u16 vdisplay, vsync_start, vsync_end, vtotal, vscan;
 
-       uint32_t vrefresh; /* vertical refresh * 1000 */
+       __u32 vrefresh;
 
-       uint32_t flags;
-       uint32_t type;
+       __u32 flags;
+       __u32 type;
        char name[DRM_DISPLAY_MODE_LEN];
 };
 
 struct drm_mode_card_res {
-       uint64_t fb_id_ptr;
-       uint64_t crtc_id_ptr;
-       uint64_t connector_id_ptr;
-       uint64_t encoder_id_ptr;
-       uint32_t count_fbs;
-       uint32_t count_crtcs;
-       uint32_t count_connectors;
-       uint32_t count_encoders;
-       uint32_t min_width, max_width;
-       uint32_t min_height, max_height;
+       __u64 fb_id_ptr;
+       __u64 crtc_id_ptr;
+       __u64 connector_id_ptr;
+       __u64 encoder_id_ptr;
+       __u32 count_fbs;
+       __u32 count_crtcs;
+       __u32 count_connectors;
+       __u32 count_encoders;
+       __u32 min_width, max_width;
+       __u32 min_height, max_height;
 };
 
 struct drm_mode_crtc {
-       uint64_t set_connectors_ptr;
-       uint32_t count_connectors;
+       __u64 set_connectors_ptr;
+       __u32 count_connectors;
 
-       uint32_t crtc_id; /**< Id */
-       uint32_t fb_id; /**< Id of framebuffer */
+       __u32 crtc_id; /**< Id */
+       __u32 fb_id; /**< Id of framebuffer */
 
-       uint32_t x, y; /**< Position on the frameuffer */
+       __u32 x, y; /**< Position on the frameuffer */
 
-       uint32_t gamma_size;
-       uint32_t mode_valid;
+       __u32 gamma_size;
+       __u32 mode_valid;
        struct drm_mode_modeinfo mode;
 };
 
@@ -126,13 +127,13 @@ struct drm_mode_crtc {
 #define DRM_MODE_ENCODER_TVDAC 4
 
 struct drm_mode_get_encoder {
-       uint32_t encoder_id;
-       uint32_t encoder_type;
+       __u32 encoder_id;
+       __u32 encoder_type;
 
-       uint32_t crtc_id; /**< Id of crtc */
+       __u32 crtc_id; /**< Id of crtc */
 
-       uint32_t possible_crtcs;
-       uint32_t possible_clones;
+       __u32 possible_crtcs;
+       __u32 possible_clones;
 };
 
 /* This is for connectors with multiple signal types. */
@@ -144,6 +145,7 @@ struct drm_mode_get_encoder {
 #define DRM_MODE_SUBCONNECTOR_Composite        5
 #define DRM_MODE_SUBCONNECTOR_SVIDEO   6
 #define DRM_MODE_SUBCONNECTOR_Component        8
+#define DRM_MODE_SUBCONNECTOR_SCART    9
 
 #define DRM_MODE_CONNECTOR_Unknown     0
 #define DRM_MODE_CONNECTOR_VGA         1
@@ -158,26 +160,28 @@ struct drm_mode_get_encoder {
 #define DRM_MODE_CONNECTOR_DisplayPort 10
 #define DRM_MODE_CONNECTOR_HDMIA       11
 #define DRM_MODE_CONNECTOR_HDMIB       12
+#define DRM_MODE_CONNECTOR_TV          13
+#define DRM_MODE_CONNECTOR_eDP         14
 
 struct drm_mode_get_connector {
 
-       uint64_t encoders_ptr;
-       uint64_t modes_ptr;
-       uint64_t props_ptr;
-       uint64_t prop_values_ptr;
+       __u64 encoders_ptr;
+       __u64 modes_ptr;
+       __u64 props_ptr;
+       __u64 prop_values_ptr;
 
-       uint32_t count_modes;
-       uint32_t count_props;
-       uint32_t count_encoders;
+       __u32 count_modes;
+       __u32 count_props;
+       __u32 count_encoders;
 
-       uint32_t encoder_id; /**< Current Encoder */
-       uint32_t connector_id; /**< Id */
-       uint32_t connector_type;
-       uint32_t connector_type_id;
+       __u32 encoder_id; /**< Current Encoder */
+       __u32 connector_id; /**< Id */
+       __u32 connector_type;
+       __u32 connector_type_id;
 
-       uint32_t connection;
-       uint32_t mm_width, mm_height; /**< HxW in millimeters */
-       uint32_t subpixel;
+       __u32 connection;
+       __u32 mm_width, mm_height; /**< HxW in millimeters */
+       __u32 subpixel;
 };
 
 #define DRM_MODE_PROP_PENDING  (1<<0)
@@ -187,46 +191,85 @@ struct drm_mode_get_connector {
 #define DRM_MODE_PROP_BLOB     (1<<4)
 
 struct drm_mode_property_enum {
-       uint64_t value;
+       __u64 value;
        char name[DRM_PROP_NAME_LEN];
 };
 
 struct drm_mode_get_property {
-       uint64_t values_ptr; /* values and blob lengths */
-       uint64_t enum_blob_ptr; /* enum and blob id ptrs */
+       __u64 values_ptr; /* values and blob lengths */
+       __u64 enum_blob_ptr; /* enum and blob id ptrs */
 
-       uint32_t prop_id;
-       uint32_t flags;
+       __u32 prop_id;
+       __u32 flags;
        char name[DRM_PROP_NAME_LEN];
 
-       uint32_t count_values;
-       uint32_t count_enum_blobs;
+       __u32 count_values;
+       __u32 count_enum_blobs;
 };
 
 struct drm_mode_connector_set_property {
-       uint64_t value;
-       uint32_t prop_id;
-       uint32_t connector_id;
+       __u64 value;
+       __u32 prop_id;
+       __u32 connector_id;
 };
 
 struct drm_mode_get_blob {
-       uint32_t blob_id;
-       uint32_t length;
-       uint64_t data;
+       __u32 blob_id;
+       __u32 length;
+       __u64 data;
 };
 
 struct drm_mode_fb_cmd {
-       uint32_t fb_id;
-       uint32_t width, height;
-       uint32_t pitch;
-       uint32_t bpp;
-       uint32_t depth;
+       __u32 fb_id;
+       __u32 width, height;
+       __u32 pitch;
+       __u32 bpp;
+       __u32 depth;
        /* driver specific handle */
-       uint32_t handle;
+       __u32 handle;
+};
+
+#define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01
+#define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02
+#define DRM_MODE_FB_DIRTY_FLAGS         0x03
+
+/*
+ * Mark a region of a framebuffer as dirty.
+ *
+ * Some hardware does not automatically update display contents
+ * as a hardware or software draw to a framebuffer. This ioctl
+ * allows userspace to tell the kernel and the hardware what
+ * regions of the framebuffer have changed.
+ *
+ * The kernel or hardware is free to update more then just the
+ * region specified by the clip rects. The kernel or hardware
+ * may also delay and/or coalesce several calls to dirty into a
+ * single update.
+ *
+ * Userspace may annotate the updates, the annotates are a
+ * promise made by the caller that the change is either a copy
+ * of pixels or a fill of a single color in the region specified.
+ *
+ * If the DRM_MODE_FB_DIRTY_ANNOTATE_COPY flag is given then
+ * the number of updated regions are half of num_clips given,
+ * where the clip rects are paired in src and dst. The width and
+ * height of each one of the pairs must match.
+ *
+ * If the DRM_MODE_FB_DIRTY_ANNOTATE_FILL flag is given the caller
+ * promises that the region specified of the clip rects is filled
+ * completely with a single color as given in the color argument.
+ */
+
+struct drm_mode_fb_dirty_cmd {
+       __u32 fb_id;
+       __u32 flags;
+       __u32 color;
+       __u32 num_clips;
+       __u64 clips_ptr;
 };
 
 struct drm_mode_mode_cmd {
-       uint32_t connector_id;
+       __u32 connector_id;
        struct drm_mode_modeinfo mode;
 };
 
@@ -248,24 +291,57 @@ struct drm_mode_mode_cmd {
  *    y
  */
 struct drm_mode_cursor {
-       uint32_t flags;
-       uint32_t crtc_id;
-       int32_t x;
-       int32_t y;
-       uint32_t width;
-       uint32_t height;
+       __u32 flags;
+       __u32 crtc_id;
+       __s32 x;
+       __s32 y;
+       __u32 width;
+       __u32 height;
        /* driver specific handle */
-       uint32_t handle;
+       __u32 handle;
 };
 
 struct drm_mode_crtc_lut {
-       uint32_t crtc_id;
-       uint32_t gamma_size;
+       __u32 crtc_id;
+       __u32 gamma_size;
 
        /* pointers to arrays */
-       uint64_t red;
-       uint64_t green;
-       uint64_t blue;
+       __u64 red;
+       __u64 green;
+       __u64 blue;
+};
+
+#define DRM_MODE_PAGE_FLIP_EVENT 0x01
+#define DRM_MODE_PAGE_FLIP_FLAGS DRM_MODE_PAGE_FLIP_EVENT
+
+/*
+ * Request a page flip on the specified crtc.
+ *
+ * This ioctl will ask KMS to schedule a page flip for the specified
+ * crtc.  Once any pending rendering targeting the specified fb (as of
+ * ioctl time) has completed, the crtc will be reprogrammed to display
+ * that fb after the next vertical refresh.  The ioctl returns
+ * immediately, but subsequent rendering to the current fb will block
+ * in the execbuffer ioctl until the page flip happens.  If a page
+ * flip is already pending as the ioctl is called, EBUSY will be
+ * returned.
+ *
+ * The ioctl supports one flag, DRM_MODE_PAGE_FLIP_EVENT, which will
+ * request that drm sends back a vblank event (see drm.h: struct
+ * drm_event_vblank) when the page flip is done.  The user_data field
+ * passed in with this ioctl will be returned as the user_data field
+ * in the vblank event struct.
+ *
+ * The reserved field must be zero until we figure out something
+ * clever to use it for.
+ */
+
+struct drm_mode_crtc_page_flip {
+       __u32 crtc_id;
+       __u32 fb_id;
+       __u32 flags;
+       __u32 reserved;
+       __u64 user_data;
 };
 
 #endif