dali-windows-backend/ExInclude/xf86drm.h

   1 /**\r
   2 * \file xf86drm.h\r
   3 * OS-independent header for DRM user-level library interface.\r
   4 *\r
   5 * \author Rickard E. (Rik) Faith <faith@valinux.com>\r
   6 */\r
   7 \r
   8 /*\r
   9 * Copyright 1999, 2000 Precision Insight, Inc., Cedar Park, Texas.\r
  10 * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.\r
  11 * All Rights Reserved.\r
  12 *\r
  13 * Permission is hereby granted, free of charge, to any person obtaining a\r
  14 * copy of this software and associated documentation files (the "Software"),\r
  15 * to deal in the Software without restriction, including without limitation\r
  16 * the rights to use, copy, modify, merge, publish, distribute, sublicense,\r
  17 * and/or sell copies of the Software, and to permit persons to whom the\r
  18 * Software is furnished to do so, subject to the following conditions:\r
  19 *\r
  20 * The above copyright notice and this permission notice (including the next\r
  21 * paragraph) shall be included in all copies or substantial portions of the\r
  22 * Software.\r
  23 *\r
  24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  25 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  26 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL\r
  27 * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR\r
  28 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,\r
  29 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER\r
  30 * DEALINGS IN THE SOFTWARE.\r
  31 *\r
  32 */\r
  33 \r
  34 #ifndef _XF86DRM_H_\r
  35 #define _XF86DRM_H_\r
  36 \r
  37 #include <stdarg.h>\r
  38 #include <sys/types.h>\r
  39 #include <stdint.h>\r
  40 \r
  41 #if defined(__cplusplus)\r
  42 extern "C" {\r
  43 #endif\r
  44 \r
  45 #ifndef DRM_MAX_MINOR\r
  46 #define DRM_MAX_MINOR   16\r
  47 #endif\r
  48 \r
  49 #if defined(__linux__)\r
  50 \r
  51 #define DRM_IOCTL_NR(n)         _IOC_NR(n)\r
  52 #define DRM_IOC_VOID            _IOC_NONE\r
  53 #define DRM_IOC_READ            _IOC_READ\r
  54 #define DRM_IOC_WRITE           _IOC_WRITE\r
  55 #define DRM_IOC_READWRITE       _IOC_READ|_IOC_WRITE\r
  56 #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)\r
  57 \r
  58 #else /* One of the *BSDs */\r
  59 \r
  60 #define DRM_IOCTL_NR(n)         ((n) & 0xff)\r
  61 #define DRM_IOC_VOID            IOC_VOID\r
  62 #define DRM_IOC_READ            IOC_OUT\r
  63 #define DRM_IOC_WRITE           IOC_IN\r
  64 #define DRM_IOC_READWRITE       IOC_INOUT\r
  65 #define DRM_IOC(dir, group, nr, size) _IOC(dir, group, nr, size)\r
  66 \r
  67 #endif\r
  68 \r
  69   /* Defaults, if nothing set in xf86config */\r
  70 #define DRM_DEV_UID      0\r
  71 #define DRM_DEV_GID      0\r
  72   /* Default /dev/dri directory permissions 0755 */\r
  73 #define DRM_DEV_DIRMODE         \\r
  74         (S_IRUSR|S_IWUSR|S_IXUSR|S_IRGRP|S_IXGRP|S_IROTH|S_IXOTH)\r
  75 #define DRM_DEV_MODE     (S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH)\r
  76 \r
  77 #ifdef __OpenBSD__\r
  78 #define DRM_DIR_NAME  "/dev"\r
  79 #define DRM_DEV_NAME  "%s/drm%d"\r
  80 #define DRM_CONTROL_DEV_NAME  "%s/drmC%d"\r
  81 #define DRM_RENDER_DEV_NAME  "%s/drmR%d"\r
  82 #else\r
  83 #define DRM_DIR_NAME  "/dev/dri"\r
  84 #define DRM_DEV_NAME  "%s/card%d"\r
  85 #define DRM_CONTROL_DEV_NAME  "%s/controlD%d"\r
  86 #define DRM_RENDER_DEV_NAME  "%s/renderD%d"\r
  87 #define DRM_PROC_NAME "/proc/dri/" /* For backward Linux compatibility */\r
  88 #endif\r
  89 \r
  90 #define DRM_ERR_NO_DEVICE  (-1001)\r
  91 #define DRM_ERR_NO_ACCESS  (-1002)\r
  92 #define DRM_ERR_NOT_ROOT   (-1003)\r
  93 #define DRM_ERR_INVALID    (-1004)\r
  94 #define DRM_ERR_NO_FD      (-1005)\r
  95 \r
  96 #define DRM_AGP_NO_HANDLE 0\r
  97 \r
  98   typedef unsigned int  drmSize, *drmSizePtr;       /**< For mapped regions */\r
  99   typedef void          *drmAddress, **drmAddressPtr; /**< For mapped regions */\r
 100 \r
 101 #if (__GNUC__ >= 3)\r
 102 #define DRM_PRINTFLIKE(f, a) __attribute__ ((format(__printf__, f, a)))\r
 103 #else\r
 104 #define DRM_PRINTFLIKE(f, a)\r
 105 #endif\r
 106 \r
 107   typedef struct _drmServerInfo {\r
 108     int( *debug_print )( const char *format, va_list ap ) DRM_PRINTFLIKE( 1, 0 );\r
 109     int( *load_module )( const char *name );\r
 110   } drmServerInfo, *drmServerInfoPtr;\r
 111 \r
 112   typedef struct drmHashEntry {\r
 113     int      fd;\r
 114     void( *f )( int, void *, void * );\r
 115     void     *tagTable;\r
 116   } drmHashEntry;\r
 117 \r
 118   extern int drmIoctl( int fd, unsigned long request, void *arg );\r
 119   extern void *drmGetHashTable( void );\r
 120   extern drmHashEntry *drmGetEntry( int fd );\r
 121 \r
 122   /**\r
 123   * Driver version information.\r
 124   *\r
 125   * \sa drmGetVersion() and drmSetVersion().\r
 126   */\r
 127   typedef struct _drmVersion {\r
 128     int     version_major;        /**< Major version */\r
 129     int     version_minor;        /**< Minor version */\r
 130     int     version_patchlevel;   /**< Patch level */\r
 131     int     name_len;             /**< Length of name buffer */\r
 132     char    *name;                /**< Name of driver */\r
 133     int     date_len;             /**< Length of date buffer */\r
 134     char    *date;                /**< User-space buffer to hold date */\r
 135     int     desc_len;             /**< Length of desc buffer */\r
 136     char    *desc;                /**< User-space buffer to hold desc */\r
 137   } drmVersion, *drmVersionPtr;\r
 138 \r
 139   typedef struct _drmStats {\r
 140     unsigned long count;             /**< Number of data */\r
 141     struct {\r
 142       unsigned long value;           /**< Value from kernel */\r
 143       const char    *long_format;  /**< Suggested format for long_name */\r
 144       const char    *long_name;    /**< Long name for value */\r
 145       const char    *rate_format;  /**< Suggested format for rate_name */\r
 146       const char    *rate_name;    /**< Short name for value per second */\r
 147       int           isvalue;       /**< True if value (vs. counter) */\r
 148       const char    *mult_names;   /**< Multiplier names (e.g., "KGM") */\r
 149       int           mult;          /**< Multiplier value (e.g., 1024) */\r
 150       int           verbose;       /**< Suggest only in verbose output */\r
 151     } data[15];\r
 152   } drmStatsT;\r
 153 \r
 154 \r
 155   /* All of these enums *MUST* match with the\r
 156   kernel implementation -- so do *NOT*\r
 157   change them!  (The drmlib implementation\r
 158   will just copy the flags instead of\r
 159   translating them.) */\r
 160   typedef enum {\r
 161     DRM_FRAME_BUFFER = 0,      /**< WC, no caching, no core dump */\r
 162     DRM_REGISTERS = 1,      /**< no caching, no core dump */\r
 163     DRM_SHM = 2,      /**< shared, cached */\r
 164     DRM_AGP = 3,          /**< AGP/GART */\r
 165     DRM_SCATTER_GATHER = 4,       /**< PCI scatter/gather */\r
 166     DRM_CONSISTENT = 5    /**< PCI consistent */\r
 167   } drmMapType;\r
 168 \r
 169   typedef enum {\r
 170     DRM_RESTRICTED = 0x0001, /**< Cannot be mapped to client-virtual */\r
 171     DRM_READ_ONLY = 0x0002, /**< Read-only in client-virtual */\r
 172     DRM_LOCKED = 0x0004, /**< Physical pages locked */\r
 173     DRM_KERNEL = 0x0008, /**< Kernel requires access */\r
 174     DRM_WRITE_COMBINING = 0x0010, /**< Use write-combining, if available */\r
 175     DRM_CONTAINS_LOCK = 0x0020, /**< SHM page that contains lock */\r
 176     DRM_REMOVABLE = 0x0040  /**< Removable mapping */\r
 177   } drmMapFlags;\r
 178 \r
 179   /**\r
 180   * \warning These values *MUST* match drm.h\r
 181   */\r
 182   typedef enum {\r
 183     /** \name Flags for DMA buffer dispatch */\r
 184     /*@{*/\r
 185     DRM_DMA_BLOCK = 0x01, /**<\r
 186                           * Block until buffer dispatched.\r
 187                           *\r
 188                           * \note the buffer may not yet have been\r
 189                           * processed by the hardware -- getting a\r
 190                           * hardware lock with the hardware quiescent\r
 191                           * will ensure that the buffer has been\r
 192                           * processed.\r
 193                           */\r
 194     DRM_DMA_WHILE_LOCKED = 0x02, /**< Dispatch while lock held */\r
 195     DRM_DMA_PRIORITY = 0x04, /**< High priority dispatch */\r
 196                              /*@}*/\r
 197 \r
 198                              /** \name Flags for DMA buffer request */\r
 199                              /*@{*/\r
 200                              DRM_DMA_WAIT = 0x10, /**< Wait for free buffers */\r
 201                              DRM_DMA_SMALLER_OK = 0x20, /**< Smaller-than-requested buffers OK */\r
 202                              DRM_DMA_LARGER_OK = 0x40  /**< Larger-than-requested buffers OK */\r
 203                                                        /*@}*/\r
 204   } drmDMAFlags;\r
 205 \r
 206   typedef enum {\r
 207     DRM_PAGE_ALIGN = 0x01,\r
 208     DRM_AGP_BUFFER = 0x02,\r
 209     DRM_SG_BUFFER = 0x04,\r
 210     DRM_FB_BUFFER = 0x08,\r
 211     DRM_PCI_BUFFER_RO = 0x10\r
 212   } drmBufDescFlags;\r
 213 \r
 214   typedef enum {\r
 215     DRM_LOCK_READY = 0x01, /**< Wait until hardware is ready for DMA */\r
 216     DRM_LOCK_QUIESCENT = 0x02, /**< Wait until hardware quiescent */\r
 217     DRM_LOCK_FLUSH = 0x04, /**< Flush this context's DMA queue first */\r
 218     DRM_LOCK_FLUSH_ALL = 0x08, /**< Flush all DMA queues first */\r
 219                                /* These *HALT* flags aren't supported yet\r
 220                                -- they will be used to support the\r
 221                                full-screen DGA-like mode. */\r
 222     DRM_HALT_ALL_QUEUES = 0x10, /**< Halt all current and future queues */\r
 223     DRM_HALT_CUR_QUEUES = 0x20  /**< Halt all current queues */\r
 224   } drmLockFlags;\r
 225 \r
 226   typedef enum {\r
 227     DRM_CONTEXT_PRESERVED = 0x01, /**< This context is preserved and\r
 228                                   never swapped. */\r
 229     DRM_CONTEXT_2DONLY = 0x02  /**< This context is for 2D rendering only. */\r
 230   } drm_context_tFlags, *drm_context_tFlagsPtr;\r
 231 \r
 232   typedef struct _drmBufDesc {\r
 233     int              count;       /**< Number of buffers of this size */\r
 234     int              size;        /**< Size in bytes */\r
 235     int              low_mark;    /**< Low water mark */\r
 236     int              high_mark;   /**< High water mark */\r
 237   } drmBufDesc, *drmBufDescPtr;\r
 238 \r
 239   typedef struct _drmBufInfo {\r
 240     int              count;       /**< Number of buffers described in list */\r
 241     drmBufDescPtr    list;        /**< List of buffer descriptions */\r
 242   } drmBufInfo, *drmBufInfoPtr;\r
 243 \r
 244   typedef struct _drmBuf {\r
 245     int              idx;         /**< Index into the master buffer list */\r
 246     int              total;       /**< Buffer size */\r
 247     int              used;        /**< Amount of buffer in use (for DMA) */\r
 248     drmAddress       address;     /**< Address */\r
 249   } drmBuf, *drmBufPtr;\r
 250 \r
 251   /**\r
 252   * Buffer mapping information.\r
 253   *\r
 254   * Used by drmMapBufs() and drmUnmapBufs() to store information about the\r
 255   * mapped buffers.\r
 256   */\r
 257   typedef struct _drmBufMap {\r
 258     int              count;       /**< Number of buffers mapped */\r
 259     drmBufPtr        list;        /**< Buffers */\r
 260   } drmBufMap, *drmBufMapPtr;\r
 261 \r
 262   typedef struct _drmLock {\r
 263     volatile unsigned int lock;\r
 264     char                      padding[60];\r
 265     /* This is big enough for most current (and future?) architectures:\r
 266     DEC Alpha:              32 bytes\r
 267     Intel Merced:           ?\r
 268     Intel P5/PPro/PII/PIII: 32 bytes\r
 269     Intel StrongARM:        32 bytes\r
 270     Intel i386/i486:        16 bytes\r
 271     MIPS:                   32 bytes (?)\r
 272     Motorola 68k:           16 bytes\r
 273     Motorola PowerPC:       32 bytes\r
 274     Sun SPARC:              32 bytes\r
 275     */\r
 276   } drmLock, *drmLockPtr;\r
 277 \r
 278   /**\r
 279   * Indices here refer to the offset into\r
 280   * list in drmBufInfo\r
 281   */\r
 282   typedef struct _drmDMAReq {\r
 283     int           send_count;     /**< Number of buffers to send */\r
 284     int           *send_list;     /**< List of handles to buffers */\r
 285     int           *send_sizes;    /**< Lengths of data to send, in bytes */\r
 286     drmDMAFlags   flags;          /**< Flags */\r
 287     int           request_count;  /**< Number of buffers requested */\r
 288     int           request_size;   /**< Desired size of buffers requested */\r
 289     int           *request_list;  /**< Buffer information */\r
 290     int           *request_sizes; /**< Minimum acceptable sizes */\r
 291     int           granted_count;  /**< Number of buffers granted at this size */\r
 292   } drmDMAReq, *drmDMAReqPtr;\r
 293 \r
 294   typedef struct _drmRegion {\r
 295     unsigned int  offset;\r
 296     drmSize       size;\r
 297     drmAddress    map;\r
 298   } drmRegion, *drmRegionPtr;\r
 299 \r
 300   typedef struct _drmTextureRegion {\r
 301     unsigned char next;\r
 302     unsigned char prev;\r
 303     unsigned char in_use;\r
 304     unsigned char padding;      /**< Explicitly pad this out */\r
 305     unsigned int  age;\r
 306   } drmTextureRegion, *drmTextureRegionPtr;\r
 307 \r
 308 \r
 309   typedef enum {\r
 310     DRM_VBLANK_ABSOLUTE = 0x0,  /**< Wait for specific vblank sequence number */\r
 311     DRM_VBLANK_RELATIVE = 0x1,  /**< Wait for given number of vblanks */\r
 312                                 /* bits 1-6 are reserved for high crtcs */\r
 313                                 DRM_VBLANK_HIGH_CRTC_MASK = 0x0000003e,\r
 314                                 DRM_VBLANK_EVENT = 0x4000000,   /**< Send event instead of blocking */\r
 315                                 DRM_VBLANK_FLIP = 0x8000000,    /**< Scheduled buffer swap should flip */\r
 316                                 DRM_VBLANK_NEXTONMISS = 0x10000000,     /**< If missed, wait for next vblank */\r
 317                                 DRM_VBLANK_SECONDARY = 0x20000000,      /**< Secondary display controller */\r
 318                                 DRM_VBLANK_SIGNAL = 0x40000000  /* Send signal instead of blocking */\r
 319   } drmVBlankSeqType;\r
 320 #define DRM_VBLANK_HIGH_CRTC_SHIFT 1\r
 321 \r
 322   typedef struct _drmVBlankReq {\r
 323     drmVBlankSeqType type;\r
 324     unsigned int sequence;\r
 325     unsigned long signal;\r
 326   } drmVBlankReq, *drmVBlankReqPtr;\r
 327 \r
 328   typedef struct _drmVBlankReply {\r
 329     drmVBlankSeqType type;\r
 330     unsigned int sequence;\r
 331     long tval_sec;\r
 332     long tval_usec;\r
 333   } drmVBlankReply, *drmVBlankReplyPtr;\r
 334 \r
 335   typedef union _drmVBlank {\r
 336     drmVBlankReq request;\r
 337     drmVBlankReply reply;\r
 338   } drmVBlank, *drmVBlankPtr;\r
 339 \r
 340   typedef struct _drmSetVersion {\r
 341     int drm_di_major;\r
 342     int drm_di_minor;\r
 343     int drm_dd_major;\r
 344     int drm_dd_minor;\r
 345   } drmSetVersion, *drmSetVersionPtr;\r
 346 \r
 347 #define __drm_dummy_lock(lock) (*(__volatile__ unsigned int *)lock)\r
 348 \r
 349 #define DRM_LOCK_HELD  0x80000000U /**< Hardware lock is held */\r
 350 #define DRM_LOCK_CONT  0x40000000U /**< Hardware lock is contended */\r
 351 \r
 352 #if defined(__GNUC__) && (__GNUC__ >= 2)\r
 353 # if defined(__i386) || defined(__AMD64__) || defined(__x86_64__) || defined(__amd64__)\r
 354   /* Reflect changes here to drmP.h */\r
 355 #define DRM_CAS(lock,old,new,__ret)                                    \\r
 356         do {                                                           \\r
 357                 int __dummy;    /* Can't mark eax as clobbered */      \\r
 358                 __asm__ __volatile__(                                  \\r
 359                         "lock ; cmpxchg %4,%1\n\t"                     \\r
 360                         "setnz %0"                                     \\r
 361                         : "=d" (__ret),                                \\r
 362                           "=m" (__drm_dummy_lock(lock)),               \\r
 363                           "=a" (__dummy)                               \\r
 364                         : "2" (old),                                   \\r
 365                           "r" (new));                                  \\r
 366         } while (0)\r
 367 \r
 368 #elif defined(__alpha__)\r
 369 \r
 370 #define DRM_CAS(lock, old, new, ret)            \\r
 371         do {                                    \\r
 372                 int tmp, old32;                 \\r
 373                 __asm__ __volatile__(           \\r
 374                 "       addl    $31, %5, %3\n"  \\r
 375                 "1:     ldl_l   %0, %2\n"       \\r
 376                 "       cmpeq   %0, %3, %1\n"   \\r
 377                 "       beq     %1, 2f\n"       \\r
 378                 "       mov     %4, %0\n"       \\r
 379                 "       stl_c   %0, %2\n"       \\r
 380                 "       beq     %0, 3f\n"       \\r
 381                 "       mb\n"                   \\r
 382                 "2:     cmpeq   %1, 0, %1\n"    \\r
 383                 ".subsection 2\n"               \\r
 384                 "3:     br      1b\n"           \\r
 385                 ".previous"                     \\r
 386                 : "=&r"(tmp), "=&r"(ret),       \\r
 387                   "=m"(__drm_dummy_lock(lock)), \\r
 388                   "=&r"(old32)                  \\r
 389                 : "r"(new), "r"(old)            \\r
 390                 : "memory");                    \\r
 391         } while (0)\r
 392 \r
 393 #elif defined(__sparc__)\r
 394 \r
 395 #define DRM_CAS(lock,old,new,__ret)                             \\r
 396 do {    register unsigned int __old __asm("o0");                \\r
 397         register unsigned int __new __asm("o1");                \\r
 398         register volatile unsigned int *__lock __asm("o2");     \\r
 399         __old = old;                                            \\r
 400         __new = new;                                            \\r
 401         __lock = (volatile unsigned int *)lock;                 \\r
 402         __asm__ __volatile__(                                   \\r
 403                 /*"cas [%2], %3, %0"*/                          \\r
 404                 ".word 0xd3e29008\n\t"                          \\r
 405                 /*"membar #StoreStore | #StoreLoad"*/           \\r
 406                 ".word 0x8143e00a"                              \\r
 407                 : "=&r" (__new)                                 \\r
 408                 : "0" (__new),                                  \\r
 409                   "r" (__lock),                                 \\r
 410                   "r" (__old)                                   \\r
 411                 : "memory");                                    \\r
 412         __ret = (__new != __old);                               \\r
 413 } while(0)\r
 414 \r
 415 #elif defined(__ia64__)\r
 416 \r
 417 #ifdef __INTEL_COMPILER\r
 418   /* this currently generates bad code (missing stop bits)... */\r
 419 #include <ia64intrin.h>\r
 420 \r
 421 #define DRM_CAS(lock,old,new,__ret)                                           \\r
 422         do {                                                                  \\r
 423                 unsigned long __result, __old = (old) & 0xffffffff;             \\r
 424                 __mf();                                                         \\r
 425                 __result = _InterlockedCompareExchange_acq(&__drm_dummy_lock(lock), (new), __old);\\r
 426                 __ret = (__result) != (__old);                                  \\r
 427 /*              __ret = (__sync_val_compare_and_swap(&__drm_dummy_lock(lock), \\r
 428                                                      (old), (new))            \\r
 429                          != (old));                                           */\\r
 430         } while (0)\r
 431 \r
 432 #else\r
 433 #define DRM_CAS(lock,old,new,__ret)                                       \\r
 434         do {                                                              \\r
 435                 unsigned int __result, __old = (old);                     \\r
 436                 __asm__ __volatile__(                                     \\r
 437                         "mf\n"                                            \\r
 438                         "mov ar.ccv=%2\n"                                 \\r
 439                         ";;\n"                                            \\r
 440                         "cmpxchg4.acq %0=%1,%3,ar.ccv"                    \\r
 441                         : "=r" (__result), "=m" (__drm_dummy_lock(lock))  \\r
 442                         : "r" ((unsigned long)__old), "r" (new)                   \\r
 443                         : "memory");                                      \\r
 444                 __ret = (__result) != (__old);                            \\r
 445         } while (0)\r
 446 \r
 447 #endif\r
 448 \r
 449 #elif defined(__powerpc__)\r
 450 \r
 451 #define DRM_CAS(lock,old,new,__ret)                     \\r
 452         do {                                            \\r
 453                 __asm__ __volatile__(                   \\r
 454                         "sync;"                         \\r
 455                         "0:    lwarx %0,0,%1;"          \\r
 456                         "      xor. %0,%3,%0;"          \\r
 457                         "      bne 1f;"                 \\r
 458                         "      stwcx. %2,0,%1;"         \\r
 459                         "      bne- 0b;"                \\r
 460                         "1:    "                        \\r
 461                         "sync;"                         \\r
 462                 : "=&r"(__ret)                          \\r
 463                 : "r"(lock), "r"(new), "r"(old)         \\r
 464                 : "cr0", "memory");                     \\r
 465         } while (0)\r
 466 \r
 467 #endif /* architecture */\r
 468 #endif /* __GNUC__ >= 2 */\r
 469 \r
 470 #ifndef DRM_CAS\r
 471 #define DRM_CAS(lock,old,new,ret) do { ret=1; } while (0) /* FAST LOCK FAILS */\r
 472 #endif\r
 473 \r
 474 #if defined(__alpha__)\r
 475 #define DRM_CAS_RESULT(_result)         long _result\r
 476 #elif defined(__powerpc__)\r
 477 #define DRM_CAS_RESULT(_result)         int _result\r
 478 #else\r
 479 #define DRM_CAS_RESULT(_result)         char _result\r
 480 #endif\r
 481 \r
 482 #define DRM_LIGHT_LOCK(fd,lock,context)                                \\r
 483         do {                                                           \\r
 484                 DRM_CAS_RESULT(__ret);                                 \\r
 485                 DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret);     \\r
 486                 if (__ret) drmGetLock(fd,context,0);                   \\r
 487         } while(0)\r
 488 \r
 489   /* This one counts fast locks -- for\r
 490   benchmarking only. */\r
 491 #define DRM_LIGHT_LOCK_COUNT(fd,lock,context,count)                    \\r
 492         do {                                                           \\r
 493                 DRM_CAS_RESULT(__ret);                                 \\r
 494                 DRM_CAS(lock,context,DRM_LOCK_HELD|context,__ret);     \\r
 495                 if (__ret) drmGetLock(fd,context,0);                   \\r
 496                 else       ++count;                                    \\r
 497         } while(0)\r
 498 \r
 499 #define DRM_LOCK(fd,lock,context,flags)                                \\r
 500         do {                                                           \\r
 501                 if (flags) drmGetLock(fd,context,flags);               \\r
 502                 else       DRM_LIGHT_LOCK(fd,lock,context);            \\r
 503         } while(0)\r
 504 \r
 505 #define DRM_UNLOCK(fd,lock,context)                                    \\r
 506         do {                                                           \\r
 507                 DRM_CAS_RESULT(__ret);                                 \\r
 508                 DRM_CAS(lock,DRM_LOCK_HELD|context,context,__ret);     \\r
 509                 if (__ret) drmUnlock(fd,context);                      \\r
 510         } while(0)\r
 511 \r
 512   /* Simple spin locks */\r
 513 #define DRM_SPINLOCK(spin,val)                                         \\r
 514         do {                                                           \\r
 515             DRM_CAS_RESULT(__ret);                                     \\r
 516             do {                                                       \\r
 517                 DRM_CAS(spin,0,val,__ret);                             \\r
 518                 if (__ret) while ((spin)->lock);                       \\r
 519             } while (__ret);                                           \\r
 520         } while(0)\r
 521 \r
 522 #define DRM_SPINLOCK_TAKE(spin,val)                                    \\r
 523         do {                                                           \\r
 524             DRM_CAS_RESULT(__ret);                                     \\r
 525             int  cur;                                                  \\r
 526             do {                                                       \\r
 527                 cur = (*spin).lock;                                    \\r
 528                 DRM_CAS(spin,cur,val,__ret);                           \\r
 529             } while (__ret);                                           \\r
 530         } while(0)\r
 531 \r
 532 #define DRM_SPINLOCK_COUNT(spin,val,count,__ret)                       \\r
 533         do {                                                           \\r
 534             int  __i;                                                  \\r
 535             __ret = 1;                                                 \\r
 536             for (__i = 0; __ret && __i < count; __i++) {               \\r
 537                 DRM_CAS(spin,0,val,__ret);                             \\r
 538                 if (__ret) for (;__i < count && (spin)->lock; __i++);  \\r
 539             }                                                          \\r
 540         } while(0)\r
 541 \r
 542 #define DRM_SPINUNLOCK(spin,val)                                       \\r
 543         do {                                                           \\r
 544             DRM_CAS_RESULT(__ret);                                     \\r
 545             if ((*spin).lock == val) { /* else server stole lock */    \\r
 546                 do {                                                   \\r
 547                     DRM_CAS(spin,val,0,__ret);                         \\r
 548                 } while (__ret);                                       \\r
 549             }                                                          \\r
 550         } while(0)\r
 551 \r
 552 \r
 553 \r
 554   /* General user-level programmer's API: unprivileged */\r
 555   extern int           drmAvailable( void );\r
 556   extern int           drmOpen( const char *name, const char *busid );\r
 557 \r
 558 #define DRM_NODE_PRIMARY 0\r
 559 #define DRM_NODE_CONTROL 1\r
 560 #define DRM_NODE_RENDER  2\r
 561 #define DRM_NODE_MAX     3\r
 562 \r
 563   extern int           drmOpenWithType( const char *name, const char *busid,\r
 564     int type );\r
 565 \r
 566   extern int           drmOpenControl( int minor );\r
 567   extern int           drmOpenRender( int minor );\r
 568   extern int           drmClose( int fd );\r
 569   extern drmVersionPtr drmGetVersion( int fd );\r
 570   extern drmVersionPtr drmGetLibVersion( int fd );\r
 571   extern int           drmGetCap( int fd, uint64_t capability, uint64_t *value );\r
 572   extern void          drmFreeVersion( drmVersionPtr );\r
 573   extern char          *drmGetBusid( int fd );\r
 574   extern int           drmGetInterruptFromBusID( int fd, int busnum, int devnum,\r
 575     int funcnum );\r
 576   extern int           drmGetClient( int fd, int idx, int *auth, int *pid,\r
 577     int *uid, unsigned long *magic,\r
 578     unsigned long *iocs );\r
 579   extern int           drmGetStats( int fd, drmStatsT *stats );\r
 580   extern int           drmSetInterfaceVersion( int fd, drmSetVersion *version );\r
 581   extern int           drmCommandNone( int fd, unsigned long drmCommandIndex );\r
 582   extern int           drmCommandRead( int fd, unsigned long drmCommandIndex,\r
 583     void *data, unsigned long size );\r
 584   extern int           drmCommandWrite( int fd, unsigned long drmCommandIndex,\r
 585     void *data, unsigned long size );\r
 586   extern int           drmCommandWriteRead( int fd, unsigned long drmCommandIndex,\r
 587     void *data, unsigned long size );\r
 588 \r
 589   /* General user-level programmer's API: X server (root) only  */\r
 590   extern void          drmFreeBusid( const char *busid );\r
 591   extern int           drmSetBusid( int fd, const char *busid );\r
 592 \r
 593   extern int           drmAddBufs( int fd, int count, int size,\r
 594     drmBufDescFlags flags,\r
 595     int agp_offset );\r
 596   extern int           drmMarkBufs( int fd, double low, double high );\r
 597   extern int           drmCtlInstHandler( int fd, int irq );\r
 598   extern int           drmCtlUninstHandler( int fd );\r
 599   extern int           drmSetClientCap( int fd, uint64_t capability,\r
 600     uint64_t value );\r
 601 \r
 602   /* General user-level programmer's API: authenticated client and/or X */\r
 603   extern int           drmUnmap( drmAddress address, drmSize size );\r
 604   extern drmBufInfoPtr drmGetBufInfo( int fd );\r
 605   extern drmBufMapPtr  drmMapBufs( int fd );\r
 606   extern int           drmUnmapBufs( drmBufMapPtr bufs );\r
 607   extern int           drmDMA( int fd, drmDMAReqPtr request );\r
 608   extern int           drmFreeBufs( int fd, int count, int *list );\r
 609 \r
 610   /* AGP/GART support: X server (root) only */\r
 611   extern int           drmAgpAcquire( int fd );\r
 612   extern int           drmAgpRelease( int fd );\r
 613   extern int           drmAgpEnable( int fd, unsigned long mode );\r
 614 \r
 615   /* AGP/GART info: authenticated client and/or X */\r
 616   extern int           drmAgpVersionMajor( int fd );\r
 617   extern int           drmAgpVersionMinor( int fd );\r
 618   extern unsigned long drmAgpGetMode( int fd );\r
 619   extern unsigned long drmAgpBase( int fd ); /* Physical location */\r
 620   extern unsigned long drmAgpSize( int fd ); /* Bytes */\r
 621   extern unsigned long drmAgpMemoryUsed( int fd );\r
 622   extern unsigned long drmAgpMemoryAvail( int fd );\r
 623   extern unsigned int  drmAgpVendorId( int fd );\r
 624   extern unsigned int  drmAgpDeviceId( int fd );\r
 625 \r
 626   /* PCI scatter/gather support: X server (root) only */\r
 627   extern int           drmWaitVBlank( int fd, drmVBlankPtr vbl );\r
 628 \r
 629   /* Support routines */\r
 630   extern void          drmSetServerInfo( drmServerInfoPtr info );\r
 631   extern int           drmError( int err, const char *label );\r
 632   extern void          *drmMalloc( int size );\r
 633   extern void          drmFree( void *pt );\r
 634 \r
 635   /* Hash table routines */\r
 636   extern void *drmHashCreate( void );\r
 637   extern int  drmHashDestroy( void *t );\r
 638   extern int  drmHashLookup( void *t, unsigned long key, void **value );\r
 639   extern int  drmHashInsert( void *t, unsigned long key, void *value );\r
 640   extern int  drmHashDelete( void *t, unsigned long key );\r
 641   extern int  drmHashFirst( void *t, unsigned long *key, void **value );\r
 642   extern int  drmHashNext( void *t, unsigned long *key, void **value );\r
 643 \r
 644   /* PRNG routines */\r
 645   extern void          *drmRandomCreate( unsigned long seed );\r
 646   extern int           drmRandomDestroy( void *state );\r
 647   extern unsigned long drmRandom( void *state );\r
 648   extern double        drmRandomDouble( void *state );\r
 649 \r
 650   /* Skip list routines */\r
 651 \r
 652   extern void *drmSLCreate( void );\r
 653   extern int  drmSLDestroy( void *l );\r
 654   extern int  drmSLLookup( void *l, unsigned long key, void **value );\r
 655   extern int  drmSLInsert( void *l, unsigned long key, void *value );\r
 656   extern int  drmSLDelete( void *l, unsigned long key );\r
 657   extern int  drmSLNext( void *l, unsigned long *key, void **value );\r
 658   extern int  drmSLFirst( void *l, unsigned long *key, void **value );\r
 659   extern void drmSLDump( void *l );\r
 660   extern int  drmSLLookupNeighbors( void *l, unsigned long key,\r
 661     unsigned long *prev_key, void **prev_value,\r
 662     unsigned long *next_key, void **next_value );\r
 663 \r
 664   extern int drmOpenOnce( void *unused, const char *BusID, int *newlyopened );\r
 665   extern int drmOpenOnceWithType( const char *BusID, int *newlyopened, int type );\r
 666   extern void drmCloseOnce( int fd );\r
 667   extern void drmMsg( const char *format, ... ) DRM_PRINTFLIKE( 1, 2 );\r
 668 \r
 669   extern int drmSetMaster( int fd );\r
 670   extern int drmDropMaster( int fd );\r
 671 \r
 672 #define DRM_EVENT_CONTEXT_VERSION 2\r
 673 \r
 674   typedef struct _drmEventContext {\r
 675 \r
 676     /* This struct is versioned so we can add more pointers if we\r
 677     * add more events. */\r
 678     int version;\r
 679 \r
 680     void( *vblank_handler )( int fd,\r
 681       unsigned int sequence,\r
 682       unsigned int tv_sec,\r
 683       unsigned int tv_usec,\r
 684       void *user_data );\r
 685 \r
 686     void( *page_flip_handler )( int fd,\r
 687       unsigned int sequence,\r
 688       unsigned int tv_sec,\r
 689       unsigned int tv_usec,\r
 690       void *user_data );\r
 691 \r
 692   } drmEventContext, *drmEventContextPtr;\r
 693 \r
 694   extern int drmHandleEvent( int fd, drmEventContextPtr evctx );\r
 695 \r
 696   extern char *drmGetDeviceNameFromFd( int fd );\r
 697   extern int drmGetNodeTypeFromFd( int fd );\r
 698 \r
 699   extern int drmPrimeHandleToFD( int fd, uint32_t handle, uint32_t flags, int *prime_fd );\r
 700   extern int drmPrimeFDToHandle( int fd, int prime_fd, uint32_t *handle );\r
 701 \r
 702   extern char *drmGetPrimaryDeviceNameFromFd( int fd );\r
 703   extern char *drmGetRenderDeviceNameFromFd( int fd );\r
 704 \r
 705 #define DRM_BUS_PCI   0\r
 706 \r
 707   typedef struct _drmPciBusInfo {\r
 708     uint16_t domain;\r
 709     uint8_t bus;\r
 710     uint8_t dev;\r
 711     uint8_t func;\r
 712   } drmPciBusInfo, *drmPciBusInfoPtr;\r
 713 \r
 714   typedef struct _drmPciDeviceInfo {\r
 715     uint16_t vendor_id;\r
 716     uint16_t device_id;\r
 717     uint16_t subvendor_id;\r
 718     uint16_t subdevice_id;\r
 719     uint8_t revision_id;\r
 720   } drmPciDeviceInfo, *drmPciDeviceInfoPtr;\r
 721 \r
 722   typedef struct _drmDevice {\r
 723     char **nodes; /* DRM_NODE_MAX sized array */\r
 724     int available_nodes; /* DRM_NODE_* bitmask */\r
 725     int bustype;\r
 726     union {\r
 727       drmPciBusInfoPtr pci;\r
 728     } businfo;\r
 729     union {\r
 730       drmPciDeviceInfoPtr pci;\r
 731     } deviceinfo;\r
 732   } drmDevice, *drmDevicePtr;\r
 733 \r
 734   extern int drmGetDevice( int fd, drmDevicePtr *device );\r
 735   extern void drmFreeDevice( drmDevicePtr *device );\r
 736 \r
 737   extern int drmGetDevices( drmDevicePtr devices[], int max_devices );\r
 738   extern void drmFreeDevices( drmDevicePtr devices[], int count );\r
 739 \r
 740 #if defined(__cplusplus)\r
 741 }\r
 742 #endif\r
 743 \r
 744 #endif\r