Initial import
[renesas/gralloc-kms.git] / bionic / 0001-bionic-Add-kernel-drm-headers.patch
1 From 0778bf808f246a6962cc17e15a13d42714d8a420 Mon Sep 17 00:00:00 2001
2 From: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
3 Date: Sat, 15 Sep 2012 04:23:37 +0200
4 Subject: [PATCH] bionic: Add kernel drm headers
5
6 Import kernel headers from Linux v3.6.
7
8 Change-Id: I21b4aa3931f42e3547cb70d2f96493b6a82a8471
9 Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
10 ---
11  libc/kernel/common/drm/drm.h         |  828 ++++++++++++++++++++++++++++
12  libc/kernel/common/drm/drm_fourcc.h  |  133 +++++
13  libc/kernel/common/drm/drm_mode.h    |  463 ++++++++++++++++
14  libc/kernel/common/drm/drm_sarea.h   |   82 +++
15  libc/kernel/common/drm/exynos_drm.h  |  203 +++++++
16  libc/kernel/common/drm/i810_drm.h    |  281 ++++++++++
17  libc/kernel/common/drm/i915_drm.h    |  913 +++++++++++++++++++++++++++++++
18  libc/kernel/common/drm/mga_drm.h     |  419 +++++++++++++++
19  libc/kernel/common/drm/nouveau_drm.h |  138 +++++
20  libc/kernel/common/drm/r128_drm.h    |  326 ++++++++++++
21  libc/kernel/common/drm/radeon_drm.h  |  976 ++++++++++++++++++++++++++++++++++
22  libc/kernel/common/drm/savage_drm.h  |  210 ++++++++
23  libc/kernel/common/drm/sis_drm.h     |   71 +++
24  libc/kernel/common/drm/via_drm.h     |  279 ++++++++++
25  libc/kernel/common/drm/vmwgfx_drm.h  |  790 +++++++++++++++++++++++++++
26  15 files changed, 6112 insertions(+), 0 deletions(-)
27  create mode 100644 libc/kernel/common/drm/drm.h
28  create mode 100644 libc/kernel/common/drm/drm_fourcc.h
29  create mode 100644 libc/kernel/common/drm/drm_mode.h
30  create mode 100644 libc/kernel/common/drm/drm_sarea.h
31  create mode 100644 libc/kernel/common/drm/exynos_drm.h
32  create mode 100644 libc/kernel/common/drm/i810_drm.h
33  create mode 100644 libc/kernel/common/drm/i915_drm.h
34  create mode 100644 libc/kernel/common/drm/mga_drm.h
35  create mode 100644 libc/kernel/common/drm/nouveau_drm.h
36  create mode 100644 libc/kernel/common/drm/r128_drm.h
37  create mode 100644 libc/kernel/common/drm/radeon_drm.h
38  create mode 100644 libc/kernel/common/drm/savage_drm.h
39  create mode 100644 libc/kernel/common/drm/sis_drm.h
40  create mode 100644 libc/kernel/common/drm/via_drm.h
41  create mode 100644 libc/kernel/common/drm/vmwgfx_drm.h
42
43 diff --git a/libc/kernel/common/drm/drm.h b/libc/kernel/common/drm/drm.h
44 new file mode 100644
45 index 0000000..9be8203
46 --- /dev/null
47 +++ b/libc/kernel/common/drm/drm.h
48 @@ -0,0 +1,828 @@
49 +/**
50 + * \file drm.h
51 + * Header for the Direct Rendering Manager
52 + *
53 + * \author Rickard E. (Rik) Faith <faith@valinux.com>
54 + *
55 + * \par Acknowledgments:
56 + * Dec 1999, Richard Henderson <rth@twiddle.net>, move to generic \c cmpxchg.
57 + */
58 +
59 +/*
60 + * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
61 + * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
62 + * All rights reserved.
63 + *
64 + * Permission is hereby granted, free of charge, to any person obtaining a
65 + * copy of this software and associated documentation files (the "Software"),
66 + * to deal in the Software without restriction, including without limitation
67 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
68 + * and/or sell copies of the Software, and to permit persons to whom the
69 + * Software is furnished to do so, subject to the following conditions:
70 + *
71 + * The above copyright notice and this permission notice (including the next
72 + * paragraph) shall be included in all copies or substantial portions of the
73 + * Software.
74 + *
75 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
76 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
77 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
78 + * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
79 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
80 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
81 + * OTHER DEALINGS IN THE SOFTWARE.
82 + */
83 +
84 +#ifndef _DRM_H_
85 +#define _DRM_H_
86 +
87 +#if defined(__linux__)
88 +
89 +#include <linux/types.h>
90 +#include <asm/ioctl.h>
91 +typedef unsigned int drm_handle_t;
92 +
93 +#else /* One of the BSDs */
94 +
95 +#include <sys/ioccom.h>
96 +#include <sys/types.h>
97 +typedef int8_t   __s8;
98 +typedef uint8_t  __u8;
99 +typedef int16_t  __s16;
100 +typedef uint16_t __u16;
101 +typedef int32_t  __s32;
102 +typedef uint32_t __u32;
103 +typedef int64_t  __s64;
104 +typedef uint64_t __u64;
105 +typedef unsigned long drm_handle_t;
106 +
107 +#endif
108 +
109 +#define DRM_NAME       "drm"     /**< Name in kernel, /dev, and /proc */
110 +#define DRM_MIN_ORDER  5         /**< At least 2^5 bytes = 32 bytes */
111 +#define DRM_MAX_ORDER  22        /**< Up to 2^22 bytes = 4MB */
112 +#define DRM_RAM_PERCENT 10       /**< How much system ram can we lock? */
113 +
114 +#define _DRM_LOCK_HELD 0x80000000U /**< Hardware lock is held */
115 +#define _DRM_LOCK_CONT 0x40000000U /**< Hardware lock is contended */
116 +#define _DRM_LOCK_IS_HELD(lock)           ((lock) & _DRM_LOCK_HELD)
117 +#define _DRM_LOCK_IS_CONT(lock)           ((lock) & _DRM_LOCK_CONT)
118 +#define _DRM_LOCKING_CONTEXT(lock) ((lock) & ~(_DRM_LOCK_HELD|_DRM_LOCK_CONT))
119 +
120 +typedef unsigned int drm_context_t;
121 +typedef unsigned int drm_drawable_t;
122 +typedef unsigned int drm_magic_t;
123 +
124 +/**
125 + * Cliprect.
126 + *
127 + * \warning: If you change this structure, make sure you change
128 + * XF86DRIClipRectRec in the server as well
129 + *
130 + * \note KW: Actually it's illegal to change either for
131 + * backwards-compatibility reasons.
132 + */
133 +struct drm_clip_rect {
134 +       unsigned short x1;
135 +       unsigned short y1;
136 +       unsigned short x2;
137 +       unsigned short y2;
138 +};
139 +
140 +/**
141 + * Drawable information.
142 + */
143 +struct drm_drawable_info {
144 +       unsigned int num_rects;
145 +       struct drm_clip_rect *rects;
146 +};
147 +
148 +/**
149 + * Texture region,
150 + */
151 +struct drm_tex_region {
152 +       unsigned char next;
153 +       unsigned char prev;
154 +       unsigned char in_use;
155 +       unsigned char padding;
156 +       unsigned int age;
157 +};
158 +
159 +/**
160 + * Hardware lock.
161 + *
162 + * The lock structure is a simple cache-line aligned integer.  To avoid
163 + * processor bus contention on a multiprocessor system, there should not be any
164 + * other data stored in the same cache line.
165 + */
166 +struct drm_hw_lock {
167 +       __volatile__ unsigned int lock;         /**< lock variable */
168 +       char padding[60];                       /**< Pad to cache line */
169 +};
170 +
171 +/**
172 + * DRM_IOCTL_VERSION ioctl argument type.
173 + *
174 + * \sa drmGetVersion().
175 + */
176 +struct drm_version {
177 +       int version_major;        /**< Major version */
178 +       int version_minor;        /**< Minor version */
179 +       int version_patchlevel;   /**< Patch level */
180 +       size_t name_len;          /**< Length of name buffer */
181 +       char *name;       /**< Name of driver */
182 +       size_t date_len;          /**< Length of date buffer */
183 +       char *date;       /**< User-space buffer to hold date */
184 +       size_t desc_len;          /**< Length of desc buffer */
185 +       char *desc;       /**< User-space buffer to hold desc */
186 +};
187 +
188 +/**
189 + * DRM_IOCTL_GET_UNIQUE ioctl argument type.
190 + *
191 + * \sa drmGetBusid() and drmSetBusId().
192 + */
193 +struct drm_unique {
194 +       size_t unique_len;        /**< Length of unique */
195 +       char *unique;     /**< Unique name for driver instantiation */
196 +};
197 +
198 +struct drm_list {
199 +       int count;                /**< Length of user-space structures */
200 +       struct drm_version *version;
201 +};
202 +
203 +struct drm_block {
204 +       int unused;
205 +};
206 +
207 +/**
208 + * DRM_IOCTL_CONTROL ioctl argument type.
209 + *
210 + * \sa drmCtlInstHandler() and drmCtlUninstHandler().
211 + */
212 +struct drm_control {
213 +       enum {
214 +               DRM_ADD_COMMAND,
215 +               DRM_RM_COMMAND,
216 +               DRM_INST_HANDLER,
217 +               DRM_UNINST_HANDLER
218 +       } func;
219 +       int irq;
220 +};
221 +
222 +/**
223 + * Type of memory to map.
224 + */
225 +enum drm_map_type {
226 +       _DRM_FRAME_BUFFER = 0,    /**< WC (no caching), no core dump */
227 +       _DRM_REGISTERS = 1,       /**< no caching, no core dump */
228 +       _DRM_SHM = 2,             /**< shared, cached */
229 +       _DRM_AGP = 3,             /**< AGP/GART */
230 +       _DRM_SCATTER_GATHER = 4,  /**< Scatter/gather memory for PCI DMA */
231 +       _DRM_CONSISTENT = 5,      /**< Consistent memory for PCI DMA */
232 +       _DRM_GEM = 6,             /**< GEM object */
233 +};
234 +
235 +/**
236 + * Memory mapping flags.
237 + */
238 +enum drm_map_flags {
239 +       _DRM_RESTRICTED = 0x01,      /**< Cannot be mapped to user-virtual */
240 +       _DRM_READ_ONLY = 0x02,
241 +       _DRM_LOCKED = 0x04,          /**< shared, cached, locked */
242 +       _DRM_KERNEL = 0x08,          /**< kernel requires access */
243 +       _DRM_WRITE_COMBINING = 0x10, /**< use write-combining if available */
244 +       _DRM_CONTAINS_LOCK = 0x20,   /**< SHM page that contains lock */
245 +       _DRM_REMOVABLE = 0x40,       /**< Removable mapping */
246 +       _DRM_DRIVER = 0x80           /**< Managed by driver */
247 +};
248 +
249 +struct drm_ctx_priv_map {
250 +       unsigned int ctx_id;     /**< Context requesting private mapping */
251 +       void *handle;            /**< Handle of map */
252 +};
253 +
254 +/**
255 + * DRM_IOCTL_GET_MAP, DRM_IOCTL_ADD_MAP and DRM_IOCTL_RM_MAP ioctls
256 + * argument type.
257 + *
258 + * \sa drmAddMap().
259 + */
260 +struct drm_map {
261 +       unsigned long offset;    /**< Requested physical address (0 for SAREA)*/
262 +       unsigned long size;      /**< Requested physical size (bytes) */
263 +       enum drm_map_type type;  /**< Type of memory to map */
264 +       enum drm_map_flags flags;        /**< Flags */
265 +       void *handle;            /**< User-space: "Handle" to pass to mmap() */
266 +                                /**< Kernel-space: kernel-virtual address */
267 +       int mtrr;                /**< MTRR slot used */
268 +       /*   Private data */
269 +};
270 +
271 +/**
272 + * DRM_IOCTL_GET_CLIENT ioctl argument type.
273 + */
274 +struct drm_client {
275 +       int idx;                /**< Which client desired? */
276 +       int auth;               /**< Is client authenticated? */
277 +       unsigned long pid;      /**< Process ID */
278 +       unsigned long uid;      /**< User ID */
279 +       unsigned long magic;    /**< Magic */
280 +       unsigned long iocs;     /**< Ioctl count */
281 +};
282 +
283 +enum drm_stat_type {
284 +       _DRM_STAT_LOCK,
285 +       _DRM_STAT_OPENS,
286 +       _DRM_STAT_CLOSES,
287 +       _DRM_STAT_IOCTLS,
288 +       _DRM_STAT_LOCKS,
289 +       _DRM_STAT_UNLOCKS,
290 +       _DRM_STAT_VALUE,        /**< Generic value */
291 +       _DRM_STAT_BYTE,         /**< Generic byte counter (1024bytes/K) */
292 +       _DRM_STAT_COUNT,        /**< Generic non-byte counter (1000/k) */
293 +
294 +       _DRM_STAT_IRQ,          /**< IRQ */
295 +       _DRM_STAT_PRIMARY,      /**< Primary DMA bytes */
296 +       _DRM_STAT_SECONDARY,    /**< Secondary DMA bytes */
297 +       _DRM_STAT_DMA,          /**< DMA */
298 +       _DRM_STAT_SPECIAL,      /**< Special DMA (e.g., priority or polled) */
299 +       _DRM_STAT_MISSED        /**< Missed DMA opportunity */
300 +           /* Add to the *END* of the list */
301 +};
302 +
303 +/**
304 + * DRM_IOCTL_GET_STATS ioctl argument type.
305 + */
306 +struct drm_stats {
307 +       unsigned long count;
308 +       struct {
309 +               unsigned long value;
310 +               enum drm_stat_type type;
311 +       } data[15];
312 +};
313 +
314 +/**
315 + * Hardware locking flags.
316 + */
317 +enum drm_lock_flags {
318 +       _DRM_LOCK_READY = 0x01,      /**< Wait until hardware is ready for DMA */
319 +       _DRM_LOCK_QUIESCENT = 0x02,  /**< Wait until hardware quiescent */
320 +       _DRM_LOCK_FLUSH = 0x04,      /**< Flush this context's DMA queue first */
321 +       _DRM_LOCK_FLUSH_ALL = 0x08,  /**< Flush all DMA queues first */
322 +       /* These *HALT* flags aren't supported yet
323 +          -- they will be used to support the
324 +          full-screen DGA-like mode. */
325 +       _DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */
326 +       _DRM_HALT_CUR_QUEUES = 0x20  /**< Halt all current queues */
327 +};
328 +
329 +/**
330 + * DRM_IOCTL_LOCK, DRM_IOCTL_UNLOCK and DRM_IOCTL_FINISH ioctl argument type.
331 + *
332 + * \sa drmGetLock() and drmUnlock().
333 + */
334 +struct drm_lock {
335 +       int context;
336 +       enum drm_lock_flags flags;
337 +};
338 +
339 +/**
340 + * DMA flags
341 + *
342 + * \warning
343 + * These values \e must match xf86drm.h.
344 + *
345 + * \sa drm_dma.
346 + */
347 +enum drm_dma_flags {
348 +       /* Flags for DMA buffer dispatch */
349 +       _DRM_DMA_BLOCK = 0x01,        /**<
350 +                                      * Block until buffer dispatched.
351 +                                      *
352 +                                      * \note The buffer may not yet have
353 +                                      * been processed by the hardware --
354 +                                      * getting a hardware lock with the
355 +                                      * hardware quiescent will ensure
356 +                                      * that the buffer has been
357 +                                      * processed.
358 +                                      */
359 +       _DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */
360 +       _DRM_DMA_PRIORITY = 0x04,     /**< High priority dispatch */
361 +
362 +       /* Flags for DMA buffer request */
363 +       _DRM_DMA_WAIT = 0x10,         /**< Wait for free buffers */
364 +       _DRM_DMA_SMALLER_OK = 0x20,   /**< Smaller-than-requested buffers OK */
365 +       _DRM_DMA_LARGER_OK = 0x40     /**< Larger-than-requested buffers OK */
366 +};
367 +
368 +/**
369 + * DRM_IOCTL_ADD_BUFS and DRM_IOCTL_MARK_BUFS ioctl argument type.
370 + *
371 + * \sa drmAddBufs().
372 + */
373 +struct drm_buf_desc {
374 +       int count;               /**< Number of buffers of this size */
375 +       int size;                /**< Size in bytes */
376 +       int low_mark;            /**< Low water mark */
377 +       int high_mark;           /**< High water mark */
378 +       enum {
379 +               _DRM_PAGE_ALIGN = 0x01, /**< Align on page boundaries for DMA */
380 +               _DRM_AGP_BUFFER = 0x02, /**< Buffer is in AGP space */
381 +               _DRM_SG_BUFFER = 0x04,  /**< Scatter/gather memory buffer */
382 +               _DRM_FB_BUFFER = 0x08,  /**< Buffer is in frame buffer */
383 +               _DRM_PCI_BUFFER_RO = 0x10 /**< Map PCI DMA buffer read-only */
384 +       } flags;
385 +       unsigned long agp_start; /**<
386 +                                 * Start address of where the AGP buffers are
387 +                                 * in the AGP aperture
388 +                                 */
389 +};
390 +
391 +/**
392 + * DRM_IOCTL_INFO_BUFS ioctl argument type.
393 + */
394 +struct drm_buf_info {
395 +       int count;              /**< Entries in list */
396 +       struct drm_buf_desc *list;
397 +};
398 +
399 +/**
400 + * DRM_IOCTL_FREE_BUFS ioctl argument type.
401 + */
402 +struct drm_buf_free {
403 +       int count;
404 +       int *list;
405 +};
406 +
407 +/**
408 + * Buffer information
409 + *
410 + * \sa drm_buf_map.
411 + */
412 +struct drm_buf_pub {
413 +       int idx;                       /**< Index into the master buffer list */
414 +       int total;                     /**< Buffer size */
415 +       int used;                      /**< Amount of buffer in use (for DMA) */
416 +       void *address;         /**< Address of buffer */
417 +};
418 +
419 +/**
420 + * DRM_IOCTL_MAP_BUFS ioctl argument type.
421 + */
422 +struct drm_buf_map {
423 +       int count;              /**< Length of the buffer list */
424 +       void *virtual;          /**< Mmap'd area in user-virtual */
425 +       struct drm_buf_pub *list;       /**< Buffer information */
426 +};
427 +
428 +/**
429 + * DRM_IOCTL_DMA ioctl argument type.
430 + *
431 + * Indices here refer to the offset into the buffer list in drm_buf_get.
432 + *
433 + * \sa drmDMA().
434 + */
435 +struct drm_dma {
436 +       int context;                      /**< Context handle */
437 +       int send_count;                   /**< Number of buffers to send */
438 +       int *send_indices;        /**< List of handles to buffers */
439 +       int *send_sizes;                  /**< Lengths of data to send */
440 +       enum drm_dma_flags flags;         /**< Flags */
441 +       int request_count;                /**< Number of buffers requested */
442 +       int request_size;                 /**< Desired size for buffers */
443 +       int *request_indices;     /**< Buffer information */
444 +       int *request_sizes;
445 +       int granted_count;                /**< Number of buffers granted */
446 +};
447 +
448 +enum drm_ctx_flags {
449 +       _DRM_CONTEXT_PRESERVED = 0x01,
450 +       _DRM_CONTEXT_2DONLY = 0x02
451 +};
452 +
453 +/**
454 + * DRM_IOCTL_ADD_CTX ioctl argument type.
455 + *
456 + * \sa drmCreateContext() and drmDestroyContext().
457 + */
458 +struct drm_ctx {
459 +       drm_context_t handle;
460 +       enum drm_ctx_flags flags;
461 +};
462 +
463 +/**
464 + * DRM_IOCTL_RES_CTX ioctl argument type.
465 + */
466 +struct drm_ctx_res {
467 +       int count;
468 +       struct drm_ctx *contexts;
469 +};
470 +
471 +/**
472 + * DRM_IOCTL_ADD_DRAW and DRM_IOCTL_RM_DRAW ioctl argument type.
473 + */
474 +struct drm_draw {
475 +       drm_drawable_t handle;
476 +};
477 +
478 +/**
479 + * DRM_IOCTL_UPDATE_DRAW ioctl argument type.
480 + */
481 +typedef enum {
482 +       DRM_DRAWABLE_CLIPRECTS,
483 +} drm_drawable_info_type_t;
484 +
485 +struct drm_update_draw {
486 +       drm_drawable_t handle;
487 +       unsigned int type;
488 +       unsigned int num;
489 +       unsigned long long data;
490 +};
491 +
492 +/**
493 + * DRM_IOCTL_GET_MAGIC and DRM_IOCTL_AUTH_MAGIC ioctl argument type.
494 + */
495 +struct drm_auth {
496 +       drm_magic_t magic;
497 +};
498 +
499 +/**
500 + * DRM_IOCTL_IRQ_BUSID ioctl argument type.
501 + *
502 + * \sa drmGetInterruptFromBusID().
503 + */
504 +struct drm_irq_busid {
505 +       int irq;        /**< IRQ number */
506 +       int busnum;     /**< bus number */
507 +       int devnum;     /**< device number */
508 +       int funcnum;    /**< function number */
509 +};
510 +
511 +enum drm_vblank_seq_type {
512 +       _DRM_VBLANK_ABSOLUTE = 0x0,     /**< Wait for specific vblank sequence number */
513 +       _DRM_VBLANK_RELATIVE = 0x1,     /**< Wait for given number of vblanks */
514 +       /* bits 1-6 are reserved for high crtcs */
515 +       _DRM_VBLANK_HIGH_CRTC_MASK = 0x0000003e,
516 +       _DRM_VBLANK_EVENT = 0x4000000,   /**< Send event instead of blocking */
517 +       _DRM_VBLANK_FLIP = 0x8000000,   /**< Scheduled buffer swap should flip */
518 +       _DRM_VBLANK_NEXTONMISS = 0x10000000,    /**< If missed, wait for next vblank */
519 +       _DRM_VBLANK_SECONDARY = 0x20000000,     /**< Secondary display controller */
520 +       _DRM_VBLANK_SIGNAL = 0x40000000 /**< Send signal instead of blocking, unsupported */
521 +};
522 +#define _DRM_VBLANK_HIGH_CRTC_SHIFT 1
523 +
524 +#define _DRM_VBLANK_TYPES_MASK (_DRM_VBLANK_ABSOLUTE | _DRM_VBLANK_RELATIVE)
525 +#define _DRM_VBLANK_FLAGS_MASK (_DRM_VBLANK_EVENT | _DRM_VBLANK_SIGNAL | \
526 +                               _DRM_VBLANK_SECONDARY | _DRM_VBLANK_NEXTONMISS)
527 +
528 +struct drm_wait_vblank_request {
529 +       enum drm_vblank_seq_type type;
530 +       unsigned int sequence;
531 +       unsigned long signal;
532 +};
533 +
534 +struct drm_wait_vblank_reply {
535 +       enum drm_vblank_seq_type type;
536 +       unsigned int sequence;
537 +       long tval_sec;
538 +       long tval_usec;
539 +};
540 +
541 +/**
542 + * DRM_IOCTL_WAIT_VBLANK ioctl argument type.
543 + *
544 + * \sa drmWaitVBlank().
545 + */
546 +union drm_wait_vblank {
547 +       struct drm_wait_vblank_request request;
548 +       struct drm_wait_vblank_reply reply;
549 +};
550 +
551 +#define _DRM_PRE_MODESET 1
552 +#define _DRM_POST_MODESET 2
553 +
554 +/**
555 + * DRM_IOCTL_MODESET_CTL ioctl argument type
556 + *
557 + * \sa drmModesetCtl().
558 + */
559 +struct drm_modeset_ctl {
560 +       __u32 crtc;
561 +       __u32 cmd;
562 +};
563 +
564 +/**
565 + * DRM_IOCTL_AGP_ENABLE ioctl argument type.
566 + *
567 + * \sa drmAgpEnable().
568 + */
569 +struct drm_agp_mode {
570 +       unsigned long mode;     /**< AGP mode */
571 +};
572 +
573 +/**
574 + * DRM_IOCTL_AGP_ALLOC and DRM_IOCTL_AGP_FREE ioctls argument type.
575 + *
576 + * \sa drmAgpAlloc() and drmAgpFree().
577 + */
578 +struct drm_agp_buffer {
579 +       unsigned long size;     /**< In bytes -- will round to page boundary */
580 +       unsigned long handle;   /**< Used for binding / unbinding */
581 +       unsigned long type;     /**< Type of memory to allocate */
582 +       unsigned long physical; /**< Physical used by i810 */
583 +};
584 +
585 +/**
586 + * DRM_IOCTL_AGP_BIND and DRM_IOCTL_AGP_UNBIND ioctls argument type.
587 + *
588 + * \sa drmAgpBind() and drmAgpUnbind().
589 + */
590 +struct drm_agp_binding {
591 +       unsigned long handle;   /**< From drm_agp_buffer */
592 +       unsigned long offset;   /**< In bytes -- will round to page boundary */
593 +};
594 +
595 +/**
596 + * DRM_IOCTL_AGP_INFO ioctl argument type.
597 + *
598 + * \sa drmAgpVersionMajor(), drmAgpVersionMinor(), drmAgpGetMode(),
599 + * drmAgpBase(), drmAgpSize(), drmAgpMemoryUsed(), drmAgpMemoryAvail(),
600 + * drmAgpVendorId() and drmAgpDeviceId().
601 + */
602 +struct drm_agp_info {
603 +       int agp_version_major;
604 +       int agp_version_minor;
605 +       unsigned long mode;
606 +       unsigned long aperture_base;    /* physical address */
607 +       unsigned long aperture_size;    /* bytes */
608 +       unsigned long memory_allowed;   /* bytes */
609 +       unsigned long memory_used;
610 +
611 +       /* PCI information */
612 +       unsigned short id_vendor;
613 +       unsigned short id_device;
614 +};
615 +
616 +/**
617 + * DRM_IOCTL_SG_ALLOC ioctl argument type.
618 + */
619 +struct drm_scatter_gather {
620 +       unsigned long size;     /**< In bytes -- will round to page boundary */
621 +       unsigned long handle;   /**< Used for mapping / unmapping */
622 +};
623 +
624 +/**
625 + * DRM_IOCTL_SET_VERSION ioctl argument type.
626 + */
627 +struct drm_set_version {
628 +       int drm_di_major;
629 +       int drm_di_minor;
630 +       int drm_dd_major;
631 +       int drm_dd_minor;
632 +};
633 +
634 +/** DRM_IOCTL_GEM_CLOSE ioctl argument type */
635 +struct drm_gem_close {
636 +       /** Handle of the object to be closed. */
637 +       __u32 handle;
638 +       __u32 pad;
639 +};
640 +
641 +/** DRM_IOCTL_GEM_FLINK ioctl argument type */
642 +struct drm_gem_flink {
643 +       /** Handle for the object being named */
644 +       __u32 handle;
645 +
646 +       /** Returned global name */
647 +       __u32 name;
648 +};
649 +
650 +/** DRM_IOCTL_GEM_OPEN ioctl argument type */
651 +struct drm_gem_open {
652 +       /** Name of object being opened */
653 +       __u32 name;
654 +
655 +       /** Returned handle for the object */
656 +       __u32 handle;
657 +
658 +       /** Returned size of the object */
659 +       __u64 size;
660 +};
661 +
662 +/** DRM_IOCTL_GET_CAP ioctl argument type */
663 +struct drm_get_cap {
664 +       __u64 capability;
665 +       __u64 value;
666 +};
667 +
668 +#define DRM_CLOEXEC O_CLOEXEC
669 +struct drm_prime_handle {
670 +       __u32 handle;
671 +
672 +       /** Flags.. only applicable for handle->fd */
673 +       __u32 flags;
674 +
675 +       /** Returned dmabuf file descriptor */
676 +       __s32 fd;
677 +};
678 +
679 +#include "drm_mode.h"
680 +
681 +#define DRM_IOCTL_BASE                 'd'
682 +#define DRM_IO(nr)                     _IO(DRM_IOCTL_BASE,nr)
683 +#define DRM_IOR(nr,type)               _IOR(DRM_IOCTL_BASE,nr,type)
684 +#define DRM_IOW(nr,type)               _IOW(DRM_IOCTL_BASE,nr,type)
685 +#define DRM_IOWR(nr,type)              _IOWR(DRM_IOCTL_BASE,nr,type)
686 +
687 +#define DRM_IOCTL_VERSION              DRM_IOWR(0x00, struct drm_version)
688 +#define DRM_IOCTL_GET_UNIQUE           DRM_IOWR(0x01, struct drm_unique)
689 +#define DRM_IOCTL_GET_MAGIC            DRM_IOR( 0x02, struct drm_auth)
690 +#define DRM_IOCTL_IRQ_BUSID            DRM_IOWR(0x03, struct drm_irq_busid)
691 +#define DRM_IOCTL_GET_MAP               DRM_IOWR(0x04, struct drm_map)
692 +#define DRM_IOCTL_GET_CLIENT            DRM_IOWR(0x05, struct drm_client)
693 +#define DRM_IOCTL_GET_STATS             DRM_IOR( 0x06, struct drm_stats)
694 +#define DRM_IOCTL_SET_VERSION          DRM_IOWR(0x07, struct drm_set_version)
695 +#define DRM_IOCTL_MODESET_CTL           DRM_IOW(0x08, struct drm_modeset_ctl)
696 +#define DRM_IOCTL_GEM_CLOSE            DRM_IOW (0x09, struct drm_gem_close)
697 +#define DRM_IOCTL_GEM_FLINK            DRM_IOWR(0x0a, struct drm_gem_flink)
698 +#define DRM_IOCTL_GEM_OPEN             DRM_IOWR(0x0b, struct drm_gem_open)
699 +#define DRM_IOCTL_GET_CAP              DRM_IOWR(0x0c, struct drm_get_cap)
700 +
701 +#define DRM_IOCTL_SET_UNIQUE           DRM_IOW( 0x10, struct drm_unique)
702 +#define DRM_IOCTL_AUTH_MAGIC           DRM_IOW( 0x11, struct drm_auth)
703 +#define DRM_IOCTL_BLOCK                        DRM_IOWR(0x12, struct drm_block)
704 +#define DRM_IOCTL_UNBLOCK              DRM_IOWR(0x13, struct drm_block)
705 +#define DRM_IOCTL_CONTROL              DRM_IOW( 0x14, struct drm_control)
706 +#define DRM_IOCTL_ADD_MAP              DRM_IOWR(0x15, struct drm_map)
707 +#define DRM_IOCTL_ADD_BUFS             DRM_IOWR(0x16, struct drm_buf_desc)
708 +#define DRM_IOCTL_MARK_BUFS            DRM_IOW( 0x17, struct drm_buf_desc)
709 +#define DRM_IOCTL_INFO_BUFS            DRM_IOWR(0x18, struct drm_buf_info)
710 +#define DRM_IOCTL_MAP_BUFS             DRM_IOWR(0x19, struct drm_buf_map)
711 +#define DRM_IOCTL_FREE_BUFS            DRM_IOW( 0x1a, struct drm_buf_free)
712 +
713 +#define DRM_IOCTL_RM_MAP               DRM_IOW( 0x1b, struct drm_map)
714 +
715 +#define DRM_IOCTL_SET_SAREA_CTX                DRM_IOW( 0x1c, struct drm_ctx_priv_map)
716 +#define DRM_IOCTL_GET_SAREA_CTX        DRM_IOWR(0x1d, struct drm_ctx_priv_map)
717 +
718 +#define DRM_IOCTL_SET_MASTER            DRM_IO(0x1e)
719 +#define DRM_IOCTL_DROP_MASTER           DRM_IO(0x1f)
720 +
721 +#define DRM_IOCTL_ADD_CTX              DRM_IOWR(0x20, struct drm_ctx)
722 +#define DRM_IOCTL_RM_CTX               DRM_IOWR(0x21, struct drm_ctx)
723 +#define DRM_IOCTL_MOD_CTX              DRM_IOW( 0x22, struct drm_ctx)
724 +#define DRM_IOCTL_GET_CTX              DRM_IOWR(0x23, struct drm_ctx)
725 +#define DRM_IOCTL_SWITCH_CTX           DRM_IOW( 0x24, struct drm_ctx)
726 +#define DRM_IOCTL_NEW_CTX              DRM_IOW( 0x25, struct drm_ctx)
727 +#define DRM_IOCTL_RES_CTX              DRM_IOWR(0x26, struct drm_ctx_res)
728 +#define DRM_IOCTL_ADD_DRAW             DRM_IOWR(0x27, struct drm_draw)
729 +#define DRM_IOCTL_RM_DRAW              DRM_IOWR(0x28, struct drm_draw)
730 +#define DRM_IOCTL_DMA                  DRM_IOWR(0x29, struct drm_dma)
731 +#define DRM_IOCTL_LOCK                 DRM_IOW( 0x2a, struct drm_lock)
732 +#define DRM_IOCTL_UNLOCK               DRM_IOW( 0x2b, struct drm_lock)
733 +#define DRM_IOCTL_FINISH               DRM_IOW( 0x2c, struct drm_lock)
734 +
735 +#define DRM_IOCTL_PRIME_HANDLE_TO_FD    DRM_IOWR(0x2d, struct drm_prime_handle)
736 +#define DRM_IOCTL_PRIME_FD_TO_HANDLE    DRM_IOWR(0x2e, struct drm_prime_handle)
737 +
738 +#define DRM_IOCTL_AGP_ACQUIRE          DRM_IO(  0x30)
739 +#define DRM_IOCTL_AGP_RELEASE          DRM_IO(  0x31)
740 +#define DRM_IOCTL_AGP_ENABLE           DRM_IOW( 0x32, struct drm_agp_mode)
741 +#define DRM_IOCTL_AGP_INFO             DRM_IOR( 0x33, struct drm_agp_info)
742 +#define DRM_IOCTL_AGP_ALLOC            DRM_IOWR(0x34, struct drm_agp_buffer)
743 +#define DRM_IOCTL_AGP_FREE             DRM_IOW( 0x35, struct drm_agp_buffer)
744 +#define DRM_IOCTL_AGP_BIND             DRM_IOW( 0x36, struct drm_agp_binding)
745 +#define DRM_IOCTL_AGP_UNBIND           DRM_IOW( 0x37, struct drm_agp_binding)
746 +
747 +#define DRM_IOCTL_SG_ALLOC             DRM_IOWR(0x38, struct drm_scatter_gather)
748 +#define DRM_IOCTL_SG_FREE              DRM_IOW( 0x39, struct drm_scatter_gather)
749 +
750 +#define DRM_IOCTL_WAIT_VBLANK          DRM_IOWR(0x3a, union drm_wait_vblank)
751 +
752 +#define DRM_IOCTL_UPDATE_DRAW          DRM_IOW(0x3f, struct drm_update_draw)
753 +
754 +#define DRM_IOCTL_MODE_GETRESOURCES    DRM_IOWR(0xA0, struct drm_mode_card_res)
755 +#define DRM_IOCTL_MODE_GETCRTC         DRM_IOWR(0xA1, struct drm_mode_crtc)
756 +#define DRM_IOCTL_MODE_SETCRTC         DRM_IOWR(0xA2, struct drm_mode_crtc)
757 +#define DRM_IOCTL_MODE_CURSOR          DRM_IOWR(0xA3, struct drm_mode_cursor)
758 +#define DRM_IOCTL_MODE_GETGAMMA                DRM_IOWR(0xA4, struct drm_mode_crtc_lut)
759 +#define DRM_IOCTL_MODE_SETGAMMA                DRM_IOWR(0xA5, struct drm_mode_crtc_lut)
760 +#define DRM_IOCTL_MODE_GETENCODER      DRM_IOWR(0xA6, struct drm_mode_get_encoder)
761 +#define DRM_IOCTL_MODE_GETCONNECTOR    DRM_IOWR(0xA7, struct drm_mode_get_connector)
762 +#define DRM_IOCTL_MODE_ATTACHMODE      DRM_IOWR(0xA8, struct drm_mode_mode_cmd)
763 +#define DRM_IOCTL_MODE_DETACHMODE      DRM_IOWR(0xA9, struct drm_mode_mode_cmd)
764 +
765 +#define DRM_IOCTL_MODE_GETPROPERTY     DRM_IOWR(0xAA, struct drm_mode_get_property)
766 +#define DRM_IOCTL_MODE_SETPROPERTY     DRM_IOWR(0xAB, struct drm_mode_connector_set_property)
767 +#define DRM_IOCTL_MODE_GETPROPBLOB     DRM_IOWR(0xAC, struct drm_mode_get_blob)
768 +#define DRM_IOCTL_MODE_GETFB           DRM_IOWR(0xAD, struct drm_mode_fb_cmd)
769 +#define DRM_IOCTL_MODE_ADDFB           DRM_IOWR(0xAE, struct drm_mode_fb_cmd)
770 +#define DRM_IOCTL_MODE_RMFB            DRM_IOWR(0xAF, unsigned int)
771 +#define DRM_IOCTL_MODE_PAGE_FLIP       DRM_IOWR(0xB0, struct drm_mode_crtc_page_flip)
772 +#define DRM_IOCTL_MODE_DIRTYFB         DRM_IOWR(0xB1, struct drm_mode_fb_dirty_cmd)
773 +
774 +#define DRM_IOCTL_MODE_CREATE_DUMB DRM_IOWR(0xB2, struct drm_mode_create_dumb)
775 +#define DRM_IOCTL_MODE_MAP_DUMB    DRM_IOWR(0xB3, struct drm_mode_map_dumb)
776 +#define DRM_IOCTL_MODE_DESTROY_DUMB    DRM_IOWR(0xB4, struct drm_mode_destroy_dumb)
777 +#define DRM_IOCTL_MODE_GETPLANERESOURCES DRM_IOWR(0xB5, struct drm_mode_get_plane_res)
778 +#define DRM_IOCTL_MODE_GETPLANE        DRM_IOWR(0xB6, struct drm_mode_get_plane)
779 +#define DRM_IOCTL_MODE_SETPLANE        DRM_IOWR(0xB7, struct drm_mode_set_plane)
780 +#define DRM_IOCTL_MODE_ADDFB2          DRM_IOWR(0xB8, struct drm_mode_fb_cmd2)
781 +#define DRM_IOCTL_MODE_OBJ_GETPROPERTIES       DRM_IOWR(0xB9, struct drm_mode_obj_get_properties)
782 +#define DRM_IOCTL_MODE_OBJ_SETPROPERTY DRM_IOWR(0xBA, struct drm_mode_obj_set_property)
783 +
784 +/**
785 + * Device specific ioctls should only be in their respective headers
786 + * The device specific ioctl range is from 0x40 to 0x99.
787 + * Generic IOCTLS restart at 0xA0.
788 + *
789 + * \sa drmCommandNone(), drmCommandRead(), drmCommandWrite(), and
790 + * drmCommandReadWrite().
791 + */
792 +#define DRM_COMMAND_BASE                0x40
793 +#define DRM_COMMAND_END                        0xA0
794 +
795 +/**
796 + * Header for events written back to userspace on the drm fd.  The
797 + * type defines the type of event, the length specifies the total
798 + * length of the event (including the header), and user_data is
799 + * typically a 64 bit value passed with the ioctl that triggered the
800 + * event.  A read on the drm fd will always only return complete
801 + * events, that is, if for example the read buffer is 100 bytes, and
802 + * there are two 64 byte events pending, only one will be returned.
803 + *
804 + * Event types 0 - 0x7fffffff are generic drm events, 0x80000000 and
805 + * up are chipset specific.
806 + */
807 +struct drm_event {
808 +       __u32 type;
809 +       __u32 length;
810 +};
811 +
812 +#define DRM_EVENT_VBLANK 0x01
813 +#define DRM_EVENT_FLIP_COMPLETE 0x02
814 +
815 +struct drm_event_vblank {
816 +       struct drm_event base;
817 +       __u64 user_data;
818 +       __u32 tv_sec;
819 +       __u32 tv_usec;
820 +       __u32 sequence;
821 +       __u32 reserved;
822 +};
823 +
824 +#define DRM_CAP_DUMB_BUFFER 0x1
825 +#define DRM_CAP_VBLANK_HIGH_CRTC 0x2
826 +#define DRM_CAP_DUMB_PREFERRED_DEPTH 0x3
827 +#define DRM_CAP_DUMB_PREFER_SHADOW 0x4
828 +#define DRM_CAP_PRIME 0x5
829 +
830 +#define DRM_PRIME_CAP_IMPORT 0x1
831 +#define DRM_PRIME_CAP_EXPORT 0x2
832 +
833 +/* typedef area */
834 +typedef struct drm_clip_rect drm_clip_rect_t;
835 +typedef struct drm_drawable_info drm_drawable_info_t;
836 +typedef struct drm_tex_region drm_tex_region_t;
837 +typedef struct drm_hw_lock drm_hw_lock_t;
838 +typedef struct drm_version drm_version_t;
839 +typedef struct drm_unique drm_unique_t;
840 +typedef struct drm_list drm_list_t;
841 +typedef struct drm_block drm_block_t;
842 +typedef struct drm_control drm_control_t;
843 +typedef enum drm_map_type drm_map_type_t;
844 +typedef enum drm_map_flags drm_map_flags_t;
845 +typedef struct drm_ctx_priv_map drm_ctx_priv_map_t;
846 +typedef struct drm_map drm_map_t;
847 +typedef struct drm_client drm_client_t;
848 +typedef enum drm_stat_type drm_stat_type_t;
849 +typedef struct drm_stats drm_stats_t;
850 +typedef enum drm_lock_flags drm_lock_flags_t;
851 +typedef struct drm_lock drm_lock_t;
852 +typedef enum drm_dma_flags drm_dma_flags_t;
853 +typedef struct drm_buf_desc drm_buf_desc_t;
854 +typedef struct drm_buf_info drm_buf_info_t;
855 +typedef struct drm_buf_free drm_buf_free_t;
856 +typedef struct drm_buf_pub drm_buf_pub_t;
857 +typedef struct drm_buf_map drm_buf_map_t;
858 +typedef struct drm_dma drm_dma_t;
859 +typedef union drm_wait_vblank drm_wait_vblank_t;
860 +typedef struct drm_agp_mode drm_agp_mode_t;
861 +typedef enum drm_ctx_flags drm_ctx_flags_t;
862 +typedef struct drm_ctx drm_ctx_t;
863 +typedef struct drm_ctx_res drm_ctx_res_t;
864 +typedef struct drm_draw drm_draw_t;
865 +typedef struct drm_update_draw drm_update_draw_t;
866 +typedef struct drm_auth drm_auth_t;
867 +typedef struct drm_irq_busid drm_irq_busid_t;
868 +typedef enum drm_vblank_seq_type drm_vblank_seq_type_t;
869 +
870 +typedef struct drm_agp_buffer drm_agp_buffer_t;
871 +typedef struct drm_agp_binding drm_agp_binding_t;
872 +typedef struct drm_agp_info drm_agp_info_t;
873 +typedef struct drm_scatter_gather drm_scatter_gather_t;
874 +typedef struct drm_set_version drm_set_version_t;
875 +
876 +#endif
877 diff --git a/libc/kernel/common/drm/drm_fourcc.h b/libc/kernel/common/drm/drm_fourcc.h
878 new file mode 100644
879 index 0000000..f462118
880 --- /dev/null
881 +++ b/libc/kernel/common/drm/drm_fourcc.h
882 @@ -0,0 +1,133 @@
883 +/*
884 + * Copyright 2011 Intel Corporation
885 + *
886 + * Permission is hereby granted, free of charge, to any person obtaining a
887 + * copy of this software and associated documentation files (the "Software"),
888 + * to deal in the Software without restriction, including without limitation
889 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
890 + * and/or sell copies of the Software, and to permit persons to whom the
891 + * Software is furnished to do so, subject to the following conditions:
892 + *
893 + * The above copyright notice and this permission notice (including the next
894 + * paragraph) shall be included in all copies or substantial portions of the
895 + * Software.
896 + *
897 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
898 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
899 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
900 + * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
901 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
902 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
903 + * OTHER DEALINGS IN THE SOFTWARE.
904 + */
905 +
906 +#ifndef DRM_FOURCC_H
907 +#define DRM_FOURCC_H
908 +
909 +#include <linux/types.h>
910 +
911 +#define fourcc_code(a, b, c, d) ((__u32)(a) | ((__u32)(b) << 8) | \
912 +                                ((__u32)(c) << 16) | ((__u32)(d) << 24))
913 +
914 +#define DRM_FORMAT_BIG_ENDIAN (1<<31) /* format is big endian instead of little endian */
915 +
916 +/* color index */
917 +#define DRM_FORMAT_C8          fourcc_code('C', '8', ' ', ' ') /* [7:0] C */
918 +
919 +/* 8 bpp RGB */
920 +#define DRM_FORMAT_RGB332      fourcc_code('R', 'G', 'B', '8') /* [7:0] R:G:B 3:3:2 */
921 +#define DRM_FORMAT_BGR233      fourcc_code('B', 'G', 'R', '8') /* [7:0] B:G:R 2:3:3 */
922 +
923 +/* 16 bpp RGB */
924 +#define DRM_FORMAT_XRGB4444    fourcc_code('X', 'R', '1', '2') /* [15:0] x:R:G:B 4:4:4:4 little endian */
925 +#define DRM_FORMAT_XBGR4444    fourcc_code('X', 'B', '1', '2') /* [15:0] x:B:G:R 4:4:4:4 little endian */
926 +#define DRM_FORMAT_RGBX4444    fourcc_code('R', 'X', '1', '2') /* [15:0] R:G:B:x 4:4:4:4 little endian */
927 +#define DRM_FORMAT_BGRX4444    fourcc_code('B', 'X', '1', '2') /* [15:0] B:G:R:x 4:4:4:4 little endian */
928 +
929 +#define DRM_FORMAT_ARGB4444    fourcc_code('A', 'R', '1', '2') /* [15:0] A:R:G:B 4:4:4:4 little endian */
930 +#define DRM_FORMAT_ABGR4444    fourcc_code('A', 'B', '1', '2') /* [15:0] A:B:G:R 4:4:4:4 little endian */
931 +#define DRM_FORMAT_RGBA4444    fourcc_code('R', 'A', '1', '2') /* [15:0] R:G:B:A 4:4:4:4 little endian */
932 +#define DRM_FORMAT_BGRA4444    fourcc_code('B', 'A', '1', '2') /* [15:0] B:G:R:A 4:4:4:4 little endian */
933 +
934 +#define DRM_FORMAT_XRGB1555    fourcc_code('X', 'R', '1', '5') /* [15:0] x:R:G:B 1:5:5:5 little endian */
935 +#define DRM_FORMAT_XBGR1555    fourcc_code('X', 'B', '1', '5') /* [15:0] x:B:G:R 1:5:5:5 little endian */
936 +#define DRM_FORMAT_RGBX5551    fourcc_code('R', 'X', '1', '5') /* [15:0] R:G:B:x 5:5:5:1 little endian */
937 +#define DRM_FORMAT_BGRX5551    fourcc_code('B', 'X', '1', '5') /* [15:0] B:G:R:x 5:5:5:1 little endian */
938 +
939 +#define DRM_FORMAT_ARGB1555    fourcc_code('A', 'R', '1', '5') /* [15:0] A:R:G:B 1:5:5:5 little endian */
940 +#define DRM_FORMAT_ABGR1555    fourcc_code('A', 'B', '1', '5') /* [15:0] A:B:G:R 1:5:5:5 little endian */
941 +#define DRM_FORMAT_RGBA5551    fourcc_code('R', 'A', '1', '5') /* [15:0] R:G:B:A 5:5:5:1 little endian */
942 +#define DRM_FORMAT_BGRA5551    fourcc_code('B', 'A', '1', '5') /* [15:0] B:G:R:A 5:5:5:1 little endian */
943 +
944 +#define DRM_FORMAT_RGB565      fourcc_code('R', 'G', '1', '6') /* [15:0] R:G:B 5:6:5 little endian */
945 +#define DRM_FORMAT_BGR565      fourcc_code('B', 'G', '1', '6') /* [15:0] B:G:R 5:6:5 little endian */
946 +
947 +/* 24 bpp RGB */
948 +#define DRM_FORMAT_RGB888      fourcc_code('R', 'G', '2', '4') /* [23:0] R:G:B little endian */
949 +#define DRM_FORMAT_BGR888      fourcc_code('B', 'G', '2', '4') /* [23:0] B:G:R little endian */
950 +
951 +/* 32 bpp RGB */
952 +#define DRM_FORMAT_XRGB8888    fourcc_code('X', 'R', '2', '4') /* [31:0] x:R:G:B 8:8:8:8 little endian */
953 +#define DRM_FORMAT_XBGR8888    fourcc_code('X', 'B', '2', '4') /* [31:0] x:B:G:R 8:8:8:8 little endian */
954 +#define DRM_FORMAT_RGBX8888    fourcc_code('R', 'X', '2', '4') /* [31:0] R:G:B:x 8:8:8:8 little endian */
955 +#define DRM_FORMAT_BGRX8888    fourcc_code('B', 'X', '2', '4') /* [31:0] B:G:R:x 8:8:8:8 little endian */
956 +
957 +#define DRM_FORMAT_ARGB8888    fourcc_code('A', 'R', '2', '4') /* [31:0] A:R:G:B 8:8:8:8 little endian */
958 +#define DRM_FORMAT_ABGR8888    fourcc_code('A', 'B', '2', '4') /* [31:0] A:B:G:R 8:8:8:8 little endian */
959 +#define DRM_FORMAT_RGBA8888    fourcc_code('R', 'A', '2', '4') /* [31:0] R:G:B:A 8:8:8:8 little endian */
960 +#define DRM_FORMAT_BGRA8888    fourcc_code('B', 'A', '2', '4') /* [31:0] B:G:R:A 8:8:8:8 little endian */
961 +
962 +#define DRM_FORMAT_XRGB2101010 fourcc_code('X', 'R', '3', '0') /* [31:0] x:R:G:B 2:10:10:10 little endian */
963 +#define DRM_FORMAT_XBGR2101010 fourcc_code('X', 'B', '3', '0') /* [31:0] x:B:G:R 2:10:10:10 little endian */
964 +#define DRM_FORMAT_RGBX1010102 fourcc_code('R', 'X', '3', '0') /* [31:0] R:G:B:x 10:10:10:2 little endian */
965 +#define DRM_FORMAT_BGRX1010102 fourcc_code('B', 'X', '3', '0') /* [31:0] B:G:R:x 10:10:10:2 little endian */
966 +
967 +#define DRM_FORMAT_ARGB2101010 fourcc_code('A', 'R', '3', '0') /* [31:0] A:R:G:B 2:10:10:10 little endian */
968 +#define DRM_FORMAT_ABGR2101010 fourcc_code('A', 'B', '3', '0') /* [31:0] A:B:G:R 2:10:10:10 little endian */
969 +#define DRM_FORMAT_RGBA1010102 fourcc_code('R', 'A', '3', '0') /* [31:0] R:G:B:A 10:10:10:2 little endian */
970 +#define DRM_FORMAT_BGRA1010102 fourcc_code('B', 'A', '3', '0') /* [31:0] B:G:R:A 10:10:10:2 little endian */
971 +
972 +/* packed YCbCr */
973 +#define DRM_FORMAT_YUYV                fourcc_code('Y', 'U', 'Y', 'V') /* [31:0] Cr0:Y1:Cb0:Y0 8:8:8:8 little endian */
974 +#define DRM_FORMAT_YVYU                fourcc_code('Y', 'V', 'Y', 'U') /* [31:0] Cb0:Y1:Cr0:Y0 8:8:8:8 little endian */
975 +#define DRM_FORMAT_UYVY                fourcc_code('U', 'Y', 'V', 'Y') /* [31:0] Y1:Cr0:Y0:Cb0 8:8:8:8 little endian */
976 +#define DRM_FORMAT_VYUY                fourcc_code('V', 'Y', 'U', 'Y') /* [31:0] Y1:Cb0:Y0:Cr0 8:8:8:8 little endian */
977 +
978 +#define DRM_FORMAT_AYUV                fourcc_code('A', 'Y', 'U', 'V') /* [31:0] A:Y:Cb:Cr 8:8:8:8 little endian */
979 +
980 +/*
981 + * 2 plane YCbCr
982 + * index 0 = Y plane, [7:0] Y
983 + * index 1 = Cr:Cb plane, [15:0] Cr:Cb little endian
984 + * or
985 + * index 1 = Cb:Cr plane, [15:0] Cb:Cr little endian
986 + */
987 +#define DRM_FORMAT_NV12                fourcc_code('N', 'V', '1', '2') /* 2x2 subsampled Cr:Cb plane */
988 +#define DRM_FORMAT_NV21                fourcc_code('N', 'V', '2', '1') /* 2x2 subsampled Cb:Cr plane */
989 +#define DRM_FORMAT_NV16                fourcc_code('N', 'V', '1', '6') /* 2x1 subsampled Cr:Cb plane */
990 +#define DRM_FORMAT_NV61                fourcc_code('N', 'V', '6', '1') /* 2x1 subsampled Cb:Cr plane */
991 +
992 +/* special NV12 tiled format */
993 +#define DRM_FORMAT_NV12MT      fourcc_code('T', 'M', '1', '2') /* 2x2 subsampled Cr:Cb plane 64x32 macroblocks */
994 +
995 +/*
996 + * 3 plane YCbCr
997 + * index 0: Y plane, [7:0] Y
998 + * index 1: Cb plane, [7:0] Cb
999 + * index 2: Cr plane, [7:0] Cr
1000 + * or
1001 + * index 1: Cr plane, [7:0] Cr
1002 + * index 2: Cb plane, [7:0] Cb
1003 + */
1004 +#define DRM_FORMAT_YUV410      fourcc_code('Y', 'U', 'V', '9') /* 4x4 subsampled Cb (1) and Cr (2) planes */
1005 +#define DRM_FORMAT_YVU410      fourcc_code('Y', 'V', 'U', '9') /* 4x4 subsampled Cr (1) and Cb (2) planes */
1006 +#define DRM_FORMAT_YUV411      fourcc_code('Y', 'U', '1', '1') /* 4x1 subsampled Cb (1) and Cr (2) planes */
1007 +#define DRM_FORMAT_YVU411      fourcc_code('Y', 'V', '1', '1') /* 4x1 subsampled Cr (1) and Cb (2) planes */
1008 +#define DRM_FORMAT_YUV420      fourcc_code('Y', 'U', '1', '2') /* 2x2 subsampled Cb (1) and Cr (2) planes */
1009 +#define DRM_FORMAT_YVU420      fourcc_code('Y', 'V', '1', '2') /* 2x2 subsampled Cr (1) and Cb (2) planes */
1010 +#define DRM_FORMAT_YUV422      fourcc_code('Y', 'U', '1', '6') /* 2x1 subsampled Cb (1) and Cr (2) planes */
1011 +#define DRM_FORMAT_YVU422      fourcc_code('Y', 'V', '1', '6') /* 2x1 subsampled Cr (1) and Cb (2) planes */
1012 +#define DRM_FORMAT_YUV444      fourcc_code('Y', 'U', '2', '4') /* non-subsampled Cb (1) and Cr (2) planes */
1013 +#define DRM_FORMAT_YVU444      fourcc_code('Y', 'V', '2', '4') /* non-subsampled Cr (1) and Cb (2) planes */
1014 +
1015 +#endif /* DRM_FOURCC_H */
1016 diff --git a/libc/kernel/common/drm/drm_mode.h b/libc/kernel/common/drm/drm_mode.h
1017 new file mode 100644
1018 index 0000000..3d6301b
1019 --- /dev/null
1020 +++ b/libc/kernel/common/drm/drm_mode.h
1021 @@ -0,0 +1,463 @@
1022 +/*
1023 + * Copyright (c) 2007 Dave Airlie <airlied@linux.ie>
1024 + * Copyright (c) 2007 Jakob Bornecrantz <wallbraker@gmail.com>
1025 + * Copyright (c) 2008 Red Hat Inc.
1026 + * Copyright (c) 2007-2008 Tungsten Graphics, Inc., Cedar Park, TX., USA
1027 + * Copyright (c) 2007-2008 Intel Corporation
1028 + *
1029 + * Permission is hereby granted, free of charge, to any person obtaining a
1030 + * copy of this software and associated documentation files (the "Software"),
1031 + * to deal in the Software without restriction, including without limitation
1032 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
1033 + * and/or sell copies of the Software, and to permit persons to whom the
1034 + * Software is furnished to do so, subject to the following conditions:
1035 + *
1036 + * The above copyright notice and this permission notice shall be included in
1037 + * all copies or substantial portions of the Software.
1038 + *
1039 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1040 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1041 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
1042 + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
1043 + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
1044 + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
1045 + * IN THE SOFTWARE.
1046 + */
1047 +
1048 +#ifndef _DRM_MODE_H
1049 +#define _DRM_MODE_H
1050 +
1051 +#include <linux/types.h>
1052 +
1053 +#define DRM_DISPLAY_INFO_LEN   32
1054 +#define DRM_CONNECTOR_NAME_LEN 32
1055 +#define DRM_DISPLAY_MODE_LEN   32
1056 +#define DRM_PROP_NAME_LEN      32
1057 +
1058 +#define DRM_MODE_TYPE_BUILTIN  (1<<0)
1059 +#define DRM_MODE_TYPE_CLOCK_C  ((1<<1) | DRM_MODE_TYPE_BUILTIN)
1060 +#define DRM_MODE_TYPE_CRTC_C   ((1<<2) | DRM_MODE_TYPE_BUILTIN)
1061 +#define DRM_MODE_TYPE_PREFERRED        (1<<3)
1062 +#define DRM_MODE_TYPE_DEFAULT  (1<<4)
1063 +#define DRM_MODE_TYPE_USERDEF  (1<<5)
1064 +#define DRM_MODE_TYPE_DRIVER   (1<<6)
1065 +
1066 +/* Video mode flags */
1067 +/* bit compatible with the xorg definitions. */
1068 +#define DRM_MODE_FLAG_PHSYNC   (1<<0)
1069 +#define DRM_MODE_FLAG_NHSYNC   (1<<1)
1070 +#define DRM_MODE_FLAG_PVSYNC   (1<<2)
1071 +#define DRM_MODE_FLAG_NVSYNC   (1<<3)
1072 +#define DRM_MODE_FLAG_INTERLACE        (1<<4)
1073 +#define DRM_MODE_FLAG_DBLSCAN  (1<<5)
1074 +#define DRM_MODE_FLAG_CSYNC    (1<<6)
1075 +#define DRM_MODE_FLAG_PCSYNC   (1<<7)
1076 +#define DRM_MODE_FLAG_NCSYNC   (1<<8)
1077 +#define DRM_MODE_FLAG_HSKEW    (1<<9) /* hskew provided */
1078 +#define DRM_MODE_FLAG_BCAST    (1<<10)
1079 +#define DRM_MODE_FLAG_PIXMUX   (1<<11)
1080 +#define DRM_MODE_FLAG_DBLCLK   (1<<12)
1081 +#define DRM_MODE_FLAG_CLKDIV2  (1<<13)
1082 +
1083 +/* DPMS flags */
1084 +/* bit compatible with the xorg definitions. */
1085 +#define DRM_MODE_DPMS_ON       0
1086 +#define DRM_MODE_DPMS_STANDBY  1
1087 +#define DRM_MODE_DPMS_SUSPEND  2
1088 +#define DRM_MODE_DPMS_OFF      3
1089 +
1090 +/* Scaling mode options */
1091 +#define DRM_MODE_SCALE_NONE            0 /* Unmodified timing (display or
1092 +                                            software can still scale) */
1093 +#define DRM_MODE_SCALE_FULLSCREEN      1 /* Full screen, ignore aspect */
1094 +#define DRM_MODE_SCALE_CENTER          2 /* Centered, no scaling */
1095 +#define DRM_MODE_SCALE_ASPECT          3 /* Full screen, preserve aspect */
1096 +
1097 +/* Dithering mode options */
1098 +#define DRM_MODE_DITHERING_OFF 0
1099 +#define DRM_MODE_DITHERING_ON  1
1100 +#define DRM_MODE_DITHERING_AUTO 2
1101 +
1102 +/* Dirty info options */
1103 +#define DRM_MODE_DIRTY_OFF      0
1104 +#define DRM_MODE_DIRTY_ON       1
1105 +#define DRM_MODE_DIRTY_ANNOTATE 2
1106 +
1107 +struct drm_mode_modeinfo {
1108 +       __u32 clock;
1109 +       __u16 hdisplay, hsync_start, hsync_end, htotal, hskew;
1110 +       __u16 vdisplay, vsync_start, vsync_end, vtotal, vscan;
1111 +
1112 +       __u32 vrefresh;
1113 +
1114 +       __u32 flags;
1115 +       __u32 type;
1116 +       char name[DRM_DISPLAY_MODE_LEN];
1117 +};
1118 +
1119 +struct drm_mode_card_res {
1120 +       __u64 fb_id_ptr;
1121 +       __u64 crtc_id_ptr;
1122 +       __u64 connector_id_ptr;
1123 +       __u64 encoder_id_ptr;
1124 +       __u32 count_fbs;
1125 +       __u32 count_crtcs;
1126 +       __u32 count_connectors;
1127 +       __u32 count_encoders;
1128 +       __u32 min_width, max_width;
1129 +       __u32 min_height, max_height;
1130 +};
1131 +
1132 +struct drm_mode_crtc {
1133 +       __u64 set_connectors_ptr;
1134 +       __u32 count_connectors;
1135 +
1136 +       __u32 crtc_id; /**< Id */
1137 +       __u32 fb_id; /**< Id of framebuffer */
1138 +
1139 +       __u32 x, y; /**< Position on the frameuffer */
1140 +
1141 +       __u32 gamma_size;
1142 +       __u32 mode_valid;
1143 +       struct drm_mode_modeinfo mode;
1144 +};
1145 +
1146 +#define DRM_MODE_PRESENT_TOP_FIELD     (1<<0)
1147 +#define DRM_MODE_PRESENT_BOTTOM_FIELD  (1<<1)
1148 +
1149 +/* Planes blend with or override other bits on the CRTC */
1150 +struct drm_mode_set_plane {
1151 +       __u32 plane_id;
1152 +       __u32 crtc_id;
1153 +       __u32 fb_id; /* fb object contains surface format type */
1154 +       __u32 flags; /* see above flags */
1155 +
1156 +       /* Signed dest location allows it to be partially off screen */
1157 +       __s32 crtc_x, crtc_y;
1158 +       __u32 crtc_w, crtc_h;
1159 +
1160 +       /* Source values are 16.16 fixed point */
1161 +       __u32 src_x, src_y;
1162 +       __u32 src_h, src_w;
1163 +};
1164 +
1165 +struct drm_mode_get_plane {
1166 +       __u32 plane_id;
1167 +
1168 +       __u32 crtc_id;
1169 +       __u32 fb_id;
1170 +
1171 +       __u32 possible_crtcs;
1172 +       __u32 gamma_size;
1173 +
1174 +       __u32 count_format_types;
1175 +       __u64 format_type_ptr;
1176 +};
1177 +
1178 +struct drm_mode_get_plane_res {
1179 +       __u64 plane_id_ptr;
1180 +       __u32 count_planes;
1181 +};
1182 +
1183 +#define DRM_MODE_ENCODER_NONE  0
1184 +#define DRM_MODE_ENCODER_DAC   1
1185 +#define DRM_MODE_ENCODER_TMDS  2
1186 +#define DRM_MODE_ENCODER_LVDS  3
1187 +#define DRM_MODE_ENCODER_TVDAC 4
1188 +#define DRM_MODE_ENCODER_VIRTUAL 5
1189 +
1190 +struct drm_mode_get_encoder {
1191 +       __u32 encoder_id;
1192 +       __u32 encoder_type;
1193 +
1194 +       __u32 crtc_id; /**< Id of crtc */
1195 +
1196 +       __u32 possible_crtcs;
1197 +       __u32 possible_clones;
1198 +};
1199 +
1200 +/* This is for connectors with multiple signal types. */
1201 +/* Try to match DRM_MODE_CONNECTOR_X as closely as possible. */
1202 +#define DRM_MODE_SUBCONNECTOR_Automatic        0
1203 +#define DRM_MODE_SUBCONNECTOR_Unknown  0
1204 +#define DRM_MODE_SUBCONNECTOR_DVID     3
1205 +#define DRM_MODE_SUBCONNECTOR_DVIA     4
1206 +#define DRM_MODE_SUBCONNECTOR_Composite        5
1207 +#define DRM_MODE_SUBCONNECTOR_SVIDEO   6
1208 +#define DRM_MODE_SUBCONNECTOR_Component        8
1209 +#define DRM_MODE_SUBCONNECTOR_SCART    9
1210 +
1211 +#define DRM_MODE_CONNECTOR_Unknown     0
1212 +#define DRM_MODE_CONNECTOR_VGA         1
1213 +#define DRM_MODE_CONNECTOR_DVII                2
1214 +#define DRM_MODE_CONNECTOR_DVID                3
1215 +#define DRM_MODE_CONNECTOR_DVIA                4
1216 +#define DRM_MODE_CONNECTOR_Composite   5
1217 +#define DRM_MODE_CONNECTOR_SVIDEO      6
1218 +#define DRM_MODE_CONNECTOR_LVDS                7
1219 +#define DRM_MODE_CONNECTOR_Component   8
1220 +#define DRM_MODE_CONNECTOR_9PinDIN     9
1221 +#define DRM_MODE_CONNECTOR_DisplayPort 10
1222 +#define DRM_MODE_CONNECTOR_HDMIA       11
1223 +#define DRM_MODE_CONNECTOR_HDMIB       12
1224 +#define DRM_MODE_CONNECTOR_TV          13
1225 +#define DRM_MODE_CONNECTOR_eDP         14
1226 +#define DRM_MODE_CONNECTOR_VIRTUAL      15
1227 +
1228 +struct drm_mode_get_connector {
1229 +
1230 +       __u64 encoders_ptr;
1231 +       __u64 modes_ptr;
1232 +       __u64 props_ptr;
1233 +       __u64 prop_values_ptr;
1234 +
1235 +       __u32 count_modes;
1236 +       __u32 count_props;
1237 +       __u32 count_encoders;
1238 +
1239 +       __u32 encoder_id; /**< Current Encoder */
1240 +       __u32 connector_id; /**< Id */
1241 +       __u32 connector_type;
1242 +       __u32 connector_type_id;
1243 +
1244 +       __u32 connection;
1245 +       __u32 mm_width, mm_height; /**< HxW in millimeters */
1246 +       __u32 subpixel;
1247 +};
1248 +
1249 +#define DRM_MODE_PROP_PENDING  (1<<0)
1250 +#define DRM_MODE_PROP_RANGE    (1<<1)
1251 +#define DRM_MODE_PROP_IMMUTABLE        (1<<2)
1252 +#define DRM_MODE_PROP_ENUM     (1<<3) /* enumerated type with text strings */
1253 +#define DRM_MODE_PROP_BLOB     (1<<4)
1254 +#define DRM_MODE_PROP_BITMASK  (1<<5) /* bitmask of enumerated types */
1255 +
1256 +struct drm_mode_property_enum {
1257 +       __u64 value;
1258 +       char name[DRM_PROP_NAME_LEN];
1259 +};
1260 +
1261 +struct drm_mode_get_property {
1262 +       __u64 values_ptr; /* values and blob lengths */
1263 +       __u64 enum_blob_ptr; /* enum and blob id ptrs */
1264 +
1265 +       __u32 prop_id;
1266 +       __u32 flags;
1267 +       char name[DRM_PROP_NAME_LEN];
1268 +
1269 +       __u32 count_values;
1270 +       __u32 count_enum_blobs;
1271 +};
1272 +
1273 +struct drm_mode_connector_set_property {
1274 +       __u64 value;
1275 +       __u32 prop_id;
1276 +       __u32 connector_id;
1277 +};
1278 +
1279 +struct drm_mode_obj_get_properties {
1280 +       __u64 props_ptr;
1281 +       __u64 prop_values_ptr;
1282 +       __u32 count_props;
1283 +       __u32 obj_id;
1284 +       __u32 obj_type;
1285 +};
1286 +
1287 +struct drm_mode_obj_set_property {
1288 +       __u64 value;
1289 +       __u32 prop_id;
1290 +       __u32 obj_id;
1291 +       __u32 obj_type;
1292 +};
1293 +
1294 +struct drm_mode_get_blob {
1295 +       __u32 blob_id;
1296 +       __u32 length;
1297 +       __u64 data;
1298 +};
1299 +
1300 +struct drm_mode_fb_cmd {
1301 +       __u32 fb_id;
1302 +       __u32 width, height;
1303 +       __u32 pitch;
1304 +       __u32 bpp;
1305 +       __u32 depth;
1306 +       /* driver specific handle */
1307 +       __u32 handle;
1308 +};
1309 +
1310 +#define DRM_MODE_FB_INTERLACED (1<<0) /* for interlaced framebuffers */
1311 +
1312 +struct drm_mode_fb_cmd2 {
1313 +       __u32 fb_id;
1314 +       __u32 width, height;
1315 +       __u32 pixel_format; /* fourcc code from drm_fourcc.h */
1316 +       __u32 flags; /* see above flags */
1317 +
1318 +       /*
1319 +        * In case of planar formats, this ioctl allows up to 4
1320 +        * buffer objects with offets and pitches per plane.
1321 +        * The pitch and offset order is dictated by the fourcc,
1322 +        * e.g. NV12 (http://fourcc.org/yuv.php#NV12) is described as:
1323 +        *
1324 +        *   YUV 4:2:0 image with a plane of 8 bit Y samples
1325 +        *   followed by an interleaved U/V plane containing
1326 +        *   8 bit 2x2 subsampled colour difference samples.
1327 +        *
1328 +        * So it would consist of Y as offset[0] and UV as
1329 +        * offeset[1].  Note that offset[0] will generally
1330 +        * be 0.
1331 +        */
1332 +       __u32 handles[4];
1333 +       __u32 pitches[4]; /* pitch for each plane */
1334 +       __u32 offsets[4]; /* offset of each plane */
1335 +};
1336 +
1337 +#define DRM_MODE_FB_DIRTY_ANNOTATE_COPY 0x01
1338 +#define DRM_MODE_FB_DIRTY_ANNOTATE_FILL 0x02
1339 +#define DRM_MODE_FB_DIRTY_FLAGS         0x03
1340 +
1341 +#define DRM_MODE_FB_DIRTY_MAX_CLIPS     256
1342 +
1343 +/*
1344 + * Mark a region of a framebuffer as dirty.
1345 + *
1346 + * Some hardware does not automatically update display contents
1347 + * as a hardware or software draw to a framebuffer. This ioctl
1348 + * allows userspace to tell the kernel and the hardware what
1349 + * regions of the framebuffer have changed.
1350 + *
1351 + * The kernel or hardware is free to update more then just the
1352 + * region specified by the clip rects. The kernel or hardware
1353 + * may also delay and/or coalesce several calls to dirty into a
1354 + * single update.
1355 + *
1356 + * Userspace may annotate the updates, the annotates are a
1357 + * promise made by the caller that the change is either a copy
1358 + * of pixels or a fill of a single color in the region specified.
1359 + *
1360 + * If the DRM_MODE_FB_DIRTY_ANNOTATE_COPY flag is given then
1361 + * the number of updated regions are half of num_clips given,
1362 + * where the clip rects are paired in src and dst. The width and
1363 + * height of each one of the pairs must match.
1364 + *
1365 + * If the DRM_MODE_FB_DIRTY_ANNOTATE_FILL flag is given the caller
1366 + * promises that the region specified of the clip rects is filled
1367 + * completely with a single color as given in the color argument.
1368 + */
1369 +
1370 +struct drm_mode_fb_dirty_cmd {
1371 +       __u32 fb_id;
1372 +       __u32 flags;
1373 +       __u32 color;
1374 +       __u32 num_clips;
1375 +       __u64 clips_ptr;
1376 +};
1377 +
1378 +struct drm_mode_mode_cmd {
1379 +       __u32 connector_id;
1380 +       struct drm_mode_modeinfo mode;
1381 +};
1382 +
1383 +#define DRM_MODE_CURSOR_BO     0x01
1384 +#define DRM_MODE_CURSOR_MOVE   0x02
1385 +#define DRM_MODE_CURSOR_FLAGS  0x03
1386 +
1387 +/*
1388 + * depending on the value in flags different members are used.
1389 + *
1390 + * CURSOR_BO uses
1391 + *    crtc
1392 + *    width
1393 + *    height
1394 + *    handle - if 0 turns the cursor of
1395 + *
1396 + * CURSOR_MOVE uses
1397 + *    crtc
1398 + *    x
1399 + *    y
1400 + */
1401 +struct drm_mode_cursor {
1402 +       __u32 flags;
1403 +       __u32 crtc_id;
1404 +       __s32 x;
1405 +       __s32 y;
1406 +       __u32 width;
1407 +       __u32 height;
1408 +       /* driver specific handle */
1409 +       __u32 handle;
1410 +};
1411 +
1412 +struct drm_mode_crtc_lut {
1413 +       __u32 crtc_id;
1414 +       __u32 gamma_size;
1415 +
1416 +       /* pointers to arrays */
1417 +       __u64 red;
1418 +       __u64 green;
1419 +       __u64 blue;
1420 +};
1421 +
1422 +#define DRM_MODE_PAGE_FLIP_EVENT 0x01
1423 +#define DRM_MODE_PAGE_FLIP_FLAGS DRM_MODE_PAGE_FLIP_EVENT
1424 +
1425 +/*
1426 + * Request a page flip on the specified crtc.
1427 + *
1428 + * This ioctl will ask KMS to schedule a page flip for the specified
1429 + * crtc.  Once any pending rendering targeting the specified fb (as of
1430 + * ioctl time) has completed, the crtc will be reprogrammed to display
1431 + * that fb after the next vertical refresh.  The ioctl returns
1432 + * immediately, but subsequent rendering to the current fb will block
1433 + * in the execbuffer ioctl until the page flip happens.  If a page
1434 + * flip is already pending as the ioctl is called, EBUSY will be
1435 + * returned.
1436 + *
1437 + * The ioctl supports one flag, DRM_MODE_PAGE_FLIP_EVENT, which will
1438 + * request that drm sends back a vblank event (see drm.h: struct
1439 + * drm_event_vblank) when the page flip is done.  The user_data field
1440 + * passed in with this ioctl will be returned as the user_data field
1441 + * in the vblank event struct.
1442 + *
1443 + * The reserved field must be zero until we figure out something
1444 + * clever to use it for.
1445 + */
1446 +
1447 +struct drm_mode_crtc_page_flip {
1448 +       __u32 crtc_id;
1449 +       __u32 fb_id;
1450 +       __u32 flags;
1451 +       __u32 reserved;
1452 +       __u64 user_data;
1453 +};
1454 +
1455 +/* create a dumb scanout buffer */
1456 +struct drm_mode_create_dumb {
1457 +       uint32_t height;
1458 +       uint32_t width;
1459 +       uint32_t bpp;
1460 +       uint32_t flags;
1461 +       /* handle, pitch, size will be returned */
1462 +       uint32_t handle;
1463 +       uint32_t pitch;
1464 +       uint64_t size;
1465 +};
1466 +
1467 +/* set up for mmap of a dumb scanout buffer */
1468 +struct drm_mode_map_dumb {
1469 +       /** Handle for the object being mapped. */
1470 +       __u32 handle;
1471 +       __u32 pad;
1472 +       /**
1473 +        * Fake offset to use for subsequent mmap call
1474 +        *
1475 +        * This is a fixed-size type for 32/64 compatibility.
1476 +        */
1477 +       __u64 offset;
1478 +};
1479 +
1480 +struct drm_mode_destroy_dumb {
1481 +       uint32_t handle;
1482 +};
1483 +
1484 +#endif
1485 diff --git a/libc/kernel/common/drm/drm_sarea.h b/libc/kernel/common/drm/drm_sarea.h
1486 new file mode 100644
1487 index 0000000..7325558
1488 --- /dev/null
1489 +++ b/libc/kernel/common/drm/drm_sarea.h
1490 @@ -0,0 +1,82 @@
1491 +/**
1492 + * \file drm_sarea.h
1493 + * \brief SAREA definitions
1494 + *
1495 + * \author Michel Dänzer <michel@daenzer.net>
1496 + */
1497 +
1498 +/*
1499 + * Copyright 2002 Tungsten Graphics, Inc., Cedar Park, Texas.
1500 + * All Rights Reserved.
1501 + *
1502 + * Permission is hereby granted, free of charge, to any person obtaining a
1503 + * copy of this software and associated documentation files (the "Software"),
1504 + * to deal in the Software without restriction, including without limitation
1505 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
1506 + * and/or sell copies of the Software, and to permit persons to whom the
1507 + * Software is furnished to do so, subject to the following conditions:
1508 + *
1509 + * The above copyright notice and this permission notice (including the next
1510 + * paragraph) shall be included in all copies or substantial portions of the
1511 + * Software.
1512 + *
1513 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1514 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1515 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
1516 + * TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
1517 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
1518 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
1519 + * OTHER DEALINGS IN THE SOFTWARE.
1520 + */
1521 +
1522 +#ifndef _DRM_SAREA_H_
1523 +#define _DRM_SAREA_H_
1524 +
1525 +#include "drm.h"
1526 +
1527 +/* SAREA area needs to be at least a page */
1528 +#if defined(__alpha__)
1529 +#define SAREA_MAX                       0x2000U
1530 +#elif defined(__ia64__)
1531 +#define SAREA_MAX                       0x10000U       /* 64kB */
1532 +#else
1533 +/* Intel 830M driver needs at least 8k SAREA */
1534 +#define SAREA_MAX                       0x2000U
1535 +#endif
1536 +
1537 +/** Maximum number of drawables in the SAREA */
1538 +#define SAREA_MAX_DRAWABLES            256
1539 +
1540 +#define SAREA_DRAWABLE_CLAIMED_ENTRY    0x80000000
1541 +
1542 +/** SAREA drawable */
1543 +struct drm_sarea_drawable {
1544 +       unsigned int stamp;
1545 +       unsigned int flags;
1546 +};
1547 +
1548 +/** SAREA frame */
1549 +struct drm_sarea_frame {
1550 +       unsigned int x;
1551 +       unsigned int y;
1552 +       unsigned int width;
1553 +       unsigned int height;
1554 +       unsigned int fullscreen;
1555 +};
1556 +
1557 +/** SAREA */
1558 +struct drm_sarea {
1559 +    /** first thing is always the DRM locking structure */
1560 +       struct drm_hw_lock lock;
1561 +    /** \todo Use readers/writer lock for drm_sarea::drawable_lock */
1562 +       struct drm_hw_lock drawable_lock;
1563 +       struct drm_sarea_drawable drawableTable[SAREA_MAX_DRAWABLES];   /**< drawables */
1564 +       struct drm_sarea_frame frame;   /**< frame */
1565 +       drm_context_t dummy_context;
1566 +};
1567 +
1568 +typedef struct drm_sarea_drawable drm_sarea_drawable_t;
1569 +typedef struct drm_sarea_frame drm_sarea_frame_t;
1570 +typedef struct drm_sarea drm_sarea_t;
1571 +
1572 +#endif                         /* _DRM_SAREA_H_ */
1573 diff --git a/libc/kernel/common/drm/exynos_drm.h b/libc/kernel/common/drm/exynos_drm.h
1574 new file mode 100644
1575 index 0000000..a2aa0c1
1576 --- /dev/null
1577 +++ b/libc/kernel/common/drm/exynos_drm.h
1578 @@ -0,0 +1,203 @@
1579 +/* exynos_drm.h
1580 + *
1581 + * Copyright (c) 2011 Samsung Electronics Co., Ltd.
1582 + * Authors:
1583 + *     Inki Dae <inki.dae@samsung.com>
1584 + *     Joonyoung Shim <jy0922.shim@samsung.com>
1585 + *     Seung-Woo Kim <sw0312.kim@samsung.com>
1586 + *
1587 + * Permission is hereby granted, free of charge, to any person obtaining a
1588 + * copy of this software and associated documentation files (the "Software"),
1589 + * to deal in the Software without restriction, including without limitation
1590 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
1591 + * and/or sell copies of the Software, and to permit persons to whom the
1592 + * Software is furnished to do so, subject to the following conditions:
1593 + *
1594 + * The above copyright notice and this permission notice (including the next
1595 + * paragraph) shall be included in all copies or substantial portions of the
1596 + * Software.
1597 + *
1598 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
1599 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
1600 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
1601 + * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
1602 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
1603 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
1604 + * OTHER DEALINGS IN THE SOFTWARE.
1605 + */
1606 +
1607 +#ifndef _EXYNOS_DRM_H_
1608 +#define _EXYNOS_DRM_H_
1609 +
1610 +#include "drm.h"
1611 +
1612 +/**
1613 + * User-desired buffer creation information structure.
1614 + *
1615 + * @size: user-desired memory allocation size.
1616 + *     - this size value would be page-aligned internally.
1617 + * @flags: user request for setting memory type or cache attributes.
1618 + * @handle: returned a handle to created gem object.
1619 + *     - this handle will be set by gem module of kernel side.
1620 + */
1621 +struct drm_exynos_gem_create {
1622 +       uint64_t size;
1623 +       unsigned int flags;
1624 +       unsigned int handle;
1625 +};
1626 +
1627 +/**
1628 + * A structure for getting buffer offset.
1629 + *
1630 + * @handle: a pointer to gem object created.
1631 + * @pad: just padding to be 64-bit aligned.
1632 + * @offset: relatived offset value of the memory region allocated.
1633 + *     - this value should be set by user.
1634 + */
1635 +struct drm_exynos_gem_map_off {
1636 +       unsigned int handle;
1637 +       unsigned int pad;
1638 +       uint64_t offset;
1639 +};
1640 +
1641 +/**
1642 + * A structure for mapping buffer.
1643 + *
1644 + * @handle: a handle to gem object created.
1645 + * @pad: just padding to be 64-bit aligned.
1646 + * @size: memory size to be mapped.
1647 + * @mapped: having user virtual address mmaped.
1648 + *     - this variable would be filled by exynos gem module
1649 + *     of kernel side with user virtual address which is allocated
1650 + *     by do_mmap().
1651 + */
1652 +struct drm_exynos_gem_mmap {
1653 +       unsigned int handle;
1654 +       unsigned int pad;
1655 +       uint64_t size;
1656 +       uint64_t mapped;
1657 +};
1658 +
1659 +/**
1660 + * A structure to gem information.
1661 + *
1662 + * @handle: a handle to gem object created.
1663 + * @flags: flag value including memory type and cache attribute and
1664 + *     this value would be set by driver.
1665 + * @size: size to memory region allocated by gem and this size would
1666 + *     be set by driver.
1667 + */
1668 +struct drm_exynos_gem_info {
1669 +       unsigned int handle;
1670 +       unsigned int flags;
1671 +       uint64_t size;
1672 +};
1673 +
1674 +/**
1675 + * A structure for user connection request of virtual display.
1676 + *
1677 + * @connection: indicate whether doing connetion or not by user.
1678 + * @extensions: if this value is 1 then the vidi driver would need additional
1679 + *     128bytes edid data.
1680 + * @edid: the edid data pointer from user side.
1681 + */
1682 +struct drm_exynos_vidi_connection {
1683 +       unsigned int connection;
1684 +       unsigned int extensions;
1685 +       uint64_t edid;
1686 +};
1687 +
1688 +/* memory type definitions. */
1689 +enum e_drm_exynos_gem_mem_type {
1690 +       /* Physically Continuous memory and used as default. */
1691 +       EXYNOS_BO_CONTIG        = 0 << 0,
1692 +       /* Physically Non-Continuous memory. */
1693 +       EXYNOS_BO_NONCONTIG     = 1 << 0,
1694 +       /* non-cachable mapping and used as default. */
1695 +       EXYNOS_BO_NONCACHABLE   = 0 << 1,
1696 +       /* cachable mapping. */
1697 +       EXYNOS_BO_CACHABLE      = 1 << 1,
1698 +       /* write-combine mapping. */
1699 +       EXYNOS_BO_WC            = 1 << 2,
1700 +       EXYNOS_BO_MASK          = EXYNOS_BO_NONCONTIG | EXYNOS_BO_CACHABLE |
1701 +                                       EXYNOS_BO_WC
1702 +};
1703 +
1704 +struct drm_exynos_g2d_get_ver {
1705 +       __u32   major;
1706 +       __u32   minor;
1707 +};
1708 +
1709 +struct drm_exynos_g2d_cmd {
1710 +       __u32   offset;
1711 +       __u32   data;
1712 +};
1713 +
1714 +enum drm_exynos_g2d_event_type {
1715 +       G2D_EVENT_NOT,
1716 +       G2D_EVENT_NONSTOP,
1717 +       G2D_EVENT_STOP,         /* not yet */
1718 +};
1719 +
1720 +struct drm_exynos_g2d_set_cmdlist {
1721 +       __u64                                   cmd;
1722 +       __u64                                   cmd_gem;
1723 +       __u32                                   cmd_nr;
1724 +       __u32                                   cmd_gem_nr;
1725 +
1726 +       /* for g2d event */
1727 +       __u64                                   event_type;
1728 +       __u64                                   user_data;
1729 +};
1730 +
1731 +struct drm_exynos_g2d_exec {
1732 +       __u64                                   async;
1733 +};
1734 +
1735 +#define DRM_EXYNOS_GEM_CREATE          0x00
1736 +#define DRM_EXYNOS_GEM_MAP_OFFSET      0x01
1737 +#define DRM_EXYNOS_GEM_MMAP            0x02
1738 +/* Reserved 0x03 ~ 0x05 for exynos specific gem ioctl */
1739 +#define DRM_EXYNOS_GEM_GET             0x04
1740 +#define DRM_EXYNOS_VIDI_CONNECTION     0x07
1741 +
1742 +/* G2D */
1743 +#define DRM_EXYNOS_G2D_GET_VER         0x20
1744 +#define DRM_EXYNOS_G2D_SET_CMDLIST     0x21
1745 +#define DRM_EXYNOS_G2D_EXEC            0x22
1746 +
1747 +#define DRM_IOCTL_EXYNOS_GEM_CREATE            DRM_IOWR(DRM_COMMAND_BASE + \
1748 +               DRM_EXYNOS_GEM_CREATE, struct drm_exynos_gem_create)
1749 +
1750 +#define DRM_IOCTL_EXYNOS_GEM_MAP_OFFSET        DRM_IOWR(DRM_COMMAND_BASE + \
1751 +               DRM_EXYNOS_GEM_MAP_OFFSET, struct drm_exynos_gem_map_off)
1752 +
1753 +#define DRM_IOCTL_EXYNOS_GEM_MMAP      DRM_IOWR(DRM_COMMAND_BASE + \
1754 +               DRM_EXYNOS_GEM_MMAP, struct drm_exynos_gem_mmap)
1755 +
1756 +#define DRM_IOCTL_EXYNOS_GEM_GET       DRM_IOWR(DRM_COMMAND_BASE + \
1757 +               DRM_EXYNOS_GEM_GET,     struct drm_exynos_gem_info)
1758 +
1759 +#define DRM_IOCTL_EXYNOS_VIDI_CONNECTION       DRM_IOWR(DRM_COMMAND_BASE + \
1760 +               DRM_EXYNOS_VIDI_CONNECTION, struct drm_exynos_vidi_connection)
1761 +
1762 +#define DRM_IOCTL_EXYNOS_G2D_GET_VER           DRM_IOWR(DRM_COMMAND_BASE + \
1763 +               DRM_EXYNOS_G2D_GET_VER, struct drm_exynos_g2d_get_ver)
1764 +#define DRM_IOCTL_EXYNOS_G2D_SET_CMDLIST       DRM_IOWR(DRM_COMMAND_BASE + \
1765 +               DRM_EXYNOS_G2D_SET_CMDLIST, struct drm_exynos_g2d_set_cmdlist)
1766 +#define DRM_IOCTL_EXYNOS_G2D_EXEC              DRM_IOWR(DRM_COMMAND_BASE + \
1767 +               DRM_EXYNOS_G2D_EXEC, struct drm_exynos_g2d_exec)
1768 +
1769 +/* EXYNOS specific events */
1770 +#define DRM_EXYNOS_G2D_EVENT           0x80000000
1771 +
1772 +struct drm_exynos_g2d_event {
1773 +       struct drm_event        base;
1774 +       __u64                   user_data;
1775 +       __u32                   tv_sec;
1776 +       __u32                   tv_usec;
1777 +       __u32                   cmdlist_no;
1778 +       __u32                   reserved;
1779 +};
1780 +
1781 +#endif /* _EXYNOS_DRM_H_ */
1782 diff --git a/libc/kernel/common/drm/i810_drm.h b/libc/kernel/common/drm/i810_drm.h
1783 new file mode 100644
1784 index 0000000..7a10bb6
1785 --- /dev/null
1786 +++ b/libc/kernel/common/drm/i810_drm.h
1787 @@ -0,0 +1,281 @@
1788 +#ifndef _I810_DRM_H_
1789 +#define _I810_DRM_H_
1790 +
1791 +/* WARNING: These defines must be the same as what the Xserver uses.
1792 + * if you change them, you must change the defines in the Xserver.
1793 + */
1794 +
1795 +#ifndef _I810_DEFINES_
1796 +#define _I810_DEFINES_
1797 +
1798 +#define I810_DMA_BUF_ORDER             12
1799 +#define I810_DMA_BUF_SZ                (1<<I810_DMA_BUF_ORDER)
1800 +#define I810_DMA_BUF_NR                256
1801 +#define I810_NR_SAREA_CLIPRECTS        8
1802 +
1803 +/* Each region is a minimum of 64k, and there are at most 64 of them.
1804 + */
1805 +#define I810_NR_TEX_REGIONS 64
1806 +#define I810_LOG_MIN_TEX_REGION_SIZE 16
1807 +#endif
1808 +
1809 +#define I810_UPLOAD_TEX0IMAGE  0x1     /* handled clientside */
1810 +#define I810_UPLOAD_TEX1IMAGE  0x2     /* handled clientside */
1811 +#define I810_UPLOAD_CTX        0x4
1812 +#define I810_UPLOAD_BUFFERS    0x8
1813 +#define I810_UPLOAD_TEX0       0x10
1814 +#define I810_UPLOAD_TEX1       0x20
1815 +#define I810_UPLOAD_CLIPRECTS  0x40
1816 +
1817 +/* Indices into buf.Setup where various bits of state are mirrored per
1818 + * context and per buffer.  These can be fired at the card as a unit,
1819 + * or in a piecewise fashion as required.
1820 + */
1821 +
1822 +/* Destbuffer state
1823 + *    - backbuffer linear offset and pitch -- invarient in the current dri
1824 + *    - zbuffer linear offset and pitch -- also invarient
1825 + *    - drawing origin in back and depth buffers.
1826 + *
1827 + * Keep the depth/back buffer state here to accommodate private buffers
1828 + * in the future.
1829 + */
1830 +#define I810_DESTREG_DI0  0    /* CMD_OP_DESTBUFFER_INFO (2 dwords) */
1831 +#define I810_DESTREG_DI1  1
1832 +#define I810_DESTREG_DV0  2    /* GFX_OP_DESTBUFFER_VARS (2 dwords) */
1833 +#define I810_DESTREG_DV1  3
1834 +#define I810_DESTREG_DR0  4    /* GFX_OP_DRAWRECT_INFO (4 dwords) */
1835 +#define I810_DESTREG_DR1  5
1836 +#define I810_DESTREG_DR2  6
1837 +#define I810_DESTREG_DR3  7
1838 +#define I810_DESTREG_DR4  8
1839 +#define I810_DEST_SETUP_SIZE 10
1840 +
1841 +/* Context state
1842 + */
1843 +#define I810_CTXREG_CF0   0    /* GFX_OP_COLOR_FACTOR */
1844 +#define I810_CTXREG_CF1   1
1845 +#define I810_CTXREG_ST0   2    /* GFX_OP_STIPPLE */
1846 +#define I810_CTXREG_ST1   3
1847 +#define I810_CTXREG_VF    4    /* GFX_OP_VERTEX_FMT */
1848 +#define I810_CTXREG_MT    5    /* GFX_OP_MAP_TEXELS */
1849 +#define I810_CTXREG_MC0   6    /* GFX_OP_MAP_COLOR_STAGES - stage 0 */
1850 +#define I810_CTXREG_MC1   7    /* GFX_OP_MAP_COLOR_STAGES - stage 1 */
1851 +#define I810_CTXREG_MC2   8    /* GFX_OP_MAP_COLOR_STAGES - stage 2 */
1852 +#define I810_CTXREG_MA0   9    /* GFX_OP_MAP_ALPHA_STAGES - stage 0 */
1853 +#define I810_CTXREG_MA1   10   /* GFX_OP_MAP_ALPHA_STAGES - stage 1 */
1854 +#define I810_CTXREG_MA2   11   /* GFX_OP_MAP_ALPHA_STAGES - stage 2 */
1855 +#define I810_CTXREG_SDM   12   /* GFX_OP_SRC_DEST_MONO */
1856 +#define I810_CTXREG_FOG   13   /* GFX_OP_FOG_COLOR */
1857 +#define I810_CTXREG_B1    14   /* GFX_OP_BOOL_1 */
1858 +#define I810_CTXREG_B2    15   /* GFX_OP_BOOL_2 */
1859 +#define I810_CTXREG_LCS   16   /* GFX_OP_LINEWIDTH_CULL_SHADE_MODE */
1860 +#define I810_CTXREG_PV    17   /* GFX_OP_PV_RULE -- Invarient! */
1861 +#define I810_CTXREG_ZA    18   /* GFX_OP_ZBIAS_ALPHAFUNC */
1862 +#define I810_CTXREG_AA    19   /* GFX_OP_ANTIALIAS */
1863 +#define I810_CTX_SETUP_SIZE 20
1864 +
1865 +/* Texture state (per tex unit)
1866 + */
1867 +#define I810_TEXREG_MI0  0     /* GFX_OP_MAP_INFO (4 dwords) */
1868 +#define I810_TEXREG_MI1  1
1869 +#define I810_TEXREG_MI2  2
1870 +#define I810_TEXREG_MI3  3
1871 +#define I810_TEXREG_MF   4     /* GFX_OP_MAP_FILTER */
1872 +#define I810_TEXREG_MLC  5     /* GFX_OP_MAP_LOD_CTL */
1873 +#define I810_TEXREG_MLL  6     /* GFX_OP_MAP_LOD_LIMITS */
1874 +#define I810_TEXREG_MCS  7     /* GFX_OP_MAP_COORD_SETS ??? */
1875 +#define I810_TEX_SETUP_SIZE 8
1876 +
1877 +/* Flags for clear ioctl
1878 + */
1879 +#define I810_FRONT   0x1
1880 +#define I810_BACK    0x2
1881 +#define I810_DEPTH   0x4
1882 +
1883 +typedef enum _drm_i810_init_func {
1884 +       I810_INIT_DMA = 0x01,
1885 +       I810_CLEANUP_DMA = 0x02,
1886 +       I810_INIT_DMA_1_4 = 0x03
1887 +} drm_i810_init_func_t;
1888 +
1889 +/* This is the init structure after v1.2 */
1890 +typedef struct _drm_i810_init {
1891 +       drm_i810_init_func_t func;
1892 +       unsigned int mmio_offset;
1893 +       unsigned int buffers_offset;
1894 +       int sarea_priv_offset;
1895 +       unsigned int ring_start;
1896 +       unsigned int ring_end;
1897 +       unsigned int ring_size;
1898 +       unsigned int front_offset;
1899 +       unsigned int back_offset;
1900 +       unsigned int depth_offset;
1901 +       unsigned int overlay_offset;
1902 +       unsigned int overlay_physical;
1903 +       unsigned int w;
1904 +       unsigned int h;
1905 +       unsigned int pitch;
1906 +       unsigned int pitch_bits;
1907 +} drm_i810_init_t;
1908 +
1909 +/* This is the init structure prior to v1.2 */
1910 +typedef struct _drm_i810_pre12_init {
1911 +       drm_i810_init_func_t func;
1912 +       unsigned int mmio_offset;
1913 +       unsigned int buffers_offset;
1914 +       int sarea_priv_offset;
1915 +       unsigned int ring_start;
1916 +       unsigned int ring_end;
1917 +       unsigned int ring_size;
1918 +       unsigned int front_offset;
1919 +       unsigned int back_offset;
1920 +       unsigned int depth_offset;
1921 +       unsigned int w;
1922 +       unsigned int h;
1923 +       unsigned int pitch;
1924 +       unsigned int pitch_bits;
1925 +} drm_i810_pre12_init_t;
1926 +
1927 +/* Warning: If you change the SAREA structure you must change the Xserver
1928 + * structure as well */
1929 +
1930 +typedef struct _drm_i810_tex_region {
1931 +       unsigned char next, prev;       /* indices to form a circular LRU  */
1932 +       unsigned char in_use;   /* owned by a client, or free? */
1933 +       int age;                /* tracked by clients to update local LRU's */
1934 +} drm_i810_tex_region_t;
1935 +
1936 +typedef struct _drm_i810_sarea {
1937 +       unsigned int ContextState[I810_CTX_SETUP_SIZE];
1938 +       unsigned int BufferState[I810_DEST_SETUP_SIZE];
1939 +       unsigned int TexState[2][I810_TEX_SETUP_SIZE];
1940 +       unsigned int dirty;
1941 +
1942 +       unsigned int nbox;
1943 +       struct drm_clip_rect boxes[I810_NR_SAREA_CLIPRECTS];
1944 +
1945 +       /* Maintain an LRU of contiguous regions of texture space.  If
1946 +        * you think you own a region of texture memory, and it has an
1947 +        * age different to the one you set, then you are mistaken and
1948 +        * it has been stolen by another client.  If global texAge
1949 +        * hasn't changed, there is no need to walk the list.
1950 +        *
1951 +        * These regions can be used as a proxy for the fine-grained
1952 +        * texture information of other clients - by maintaining them
1953 +        * in the same lru which is used to age their own textures,
1954 +        * clients have an approximate lru for the whole of global
1955 +        * texture space, and can make informed decisions as to which
1956 +        * areas to kick out.  There is no need to choose whether to
1957 +        * kick out your own texture or someone else's - simply eject
1958 +        * them all in LRU order.
1959 +        */
1960 +
1961 +       drm_i810_tex_region_t texList[I810_NR_TEX_REGIONS + 1];
1962 +       /* Last elt is sentinal */
1963 +       int texAge;             /* last time texture was uploaded */
1964 +       int last_enqueue;       /* last time a buffer was enqueued */
1965 +       int last_dispatch;      /* age of the most recently dispatched buffer */
1966 +       int last_quiescent;     /*  */
1967 +       int ctxOwner;           /* last context to upload state */
1968 +
1969 +       int vertex_prim;
1970 +
1971 +       int pf_enabled;         /* is pageflipping allowed? */
1972 +       int pf_active;
1973 +       int pf_current_page;    /* which buffer is being displayed? */
1974 +} drm_i810_sarea_t;
1975 +
1976 +/* WARNING: If you change any of these defines, make sure to change the
1977 + * defines in the Xserver file (xf86drmMga.h)
1978 + */
1979 +
1980 +/* i810 specific ioctls
1981 + * The device specific ioctl range is 0x40 to 0x79.
1982 + */
1983 +#define DRM_I810_INIT          0x00
1984 +#define DRM_I810_VERTEX                0x01
1985 +#define DRM_I810_CLEAR         0x02
1986 +#define DRM_I810_FLUSH         0x03
1987 +#define DRM_I810_GETAGE                0x04
1988 +#define DRM_I810_GETBUF                0x05
1989 +#define DRM_I810_SWAP          0x06
1990 +#define DRM_I810_COPY          0x07
1991 +#define DRM_I810_DOCOPY                0x08
1992 +#define DRM_I810_OV0INFO       0x09
1993 +#define DRM_I810_FSTATUS       0x0a
1994 +#define DRM_I810_OV0FLIP       0x0b
1995 +#define DRM_I810_MC            0x0c
1996 +#define DRM_I810_RSTATUS       0x0d
1997 +#define DRM_I810_FLIP          0x0e
1998 +
1999 +#define DRM_IOCTL_I810_INIT            DRM_IOW( DRM_COMMAND_BASE + DRM_I810_INIT, drm_i810_init_t)
2000 +#define DRM_IOCTL_I810_VERTEX          DRM_IOW( DRM_COMMAND_BASE + DRM_I810_VERTEX, drm_i810_vertex_t)
2001 +#define DRM_IOCTL_I810_CLEAR           DRM_IOW( DRM_COMMAND_BASE + DRM_I810_CLEAR, drm_i810_clear_t)
2002 +#define DRM_IOCTL_I810_FLUSH           DRM_IO(  DRM_COMMAND_BASE + DRM_I810_FLUSH)
2003 +#define DRM_IOCTL_I810_GETAGE          DRM_IO(  DRM_COMMAND_BASE + DRM_I810_GETAGE)
2004 +#define DRM_IOCTL_I810_GETBUF          DRM_IOWR(DRM_COMMAND_BASE + DRM_I810_GETBUF, drm_i810_dma_t)
2005 +#define DRM_IOCTL_I810_SWAP            DRM_IO(  DRM_COMMAND_BASE + DRM_I810_SWAP)
2006 +#define DRM_IOCTL_I810_COPY            DRM_IOW( DRM_COMMAND_BASE + DRM_I810_COPY, drm_i810_copy_t)
2007 +#define DRM_IOCTL_I810_DOCOPY          DRM_IO(  DRM_COMMAND_BASE + DRM_I810_DOCOPY)
2008 +#define DRM_IOCTL_I810_OV0INFO         DRM_IOR( DRM_COMMAND_BASE + DRM_I810_OV0INFO, drm_i810_overlay_t)
2009 +#define DRM_IOCTL_I810_FSTATUS         DRM_IO ( DRM_COMMAND_BASE + DRM_I810_FSTATUS)
2010 +#define DRM_IOCTL_I810_OV0FLIP         DRM_IO ( DRM_COMMAND_BASE + DRM_I810_OV0FLIP)
2011 +#define DRM_IOCTL_I810_MC              DRM_IOW( DRM_COMMAND_BASE + DRM_I810_MC, drm_i810_mc_t)
2012 +#define DRM_IOCTL_I810_RSTATUS         DRM_IO ( DRM_COMMAND_BASE + DRM_I810_RSTATUS)
2013 +#define DRM_IOCTL_I810_FLIP             DRM_IO ( DRM_COMMAND_BASE + DRM_I810_FLIP)
2014 +
2015 +typedef struct _drm_i810_clear {
2016 +       int clear_color;
2017 +       int clear_depth;
2018 +       int flags;
2019 +} drm_i810_clear_t;
2020 +
2021 +/* These may be placeholders if we have more cliprects than
2022 + * I810_NR_SAREA_CLIPRECTS.  In that case, the client sets discard to
2023 + * false, indicating that the buffer will be dispatched again with a
2024 + * new set of cliprects.
2025 + */
2026 +typedef struct _drm_i810_vertex {
2027 +       int idx;                /* buffer index */
2028 +       int used;               /* nr bytes in use */
2029 +       int discard;            /* client is finished with the buffer? */
2030 +} drm_i810_vertex_t;
2031 +
2032 +typedef struct _drm_i810_copy_t {
2033 +       int idx;                /* buffer index */
2034 +       int used;               /* nr bytes in use */
2035 +       void *address;          /* Address to copy from */
2036 +} drm_i810_copy_t;
2037 +
2038 +#define PR_TRIANGLES         (0x0<<18)
2039 +#define PR_TRISTRIP_0        (0x1<<18)
2040 +#define PR_TRISTRIP_1        (0x2<<18)
2041 +#define PR_TRIFAN            (0x3<<18)
2042 +#define PR_POLYGON           (0x4<<18)
2043 +#define PR_LINES             (0x5<<18)
2044 +#define PR_LINESTRIP         (0x6<<18)
2045 +#define PR_RECTS             (0x7<<18)
2046 +#define PR_MASK              (0x7<<18)
2047 +
2048 +typedef struct drm_i810_dma {
2049 +       void *virtual;
2050 +       int request_idx;
2051 +       int request_size;
2052 +       int granted;
2053 +} drm_i810_dma_t;
2054 +
2055 +typedef struct _drm_i810_overlay_t {
2056 +       unsigned int offset;    /* Address of the Overlay Regs */
2057 +       unsigned int physical;
2058 +} drm_i810_overlay_t;
2059 +
2060 +typedef struct _drm_i810_mc {
2061 +       int idx;                /* buffer index */
2062 +       int used;               /* nr bytes in use */
2063 +       int num_blocks;         /* number of GFXBlocks */
2064 +       int *length;            /* List of lengths for GFXBlocks (FUTURE) */
2065 +       unsigned int last_render;       /* Last Render Request */
2066 +} drm_i810_mc_t;
2067 +
2068 +#endif                         /* _I810_DRM_H_ */
2069 diff --git a/libc/kernel/common/drm/i915_drm.h b/libc/kernel/common/drm/i915_drm.h
2070 new file mode 100644
2071 index 0000000..5c8fabe
2072 --- /dev/null
2073 +++ b/libc/kernel/common/drm/i915_drm.h
2074 @@ -0,0 +1,913 @@
2075 +/*
2076 + * Copyright 2003 Tungsten Graphics, Inc., Cedar Park, Texas.
2077 + * All Rights Reserved.
2078 + *
2079 + * Permission is hereby granted, free of charge, to any person obtaining a
2080 + * copy of this software and associated documentation files (the
2081 + * "Software"), to deal in the Software without restriction, including
2082 + * without limitation the rights to use, copy, modify, merge, publish,
2083 + * distribute, sub license, and/or sell copies of the Software, and to
2084 + * permit persons to whom the Software is furnished to do so, subject to
2085 + * the following conditions:
2086 + *
2087 + * The above copyright notice and this permission notice (including the
2088 + * next paragraph) shall be included in all copies or substantial portions
2089 + * of the Software.
2090 + *
2091 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
2092 + * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
2093 + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
2094 + * IN NO EVENT SHALL TUNGSTEN GRAPHICS AND/OR ITS SUPPLIERS BE LIABLE FOR
2095 + * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
2096 + * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
2097 + * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
2098 + *
2099 + */
2100 +
2101 +#ifndef _I915_DRM_H_
2102 +#define _I915_DRM_H_
2103 +
2104 +#include "drm.h"
2105 +
2106 +/* Please note that modifications to all structs defined here are
2107 + * subject to backwards-compatibility constraints.
2108 + */
2109 +
2110 +
2111 +/* Each region is a minimum of 16k, and there are at most 255 of them.
2112 + */
2113 +#define I915_NR_TEX_REGIONS 255        /* table size 2k - maximum due to use
2114 +                                * of chars for next/prev indices */
2115 +#define I915_LOG_MIN_TEX_REGION_SIZE 14
2116 +
2117 +typedef struct _drm_i915_init {
2118 +       enum {
2119 +               I915_INIT_DMA = 0x01,
2120 +               I915_CLEANUP_DMA = 0x02,
2121 +               I915_RESUME_DMA = 0x03
2122 +       } func;
2123 +       unsigned int mmio_offset;
2124 +       int sarea_priv_offset;
2125 +       unsigned int ring_start;
2126 +       unsigned int ring_end;
2127 +       unsigned int ring_size;
2128 +       unsigned int front_offset;
2129 +       unsigned int back_offset;
2130 +       unsigned int depth_offset;
2131 +       unsigned int w;
2132 +       unsigned int h;
2133 +       unsigned int pitch;
2134 +       unsigned int pitch_bits;
2135 +       unsigned int back_pitch;
2136 +       unsigned int depth_pitch;
2137 +       unsigned int cpp;
2138 +       unsigned int chipset;
2139 +} drm_i915_init_t;
2140 +
2141 +typedef struct _drm_i915_sarea {
2142 +       struct drm_tex_region texList[I915_NR_TEX_REGIONS + 1];
2143 +       int last_upload;        /* last time texture was uploaded */
2144 +       int last_enqueue;       /* last time a buffer was enqueued */
2145 +       int last_dispatch;      /* age of the most recently dispatched buffer */
2146 +       int ctxOwner;           /* last context to upload state */
2147 +       int texAge;
2148 +       int pf_enabled;         /* is pageflipping allowed? */
2149 +       int pf_active;
2150 +       int pf_current_page;    /* which buffer is being displayed? */
2151 +       int perf_boxes;         /* performance boxes to be displayed */
2152 +       int width, height;      /* screen size in pixels */
2153 +
2154 +       drm_handle_t front_handle;
2155 +       int front_offset;
2156 +       int front_size;
2157 +
2158 +       drm_handle_t back_handle;
2159 +       int back_offset;
2160 +       int back_size;
2161 +
2162 +       drm_handle_t depth_handle;
2163 +       int depth_offset;
2164 +       int depth_size;
2165 +
2166 +       drm_handle_t tex_handle;
2167 +       int tex_offset;
2168 +       int tex_size;
2169 +       int log_tex_granularity;
2170 +       int pitch;
2171 +       int rotation;           /* 0, 90, 180 or 270 */
2172 +       int rotated_offset;
2173 +       int rotated_size;
2174 +       int rotated_pitch;
2175 +       int virtualX, virtualY;
2176 +
2177 +       unsigned int front_tiled;
2178 +       unsigned int back_tiled;
2179 +       unsigned int depth_tiled;
2180 +       unsigned int rotated_tiled;
2181 +       unsigned int rotated2_tiled;
2182 +
2183 +       int pipeA_x;
2184 +       int pipeA_y;
2185 +       int pipeA_w;
2186 +       int pipeA_h;
2187 +       int pipeB_x;
2188 +       int pipeB_y;
2189 +       int pipeB_w;
2190 +       int pipeB_h;
2191 +
2192 +       /* fill out some space for old userspace triple buffer */
2193 +       drm_handle_t unused_handle;
2194 +       __u32 unused1, unused2, unused3;
2195 +
2196 +       /* buffer object handles for static buffers. May change
2197 +        * over the lifetime of the client.
2198 +        */
2199 +       __u32 front_bo_handle;
2200 +       __u32 back_bo_handle;
2201 +       __u32 unused_bo_handle;
2202 +       __u32 depth_bo_handle;
2203 +
2204 +} drm_i915_sarea_t;
2205 +
2206 +/* due to userspace building against these headers we need some compat here */
2207 +#define planeA_x pipeA_x
2208 +#define planeA_y pipeA_y
2209 +#define planeA_w pipeA_w
2210 +#define planeA_h pipeA_h
2211 +#define planeB_x pipeB_x
2212 +#define planeB_y pipeB_y
2213 +#define planeB_w pipeB_w
2214 +#define planeB_h pipeB_h
2215 +
2216 +/* Flags for perf_boxes
2217 + */
2218 +#define I915_BOX_RING_EMPTY    0x1
2219 +#define I915_BOX_FLIP          0x2
2220 +#define I915_BOX_WAIT          0x4
2221 +#define I915_BOX_TEXTURE_LOAD  0x8
2222 +#define I915_BOX_LOST_CONTEXT  0x10
2223 +
2224 +/* I915 specific ioctls
2225 + * The device specific ioctl range is 0x40 to 0x79.
2226 + */
2227 +#define DRM_I915_INIT          0x00
2228 +#define DRM_I915_FLUSH         0x01
2229 +#define DRM_I915_FLIP          0x02
2230 +#define DRM_I915_BATCHBUFFER   0x03
2231 +#define DRM_I915_IRQ_EMIT      0x04
2232 +#define DRM_I915_IRQ_WAIT      0x05
2233 +#define DRM_I915_GETPARAM      0x06
2234 +#define DRM_I915_SETPARAM      0x07
2235 +#define DRM_I915_ALLOC         0x08
2236 +#define DRM_I915_FREE          0x09
2237 +#define DRM_I915_INIT_HEAP     0x0a
2238 +#define DRM_I915_CMDBUFFER     0x0b
2239 +#define DRM_I915_DESTROY_HEAP  0x0c
2240 +#define DRM_I915_SET_VBLANK_PIPE       0x0d
2241 +#define DRM_I915_GET_VBLANK_PIPE       0x0e
2242 +#define DRM_I915_VBLANK_SWAP   0x0f
2243 +#define DRM_I915_HWS_ADDR      0x11
2244 +#define DRM_I915_GEM_INIT      0x13
2245 +#define DRM_I915_GEM_EXECBUFFER        0x14
2246 +#define DRM_I915_GEM_PIN       0x15
2247 +#define DRM_I915_GEM_UNPIN     0x16
2248 +#define DRM_I915_GEM_BUSY      0x17
2249 +#define DRM_I915_GEM_THROTTLE  0x18
2250 +#define DRM_I915_GEM_ENTERVT   0x19
2251 +#define DRM_I915_GEM_LEAVEVT   0x1a
2252 +#define DRM_I915_GEM_CREATE    0x1b
2253 +#define DRM_I915_GEM_PREAD     0x1c
2254 +#define DRM_I915_GEM_PWRITE    0x1d
2255 +#define DRM_I915_GEM_MMAP      0x1e
2256 +#define DRM_I915_GEM_SET_DOMAIN        0x1f
2257 +#define DRM_I915_GEM_SW_FINISH 0x20
2258 +#define DRM_I915_GEM_SET_TILING        0x21
2259 +#define DRM_I915_GEM_GET_TILING        0x22
2260 +#define DRM_I915_GEM_GET_APERTURE 0x23
2261 +#define DRM_I915_GEM_MMAP_GTT  0x24
2262 +#define DRM_I915_GET_PIPE_FROM_CRTC_ID 0x25
2263 +#define DRM_I915_GEM_MADVISE   0x26
2264 +#define DRM_I915_OVERLAY_PUT_IMAGE     0x27
2265 +#define DRM_I915_OVERLAY_ATTRS 0x28
2266 +#define DRM_I915_GEM_EXECBUFFER2       0x29
2267 +#define DRM_I915_GET_SPRITE_COLORKEY   0x2a
2268 +#define DRM_I915_SET_SPRITE_COLORKEY   0x2b
2269 +#define DRM_I915_GEM_WAIT      0x2c
2270 +#define DRM_I915_GEM_CONTEXT_CREATE    0x2d
2271 +#define DRM_I915_GEM_CONTEXT_DESTROY   0x2e
2272 +
2273 +#define DRM_IOCTL_I915_INIT            DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT, drm_i915_init_t)
2274 +#define DRM_IOCTL_I915_FLUSH           DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLUSH)
2275 +#define DRM_IOCTL_I915_FLIP            DRM_IO ( DRM_COMMAND_BASE + DRM_I915_FLIP)
2276 +#define DRM_IOCTL_I915_BATCHBUFFER     DRM_IOW( DRM_COMMAND_BASE + DRM_I915_BATCHBUFFER, drm_i915_batchbuffer_t)
2277 +#define DRM_IOCTL_I915_IRQ_EMIT         DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_IRQ_EMIT, drm_i915_irq_emit_t)
2278 +#define DRM_IOCTL_I915_IRQ_WAIT         DRM_IOW( DRM_COMMAND_BASE + DRM_I915_IRQ_WAIT, drm_i915_irq_wait_t)
2279 +#define DRM_IOCTL_I915_GETPARAM         DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GETPARAM, drm_i915_getparam_t)
2280 +#define DRM_IOCTL_I915_SETPARAM         DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SETPARAM, drm_i915_setparam_t)
2281 +#define DRM_IOCTL_I915_ALLOC            DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_ALLOC, drm_i915_mem_alloc_t)
2282 +#define DRM_IOCTL_I915_FREE             DRM_IOW( DRM_COMMAND_BASE + DRM_I915_FREE, drm_i915_mem_free_t)
2283 +#define DRM_IOCTL_I915_INIT_HEAP        DRM_IOW( DRM_COMMAND_BASE + DRM_I915_INIT_HEAP, drm_i915_mem_init_heap_t)
2284 +#define DRM_IOCTL_I915_CMDBUFFER       DRM_IOW( DRM_COMMAND_BASE + DRM_I915_CMDBUFFER, drm_i915_cmdbuffer_t)
2285 +#define DRM_IOCTL_I915_DESTROY_HEAP    DRM_IOW( DRM_COMMAND_BASE + DRM_I915_DESTROY_HEAP, drm_i915_mem_destroy_heap_t)
2286 +#define DRM_IOCTL_I915_SET_VBLANK_PIPE DRM_IOW( DRM_COMMAND_BASE + DRM_I915_SET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
2287 +#define DRM_IOCTL_I915_GET_VBLANK_PIPE DRM_IOR( DRM_COMMAND_BASE + DRM_I915_GET_VBLANK_PIPE, drm_i915_vblank_pipe_t)
2288 +#define DRM_IOCTL_I915_VBLANK_SWAP     DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_VBLANK_SWAP, drm_i915_vblank_swap_t)
2289 +#define DRM_IOCTL_I915_HWS_ADDR                DRM_IOW(DRM_COMMAND_BASE + DRM_I915_HWS_ADDR, struct drm_i915_gem_init)
2290 +#define DRM_IOCTL_I915_GEM_INIT                DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_INIT, struct drm_i915_gem_init)
2291 +#define DRM_IOCTL_I915_GEM_EXECBUFFER  DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_EXECBUFFER, struct drm_i915_gem_execbuffer)
2292 +#define DRM_IOCTL_I915_GEM_EXECBUFFER2 DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_EXECBUFFER2, struct drm_i915_gem_execbuffer2)
2293 +#define DRM_IOCTL_I915_GEM_PIN         DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_PIN, struct drm_i915_gem_pin)
2294 +#define DRM_IOCTL_I915_GEM_UNPIN       DRM_IOW(DRM_COMMAND_BASE + DRM_I915_GEM_UNPIN, struct drm_i915_gem_unpin)
2295 +#define DRM_IOCTL_I915_GEM_BUSY                DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_BUSY, struct drm_i915_gem_busy)
2296 +#define DRM_IOCTL_I915_GEM_THROTTLE    DRM_IO ( DRM_COMMAND_BASE + DRM_I915_GEM_THROTTLE)
2297 +#define DRM_IOCTL_I915_GEM_ENTERVT     DRM_IO(DRM_COMMAND_BASE + DRM_I915_GEM_ENTERVT)
2298 +#define DRM_IOCTL_I915_GEM_LEAVEVT     DRM_IO(DRM_COMMAND_BASE + DRM_I915_GEM_LEAVEVT)
2299 +#define DRM_IOCTL_I915_GEM_CREATE      DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_CREATE, struct drm_i915_gem_create)
2300 +#define DRM_IOCTL_I915_GEM_PREAD       DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_PREAD, struct drm_i915_gem_pread)
2301 +#define DRM_IOCTL_I915_GEM_PWRITE      DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_PWRITE, struct drm_i915_gem_pwrite)
2302 +#define DRM_IOCTL_I915_GEM_MMAP                DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP, struct drm_i915_gem_mmap)
2303 +#define DRM_IOCTL_I915_GEM_MMAP_GTT    DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MMAP_GTT, struct drm_i915_gem_mmap_gtt)
2304 +#define DRM_IOCTL_I915_GEM_SET_DOMAIN  DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_SET_DOMAIN, struct drm_i915_gem_set_domain)
2305 +#define DRM_IOCTL_I915_GEM_SW_FINISH   DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_SW_FINISH, struct drm_i915_gem_sw_finish)
2306 +#define DRM_IOCTL_I915_GEM_SET_TILING  DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_SET_TILING, struct drm_i915_gem_set_tiling)
2307 +#define DRM_IOCTL_I915_GEM_GET_TILING  DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_GET_TILING, struct drm_i915_gem_get_tiling)
2308 +#define DRM_IOCTL_I915_GEM_GET_APERTURE        DRM_IOR  (DRM_COMMAND_BASE + DRM_I915_GEM_GET_APERTURE, struct drm_i915_gem_get_aperture)
2309 +#define DRM_IOCTL_I915_GET_PIPE_FROM_CRTC_ID DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GET_PIPE_FROM_CRTC_ID, struct drm_i915_get_pipe_from_crtc_id)
2310 +#define DRM_IOCTL_I915_GEM_MADVISE     DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_MADVISE, struct drm_i915_gem_madvise)
2311 +#define DRM_IOCTL_I915_OVERLAY_PUT_IMAGE       DRM_IOW(DRM_COMMAND_BASE + DRM_I915_OVERLAY_PUT_IMAGE, struct drm_intel_overlay_put_image)
2312 +#define DRM_IOCTL_I915_OVERLAY_ATTRS   DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_OVERLAY_ATTRS, struct drm_intel_overlay_attrs)
2313 +#define DRM_IOCTL_I915_SET_SPRITE_COLORKEY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_SET_SPRITE_COLORKEY, struct drm_intel_sprite_colorkey)
2314 +#define DRM_IOCTL_I915_GET_SPRITE_COLORKEY DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_SET_SPRITE_COLORKEY, struct drm_intel_sprite_colorkey)
2315 +#define DRM_IOCTL_I915_GEM_WAIT                DRM_IOWR(DRM_COMMAND_BASE + DRM_I915_GEM_WAIT, struct drm_i915_gem_wait)
2316 +#define DRM_IOCTL_I915_GEM_CONTEXT_CREATE      DRM_IOWR (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_CREATE, struct drm_i915_gem_context_create)
2317 +#define DRM_IOCTL_I915_GEM_CONTEXT_DESTROY     DRM_IOW (DRM_COMMAND_BASE + DRM_I915_GEM_CONTEXT_DESTROY, struct drm_i915_gem_context_destroy)
2318 +
2319 +/* Allow drivers to submit batchbuffers directly to hardware, relying
2320 + * on the security mechanisms provided by hardware.
2321 + */
2322 +typedef struct drm_i915_batchbuffer {
2323 +       int start;              /* agp offset */
2324 +       int used;               /* nr bytes in use */
2325 +       int DR1;                /* hw flags for GFX_OP_DRAWRECT_INFO */
2326 +       int DR4;                /* window origin for GFX_OP_DRAWRECT_INFO */
2327 +       int num_cliprects;      /* mulitpass with multiple cliprects? */
2328 +       struct drm_clip_rect *cliprects;        /* pointer to userspace cliprects */
2329 +} drm_i915_batchbuffer_t;
2330 +
2331 +/* As above, but pass a pointer to userspace buffer which can be
2332 + * validated by the kernel prior to sending to hardware.
2333 + */
2334 +typedef struct _drm_i915_cmdbuffer {
2335 +       char *buf;      /* pointer to userspace command buffer */
2336 +       int sz;                 /* nr bytes in buf */
2337 +       int DR1;                /* hw flags for GFX_OP_DRAWRECT_INFO */
2338 +       int DR4;                /* window origin for GFX_OP_DRAWRECT_INFO */
2339 +       int num_cliprects;      /* mulitpass with multiple cliprects? */
2340 +       struct drm_clip_rect *cliprects;        /* pointer to userspace cliprects */
2341 +} drm_i915_cmdbuffer_t;
2342 +
2343 +/* Userspace can request & wait on irq's:
2344 + */
2345 +typedef struct drm_i915_irq_emit {
2346 +       int *irq_seq;
2347 +} drm_i915_irq_emit_t;
2348 +
2349 +typedef struct drm_i915_irq_wait {
2350 +       int irq_seq;
2351 +} drm_i915_irq_wait_t;
2352 +
2353 +/* Ioctl to query kernel params:
2354 + */
2355 +#define I915_PARAM_IRQ_ACTIVE            1
2356 +#define I915_PARAM_ALLOW_BATCHBUFFER     2
2357 +#define I915_PARAM_LAST_DISPATCH         3
2358 +#define I915_PARAM_CHIPSET_ID            4
2359 +#define I915_PARAM_HAS_GEM               5
2360 +#define I915_PARAM_NUM_FENCES_AVAIL      6
2361 +#define I915_PARAM_HAS_OVERLAY           7
2362 +#define I915_PARAM_HAS_PAGEFLIPPING     8
2363 +#define I915_PARAM_HAS_EXECBUF2          9
2364 +#define I915_PARAM_HAS_BSD              10
2365 +#define I915_PARAM_HAS_BLT              11
2366 +#define I915_PARAM_HAS_RELAXED_FENCING  12
2367 +#define I915_PARAM_HAS_COHERENT_RINGS   13
2368 +#define I915_PARAM_HAS_EXEC_CONSTANTS   14
2369 +#define I915_PARAM_HAS_RELAXED_DELTA    15
2370 +#define I915_PARAM_HAS_GEN7_SOL_RESET   16
2371 +#define I915_PARAM_HAS_LLC                      17
2372 +#define I915_PARAM_HAS_ALIASING_PPGTT   18
2373 +#define I915_PARAM_HAS_WAIT_TIMEOUT     19
2374 +
2375 +typedef struct drm_i915_getparam {
2376 +       int param;
2377 +       int *value;
2378 +} drm_i915_getparam_t;
2379 +
2380 +/* Ioctl to set kernel params:
2381 + */
2382 +#define I915_SETPARAM_USE_MI_BATCHBUFFER_START            1
2383 +#define I915_SETPARAM_TEX_LRU_LOG_GRANULARITY             2
2384 +#define I915_SETPARAM_ALLOW_BATCHBUFFER                   3
2385 +#define I915_SETPARAM_NUM_USED_FENCES                     4
2386 +
2387 +typedef struct drm_i915_setparam {
2388 +       int param;
2389 +       int value;
2390 +} drm_i915_setparam_t;
2391 +
2392 +/* A memory manager for regions of shared memory:
2393 + */
2394 +#define I915_MEM_REGION_AGP 1
2395 +
2396 +typedef struct drm_i915_mem_alloc {
2397 +       int region;
2398 +       int alignment;
2399 +       int size;
2400 +       int *region_offset;     /* offset from start of fb or agp */
2401 +} drm_i915_mem_alloc_t;
2402 +
2403 +typedef struct drm_i915_mem_free {
2404 +       int region;
2405 +       int region_offset;
2406 +} drm_i915_mem_free_t;
2407 +
2408 +typedef struct drm_i915_mem_init_heap {
2409 +       int region;
2410 +       int size;
2411 +       int start;
2412 +} drm_i915_mem_init_heap_t;
2413 +
2414 +/* Allow memory manager to be torn down and re-initialized (eg on
2415 + * rotate):
2416 + */
2417 +typedef struct drm_i915_mem_destroy_heap {
2418 +       int region;
2419 +} drm_i915_mem_destroy_heap_t;
2420 +
2421 +/* Allow X server to configure which pipes to monitor for vblank signals
2422 + */
2423 +#define        DRM_I915_VBLANK_PIPE_A  1
2424 +#define        DRM_I915_VBLANK_PIPE_B  2
2425 +
2426 +typedef struct drm_i915_vblank_pipe {
2427 +       int pipe;
2428 +} drm_i915_vblank_pipe_t;
2429 +
2430 +/* Schedule buffer swap at given vertical blank:
2431 + */
2432 +typedef struct drm_i915_vblank_swap {
2433 +       drm_drawable_t drawable;
2434 +       enum drm_vblank_seq_type seqtype;
2435 +       unsigned int sequence;
2436 +} drm_i915_vblank_swap_t;
2437 +
2438 +typedef struct drm_i915_hws_addr {
2439 +       __u64 addr;
2440 +} drm_i915_hws_addr_t;
2441 +
2442 +struct drm_i915_gem_init {
2443 +       /**
2444 +        * Beginning offset in the GTT to be managed by the DRM memory
2445 +        * manager.
2446 +        */
2447 +       __u64 gtt_start;
2448 +       /**
2449 +        * Ending offset in the GTT to be managed by the DRM memory
2450 +        * manager.
2451 +        */
2452 +       __u64 gtt_end;
2453 +};
2454 +
2455 +struct drm_i915_gem_create {
2456 +       /**
2457 +        * Requested size for the object.
2458 +        *
2459 +        * The (page-aligned) allocated size for the object will be returned.
2460 +        */
2461 +       __u64 size;
2462 +       /**
2463 +        * Returned handle for the object.
2464 +        *
2465 +        * Object handles are nonzero.
2466 +        */
2467 +       __u32 handle;
2468 +       __u32 pad;
2469 +};
2470 +
2471 +struct drm_i915_gem_pread {
2472 +       /** Handle for the object being read. */
2473 +       __u32 handle;
2474 +       __u32 pad;
2475 +       /** Offset into the object to read from */
2476 +       __u64 offset;
2477 +       /** Length of data to read */
2478 +       __u64 size;
2479 +       /**
2480 +        * Pointer to write the data into.
2481 +        *
2482 +        * This is a fixed-size type for 32/64 compatibility.
2483 +        */
2484 +       __u64 data_ptr;
2485 +};
2486 +
2487 +struct drm_i915_gem_pwrite {
2488 +       /** Handle for the object being written to. */
2489 +       __u32 handle;
2490 +       __u32 pad;
2491 +       /** Offset into the object to write to */
2492 +       __u64 offset;
2493 +       /** Length of data to write */
2494 +       __u64 size;
2495 +       /**
2496 +        * Pointer to read the data from.
2497 +        *
2498 +        * This is a fixed-size type for 32/64 compatibility.
2499 +        */
2500 +       __u64 data_ptr;
2501 +};
2502 +
2503 +struct drm_i915_gem_mmap {
2504 +       /** Handle for the object being mapped. */
2505 +       __u32 handle;
2506 +       __u32 pad;
2507 +       /** Offset in the object to map. */
2508 +       __u64 offset;
2509 +       /**
2510 +        * Length of data to map.
2511 +        *
2512 +        * The value will be page-aligned.
2513 +        */
2514 +       __u64 size;
2515 +       /**
2516 +        * Returned pointer the data was mapped at.
2517 +        *
2518 +        * This is a fixed-size type for 32/64 compatibility.
2519 +        */
2520 +       __u64 addr_ptr;
2521 +};
2522 +
2523 +struct drm_i915_gem_mmap_gtt {
2524 +       /** Handle for the object being mapped. */
2525 +       __u32 handle;
2526 +       __u32 pad;
2527 +       /**
2528 +        * Fake offset to use for subsequent mmap call
2529 +        *
2530 +        * This is a fixed-size type for 32/64 compatibility.
2531 +        */
2532 +       __u64 offset;
2533 +};
2534 +
2535 +struct drm_i915_gem_set_domain {
2536 +       /** Handle for the object */
2537 +       __u32 handle;
2538 +
2539 +       /** New read domains */
2540 +       __u32 read_domains;
2541 +
2542 +       /** New write domain */
2543 +       __u32 write_domain;
2544 +};
2545 +
2546 +struct drm_i915_gem_sw_finish {
2547 +       /** Handle for the object */
2548 +       __u32 handle;
2549 +};
2550 +
2551 +struct drm_i915_gem_relocation_entry {
2552 +       /**
2553 +        * Handle of the buffer being pointed to by this relocation entry.
2554 +        *
2555 +        * It's appealing to make this be an index into the mm_validate_entry
2556 +        * list to refer to the buffer, but this allows the driver to create
2557 +        * a relocation list for state buffers and not re-write it per
2558 +        * exec using the buffer.
2559 +        */
2560 +       __u32 target_handle;
2561 +
2562 +       /**
2563 +        * Value to be added to the offset of the target buffer to make up
2564 +        * the relocation entry.
2565 +        */
2566 +       __u32 delta;
2567 +
2568 +       /** Offset in the buffer the relocation entry will be written into */
2569 +       __u64 offset;
2570 +
2571 +       /**
2572 +        * Offset value of the target buffer that the relocation entry was last
2573 +        * written as.
2574 +        *
2575 +        * If the buffer has the same offset as last time, we can skip syncing
2576 +        * and writing the relocation.  This value is written back out by
2577 +        * the execbuffer ioctl when the relocation is written.
2578 +        */
2579 +       __u64 presumed_offset;
2580 +
2581 +       /**
2582 +        * Target memory domains read by this operation.
2583 +        */
2584 +       __u32 read_domains;
2585 +
2586 +       /**
2587 +        * Target memory domains written by this operation.
2588 +        *
2589 +        * Note that only one domain may be written by the whole
2590 +        * execbuffer operation, so that where there are conflicts,
2591 +        * the application will get -EINVAL back.
2592 +        */
2593 +       __u32 write_domain;
2594 +};
2595 +
2596 +/** @{
2597 + * Intel memory domains
2598 + *
2599 + * Most of these just align with the various caches in
2600 + * the system and are used to flush and invalidate as
2601 + * objects end up cached in different domains.
2602 + */
2603 +/** CPU cache */
2604 +#define I915_GEM_DOMAIN_CPU            0x00000001
2605 +/** Render cache, used by 2D and 3D drawing */
2606 +#define I915_GEM_DOMAIN_RENDER         0x00000002
2607 +/** Sampler cache, used by texture engine */
2608 +#define I915_GEM_DOMAIN_SAMPLER                0x00000004
2609 +/** Command queue, used to load batch buffers */
2610 +#define I915_GEM_DOMAIN_COMMAND                0x00000008
2611 +/** Instruction cache, used by shader programs */
2612 +#define I915_GEM_DOMAIN_INSTRUCTION    0x00000010
2613 +/** Vertex address cache */
2614 +#define I915_GEM_DOMAIN_VERTEX         0x00000020
2615 +/** GTT domain - aperture and scanout */
2616 +#define I915_GEM_DOMAIN_GTT            0x00000040
2617 +/** @} */
2618 +
2619 +struct drm_i915_gem_exec_object {
2620 +       /**
2621 +        * User's handle for a buffer to be bound into the GTT for this
2622 +        * operation.
2623 +        */
2624 +       __u32 handle;
2625 +
2626 +       /** Number of relocations to be performed on this buffer */
2627 +       __u32 relocation_count;
2628 +       /**
2629 +        * Pointer to array of struct drm_i915_gem_relocation_entry containing
2630 +        * the relocations to be performed in this buffer.
2631 +        */
2632 +       __u64 relocs_ptr;
2633 +
2634 +       /** Required alignment in graphics aperture */
2635 +       __u64 alignment;
2636 +
2637 +       /**
2638 +        * Returned value of the updated offset of the object, for future
2639 +        * presumed_offset writes.
2640 +        */
2641 +       __u64 offset;
2642 +};
2643 +
2644 +struct drm_i915_gem_execbuffer {
2645 +       /**
2646 +        * List of buffers to be validated with their relocations to be
2647 +        * performend on them.
2648 +        *
2649 +        * This is a pointer to an array of struct drm_i915_gem_validate_entry.
2650 +        *
2651 +        * These buffers must be listed in an order such that all relocations
2652 +        * a buffer is performing refer to buffers that have already appeared
2653 +        * in the validate list.
2654 +        */
2655 +       __u64 buffers_ptr;
2656 +       __u32 buffer_count;
2657 +
2658 +       /** Offset in the batchbuffer to start execution from. */
2659 +       __u32 batch_start_offset;
2660 +       /** Bytes used in batchbuffer from batch_start_offset */
2661 +       __u32 batch_len;
2662 +       __u32 DR1;
2663 +       __u32 DR4;
2664 +       __u32 num_cliprects;
2665 +       /** This is a struct drm_clip_rect *cliprects */
2666 +       __u64 cliprects_ptr;
2667 +};
2668 +
2669 +struct drm_i915_gem_exec_object2 {
2670 +       /**
2671 +        * User's handle for a buffer to be bound into the GTT for this
2672 +        * operation.
2673 +        */
2674 +       __u32 handle;
2675 +
2676 +       /** Number of relocations to be performed on this buffer */
2677 +       __u32 relocation_count;
2678 +       /**
2679 +        * Pointer to array of struct drm_i915_gem_relocation_entry containing
2680 +        * the relocations to be performed in this buffer.
2681 +        */
2682 +       __u64 relocs_ptr;
2683 +
2684 +       /** Required alignment in graphics aperture */
2685 +       __u64 alignment;
2686 +
2687 +       /**
2688 +        * Returned value of the updated offset of the object, for future
2689 +        * presumed_offset writes.
2690 +        */
2691 +       __u64 offset;
2692 +
2693 +#define EXEC_OBJECT_NEEDS_FENCE (1<<0)
2694 +       __u64 flags;
2695 +       __u64 rsvd1;
2696 +       __u64 rsvd2;
2697 +};
2698 +
2699 +struct drm_i915_gem_execbuffer2 {
2700 +       /**
2701 +        * List of gem_exec_object2 structs
2702 +        */
2703 +       __u64 buffers_ptr;
2704 +       __u32 buffer_count;
2705 +
2706 +       /** Offset in the batchbuffer to start execution from. */
2707 +       __u32 batch_start_offset;
2708 +       /** Bytes used in batchbuffer from batch_start_offset */
2709 +       __u32 batch_len;
2710 +       __u32 DR1;
2711 +       __u32 DR4;
2712 +       __u32 num_cliprects;
2713 +       /** This is a struct drm_clip_rect *cliprects */
2714 +       __u64 cliprects_ptr;
2715 +#define I915_EXEC_RING_MASK              (7<<0)
2716 +#define I915_EXEC_DEFAULT                (0<<0)
2717 +#define I915_EXEC_RENDER                 (1<<0)
2718 +#define I915_EXEC_BSD                    (2<<0)
2719 +#define I915_EXEC_BLT                    (3<<0)
2720 +
2721 +/* Used for switching the constants addressing mode on gen4+ RENDER ring.
2722 + * Gen6+ only supports relative addressing to dynamic state (default) and
2723 + * absolute addressing.
2724 + *
2725 + * These flags are ignored for the BSD and BLT rings.
2726 + */
2727 +#define I915_EXEC_CONSTANTS_MASK       (3<<6)
2728 +#define I915_EXEC_CONSTANTS_REL_GENERAL (0<<6) /* default */
2729 +#define I915_EXEC_CONSTANTS_ABSOLUTE   (1<<6)
2730 +#define I915_EXEC_CONSTANTS_REL_SURFACE (2<<6) /* gen4/5 only */
2731 +       __u64 flags;
2732 +       __u64 rsvd1; /* now used for context info */
2733 +       __u64 rsvd2;
2734 +};
2735 +
2736 +/** Resets the SO write offset registers for transform feedback on gen7. */
2737 +#define I915_EXEC_GEN7_SOL_RESET       (1<<8)
2738 +
2739 +#define I915_EXEC_CONTEXT_ID_MASK      (0xffffffff)
2740 +#define i915_execbuffer2_set_context_id(eb2, context) \
2741 +       (eb2).rsvd1 = context & I915_EXEC_CONTEXT_ID_MASK
2742 +#define i915_execbuffer2_get_context_id(eb2) \
2743 +       ((eb2).rsvd1 & I915_EXEC_CONTEXT_ID_MASK)
2744 +
2745 +struct drm_i915_gem_pin {
2746 +       /** Handle of the buffer to be pinned. */
2747 +       __u32 handle;
2748 +       __u32 pad;
2749 +
2750 +       /** alignment required within the aperture */
2751 +       __u64 alignment;
2752 +
2753 +       /** Returned GTT offset of the buffer. */
2754 +       __u64 offset;
2755 +};
2756 +
2757 +struct drm_i915_gem_unpin {
2758 +       /** Handle of the buffer to be unpinned. */
2759 +       __u32 handle;
2760 +       __u32 pad;
2761 +};
2762 +
2763 +struct drm_i915_gem_busy {
2764 +       /** Handle of the buffer to check for busy */
2765 +       __u32 handle;
2766 +
2767 +       /** Return busy status (1 if busy, 0 if idle) */
2768 +       __u32 busy;
2769 +};
2770 +
2771 +#define I915_TILING_NONE       0
2772 +#define I915_TILING_X          1
2773 +#define I915_TILING_Y          2
2774 +
2775 +#define I915_BIT_6_SWIZZLE_NONE                0
2776 +#define I915_BIT_6_SWIZZLE_9           1
2777 +#define I915_BIT_6_SWIZZLE_9_10                2
2778 +#define I915_BIT_6_SWIZZLE_9_11                3
2779 +#define I915_BIT_6_SWIZZLE_9_10_11     4
2780 +/* Not seen by userland */
2781 +#define I915_BIT_6_SWIZZLE_UNKNOWN     5
2782 +/* Seen by userland. */
2783 +#define I915_BIT_6_SWIZZLE_9_17                6
2784 +#define I915_BIT_6_SWIZZLE_9_10_17     7
2785 +
2786 +struct drm_i915_gem_set_tiling {
2787 +       /** Handle of the buffer to have its tiling state updated */
2788 +       __u32 handle;
2789 +
2790 +       /**
2791 +        * Tiling mode for the object (I915_TILING_NONE, I915_TILING_X,
2792 +        * I915_TILING_Y).
2793 +        *
2794 +        * This value is to be set on request, and will be updated by the
2795 +        * kernel on successful return with the actual chosen tiling layout.
2796 +        *
2797 +        * The tiling mode may be demoted to I915_TILING_NONE when the system
2798 +        * has bit 6 swizzling that can't be managed correctly by GEM.
2799 +        *
2800 +        * Buffer contents become undefined when changing tiling_mode.
2801 +        */
2802 +       __u32 tiling_mode;
2803 +
2804 +       /**
2805 +        * Stride in bytes for the object when in I915_TILING_X or
2806 +        * I915_TILING_Y.
2807 +        */
2808 +       __u32 stride;
2809 +
2810 +       /**
2811 +        * Returned address bit 6 swizzling required for CPU access through
2812 +        * mmap mapping.
2813 +        */
2814 +       __u32 swizzle_mode;
2815 +};
2816 +
2817 +struct drm_i915_gem_get_tiling {
2818 +       /** Handle of the buffer to get tiling state for. */
2819 +       __u32 handle;
2820 +
2821 +       /**
2822 +        * Current tiling mode for the object (I915_TILING_NONE, I915_TILING_X,
2823 +        * I915_TILING_Y).
2824 +        */
2825 +       __u32 tiling_mode;
2826 +
2827 +       /**
2828 +        * Returned address bit 6 swizzling required for CPU access through
2829 +        * mmap mapping.
2830 +        */
2831 +       __u32 swizzle_mode;
2832 +};
2833 +
2834 +struct drm_i915_gem_get_aperture {
2835 +       /** Total size of the aperture used by i915_gem_execbuffer, in bytes */
2836 +       __u64 aper_size;
2837 +
2838 +       /**
2839 +        * Available space in the aperture used by i915_gem_execbuffer, in
2840 +        * bytes
2841 +        */
2842 +       __u64 aper_available_size;
2843 +};
2844 +
2845 +struct drm_i915_get_pipe_from_crtc_id {
2846 +       /** ID of CRTC being requested **/
2847 +       __u32 crtc_id;
2848 +
2849 +       /** pipe of requested CRTC **/
2850 +       __u32 pipe;
2851 +};
2852 +
2853 +#define I915_MADV_WILLNEED 0
2854 +#define I915_MADV_DONTNEED 1
2855 +#define __I915_MADV_PURGED 2 /* internal state */
2856 +
2857 +struct drm_i915_gem_madvise {
2858 +       /** Handle of the buffer to change the backing store advice */
2859 +       __u32 handle;
2860 +
2861 +       /* Advice: either the buffer will be needed again in the near future,
2862 +        *         or wont be and could be discarded under memory pressure.
2863 +        */
2864 +       __u32 madv;
2865 +
2866 +       /** Whether the backing store still exists. */
2867 +       __u32 retained;
2868 +};
2869 +
2870 +/* flags */
2871 +#define I915_OVERLAY_TYPE_MASK                 0xff
2872 +#define I915_OVERLAY_YUV_PLANAR        0x01
2873 +#define I915_OVERLAY_YUV_PACKED        0x02
2874 +#define I915_OVERLAY_RGB               0x03
2875 +
2876 +#define I915_OVERLAY_DEPTH_MASK                0xff00
2877 +#define I915_OVERLAY_RGB24             0x1000
2878 +#define I915_OVERLAY_RGB16             0x2000
2879 +#define I915_OVERLAY_RGB15             0x3000
2880 +#define I915_OVERLAY_YUV422            0x0100
2881 +#define I915_OVERLAY_YUV411            0x0200
2882 +#define I915_OVERLAY_YUV420            0x0300
2883 +#define I915_OVERLAY_YUV410            0x0400
2884 +
2885 +#define I915_OVERLAY_SWAP_MASK         0xff0000
2886 +#define I915_OVERLAY_NO_SWAP           0x000000
2887 +#define I915_OVERLAY_UV_SWAP           0x010000
2888 +#define I915_OVERLAY_Y_SWAP            0x020000
2889 +#define I915_OVERLAY_Y_AND_UV_SWAP     0x030000
2890 +
2891 +#define I915_OVERLAY_FLAGS_MASK                0xff000000
2892 +#define I915_OVERLAY_ENABLE            0x01000000
2893 +
2894 +struct drm_intel_overlay_put_image {
2895 +       /* various flags and src format description */
2896 +       __u32 flags;
2897 +       /* source picture description */
2898 +       __u32 bo_handle;
2899 +       /* stride values and offsets are in bytes, buffer relative */
2900 +       __u16 stride_Y; /* stride for packed formats */
2901 +       __u16 stride_UV;
2902 +       __u32 offset_Y; /* offset for packet formats */
2903 +       __u32 offset_U;
2904 +       __u32 offset_V;
2905 +       /* in pixels */
2906 +       __u16 src_width;
2907 +       __u16 src_height;
2908 +       /* to compensate the scaling factors for partially covered surfaces */
2909 +       __u16 src_scan_width;
2910 +       __u16 src_scan_height;
2911 +       /* output crtc description */
2912 +       __u32 crtc_id;
2913 +       __u16 dst_x;
2914 +       __u16 dst_y;
2915 +       __u16 dst_width;
2916 +       __u16 dst_height;
2917 +};
2918 +
2919 +/* flags */
2920 +#define I915_OVERLAY_UPDATE_ATTRS      (1<<0)
2921 +#define I915_OVERLAY_UPDATE_GAMMA      (1<<1)
2922 +struct drm_intel_overlay_attrs {
2923 +       __u32 flags;
2924 +       __u32 color_key;
2925 +       __s32 brightness;
2926 +       __u32 contrast;
2927 +       __u32 saturation;
2928 +       __u32 gamma0;
2929 +       __u32 gamma1;
2930 +       __u32 gamma2;
2931 +       __u32 gamma3;
2932 +       __u32 gamma4;
2933 +       __u32 gamma5;
2934 +};
2935 +
2936 +/*
2937 + * Intel sprite handling
2938 + *
2939 + * Color keying works with a min/mask/max tuple.  Both source and destination
2940 + * color keying is allowed.
2941 + *
2942 + * Source keying:
2943 + * Sprite pixels within the min & max values, masked against the color channels
2944 + * specified in the mask field, will be transparent.  All other pixels will
2945 + * be displayed on top of the primary plane.  For RGB surfaces, only the min
2946 + * and mask fields will be used; ranged compares are not allowed.
2947 + *
2948 + * Destination keying:
2949 + * Primary plane pixels that match the min value, masked against the color
2950 + * channels specified in the mask field, will be replaced by corresponding
2951 + * pixels from the sprite plane.
2952 + *
2953 + * Note that source & destination keying are exclusive; only one can be
2954 + * active on a given plane.
2955 + */
2956 +
2957 +#define I915_SET_COLORKEY_NONE         (1<<0) /* disable color key matching */
2958 +#define I915_SET_COLORKEY_DESTINATION  (1<<1)
2959 +#define I915_SET_COLORKEY_SOURCE       (1<<2)
2960 +struct drm_intel_sprite_colorkey {
2961 +       __u32 plane_id;
2962 +       __u32 min_value;
2963 +       __u32 channel_mask;
2964 +       __u32 max_value;
2965 +       __u32 flags;
2966 +};
2967 +
2968 +struct drm_i915_gem_wait {
2969 +       /** Handle of BO we shall wait on */
2970 +       __u32 bo_handle;
2971 +       __u32 flags;
2972 +       /** Number of nanoseconds to wait, Returns time remaining. */
2973 +       __s64 timeout_ns;
2974 +};
2975 +
2976 +struct drm_i915_gem_context_create {
2977 +       /*  output: id of new context*/
2978 +       __u32 ctx_id;
2979 +       __u32 pad;
2980 +};
2981 +
2982 +struct drm_i915_gem_context_destroy {
2983 +       __u32 ctx_id;
2984 +       __u32 pad;
2985 +};
2986 +
2987 +#endif                         /* _I915_DRM_H_ */
2988 diff --git a/libc/kernel/common/drm/mga_drm.h b/libc/kernel/common/drm/mga_drm.h
2989 new file mode 100644
2990 index 0000000..ff812de
2991 --- /dev/null
2992 +++ b/libc/kernel/common/drm/mga_drm.h
2993 @@ -0,0 +1,419 @@
2994 +/* mga_drm.h -- Public header for the Matrox g200/g400 driver -*- linux-c -*-
2995 + * Created: Tue Jan 25 01:50:01 1999 by jhartmann@precisioninsight.com
2996 + *
2997 + * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
2998 + * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
2999 + * All rights reserved.
3000 + *
3001 + * Permission is hereby granted, free of charge, to any person obtaining a
3002 + * copy of this software and associated documentation files (the "Software"),
3003 + * to deal in the Software without restriction, including without limitation
3004 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
3005 + * and/or sell copies of the Software, and to permit persons to whom the
3006 + * Software is furnished to do so, subject to the following conditions:
3007 + *
3008 + * The above copyright notice and this permission notice (including the next
3009 + * paragraph) shall be included in all copies or substantial portions of the
3010 + * Software.
3011 + *
3012 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3013 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3014 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
3015 + * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
3016 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
3017 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
3018 + * OTHER DEALINGS IN THE SOFTWARE.
3019 + *
3020 + * Authors:
3021 + *    Jeff Hartmann <jhartmann@valinux.com>
3022 + *    Keith Whitwell <keith@tungstengraphics.com>
3023 + *
3024 + * Rewritten by:
3025 + *    Gareth Hughes <gareth@valinux.com>
3026 + */
3027 +
3028 +#ifndef __MGA_DRM_H__
3029 +#define __MGA_DRM_H__
3030 +
3031 +#include "drm.h"
3032 +
3033 +/* WARNING: If you change any of these defines, make sure to change the
3034 + * defines in the Xserver file (mga_sarea.h)
3035 + */
3036 +
3037 +#ifndef __MGA_SAREA_DEFINES__
3038 +#define __MGA_SAREA_DEFINES__
3039 +
3040 +/* WARP pipe flags
3041 + */
3042 +#define MGA_F                  0x1     /* fog */
3043 +#define MGA_A                  0x2     /* alpha */
3044 +#define MGA_S                  0x4     /* specular */
3045 +#define MGA_T2                 0x8     /* multitexture */
3046 +
3047 +#define MGA_WARP_TGZ           0
3048 +#define MGA_WARP_TGZF          (MGA_F)
3049 +#define MGA_WARP_TGZA          (MGA_A)
3050 +#define MGA_WARP_TGZAF         (MGA_F|MGA_A)
3051 +#define MGA_WARP_TGZS          (MGA_S)
3052 +#define MGA_WARP_TGZSF         (MGA_S|MGA_F)
3053 +#define MGA_WARP_TGZSA         (MGA_S|MGA_A)
3054 +#define MGA_WARP_TGZSAF                (MGA_S|MGA_F|MGA_A)
3055 +#define MGA_WARP_T2GZ          (MGA_T2)
3056 +#define MGA_WARP_T2GZF         (MGA_T2|MGA_F)
3057 +#define MGA_WARP_T2GZA         (MGA_T2|MGA_A)
3058 +#define MGA_WARP_T2GZAF                (MGA_T2|MGA_A|MGA_F)
3059 +#define MGA_WARP_T2GZS         (MGA_T2|MGA_S)
3060 +#define MGA_WARP_T2GZSF                (MGA_T2|MGA_S|MGA_F)
3061 +#define MGA_WARP_T2GZSA                (MGA_T2|MGA_S|MGA_A)
3062 +#define MGA_WARP_T2GZSAF       (MGA_T2|MGA_S|MGA_F|MGA_A)
3063 +
3064 +#define MGA_MAX_G200_PIPES     8       /* no multitex */
3065 +#define MGA_MAX_G400_PIPES     16
3066 +#define MGA_MAX_WARP_PIPES     MGA_MAX_G400_PIPES
3067 +#define MGA_WARP_UCODE_SIZE    32768   /* in bytes */
3068 +
3069 +#define MGA_CARD_TYPE_G200     1
3070 +#define MGA_CARD_TYPE_G400     2
3071 +#define MGA_CARD_TYPE_G450     3       /* not currently used */
3072 +#define MGA_CARD_TYPE_G550     4
3073 +
3074 +#define MGA_FRONT              0x1
3075 +#define MGA_BACK               0x2
3076 +#define MGA_DEPTH              0x4
3077 +
3078 +/* What needs to be changed for the current vertex dma buffer?
3079 + */
3080 +#define MGA_UPLOAD_CONTEXT     0x1
3081 +#define MGA_UPLOAD_TEX0                0x2
3082 +#define MGA_UPLOAD_TEX1                0x4
3083 +#define MGA_UPLOAD_PIPE                0x8
3084 +#define MGA_UPLOAD_TEX0IMAGE   0x10    /* handled client-side */
3085 +#define MGA_UPLOAD_TEX1IMAGE   0x20    /* handled client-side */
3086 +#define MGA_UPLOAD_2D          0x40
3087 +#define MGA_WAIT_AGE           0x80    /* handled client-side */
3088 +#define MGA_UPLOAD_CLIPRECTS   0x100   /* handled client-side */
3089 +#if 0
3090 +#define MGA_DMA_FLUSH          0x200   /* set when someone gets the lock
3091 +                                          quiescent */
3092 +#endif
3093 +
3094 +/* 32 buffers of 64k each, total 2 meg.
3095 + */
3096 +#define MGA_BUFFER_SIZE                (1 << 16)
3097 +#define MGA_NUM_BUFFERS                128
3098 +
3099 +/* Keep these small for testing.
3100 + */
3101 +#define MGA_NR_SAREA_CLIPRECTS 8
3102 +
3103 +/* 2 heaps (1 for card, 1 for agp), each divided into up to 128
3104 + * regions, subject to a minimum region size of (1<<16) == 64k.
3105 + *
3106 + * Clients may subdivide regions internally, but when sharing between
3107 + * clients, the region size is the minimum granularity.
3108 + */
3109 +
3110 +#define MGA_CARD_HEAP                  0
3111 +#define MGA_AGP_HEAP                   1
3112 +#define MGA_NR_TEX_HEAPS               2
3113 +#define MGA_NR_TEX_REGIONS             16
3114 +#define MGA_LOG_MIN_TEX_REGION_SIZE    16
3115 +
3116 +#define  DRM_MGA_IDLE_RETRY          2048
3117 +
3118 +#endif                         /* __MGA_SAREA_DEFINES__ */
3119 +
3120 +/* Setup registers for 3D context
3121 + */
3122 +typedef struct {
3123 +       unsigned int dstorg;
3124 +       unsigned int maccess;
3125 +       unsigned int plnwt;
3126 +       unsigned int dwgctl;
3127 +       unsigned int alphactrl;
3128 +       unsigned int fogcolor;
3129 +       unsigned int wflag;
3130 +       unsigned int tdualstage0;
3131 +       unsigned int tdualstage1;
3132 +       unsigned int fcol;
3133 +       unsigned int stencil;
3134 +       unsigned int stencilctl;
3135 +} drm_mga_context_regs_t;
3136 +
3137 +/* Setup registers for 2D, X server
3138 + */
3139 +typedef struct {
3140 +       unsigned int pitch;
3141 +} drm_mga_server_regs_t;
3142 +
3143 +/* Setup registers for each texture unit
3144 + */
3145 +typedef struct {
3146 +       unsigned int texctl;
3147 +       unsigned int texctl2;
3148 +       unsigned int texfilter;
3149 +       unsigned int texbordercol;
3150 +       unsigned int texorg;
3151 +       unsigned int texwidth;
3152 +       unsigned int texheight;
3153 +       unsigned int texorg1;
3154 +       unsigned int texorg2;
3155 +       unsigned int texorg3;
3156 +       unsigned int texorg4;
3157 +} drm_mga_texture_regs_t;
3158 +
3159 +/* General aging mechanism
3160 + */
3161 +typedef struct {
3162 +       unsigned int head;      /* Position of head pointer          */
3163 +       unsigned int wrap;      /* Primary DMA wrap count            */
3164 +} drm_mga_age_t;
3165 +
3166 +typedef struct _drm_mga_sarea {
3167 +       /* The channel for communication of state information to the kernel
3168 +        * on firing a vertex dma buffer.
3169 +        */
3170 +       drm_mga_context_regs_t context_state;
3171 +       drm_mga_server_regs_t server_state;
3172 +       drm_mga_texture_regs_t tex_state[2];
3173 +       unsigned int warp_pipe;
3174 +       unsigned int dirty;
3175 +       unsigned int vertsize;
3176 +
3177 +       /* The current cliprects, or a subset thereof.
3178 +        */
3179 +       struct drm_clip_rect boxes[MGA_NR_SAREA_CLIPRECTS];
3180 +       unsigned int nbox;
3181 +
3182 +       /* Information about the most recently used 3d drawable.  The
3183 +        * client fills in the req_* fields, the server fills in the
3184 +        * exported_ fields and puts the cliprects into boxes, above.
3185 +        *
3186 +        * The client clears the exported_drawable field before
3187 +        * clobbering the boxes data.
3188 +        */
3189 +       unsigned int req_drawable;      /* the X drawable id */
3190 +       unsigned int req_draw_buffer;   /* MGA_FRONT or MGA_BACK */
3191 +
3192 +       unsigned int exported_drawable;
3193 +       unsigned int exported_index;
3194 +       unsigned int exported_stamp;
3195 +       unsigned int exported_buffers;
3196 +       unsigned int exported_nfront;
3197 +       unsigned int exported_nback;
3198 +       int exported_back_x, exported_front_x, exported_w;
3199 +       int exported_back_y, exported_front_y, exported_h;
3200 +       struct drm_clip_rect exported_boxes[MGA_NR_SAREA_CLIPRECTS];
3201 +
3202 +       /* Counters for aging textures and for client-side throttling.
3203 +        */
3204 +       unsigned int status[4];
3205 +       unsigned int last_wrap;
3206 +
3207 +       drm_mga_age_t last_frame;
3208 +       unsigned int last_enqueue;      /* last time a buffer was enqueued */
3209 +       unsigned int last_dispatch;     /* age of the most recently dispatched buffer */
3210 +       unsigned int last_quiescent;    /*  */
3211 +
3212 +       /* LRU lists for texture memory in agp space and on the card.
3213 +        */
3214 +       struct drm_tex_region texList[MGA_NR_TEX_HEAPS][MGA_NR_TEX_REGIONS + 1];
3215 +       unsigned int texAge[MGA_NR_TEX_HEAPS];
3216 +
3217 +       /* Mechanism to validate card state.
3218 +        */
3219 +       int ctxOwner;
3220 +} drm_mga_sarea_t;
3221 +
3222 +/* MGA specific ioctls
3223 + * The device specific ioctl range is 0x40 to 0x79.
3224 + */
3225 +#define DRM_MGA_INIT     0x00
3226 +#define DRM_MGA_FLUSH    0x01
3227 +#define DRM_MGA_RESET    0x02
3228 +#define DRM_MGA_SWAP     0x03
3229 +#define DRM_MGA_CLEAR    0x04
3230 +#define DRM_MGA_VERTEX   0x05
3231 +#define DRM_MGA_INDICES  0x06
3232 +#define DRM_MGA_ILOAD    0x07
3233 +#define DRM_MGA_BLIT     0x08
3234 +#define DRM_MGA_GETPARAM 0x09
3235 +
3236 +/* 3.2:
3237 + * ioctls for operating on fences.
3238 + */
3239 +#define DRM_MGA_SET_FENCE      0x0a
3240 +#define DRM_MGA_WAIT_FENCE     0x0b
3241 +#define DRM_MGA_DMA_BOOTSTRAP  0x0c
3242 +
3243 +#define DRM_IOCTL_MGA_INIT     DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_INIT, drm_mga_init_t)
3244 +#define DRM_IOCTL_MGA_FLUSH    DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_FLUSH, struct drm_lock)
3245 +#define DRM_IOCTL_MGA_RESET    DRM_IO(  DRM_COMMAND_BASE + DRM_MGA_RESET)
3246 +#define DRM_IOCTL_MGA_SWAP     DRM_IO(  DRM_COMMAND_BASE + DRM_MGA_SWAP)
3247 +#define DRM_IOCTL_MGA_CLEAR    DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_CLEAR, drm_mga_clear_t)
3248 +#define DRM_IOCTL_MGA_VERTEX   DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_VERTEX, drm_mga_vertex_t)
3249 +#define DRM_IOCTL_MGA_INDICES  DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_INDICES, drm_mga_indices_t)
3250 +#define DRM_IOCTL_MGA_ILOAD    DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_ILOAD, drm_mga_iload_t)
3251 +#define DRM_IOCTL_MGA_BLIT     DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_BLIT, drm_mga_blit_t)
3252 +#define DRM_IOCTL_MGA_GETPARAM DRM_IOWR(DRM_COMMAND_BASE + DRM_MGA_GETPARAM, drm_mga_getparam_t)
3253 +#define DRM_IOCTL_MGA_SET_FENCE     DRM_IOW( DRM_COMMAND_BASE + DRM_MGA_SET_FENCE, __u32)
3254 +#define DRM_IOCTL_MGA_WAIT_FENCE    DRM_IOWR(DRM_COMMAND_BASE + DRM_MGA_WAIT_FENCE, __u32)
3255 +#define DRM_IOCTL_MGA_DMA_BOOTSTRAP DRM_IOWR(DRM_COMMAND_BASE + DRM_MGA_DMA_BOOTSTRAP, drm_mga_dma_bootstrap_t)
3256 +
3257 +typedef struct _drm_mga_warp_index {
3258 +       int installed;
3259 +       unsigned long phys_addr;
3260 +       int size;
3261 +} drm_mga_warp_index_t;
3262 +
3263 +typedef struct drm_mga_init {
3264 +       enum {
3265 +               MGA_INIT_DMA = 0x01,
3266 +               MGA_CLEANUP_DMA = 0x02
3267 +       } func;
3268 +
3269 +       unsigned long sarea_priv_offset;
3270 +
3271 +       int chipset;
3272 +       int sgram;
3273 +
3274 +       unsigned int maccess;
3275 +
3276 +       unsigned int fb_cpp;
3277 +       unsigned int front_offset, front_pitch;
3278 +       unsigned int back_offset, back_pitch;
3279 +
3280 +       unsigned int depth_cpp;
3281 +       unsigned int depth_offset, depth_pitch;
3282 +
3283 +       unsigned int texture_offset[MGA_NR_TEX_HEAPS];
3284 +       unsigned int texture_size[MGA_NR_TEX_HEAPS];
3285 +
3286 +       unsigned long fb_offset;
3287 +       unsigned long mmio_offset;
3288 +       unsigned long status_offset;
3289 +       unsigned long warp_offset;
3290 +       unsigned long primary_offset;
3291 +       unsigned long buffers_offset;
3292 +} drm_mga_init_t;
3293 +
3294 +typedef struct drm_mga_dma_bootstrap {
3295 +       /**
3296 +        * \name AGP texture region
3297 +        *
3298 +        * On return from the DRM_MGA_DMA_BOOTSTRAP ioctl, these fields will
3299 +        * be filled in with the actual AGP texture settings.
3300 +        *
3301 +        * \warning
3302 +        * If these fields are non-zero, but dma_mga_dma_bootstrap::agp_mode
3303 +        * is zero, it means that PCI memory (most likely through the use of
3304 +        * an IOMMU) is being used for "AGP" textures.
3305 +        */
3306 +       /*@{ */
3307 +       unsigned long texture_handle; /**< Handle used to map AGP textures. */
3308 +       __u32 texture_size;           /**< Size of the AGP texture region. */
3309 +       /*@} */
3310 +
3311 +       /**
3312 +        * Requested size of the primary DMA region.
3313 +        *
3314 +        * On return from the DRM_MGA_DMA_BOOTSTRAP ioctl, this field will be
3315 +        * filled in with the actual AGP mode.  If AGP was not available
3316 +        */
3317 +       __u32 primary_size;
3318 +
3319 +       /**
3320 +        * Requested number of secondary DMA buffers.
3321 +        *
3322 +        * On return from the DRM_MGA_DMA_BOOTSTRAP ioctl, this field will be
3323 +        * filled in with the actual number of secondary DMA buffers
3324 +        * allocated.  Particularly when PCI DMA is used, this may be
3325 +        * (subtantially) less than the number requested.
3326 +        */
3327 +       __u32 secondary_bin_count;
3328 +
3329 +       /**
3330 +        * Requested size of each secondary DMA buffer.
3331 +        *
3332 +        * While the kernel \b is free to reduce
3333 +        * dma_mga_dma_bootstrap::secondary_bin_count, it is \b not allowed
3334 +        * to reduce dma_mga_dma_bootstrap::secondary_bin_size.
3335 +        */
3336 +       __u32 secondary_bin_size;
3337 +
3338 +       /**
3339 +        * Bit-wise mask of AGPSTAT2_* values.  Currently only \c AGPSTAT2_1X,
3340 +        * \c AGPSTAT2_2X, and \c AGPSTAT2_4X are supported.  If this value is
3341 +        * zero, it means that PCI DMA should be used, even if AGP is
3342 +        * possible.
3343 +        *
3344 +        * On return from the DRM_MGA_DMA_BOOTSTRAP ioctl, this field will be
3345 +        * filled in with the actual AGP mode.  If AGP was not available
3346 +        * (i.e., PCI DMA was used), this value will be zero.
3347 +        */
3348 +       __u32 agp_mode;
3349 +
3350 +       /**
3351 +        * Desired AGP GART size, measured in megabytes.
3352 +        */
3353 +       __u8 agp_size;
3354 +} drm_mga_dma_bootstrap_t;
3355 +
3356 +typedef struct drm_mga_clear {
3357 +       unsigned int flags;
3358 +       unsigned int clear_color;
3359 +       unsigned int clear_depth;
3360 +       unsigned int color_mask;
3361 +       unsigned int depth_mask;
3362 +} drm_mga_clear_t;
3363 +
3364 +typedef struct drm_mga_vertex {
3365 +       int idx;                /* buffer to queue */
3366 +       int used;               /* bytes in use */
3367 +       int discard;            /* client finished with buffer?  */
3368 +} drm_mga_vertex_t;
3369 +
3370 +typedef struct drm_mga_indices {
3371 +       int idx;                /* buffer to queue */
3372 +       unsigned int start;
3373 +       unsigned int end;
3374 +       int discard;            /* client finished with buffer?  */
3375 +} drm_mga_indices_t;
3376 +
3377 +typedef struct drm_mga_iload {
3378 +       int idx;
3379 +       unsigned int dstorg;
3380 +       unsigned int length;
3381 +} drm_mga_iload_t;
3382 +
3383 +typedef struct _drm_mga_blit {
3384 +       unsigned int planemask;
3385 +       unsigned int srcorg;
3386 +       unsigned int dstorg;
3387 +       int src_pitch, dst_pitch;
3388 +       int delta_sx, delta_sy;
3389 +       int delta_dx, delta_dy;
3390 +       int height, ydir;       /* flip image vertically */
3391 +       int source_pitch, dest_pitch;
3392 +} drm_mga_blit_t;
3393 +
3394 +/* 3.1: An ioctl to get parameters that aren't available to the 3d
3395 + * client any other way.
3396 + */
3397 +#define MGA_PARAM_IRQ_NR            1
3398 +
3399 +/* 3.2: Query the actual card type.  The DDX only distinguishes between
3400 + * G200 chips and non-G200 chips, which it calls G400.  It turns out that
3401 + * there are some very sublte differences between the G4x0 chips and the G550
3402 + * chips.  Using this parameter query, a client-side driver can detect the
3403 + * difference between a G4x0 and a G550.
3404 + */
3405 +#define MGA_PARAM_CARD_TYPE         2
3406 +
3407 +typedef struct drm_mga_getparam {
3408 +       int param;
3409 +       void *value;
3410 +} drm_mga_getparam_t;
3411 +
3412 +#endif
3413 diff --git a/libc/kernel/common/drm/nouveau_drm.h b/libc/kernel/common/drm/nouveau_drm.h
3414 new file mode 100644
3415 index 0000000..2a5769f
3416 --- /dev/null
3417 +++ b/libc/kernel/common/drm/nouveau_drm.h
3418 @@ -0,0 +1,138 @@
3419 +/*
3420 + * Copyright 2005 Stephane Marchesin.
3421 + * All Rights Reserved.
3422 + *
3423 + * Permission is hereby granted, free of charge, to any person obtaining a
3424 + * copy of this software and associated documentation files (the "Software"),
3425 + * to deal in the Software without restriction, including without limitation
3426 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
3427 + * and/or sell copies of the Software, and to permit persons to whom the
3428 + * Software is furnished to do so, subject to the following conditions:
3429 + *
3430 + * The above copyright notice and this permission notice (including the next
3431 + * paragraph) shall be included in all copies or substantial portions of the
3432 + * Software.
3433 + *
3434 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3435 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3436 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
3437 + * VA LINUX SYSTEMS AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
3438 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
3439 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
3440 + * OTHER DEALINGS IN THE SOFTWARE.
3441 + */
3442 +
3443 +#ifndef __NOUVEAU_DRM_H__
3444 +#define __NOUVEAU_DRM_H__
3445 +
3446 +#define NOUVEAU_GEM_DOMAIN_CPU       (1 << 0)
3447 +#define NOUVEAU_GEM_DOMAIN_VRAM      (1 << 1)
3448 +#define NOUVEAU_GEM_DOMAIN_GART      (1 << 2)
3449 +#define NOUVEAU_GEM_DOMAIN_MAPPABLE  (1 << 3)
3450 +
3451 +#define NOUVEAU_GEM_TILE_COMP        0x00030000 /* nv50-only */
3452 +#define NOUVEAU_GEM_TILE_LAYOUT_MASK 0x0000ff00
3453 +#define NOUVEAU_GEM_TILE_16BPP       0x00000001
3454 +#define NOUVEAU_GEM_TILE_32BPP       0x00000002
3455 +#define NOUVEAU_GEM_TILE_ZETA        0x00000004
3456 +#define NOUVEAU_GEM_TILE_NONCONTIG   0x00000008
3457 +
3458 +struct drm_nouveau_gem_info {
3459 +       uint32_t handle;
3460 +       uint32_t domain;
3461 +       uint64_t size;
3462 +       uint64_t offset;
3463 +       uint64_t map_handle;
3464 +       uint32_t tile_mode;
3465 +       uint32_t tile_flags;
3466 +};
3467 +
3468 +struct drm_nouveau_gem_new {
3469 +       struct drm_nouveau_gem_info info;
3470 +       uint32_t channel_hint;
3471 +       uint32_t align;
3472 +};
3473 +
3474 +#define NOUVEAU_GEM_MAX_BUFFERS 1024
3475 +struct drm_nouveau_gem_pushbuf_bo_presumed {
3476 +       uint32_t valid;
3477 +       uint32_t domain;
3478 +       uint64_t offset;
3479 +};
3480 +
3481 +struct drm_nouveau_gem_pushbuf_bo {
3482 +       uint64_t user_priv;
3483 +       uint32_t handle;
3484 +       uint32_t read_domains;
3485 +       uint32_t write_domains;
3486 +       uint32_t valid_domains;
3487 +       struct drm_nouveau_gem_pushbuf_bo_presumed presumed;
3488 +};
3489 +
3490 +#define NOUVEAU_GEM_RELOC_LOW  (1 << 0)
3491 +#define NOUVEAU_GEM_RELOC_HIGH (1 << 1)
3492 +#define NOUVEAU_GEM_RELOC_OR   (1 << 2)
3493 +#define NOUVEAU_GEM_MAX_RELOCS 1024
3494 +struct drm_nouveau_gem_pushbuf_reloc {
3495 +       uint32_t reloc_bo_index;
3496 +       uint32_t reloc_bo_offset;
3497 +       uint32_t bo_index;
3498 +       uint32_t flags;
3499 +       uint32_t data;
3500 +       uint32_t vor;
3501 +       uint32_t tor;
3502 +};
3503 +
3504 +#define NOUVEAU_GEM_MAX_PUSH 512
3505 +struct drm_nouveau_gem_pushbuf_push {
3506 +       uint32_t bo_index;
3507 +       uint32_t pad;
3508 +       uint64_t offset;
3509 +       uint64_t length;
3510 +};
3511 +
3512 +struct drm_nouveau_gem_pushbuf {
3513 +       uint32_t channel;
3514 +       uint32_t nr_buffers;
3515 +       uint64_t buffers;
3516 +       uint32_t nr_relocs;
3517 +       uint32_t nr_push;
3518 +       uint64_t relocs;
3519 +       uint64_t push;
3520 +       uint32_t suffix0;
3521 +       uint32_t suffix1;
3522 +       uint64_t vram_available;
3523 +       uint64_t gart_available;
3524 +};
3525 +
3526 +#define NOUVEAU_GEM_CPU_PREP_NOWAIT                                  0x00000001
3527 +#define NOUVEAU_GEM_CPU_PREP_WRITE                                   0x00000004
3528 +struct drm_nouveau_gem_cpu_prep {
3529 +       uint32_t handle;
3530 +       uint32_t flags;
3531 +};
3532 +
3533 +struct drm_nouveau_gem_cpu_fini {
3534 +       uint32_t handle;
3535 +};
3536 +
3537 +#define DRM_NOUVEAU_GETPARAM           0x00 /* deprecated */
3538 +#define DRM_NOUVEAU_SETPARAM           0x01 /* deprecated */
3539 +#define DRM_NOUVEAU_CHANNEL_ALLOC      0x02 /* deprecated */
3540 +#define DRM_NOUVEAU_CHANNEL_FREE       0x03 /* deprecated */
3541 +#define DRM_NOUVEAU_GROBJ_ALLOC        0x04 /* deprecated */
3542 +#define DRM_NOUVEAU_NOTIFIEROBJ_ALLOC  0x05 /* deprecated */
3543 +#define DRM_NOUVEAU_GPUOBJ_FREE        0x06 /* deprecated */
3544 +#define DRM_NOUVEAU_GEM_NEW            0x40
3545 +#define DRM_NOUVEAU_GEM_PUSHBUF        0x41
3546 +#define DRM_NOUVEAU_GEM_CPU_PREP       0x42
3547 +#define DRM_NOUVEAU_GEM_CPU_FINI       0x43
3548 +#define DRM_NOUVEAU_GEM_INFO           0x44
3549 +
3550 +#define DRM_IOCTL_NOUVEAU_GEM_NEW            DRM_IOWR(DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_NEW, struct drm_nouveau_gem_new)
3551 +#define DRM_IOCTL_NOUVEAU_GEM_PUSHBUF        DRM_IOWR(DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_PUSHBUF, struct drm_nouveau_gem_pushbuf)
3552 +#define DRM_IOCTL_NOUVEAU_GEM_CPU_PREP       DRM_IOW (DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_CPU_PREP, struct drm_nouveau_gem_cpu_prep)
3553 +#define DRM_IOCTL_NOUVEAU_GEM_CPU_FINI       DRM_IOW (DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_CPU_FINI, struct drm_nouveau_gem_cpu_fini)
3554 +#define DRM_IOCTL_NOUVEAU_GEM_INFO           DRM_IOWR(DRM_COMMAND_BASE + DRM_NOUVEAU_GEM_INFO, struct drm_nouveau_gem_info)
3555 +
3556 +#endif /* __NOUVEAU_DRM_H__ */
3557 diff --git a/libc/kernel/common/drm/r128_drm.h b/libc/kernel/common/drm/r128_drm.h
3558 new file mode 100644
3559 index 0000000..ede78ff
3560 --- /dev/null
3561 +++ b/libc/kernel/common/drm/r128_drm.h
3562 @@ -0,0 +1,326 @@
3563 +/* r128_drm.h -- Public header for the r128 driver -*- linux-c -*-
3564 + * Created: Wed Apr  5 19:24:19 2000 by kevin@precisioninsight.com
3565 + */
3566 +/*
3567 + * Copyright 2000 Precision Insight, Inc., Cedar Park, Texas.
3568 + * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
3569 + * All rights reserved.
3570 + *
3571 + * Permission is hereby granted, free of charge, to any person obtaining a
3572 + * copy of this software and associated documentation files (the "Software"),
3573 + * to deal in the Software without restriction, including without limitation
3574 + * the rights to use, copy, modify, merge, publish, distribute, sublicense,
3575 + * and/or sell copies of the Software, and to permit persons to whom the
3576 + * Software is furnished to do so, subject to the following conditions:
3577 + *
3578 + * The above copyright notice and this permission notice (including the next
3579 + * paragraph) shall be included in all copies or substantial portions of the
3580 + * Software.
3581 + *
3582 + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
3583 + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
3584 + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
3585 + * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
3586 + * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
3587 + * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
3588 + * DEALINGS IN THE SOFTWARE.
3589 + *
3590 + * Authors:
3591 + *    Gareth Hughes <gareth@valinux.com>
3592 + *    Kevin E. Martin <martin@valinux.com>
3593 + */
3594 +
3595 +#ifndef __R128_DRM_H__
3596 +#define __R128_DRM_H__
3597 +
3598 +/* WARNING: If you change any of these defines, make sure to change the
3599 + * defines in the X server file (r128_sarea.h)
3600 + */
3601 +#ifndef __R128_SAREA_DEFINES__
3602 +#define __R128_SAREA_DEFINES__
3603 +
3604 +/* What needs to be changed for the current vertex buffer?
3605 + */
3606 +#define R128_UPLOAD_CONTEXT            0x001
3607 +#define R128_UPLOAD_SETUP              0x002
3608 +#define R128_UPLOAD_TEX0               0x004
3609 +#define R128_UPLOAD_TEX1               0x008
3610 +#define R128_UPLOAD_TEX0IMAGES         0x010
3611 +#define R128_UPLOAD_TEX1IMAGES         0x020
3612 +#define R128_UPLOAD_CORE               0x040
3613 +#define R128_UPLOAD_MASKS              0x080
3614 +#define R128_UPLOAD_WINDOW             0x100
3615 +#define R128_UPLOAD_CLIPRECTS          0x200   /* handled client-side */
3616 +#define R128_REQUIRE_QUIESCENCE                0x400
3617 +#define R128_UPLOAD_ALL                        0x7ff
3618 +
3619 +#define R128_FRONT                     0x1
3620 +#define R128_BACK                      0x2
3621 +#define R128_DEPTH                     0x4
3622 +
3623 +/* Primitive types
3624 + */
3625 +#define R128_POINTS                    0x1
3626 +#define R128_LINES                     0x2
3627 +#define R128_LINE_STRIP                        0x3
3628 +#define R128_TRIANGLES                 0x4
3629 +#define R128_TRIANGLE_FAN              0x5
3630 +#define R128_TRIANGLE_STRIP            0x6
3631 +
3632 +/* Vertex/indirect buffer size
3633 + */
3634 +#define R128_BUFFER_SIZE               16384
3635 +
3636 +/* Byte offsets for indirect buffer data
3637 + */
3638 +#define R128_INDEX_PRIM_OFFSET         20
3639 +#define R128_HOSTDATA_BLIT_OFFSET      32
3640 +
3641 +/* Keep these small for testing.
3642 + */
3643 +#define R128_NR_SAREA_CLIPRECTS                12
3644 +
3645 +/* There are 2 heaps (local/AGP).  Each region within a heap is a
3646 + *  minimum of 64k, and there are at most 64 of them per heap.
3647 + */
3648 +#define R128_LOCAL_TEX_HEAP            0
3649 +#define R128_AGP_TEX_HEAP              1
3650 +#define R128_NR_TEX_HEAPS              2
3651 +#define R128_NR_TEX_REGIONS            64
3652 +#define R128_LOG_TEX_GRANULARITY       16
3653 +
3654 +#define R128_NR_CONTEXT_REGS           12
3655 +
3656 +#define R128_MAX_TEXTURE_LEVELS                11
3657 +#define R128_MAX_TEXTURE_UNITS         2
3658 +
3659 +#endif                         /* __R128_SAREA_DEFINES__ */
3660 +
3661 +typedef struct {
3662 +       /* Context state - can be written in one large chunk */
3663 +       unsigned int dst_pitch_offset_c;
3664 +       unsigned int dp_gui_master_cntl_c;
3665 +       unsigned int sc_top_left_c;
3666 +       unsigned int sc_bottom_right_c;
3667 +       unsigned int z_offset_c;
3668 +       unsigned int z_pitch_c;
3669 +       unsigned int z_sten_cntl_c;
3670 +       unsigned int tex_cntl_c;
3671 +       unsigned int misc_3d_state_cntl_reg;
3672 +       unsigned int texture_clr_cmp_clr_c;
3673 +       unsigned int texture_clr_cmp_msk_c;
3674 +       unsigned int fog_color_c;
3675 +
3676 +       /* Texture state */
3677 +       unsigned int tex_size_pitch_c;
3678 +       unsigned int constant_color_c;
3679 +
3680 +       /* Setup state */
3681 +       unsigned int pm4_vc_fpu_setup;
3682 +       unsigned int setup_cntl;
3683 +
3684 +       /* Mask state */
3685 +       unsigned int dp_write_mask;
3686 +       unsigned int sten_ref_mask_c;
3687 +       unsigned int plane_3d_mask_c;
3688 +
3689 +       /* Window state */
3690 +       unsigned int window_xy_offset;
3691 +
3692 +       /* Core state */
3693 +       unsigned int scale_3d_cntl;
3694 +} drm_r128_context_regs_t;
3695 +
3696 +/* Setup registers for each texture unit
3697 + */
3698 +typedef struct {
3699 +       unsigned int tex_cntl;
3700 +       unsigned int tex_combine_cntl;
3701 +       unsigned int tex_size_pitch;
3702 +       unsigned int tex_offset[R128_MAX_TEXTURE_LEVELS];
3703 +       unsigned int tex_border_color;
3704 +} drm_r128_texture_regs_t;
3705 +
3706 +typedef struct drm_r128_sarea {
3707 +       /* The channel for communication of state information to the kernel
3708 +        * on firing a vertex buffer.
3709 +        */
3710 +       drm_r128_context_regs_t context_state;
3711 +       drm_r128_texture_regs_t tex_state[R128_MAX_TEXTURE_UNITS];
3712 +       unsigned int dirty;
3713 +       unsigned int vertsize;
3714 +       unsigned int vc_format;
3715 +
3716 +       /* The current cliprects, or a subset thereof.
3717 +        */
3718 +       struct drm_clip_rect boxes[R128_NR_SAREA_CLIPRECTS];
3719 +       unsigned int nbox;
3720 +
3721 +       /* Counters for client-side throttling of rendering clients.
3722 +        */
3723 +       unsigned int last_frame;
3724 +       unsigned int last_dispatch;
3725 +
3726 +       struct drm_tex_region tex_list[R128_NR_TEX_HEAPS][R128_NR_TEX_REGIONS + 1];
3727 +       unsigned int tex_age[R128_NR_TEX_HEAPS];
3728 +       int ctx_owner;
3729 +       int pfAllowPageFlip;    /* number of 3d windows (0,1,2 or more) */
3730 +       int pfCurrentPage;      /* which buffer is being displayed? */
3731 +} drm_r128_sarea_t;
3732 +
3733 +/* WARNING: If you change any of these defines, make sure to change the
3734 + * defines in the Xserver file (xf86drmR128.h)
3735 + */
3736 +
3737 +/* Rage 128 specific ioctls
3738 + * The device specific ioctl range is 0x40 to 0x79.
3739 + */
3740 +#define DRM_R128_INIT       0x00
3741 +#define DRM_R128_CCE_START  0x01
3742 +#define DRM_R128_CCE_STOP   0x02
3743 +#define DRM_R128_CCE_RESET  0x03
3744 +#define DRM_R128_CCE_IDLE   0x04
3745 +/* 0x05 not used */
3746 +#define DRM_R128_RESET      0x06
3747 +#define DRM_R128_SWAP       0x07
3748 +#define DRM_R128_CLEAR      0x08
3749 +#define DRM_R128_VERTEX     0x09
3750 +#define DRM_R128_INDICES    0x0a
3751 +#define DRM_R128_BLIT       0x0b
3752 +#define DRM_R128_DEPTH      0x0c
3753 +#define DRM_R128_STIPPLE    0x0d
3754 +/* 0x0e not used */
3755 +#define DRM_R128_INDIRECT   0x0f
3756 +#define DRM_R128_FULLSCREEN 0x10
3757 +#define DRM_R128_CLEAR2     0x11
3758 +#define DRM_R128_GETPARAM   0x12
3759 +#define DRM_R128_FLIP       0x13
3760 +
3761 +#define DRM_IOCTL_R128_INIT       DRM_IOW( DRM_COMMAND_BASE + DRM_R128_INIT, drm_r128_init_t)
3762 +#define DRM_IOCTL_R128_CCE_START  DRM_IO(  DRM_COMMAND_BASE + DRM_R128_CCE_START)
3763 +#define DRM_IOCTL_R128_CCE_STOP   DRM_IOW( DRM_COMMAND_BASE + DRM_R128_CCE_STOP, drm_r128_cce_stop_t)
3764 +#define DRM_IOCTL_R128_CCE_RESET  DRM_IO(  DRM_COMMAND_BASE + DRM_R128_CCE_RESET)
3765 +#define DRM_IOCTL_R128_CCE_IDLE   DRM_IO(  DRM_COMMAND_BASE + DRM_R128_CCE_IDLE)
3766 +/* 0x05 not used */
3767 +#define DRM_IOCTL_R128_RESET      DRM_IO(  DRM_COMMAND_BASE + DRM_R128_RESET)
3768 +#define DRM_IOCTL_R128_SWAP       DRM_IO(  DRM_COMMAND_BASE + DRM_R128_SWAP)
3769 +#define DRM_IOCTL_R128_CLEAR      DRM_IOW( DRM_COMMAND_BASE + DRM_R128_CLEAR, drm_r128_clear_t)
3770 +#define DRM_IOCTL_R128_VERTEX     DRM_IOW( DRM_COMMAND_BASE + DRM_R128_VERTEX, drm_r128_vertex_t)
3771 +#define DRM_IOCTL_R128_INDICES    DRM_IOW( DRM_COMMAND_BASE + DRM_R128_INDICES, drm_r128_indices_t)
3772 +#define DRM_IOCTL_R128_BLIT       DRM_IOW( DRM_COMMAND_BASE + DRM_R128_BLIT, drm_r128_blit_t)
3773 +#define DRM_IOCTL_R128_DEPTH      DRM_IOW( DRM_COMMAND_BASE + DRM_R128_DEPTH, drm_r128_depth_t)
3774 +#define DRM_IOCTL_R128_STIPPLE    DRM_IOW( DRM_COMMAND_BASE + DRM_R128_STIPPLE, drm_r128_stipple_t)
3775 +/* 0x0e not used */
3776 +#define DRM_IOCTL_R128_INDIRECT   DRM_IOWR(DRM_COMMAND_BASE + DRM_R128_INDIRECT, drm_r128_indirect_t)
3777 +#define DRM_IOCTL_R128_FULLSCREEN DRM_IOW( DRM_COMMAND_BASE + DRM_R128_FULLSCREEN, drm_r128_fullscreen_t)
3778 +#define DRM_IOCTL_R128_CLEAR2     DRM_IOW( DRM_COMMAND_BASE + DRM_R128_CLEAR2, drm_r128_clear2_t)
3779 +#define DRM_IOCTL_R128_GETPARAM   DRM_IOWR( DRM_COMMAND_BASE + DRM_R128_GETPARAM, drm_r128_getparam_t)
3780 +#define DRM_IOCTL_R128_FLIP       DRM_IO(  DRM_COMMAND_BASE + DRM_R128_FLIP)
3781 +
3782 +typedef struct drm_r128_init {
3783 +       enum {
3784 +               R128_INIT_CCE = 0x01,
3785 +               R128_CLEANUP_CCE = 0x02
3786 +       } func;
3787 +       unsigned long sarea_priv_offset;
3788 +       int is_pci;
3789 +       int cce_mode;
3790 +       int cce_secure;
3791 +       int ring_size;
3792 +       int usec_timeout;
3793 +
3794 +       unsigned int fb_bpp;
3795 +       unsigned int front_offset, front_pitch;
3796 +       unsigned int back_offset, back_pitch;
3797 +       unsigned int depth_bpp;
3798 +       unsigned int depth_offset, depth_pitch;
3799 +       unsigned int span_offset;
3800 +
3801 +       unsigned long fb_offset;
3802 +       unsigned long mmio_offset;
3803 +       unsigned long ring_offset;
3804 +       unsigned long ring_rptr_offset;
3805 +       unsigned long buffers_offset;
3806 +       unsigned long agp_textures_offset;
3807 +} drm_r128_init_t;
3808 +
3809 +typedef struct drm_r128_cce_stop {
3810 +       int flush;
3811 +       int idle;
3812 +} drm_r128_cce_stop_t;
3813 +
3814 +typedef struct drm_r128_clear {
3815 +       unsigned int flags;
3816 +       unsigned int clear_color;
3817 +       unsigned int clear_depth;
3818 +       unsigned int color_mask;
3819 +       unsigned int depth_mask;
3820 +} drm_r128_clear_t;
3821 +
3822 +typedef struct drm_r128_vertex {
3823 +       int prim;
3824 +       int idx;                /* Index of vertex buffer */
3825 +       int count;              /* Number of vertices in buffer */
3826 +       int discard;            /* Client finished with buffer? */
3827 +} drm_r128_vertex_t;
3828 +
3829 +typedef struct drm_r128_indices {
3830 +       int prim;
3831 +       int idx;
3832 +       int start;
3833 +       int end;
3834 +       int discard;            /* Client finished with buffer? */
3835 +} drm_r128_indices_t;
3836 +
3837 +typedef struct drm_r128_blit {
3838 +       int idx;
3839 +       int pitch;
3840 +       int offset;
3841 +       int format;
3842 +       unsigned short x, y;
3843 +       unsigned short width, height;
3844 +} drm_r128_blit_t;
3845 +
3846 +typedef struct drm_r128_depth {
3847 +       enum {
3848 +               R128_WRITE_SPAN = 0x01,
3849 +               R128_WRITE_PIXELS = 0x02,
3850 +               R128_READ_SPAN = 0x03,
3851 +               R128_READ_PIXELS = 0x04
3852 +       } func;
3853 +       int n;
3854 +       int *x;
3855 +       int *y;
3856 +       unsigned int *buffer;
3857 +       unsigned char *mask;
3858 +} drm_r128_depth_t;
3859 +
3860 +typedef struct drm_r128_stipple {
3861 +       unsigned int *mask;
3862 +} drm_r128_stipple_t;
3863 +
3864 +typedef struct drm_r128_indirect {
3865 +       int idx;
3866 +       int start;
3867 +       int end;
3868 +       int discard;
3869 +} drm_r128_indirect_t;
3870 +
3871 +typedef struct drm_r128_fullscreen {
3872 +       enum {