1/**
2 * \file xf86drm.h
3 * OS-independent header for DRM user-level library interface.
4 *
5 * \author Rickard E. (Rik) Faith <faith@valinux.com>
6 */
7
8/*
9 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.
10 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
11 * All Rights Reserved.
12 *
13 * Permission is hereby granted, free of charge, to any person obtaining a
14 * copy of this software and associated documentation files (the "Software"),
15 * to deal in the Software without restriction, including without limitation
16 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
17 * and/or sell copies of the Software, and to permit persons to whom the
18 * Software is furnished to do so, subject to the following conditions:
19 *
20 * The above copyright notice and this permission notice (including the next
21 * paragraph) shall be included in all copies or substantial portions of the
22 * Software.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
27 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
28 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
29 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
30 * DEALINGS IN THE SOFTWARE.
31 *
32 */
33
34#ifndef _XF86DRM_H_
35#define _XF86DRM_H_
36
37#include <stdarg.h>
38#include <sys/types.h>
39#include <stdint.h>
40#include <drm.h>
41
42#if defined(__cplusplus)
43extern "C" {
44#endif
45
46#ifndef DRM_MAX_MINOR
47#define DRM_MAX_MINOR 16
48#endif
49
50#if defined(__linux__)
51
52#define DRM_IOCTL_NR(n) _IOC_NR(n)
53#define DRM_IOC_VOID _IOC_NONE
54#define DRM_IOC_READ _IOC_READ
55#define DRM_IOC_WRITE _IOC_WRITE
56#define DRM_IOC_READWRITE _IOC_READ|_IOC_WRITE
57#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
58
59#else /* One of the *BSDs */
60
61#include <sys/ioccom.h>
62#define DRM_IOCTL_NR(n) ((n) & 0xff)
63#define DRM_IOC_VOID IOC_VOID
64#define DRM_IOC_READ IOC_OUT
65#define DRM_IOC_WRITE IOC_IN
66#define DRM_IOC_READWRITE IOC_INOUT
67#define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)
68
69#endif
70
71 /* Defaults, if nothing set in xf86config */
72#define DRM_DEV_UID 0
73#define DRM_DEV_GID 0
74/* Default /dev/dri directory permissions 0755 */
75#define DRM_DEV_DIRMODE \
76 (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)
77#define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
78
79#ifdef __OpenBSD__
80#define DRM_DIR_NAME "/dev"
81#define DRM_PRIMARY_MINOR_NAME "drm"
82#define DRM_CONTROL_MINOR_NAME "drmC"
83#define DRM_RENDER_MINOR_NAME "drmR"
84#else
85#define DRM_DIR_NAME "/dev/dri"
86#define DRM_PRIMARY_MINOR_NAME "card"
87#define DRM_CONTROL_MINOR_NAME "controlD"
88#define DRM_RENDER_MINOR_NAME "renderD"
89#define DRM_PROC_NAME "/proc/dri/" /* For backward Linux compatibility */
90#endif
91
92#define DRM_DEV_NAME "%s/" DRM_PRIMARY_MINOR_NAME "%d"
93#define DRM_CONTROL_DEV_NAME "%s/" DRM_CONTROL_MINOR_NAME "%d"
94#define DRM_RENDER_DEV_NAME "%s/" DRM_RENDER_MINOR_NAME "%d"
95
96#define DRM_NODE_NAME_MAX \
97 (sizeof(DRM_DIR_NAME) + 1 /* slash */ \
98 + MAX3(sizeof(DRM_PRIMARY_MINOR_NAME), \
99 sizeof(DRM_CONTROL_MINOR_NAME), \
100 sizeof(DRM_RENDER_MINOR_NAME)) \
101 + sizeof("144") /* highest possible node number */ \
102 + 1) /* NULL-terminator */
103
104#define DRM_ERR_NO_DEVICE (-1001)
105#define DRM_ERR_NO_ACCESS (-1002)
106#define DRM_ERR_NOT_ROOT (-1003)
107#define DRM_ERR_INVALID (-1004)
108#define DRM_ERR_NO_FD (-1005)
109
110#define DRM_AGP_NO_HANDLE 0
111
112typedef unsigned int drmSize, *drmSizePtr; /**< For mapped regions */
113typedef void *drmAddress, **drmAddressPtr; /**< For mapped regions */
114
115#if (__GNUC__ >= 3)
116#define DRM_PRINTFLIKE(f, a) __attribute__ ((format(__printf__, f, a)))
117#else
118#define DRM_PRINTFLIKE(f, a)
119#endif
120
121typedef struct _drmServerInfo {
122 int (*debug_print)(const char *format, va_list ap) DRM_PRINTFLIKE(1,0);
123 int (*load_module)(const char *name);
124 void (*get_perms)(gid_t *, mode_t *);
125} drmServerInfo, *drmServerInfoPtr;
126
127typedef struct drmHashEntry {
128 int fd;
129 void (*f)(int, void *, void *);
130 void *tagTable;
131} drmHashEntry;
132
133extern int drmIoctl(int fd, unsigned long request, void *arg);
134extern void *drmGetHashTable(void);
135extern drmHashEntry *drmGetEntry(int fd);
136
137/**
138 * Driver version information.
139 *
140 * \sa drmGetVersion() and drmSetVersion().
141 */
142typedef struct _drmVersion {
143 int version_major; /**< Major version */
144 int version_minor; /**< Minor version */
145 int version_patchlevel; /**< Patch level */
146 int name_len; /**< Length of name buffer */
147 char *name; /**< Name of driver */
148 int date_len; /**< Length of date buffer */
149 char *date; /**< User-space buffer to hold date */
150 int desc_len; /**< Length of desc buffer */
151 char *desc; /**< User-space buffer to hold desc */
152} drmVersion, *drmVersionPtr;
153
154typedef struct _drmStats {
155 unsigned long count; /**< Number of data */
156 struct {
157 unsigned long value; /**< Value from kernel */
158 const char *long_format; /**< Suggested format for long_name */
159 const char *long_name; /**< Long name for value */
160 const char *rate_format; /**< Suggested format for rate_name */
161 const char *rate_name; /**< Short name for value per second */
162 int isvalue; /**< True if value (vs. counter) */
163 const char *mult_names; /**< Multiplier names (e.g., "KGM") */
164 int mult; /**< Multiplier value (e.g., 1024) */
165 int verbose; /**< Suggest only in verbose output */
166 } data[15];
167} drmStatsT;
168
169
170 /* All of these enums *MUST* match with the
171 kernel implementation -- so do *NOT*
172 change them! (The drmlib implementation
173 will just copy the flags instead of
174 translating them.) */
175typedef enum {
176 DRM_FRAME_BUFFER = 0, /**< WC, no caching, no core dump */
177 DRM_REGISTERS = 1, /**< no caching, no core dump */
178 DRM_SHM = 2, /**< shared, cached */
179 DRM_AGP = 3, /**< AGP/GART */
180 DRM_SCATTER_GATHER = 4, /**< PCI scatter/gather */
181 DRM_CONSISTENT = 5 /**< PCI consistent */
182} drmMapType;
183
184typedef enum {
185 DRM_RESTRICTED = 0x0001, /**< Cannot be mapped to client-virtual */
186 DRM_READ_ONLY = 0x0002, /**< Read-only in client-virtual */
187 DRM_LOCKED = 0x0004, /**< Physical pages locked */
188 DRM_KERNEL = 0x0008, /**< Kernel requires access */
189 DRM_WRITE_COMBINING = 0x0010, /**< Use write-combining, if available */
190 DRM_CONTAINS_LOCK = 0x0020, /**< SHM page that contains lock */
191 DRM_REMOVABLE = 0x0040 /**< Removable mapping */
192} drmMapFlags;
193
194/**
195 * \warning These values *MUST* match drm.h
196 */
197typedef enum {
198 /** \name Flags for DMA buffer dispatch */
199 /*@{*/
200 DRM_DMA_BLOCK = 0x01, /**<
201 * Block until buffer dispatched.
202 *
203 * \note the buffer may not yet have been
204 * processed by the hardware -- getting a
205 * hardware lock with the hardware quiescent
206 * will ensure that the buffer has been
207 * processed.
208 */
209 DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */
210 DRM_DMA_PRIORITY = 0x04, /**< High priority dispatch */
211 /*@}*/
212
213 /** \name Flags for DMA buffer request */
214 /*@{*/
215 DRM_DMA_WAIT = 0x10, /**< Wait for free buffers */
216 DRM_DMA_SMALLER_OK = 0x20, /**< Smaller-than-requested buffers OK */
217 DRM_DMA_LARGER_OK = 0x40 /**< Larger-than-requested buffers OK */
218 /*@}*/
219} drmDMAFlags;
220
221typedef enum {
222 DRM_PAGE_ALIGN = 0x01,
223 DRM_AGP_BUFFER = 0x02,
224 DRM_SG_BUFFER = 0x04,
225 DRM_FB_BUFFER = 0x08,
226 DRM_PCI_BUFFER_RO = 0x10
227} drmBufDescFlags;
228
229typedef enum {
230 DRM_LOCK_READY = 0x01, /**< Wait until hardware is ready for DMA */
231 DRM_LOCK_QUIESCENT = 0x02, /**< Wait until hardware quiescent */
232 DRM_LOCK_FLUSH = 0x04, /**< Flush this context's DMA queue first */
233 DRM_LOCK_FLUSH_ALL = 0x08, /**< Flush all DMA queues first */
234 /* These *HALT* flags aren't supported yet
235 -- they will be used to support the
236 full-screen DGA-like mode. */
237 DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */
238 DRM_HALT_CUR_QUEUES = 0x20 /**< Halt all current queues */
239} drmLockFlags;
240
241typedef enum {
242 DRM_CONTEXT_PRESERVED = 0x01, /**< This context is preserved and
243 never swapped. */
244 DRM_CONTEXT_2DONLY = 0x02 /**< This context is for 2D rendering only. */
245} drm_context_tFlags, *drm_context_tFlagsPtr;
246
247typedef struct _drmBufDesc {
248 int count; /**< Number of buffers of this size */
249 int size; /**< Size in bytes */
250 int low_mark; /**< Low water mark */
251 int high_mark; /**< High water mark */
252} drmBufDesc, *drmBufDescPtr;
253
254typedef struct _drmBufInfo {
255 int count; /**< Number of buffers described in list */
256 drmBufDescPtr list; /**< List of buffer descriptions */
257} drmBufInfo, *drmBufInfoPtr;
258
259typedef struct _drmBuf {
260 int idx; /**< Index into the master buffer list */
261 int total; /**< Buffer size */
262 int used; /**< Amount of buffer in use (for DMA) */
263 drmAddress address; /**< Address */
264} drmBuf, *drmBufPtr;
265
266/**
267 * Buffer mapping information.
268 *
269 * Used by drmMapBufs() and drmUnmapBufs() to store information about the
270 * mapped buffers.
271 */
272typedef struct _drmBufMap {
273 int count; /**< Number of buffers mapped */
274 drmBufPtr list; /**< Buffers */
275} drmBufMap, *drmBufMapPtr;
276
277typedef struct _drmLock {
278 volatile unsigned int lock;
279 char padding[60];
280 /* This is big enough for most current (and future?) architectures:
281 DEC Alpha: 32 bytes
282 Intel Merced: ?
283 Intel P5/PPro/PII/PIII: 32 bytes
284 Intel StrongARM: 32 bytes
285 Intel i386/i486: 16 bytes
286 MIPS: 32 bytes (?)
287 Motorola 68k: 16 bytes
288 Motorola PowerPC: 32 bytes
289 Sun SPARC: 32 bytes
290 */
291} drmLock, *drmLockPtr;
292
293/**
294 * Indices here refer to the offset into
295 * list in drmBufInfo
296 */
297typedef struct _drmDMAReq {
298 drm_context_t context; /**< Context handle */
299 int send_count; /**< Number of buffers to send */
300 int *send_list; /**< List of handles to buffers */
301 int *send_sizes; /**< Lengths of data to send, in bytes */
302 drmDMAFlags flags; /**< Flags */
303 int request_count; /**< Number of buffers requested */
304 int request_size; /**< Desired size of buffers requested */
305 int *request_list; /**< Buffer information */
306 int *request_sizes; /**< Minimum acceptable sizes */
307 int granted_count; /**< Number of buffers granted at this size */
308} drmDMAReq, *drmDMAReqPtr;
309
310typedef struct _drmRegion {
311 drm_handle_t handle;
312 unsigned int offset;
313 drmSize size;
314 drmAddress map;
315} drmRegion, *drmRegionPtr;
316
317typedef struct _drmTextureRegion {
318 unsigned char next;
319 unsigned char prev;
320 unsigned char in_use;
321 unsigned char padding; /**< Explicitly pad this out */
322 unsigned int age;
323} drmTextureRegion, *drmTextureRegionPtr;
324
325
326typedef enum {
327 DRM_VBLANK_ABSOLUTE = 0x0, /**< Wait for specific vblank sequence number */
328 DRM_VBLANK_RELATIVE = 0x1, /**< Wait for given number of vblanks */
329 /* bits 1-6 are reserved for high crtcs */
330 DRM_VBLANK_HIGH_CRTC_MASK = 0x0000003e,
331 DRM_VBLANK_EVENT = 0x4000000, /**< Send event instead of blocking */
332 DRM_VBLANK_FLIP = 0x8000000, /**< Scheduled buffer swap should flip */
333 DRM_VBLANK_NEXTONMISS = 0x10000000, /**< If missed, wait for next vblank */
334 DRM_VBLANK_SECONDARY = 0x20000000, /**< Secondary display controller */
335 DRM_VBLANK_SIGNAL = 0x40000000 /* Send signal instead of blocking */
336} drmVBlankSeqType;
337#define DRM_VBLANK_HIGH_CRTC_SHIFT 1
338
339typedef struct _drmVBlankReq {
340 drmVBlankSeqType type;
341 unsigned int sequence;
342 unsigned long signal;
343} drmVBlankReq, *drmVBlankReqPtr;
344
345typedef struct _drmVBlankReply {
346 drmVBlankSeqType type;
347 unsigned int sequence;
348 long tval_sec;
349 long tval_usec;
350} drmVBlankReply, *drmVBlankReplyPtr;
351
352typedef union _drmVBlank {
353 drmVBlankReq request;
354 drmVBlankReply reply;
355} drmVBlank, *drmVBlankPtr;
356
357typedef struct _drmSetVersion {
358 int drm_di_major;
359 int drm_di_minor;
360 int drm_dd_major;
361 int drm_dd_minor;
362} drmSetVersion, *drmSetVersionPtr;
363
364#define __drm_dummy_lock(lock) (*(__volatile__ unsigned int *)lock)
365
366#define DRM_LOCK_HELD 0x80000000U /**< Hardware lock is held */
367#define DRM_LOCK_CONT 0x40000000U /**< Hardware lock is contended */
368
369#if defined(__GNUC__) && (__GNUC__ >= 2)
370# if defined(__i386) || defined(__AMD64__) || defined(__x86_64__) || defined(__amd64__)
371 /* Reflect changes here to drmP.h */
372#define DRM_CAS(lock,old,new,__ret) \
373 do { \
374 int __dummy; /* Can't mark eax as clobbered */ \
375 __asm__ __volatile__( \
376 "lock ; cmpxchg %4,%1\n\t" \
377 "setnz %0" \
378 : "=d" (__ret), \
379 "=m" (__drm_dummy_lock(lock)), \
380 "=a" (__dummy) \
381 : "2" (old), \
382 "r" (new)); \
383 } while (0)
384
385#elif defined(__alpha__)
386
387#define DRM_CAS(lock, old, new, ret) \
388 do { \
389 int tmp, old32; \
390 __asm__ __volatile__( \
391 " addl $31, %5, %3\n" \
392 "1: ldl_l %0, %2\n" \
393 " cmpeq %0, %3, %1\n" \
394 " beq %1, 2f\n" \
395 " mov %4, %0\n" \
396 " stl_c %0, %2\n" \
397 " beq %0, 3f\n" \
398 " mb\n" \
399 "2: cmpeq %1, 0, %1\n" \
400 ".subsection 2\n" \
401 "3: br 1b\n" \
402 ".previous" \
403 : "=&r"(tmp), "=&r"(ret), \
404 "=m"(__drm_dummy_lock(lock)), \
405 "=&r"(old32) \
406 : "r"(new), "r"(old) \
407 : "memory"); \
408 } while (0)
409
410#elif defined(__sparc__)
411
412#define DRM_CAS(lock,old,new,__ret) \
413do { register unsigned int __old __asm("o0"); \
414 register unsigned int __new __asm("o1"); \
415 register volatile unsigned int *__lock __asm("o2"); \
416 __old = old; \
417 __new = new; \
418 __lock = (volatile unsigned int *)lock; \
419 __asm__ __volatile__( \
420 /*"cas [%2], %3, %0"*/ \
421 ".word 0xd3e29008\n\t" \
422 /*"membar #StoreStore | #StoreLoad"*/ \
423 ".word 0x8143e00a" \
424 : "=&r" (__new) \
425 : "0" (__new), \
426 "r" (__lock), \
427 "r" (__old) \
428 : "memory"); \
429 __ret = (__new != __old); \
430} while(0)
431
432#elif defined(__ia64__)
433
434#ifdef __INTEL_COMPILER
435/* this currently generates bad code (missing stop bits)... */
436#include <ia64intrin.h>
437
438#define DRM_CAS(lock,old,new,__ret) \
439 do { \
440 unsigned long __result, __old = (old) & 0xffffffff; \
441 __mf(); \
442 __result = _InterlockedCompareExchange_acq(&__drm_dummy_lock(lock), (new), __old);\
443 __ret = (__result) != (__old); \
444/* __ret = (__sync_val_compare_and_swap(&__drm_dummy_lock(lock), \
445 (old), (new)) \
446 != (old)); */\
447 } while (0)
448
449#else
450#define DRM_CAS(lock,old,new,__ret) \
451 do { \
452 unsigned int __result, __old = (old); \
453 __asm__ __volatile__( \
454 "mf\n" \
455 "mov ar.ccv=%2\n" \
456 ";;\n" \
457 "cmpxchg4.acq %0=%1,%3,ar.ccv" \
458 : "=r" (__result), "=m" (__drm_dummy_lock(lock)) \
459 : "r" ((unsigned long)__old), "r" (new) \
460 : "memory"); \
461 __ret = (__result) != (__old); \
462 } while (0)
463
464#endif
465
466#elif defined(__powerpc__)
467
468#define DRM_CAS(lock,old,new,__ret) \
469 do { \
470 __asm__ __volatile__( \
471 "sync;" \
472 "0: lwarx %0,0,%1;" \
473 " xor. %0,%3,%0;" \
474 " bne 1f;" \
475 " stwcx. %2,0,%1;" \
476 " bne- 0b;" \
477 "1: " \
478 "sync;" \
479 : "=&r"(__ret) \
480 : "r"(lock), "r"(new), "r"(old) \
481 : "cr0", "memory"); \
482 } while (0)
483
484# elif defined (__ARM_ARCH_6__) || defined(__ARM_ARCH_6J__) \
485 || defined (__ARM_ARCH_6Z__) || defined(__ARM_ARCH_6ZK__) \
486 || defined (__ARM_ARCH_6K__) || defined(__ARM_ARCH_6T2__) \
487 || defined (__ARM_ARCH_7__) || defined(__ARM_ARCH_7A__) \
488 || defined(__ARM_ARCH_7R__) || defined(__ARM_ARCH_7M__) \
489 || defined(__ARM_ARCH_7EM__)
490 /* excluding ARMv4/ARMv5 and lower (lacking ldrex/strex support) */
491 #undef DRM_DEV_MODE
492 #define DRM_DEV_MODE (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)
493
494 #define DRM_CAS(lock,old,new,__ret) \
495 do { \
496 __asm__ __volatile__ ( \
497 "1: ldrex %0, [%1]\n" \
498 " teq %0, %2\n" \
499 " ite eq\n" \
500 " strexeq %0, %3, [%1]\n" \
501 " movne %0, #1\n" \
502 : "=&r" (__ret) \
503 : "r" (lock), "r" (old), "r" (new) \
504 : "cc","memory"); \
505 } while (0)
506
507#endif /* architecture */
508#endif /* __GNUC__ >= 2 */
509
510#ifndef DRM_CAS
511#define DRM_CAS(lock,old,new,ret) do { ret=1; } while (0) /* FAST LOCK FAILS */
512#endif
513
514#if defined(__alpha__)
515#define DRM_CAS_RESULT(_result) long _result
516#elif defined(__powerpc__)
517#define DRM_CAS_RESULT(_result) int _result
518#else
519#define DRM_CAS_RESULT(_result) char _result
520#endif
521
522#define DRM_LIGHT_LOCK(fd,lock,context) \
523 do { \
524 DRM_CAS_RESULT(__ret); \
525 DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret); \
526 if (__ret) drmGetLock(fd,context,0); \
527 } while(0)
528
529 /* This one counts fast locks -- for
530 benchmarking only. */
531#define DRM_LIGHT_LOCK_COUNT(fd,lock,context,count) \
532 do { \
533 DRM_CAS_RESULT(__ret); \
534 DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret); \
535 if (__ret) drmGetLock(fd,context,0); \
536 else ++count; \
537 } while(0)
538
539#define DRM_LOCK(fd,lock,context,flags) \
540 do { \
541 if (flags) drmGetLock(fd,context,flags); \
542 else DRM_LIGHT_LOCK(fd,lock,context); \
543 } while(0)
544
545#define DRM_UNLOCK(fd,lock,context) \
546 do { \
547 DRM_CAS_RESULT(__ret); \
548 DRM_CAS(lock,DRM_LOCK_HELD|context,context,__ret); \
549 if (__ret) drmUnlock(fd,context); \
550 } while(0)
551
552 /* Simple spin locks */
553#define DRM_SPINLOCK(spin,val) \
554 do { \
555 DRM_CAS_RESULT(__ret); \
556 do { \
557 DRM_CAS(spin,0,val,__ret); \
558 if (__ret) while ((spin)->lock); \
559 } while (__ret); \
560 } while(0)
561
562#define DRM_SPINLOCK_TAKE(spin,val) \
563 do { \
564 DRM_CAS_RESULT(__ret); \
565 int cur; \
566 do { \
567 cur = (*spin).lock; \
568 DRM_CAS(spin,cur,val,__ret); \
569 } while (__ret); \
570 } while(0)
571
572#define DRM_SPINLOCK_COUNT(spin,val,count,__ret) \
573 do { \
574 int __i; \
575 __ret = 1; \
576 for (__i = 0; __ret && __i < count; __i++) { \
577 DRM_CAS(spin,0,val,__ret); \
578 if (__ret) for (;__i < count && (spin)->lock; __i++); \
579 } \
580 } while(0)
581
582#define DRM_SPINUNLOCK(spin,val) \
583 do { \
584 DRM_CAS_RESULT(__ret); \
585 if ((*spin).lock == val) { /* else server stole lock */ \
586 do { \
587 DRM_CAS(spin,val,0,__ret); \
588 } while (__ret); \
589 } \
590 } while(0)
591
592
593
594/* General user-level programmer's API: unprivileged */
595extern int drmAvailable(void);
596extern int drmOpen(const char *name, const char *busid);
597
598#define DRM_NODE_PRIMARY 0
599#define DRM_NODE_CONTROL 1
600#define DRM_NODE_RENDER 2
601#define DRM_NODE_MAX 3
602
603extern int drmOpenWithType(const char *name, const char *busid,
604 int type);
605
606extern int drmOpenControl(int minor);
607extern int drmOpenRender(int minor);
608extern int drmClose(int fd);
609extern drmVersionPtr drmGetVersion(int fd);
610extern drmVersionPtr drmGetLibVersion(int fd);
611extern int drmGetCap(int fd, uint64_t capability, uint64_t *value);
612extern void drmFreeVersion(drmVersionPtr);
613extern int drmGetMagic(int fd, drm_magic_t * magic);
614extern char *drmGetBusid(int fd);
615extern int drmGetInterruptFromBusID(int fd, int busnum, int devnum,
616 int funcnum);
617extern int drmGetMap(int fd, int idx, drm_handle_t *offset,
618 drmSize *size, drmMapType *type,
619 drmMapFlags *flags, drm_handle_t *handle,
620 int *mtrr);
621extern int drmGetClient(int fd, int idx, int *auth, int *pid,
622 int *uid, unsigned long *magic,
623 unsigned long *iocs);
624extern int drmGetStats(int fd, drmStatsT *stats);
625extern int drmSetInterfaceVersion(int fd, drmSetVersion *version);
626extern int drmCommandNone(int fd, unsigned long drmCommandIndex);
627extern int drmCommandRead(int fd, unsigned long drmCommandIndex,
628 void *data, unsigned long size);
629extern int drmCommandWrite(int fd, unsigned long drmCommandIndex,
630 void *data, unsigned long size);
631extern int drmCommandWriteRead(int fd, unsigned long drmCommandIndex,
632 void *data, unsigned long size);
633
634/* General user-level programmer's API: X server (root) only */
635extern void drmFreeBusid(const char *busid);
636extern int drmSetBusid(int fd, const char *busid);
637extern int drmAuthMagic(int fd, drm_magic_t magic);
638extern int drmAddMap(int fd,
639 drm_handle_t offset,
640 drmSize size,
641 drmMapType type,
642 drmMapFlags flags,
643 drm_handle_t * handle);
644extern int drmRmMap(int fd, drm_handle_t handle);
645extern int drmAddContextPrivateMapping(int fd, drm_context_t ctx_id,
646 drm_handle_t handle);
647
648extern int drmAddBufs(int fd, int count, int size,
649 drmBufDescFlags flags,
650 int agp_offset);
651extern int drmMarkBufs(int fd, double low, double high);
652extern int drmCreateContext(int fd, drm_context_t * handle);
653extern int drmSetContextFlags(int fd, drm_context_t context,
654 drm_context_tFlags flags);
655extern int drmGetContextFlags(int fd, drm_context_t context,
656 drm_context_tFlagsPtr flags);
657extern int drmAddContextTag(int fd, drm_context_t context, void *tag);
658extern int drmDelContextTag(int fd, drm_context_t context);
659extern void *drmGetContextTag(int fd, drm_context_t context);
660extern drm_context_t * drmGetReservedContextList(int fd, int *count);
661extern void drmFreeReservedContextList(drm_context_t *);
662extern int drmSwitchToContext(int fd, drm_context_t context);
663extern int drmDestroyContext(int fd, drm_context_t handle);
664extern int drmCreateDrawable(int fd, drm_drawable_t * handle);
665extern int drmDestroyDrawable(int fd, drm_drawable_t handle);
666extern int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
667 drm_drawable_info_type_t type,
668 unsigned int num, void *data);
669extern int drmCtlInstHandler(int fd, int irq);
670extern int drmCtlUninstHandler(int fd);
671extern int drmSetClientCap(int fd, uint64_t capability,
672 uint64_t value);
673
674extern int drmCrtcGetSequence(int fd, uint32_t crtcId,
675 uint64_t *sequence, uint64_t *ns);
676extern int drmCrtcQueueSequence(int fd, uint32_t crtcId,
677 uint32_t flags, uint64_t sequence,
678 uint64_t *sequence_queued,
679 uint64_t user_data);
680/* General user-level programmer's API: authenticated client and/or X */
681extern int drmMap(int fd,
682 drm_handle_t handle,
683 drmSize size,
684 drmAddressPtr address);
685extern int drmUnmap(drmAddress address, drmSize size);
686extern drmBufInfoPtr drmGetBufInfo(int fd);
687extern drmBufMapPtr drmMapBufs(int fd);
688extern int drmUnmapBufs(drmBufMapPtr bufs);
689extern int drmDMA(int fd, drmDMAReqPtr request);
690extern int drmFreeBufs(int fd, int count, int *list);
691extern int drmGetLock(int fd,
692 drm_context_t context,
693 drmLockFlags flags);
694extern int drmUnlock(int fd, drm_context_t context);
695extern int drmFinish(int fd, int context, drmLockFlags flags);
696extern int drmGetContextPrivateMapping(int fd, drm_context_t ctx_id,
697 drm_handle_t * handle);
698
699/* AGP/GART support: X server (root) only */
700extern int drmAgpAcquire(int fd);
701extern int drmAgpRelease(int fd);
702extern int drmAgpEnable(int fd, unsigned long mode);
703extern int drmAgpAlloc(int fd, unsigned long size,
704 unsigned long type, unsigned long *address,
705 drm_handle_t *handle);
706extern int drmAgpFree(int fd, drm_handle_t handle);
707extern int drmAgpBind(int fd, drm_handle_t handle,
708 unsigned long offset);
709extern int drmAgpUnbind(int fd, drm_handle_t handle);
710
711/* AGP/GART info: authenticated client and/or X */
712extern int drmAgpVersionMajor(int fd);
713extern int drmAgpVersionMinor(int fd);
714extern unsigned long drmAgpGetMode(int fd);
715extern unsigned long drmAgpBase(int fd); /* Physical location */
716extern unsigned long drmAgpSize(int fd); /* Bytes */
717extern unsigned long drmAgpMemoryUsed(int fd);
718extern unsigned long drmAgpMemoryAvail(int fd);
719extern unsigned int drmAgpVendorId(int fd);
720extern unsigned int drmAgpDeviceId(int fd);
721
722/* PCI scatter/gather support: X server (root) only */
723extern int drmScatterGatherAlloc(int fd, unsigned long size,
724 drm_handle_t *handle);
725extern int drmScatterGatherFree(int fd, drm_handle_t handle);
726
727extern int drmWaitVBlank(int fd, drmVBlankPtr vbl);
728
729/* Support routines */
730extern void drmSetServerInfo(drmServerInfoPtr info);
731extern int drmError(int err, const char *label);
732extern void *drmMalloc(int size);
733extern void drmFree(void *pt);
734
735/* Hash table routines */
736extern void *drmHashCreate(void);
737extern int drmHashDestroy(void *t);
738extern int drmHashLookup(void *t, unsigned long key, void **value);
739extern int drmHashInsert(void *t, unsigned long key, void *value);
740extern int drmHashDelete(void *t, unsigned long key);
741extern int drmHashFirst(void *t, unsigned long *key, void **value);
742extern int drmHashNext(void *t, unsigned long *key, void **value);
743
744/* PRNG routines */
745extern void *drmRandomCreate(unsigned long seed);
746extern int drmRandomDestroy(void *state);
747extern unsigned long drmRandom(void *state);
748extern double drmRandomDouble(void *state);
749
750/* Skip list routines */
751
752extern void *drmSLCreate(void);
753extern int drmSLDestroy(void *l);
754extern int drmSLLookup(void *l, unsigned long key, void **value);
755extern int drmSLInsert(void *l, unsigned long key, void *value);
756extern int drmSLDelete(void *l, unsigned long key);
757extern int drmSLNext(void *l, unsigned long *key, void **value);
758extern int drmSLFirst(void *l, unsigned long *key, void **value);
759extern void drmSLDump(void *l);
760extern int drmSLLookupNeighbors(void *l, unsigned long key,
761 unsigned long *prev_key, void **prev_value,
762 unsigned long *next_key, void **next_value);
763
764extern int drmOpenOnce(void *unused, const char *BusID, int *newlyopened);
765extern int drmOpenOnceWithType(const char *BusID, int *newlyopened, int type);
766extern void drmCloseOnce(int fd);
767extern void drmMsg(const char *format, ...) DRM_PRINTFLIKE(1, 2);
768
769extern int drmSetMaster(int fd);
770extern int drmDropMaster(int fd);
771extern int drmIsMaster(int fd);
772
773#define DRM_EVENT_CONTEXT_VERSION 4
774
775typedef struct _drmEventContext {
776
777 /* This struct is versioned so we can add more pointers if we
778 * add more events. */
779 int version;
780
781 void (*vblank_handler)(int fd,
782 unsigned int sequence,
783 unsigned int tv_sec,
784 unsigned int tv_usec,
785 void *user_data);
786
787 void (*page_flip_handler)(int fd,
788 unsigned int sequence,
789 unsigned int tv_sec,
790 unsigned int tv_usec,
791 void *user_data);
792
793 void (*page_flip_handler2)(int fd,
794 unsigned int sequence,
795 unsigned int tv_sec,
796 unsigned int tv_usec,
797 unsigned int crtc_id,
798 void *user_data);
799
800 void (*sequence_handler)(int fd,
801 uint64_t sequence,
802 uint64_t ns,
803 uint64_t user_data);
804} drmEventContext, *drmEventContextPtr;
805
806extern int drmHandleEvent(int fd, drmEventContextPtr evctx);
807
808extern char *drmGetDeviceNameFromFd(int fd);
809
810/* Improved version of drmGetDeviceNameFromFd which attributes for any type of
811 * device/node - card, control or renderD.
812 */
813extern char *drmGetDeviceNameFromFd2(int fd);
814extern int drmGetNodeTypeFromFd(int fd);
815
816/* Convert between GEM handles and DMA-BUF file descriptors.
817 *
818 * Warning: since GEM handles are not reference-counted and are unique per
819 * DRM file description, the caller is expected to perform its own reference
820 * counting. drmPrimeFDToHandle is guaranteed to return the same handle for
821 * different FDs if they reference the same underlying buffer object. This
822 * could even be a buffer object originally created on the same DRM FD.
823 *
824 * When sharing a DRM FD with an API such as EGL or GBM, the caller must not
825 * use drmPrimeHandleToFD nor drmPrimeFDToHandle. A single user-space
826 * reference-counting implementation is necessary to avoid double-closing GEM
827 * handles.
828 *
829 * Two processes can't share the same DRM FD and both use it to create or
830 * import GEM handles, even when using a single user-space reference-counting
831 * implementation like GBM, because GBM doesn't share its state between
832 * processes.
833 */
834extern int drmPrimeHandleToFD(int fd, uint32_t handle, uint32_t flags, int *prime_fd);
835extern int drmPrimeFDToHandle(int fd, int prime_fd, uint32_t *handle);
836
837extern int drmCloseBufferHandle(int fd, uint32_t handle);
838
839extern char *drmGetPrimaryDeviceNameFromFd(int fd);
840extern char *drmGetRenderDeviceNameFromFd(int fd);
841
842#define DRM_BUS_PCI 0
843#define DRM_BUS_USB 1
844#define DRM_BUS_PLATFORM 2
845#define DRM_BUS_HOST1X 3
846
847typedef struct _drmPciBusInfo {
848 uint16_t domain;
849 uint8_t bus;
850 uint8_t dev;
851 uint8_t func;
852} drmPciBusInfo, *drmPciBusInfoPtr;
853
854typedef struct _drmPciDeviceInfo {
855 uint16_t vendor_id;
856 uint16_t device_id;
857 uint16_t subvendor_id;
858 uint16_t subdevice_id;
859 uint8_t revision_id;
860} drmPciDeviceInfo, *drmPciDeviceInfoPtr;
861
862typedef struct _drmUsbBusInfo {
863 uint8_t bus;
864 uint8_t dev;
865} drmUsbBusInfo, *drmUsbBusInfoPtr;
866
867typedef struct _drmUsbDeviceInfo {
868 uint16_t vendor;
869 uint16_t product;
870} drmUsbDeviceInfo, *drmUsbDeviceInfoPtr;
871
872#define DRM_PLATFORM_DEVICE_NAME_LEN 512
873
874typedef struct _drmPlatformBusInfo {
875 char fullname[DRM_PLATFORM_DEVICE_NAME_LEN];
876} drmPlatformBusInfo, *drmPlatformBusInfoPtr;
877
878typedef struct _drmPlatformDeviceInfo {
879 char **compatible; /* NULL terminated list of compatible strings */
880} drmPlatformDeviceInfo, *drmPlatformDeviceInfoPtr;
881
882#define DRM_HOST1X_DEVICE_NAME_LEN 512
883
884typedef struct _drmHost1xBusInfo {
885 char fullname[DRM_HOST1X_DEVICE_NAME_LEN];
886} drmHost1xBusInfo, *drmHost1xBusInfoPtr;
887
888typedef struct _drmHost1xDeviceInfo {
889 char **compatible; /* NULL terminated list of compatible strings */
890} drmHost1xDeviceInfo, *drmHost1xDeviceInfoPtr;
891
892typedef struct _drmDevice {
893 char **nodes; /* DRM_NODE_MAX sized array */
894 int available_nodes; /* DRM_NODE_* bitmask */
895 int bustype;
896 union {
897 drmPciBusInfoPtr pci;
898 drmUsbBusInfoPtr usb;
899 drmPlatformBusInfoPtr platform;
900 drmHost1xBusInfoPtr host1x;
901 } businfo;
902 union {
903 drmPciDeviceInfoPtr pci;
904 drmUsbDeviceInfoPtr usb;
905 drmPlatformDeviceInfoPtr platform;
906 drmHost1xDeviceInfoPtr host1x;
907 } deviceinfo;
908} drmDevice, *drmDevicePtr;
909
910extern int drmGetDevice(int fd, drmDevicePtr *device);
911extern void drmFreeDevice(drmDevicePtr *device);
912
913extern int drmGetDevices(drmDevicePtr devices[], int max_devices);
914extern void drmFreeDevices(drmDevicePtr devices[], int count);
915
916#define DRM_DEVICE_GET_PCI_REVISION (1 << 0)
917extern int drmGetDevice2(int fd, uint32_t flags, drmDevicePtr *device);
918extern int drmGetDevices2(uint32_t flags, drmDevicePtr devices[], int max_devices);
919
920extern int drmGetDeviceFromDevId(dev_t dev_id, uint32_t flags, drmDevicePtr *device);
921
922extern int drmDevicesEqual(drmDevicePtr a, drmDevicePtr b);
923
924extern int drmSyncobjCreate(int fd, uint32_t flags, uint32_t *handle);
925extern int drmSyncobjDestroy(int fd, uint32_t handle);
926extern int drmSyncobjHandleToFD(int fd, uint32_t handle, int *obj_fd);
927extern int drmSyncobjFDToHandle(int fd, int obj_fd, uint32_t *handle);
928
929extern int drmSyncobjImportSyncFile(int fd, uint32_t handle, int sync_file_fd);
930extern int drmSyncobjExportSyncFile(int fd, uint32_t handle, int *sync_file_fd);
931extern int drmSyncobjWait(int fd, uint32_t *handles, unsigned num_handles,
932 int64_t timeout_nsec, unsigned flags,
933 uint32_t *first_signaled);
934extern int drmSyncobjReset(int fd, const uint32_t *handles, uint32_t handle_count);
935extern int drmSyncobjSignal(int fd, const uint32_t *handles, uint32_t handle_count);
936extern int drmSyncobjTimelineSignal(int fd, const uint32_t *handles,
937 uint64_t *points, uint32_t handle_count);
938extern int drmSyncobjTimelineWait(int fd, uint32_t *handles, uint64_t *points,
939 unsigned num_handles,
940 int64_t timeout_nsec, unsigned flags,
941 uint32_t *first_signaled);
942extern int drmSyncobjQuery(int fd, uint32_t *handles, uint64_t *points,
943 uint32_t handle_count);
944extern int drmSyncobjQuery2(int fd, uint32_t *handles, uint64_t *points,
945 uint32_t handle_count, uint32_t flags);
946extern int drmSyncobjTransfer(int fd,
947 uint32_t dst_handle, uint64_t dst_point,
948 uint32_t src_handle, uint64_t src_point,
949 uint32_t flags);
950
951extern char *
952drmGetFormatModifierVendor(uint64_t modifier);
953
954extern char *
955drmGetFormatModifierName(uint64_t modifier);
956
957extern char *
958drmGetFormatName(uint32_t format);
959
960#ifndef fourcc_mod_get_vendor
961#define fourcc_mod_get_vendor(modifier) \
962 (((modifier) >> 56) & 0xff)
963#endif
964
965#if defined(__cplusplus)
966}
967#endif
968
969#endif
970

source code of include/xf86drm.h