libdrm/xf86drm.c

   1 /**
   2  * \file xf86drm.c
   3  * User-level interface to DRM device
   4  *
   5  * \author Rickard E. (Rik) Faith <faith@valinux.com>
   6  * \author Kevin E. Martin <martin@valinux.com>
   7  */
   8
   9 /*
  10  * Copyright 1999 Precision Insight, Inc., Cedar Park, Texas.
  11  * Copyright 2000 VA Linux Systems, Inc., Sunnyvale, California.
  12  * All Rights Reserved.
  13  *
  14  * Permission is hereby granted, free of charge, to any person obtaining a
  15  * copy of this software and associated documentation files (the "Software"),
  16  * to deal in the Software without restriction, including without limitation
  17  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  18  * and/or sell copies of the Software, and to permit persons to whom the
  19  * Software is furnished to do so, subject to the following conditions:
  20  *
  21  * The above copyright notice and this permission notice (including the next
  22  * paragraph) shall be included in all copies or substantial portions of the
  23  * Software.
  24  *
  25  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  26  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  27  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  28  * PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  29  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  30  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
  31  * DEALINGS IN THE SOFTWARE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 # include <config.h>
  36 #endif
  37 #include <stdio.h>
  38 #include <stdlib.h>
  39 #include <unistd.h>
  40 #include <string.h>
  41 #include <ctype.h>
  42 #include <fcntl.h>
  43 #include <errno.h>
  44 #include <signal.h>
  45 #include <sys/types.h>
  46 #include <sys/stat.h>
  47 #define stat_t struct stat
  48 #include <sys/ioctl.h>
  49 #include <sys/mman.h>
  50 #include <sys/time.h>
  51 #include <stdarg.h>
  52
  53 /* Not all systems have MAP_FAILED defined */
  54 #ifndef MAP_FAILED
  55 #define MAP_FAILED ((void *)-1)
  56 #endif
  57
  58 #include "xf86drm.h"
  59
  60 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__)
  61 #define DRM_MAJOR 145
  62 #endif
  63
  64 #ifdef __NetBSD__
  65 #define DRM_MAJOR 34
  66 #endif
  67
  68 # ifdef __OpenBSD__
  69 #  define DRM_MAJOR 81
  70 # endif
  71
  72 #ifndef DRM_MAJOR
  73 #define DRM_MAJOR 226           /* Linux */
  74 #endif
  75
  76 #ifndef DRM_MAX_MINOR
  77 #define DRM_MAX_MINOR 16
  78 #endif
  79
  80 /*
  81  * This definition needs to be changed on some systems if dev_t is a structure.
  82  * If there is a header file we can get it from, there would be best.
  83  */
  84 #ifndef makedev
  85 #define makedev(x,y)    ((dev_t)(((x) << 8) | (y)))
  86 #endif
  87
  88 #define DRM_MSG_VERBOSITY 3
  89
  90 #define DRM_NODE_CONTROL 0
  91 #define DRM_NODE_RENDER 1
  92
  93 static drmServerInfoPtr drm_server_info;
  94
  95 void drmSetServerInfo(drmServerInfoPtr info)
  96 {
  97     drm_server_info = info;
  98 }
  99
 100 /**
 101  * Output a message to stderr.
 102  *
 103  * \param format printf() like format string.
 104  *
 105  * \internal
 106  * This function is a wrapper around vfprintf().
 107  */
 108
 109 static int drmDebugPrint(const char *format, va_list ap)
 110 {
 111     return vfprintf(stderr, format, ap);
 112 }
 113
 114 static int (*drm_debug_print)(const char *format, va_list ap) = drmDebugPrint;
 115
 116 static void
 117 drmMsg(const char *format, ...)
 118 {
 119     va_list     ap;
 120     const char *env;
 121     if (((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) || drm_server_info)
 122     {
 123         va_start(ap, format);
 124         if (drm_server_info) {
 125           drm_server_info->debug_print(format,ap);
 126         } else {
 127           drm_debug_print(format, ap);
 128         }
 129         va_end(ap);
 130     }
 131 }
 132
 133 void
 134 drmSetDebugMsgFunction(int (*debug_msg_ptr)(const char *format, va_list ap))
 135 {
 136     drm_debug_print = debug_msg_ptr;
 137 }
 138
 139 static void *drmHashTable = NULL; /* Context switch callbacks */
 140
 141 void *drmGetHashTable(void)
 142 {
 143     return drmHashTable;
 144 }
 145
 146 void *drmMalloc(int size)
 147 {
 148     void *pt;
 149     if ((pt = malloc(size)))
 150         memset(pt, 0, size);
 151     return pt;
 152 }
 153
 154 void drmFree(void *pt)
 155 {
 156     if (pt)
 157         free(pt);
 158 }
 159
 160 /* drmStrdup can't use strdup(3), since it doesn't call _DRM_MALLOC... */
 161 static char *drmStrdup(const char *s)
 162 {
 163     char *retval;
 164
 165     if (!s)
 166         return NULL;
 167
 168     retval = malloc(strlen(s)+1);
 169     if (!retval)
 170         return NULL;
 171
 172     strcpy(retval, s);
 173
 174     return retval;
 175 }
 176
 177
 178 static unsigned long drmGetKeyFromFd(int fd)
 179 {
 180     stat_t     st;
 181
 182     st.st_rdev = 0;
 183     fstat(fd, &st);
 184     return st.st_rdev;
 185 }
 186
 187 drmHashEntry *drmGetEntry(int fd)
 188 {
 189     unsigned long key = drmGetKeyFromFd(fd);
 190     void          *value;
 191     drmHashEntry  *entry;
 192
 193     if (!drmHashTable)
 194         drmHashTable = drmHashCreate();
 195
 196     if (drmHashLookup(drmHashTable, key, &value)) {
 197         entry           = drmMalloc(sizeof(*entry));
 198         entry->fd       = fd;
 199         entry->f        = NULL;
 200         entry->tagTable = drmHashCreate();
 201         drmHashInsert(drmHashTable, key, entry);
 202     } else {
 203         entry = value;
 204     }
 205     return entry;
 206 }
 207
 208 /**
 209  * Compare two busid strings
 210  *
 211  * \param first
 212  * \param second
 213  *
 214  * \return 1 if matched.
 215  *
 216  * \internal
 217  * This function compares two bus ID strings.  It understands the older
 218  * PCI:b:d:f format and the newer pci:oooo:bb:dd.f format.  In the format, o is
 219  * domain, b is bus, d is device, f is function.
 220  */
 221 static int drmMatchBusID(const char *id1, const char *id2)
 222 {
 223     /* First, check if the IDs are exactly the same */
 224     if (strcasecmp(id1, id2) == 0)
 225         return 1;
 226
 227     /* Try to match old/new-style PCI bus IDs. */
 228     if (strncasecmp(id1, "pci", 3) == 0) {
 229         int o1, b1, d1, f1;
 230         int o2, b2, d2, f2;
 231         int ret;
 232
 233         ret = sscanf(id1, "pci:%04x:%02x:%02x.%d", &o1, &b1, &d1, &f1);
 234         if (ret != 4) {
 235             o1 = 0;
 236             ret = sscanf(id1, "PCI:%d:%d:%d", &b1, &d1, &f1);
 237             if (ret != 3)
 238                 return 0;
 239         }
 240
 241         ret = sscanf(id2, "pci:%04x:%02x:%02x.%d", &o2, &b2, &d2, &f2);
 242         if (ret != 4) {
 243             o2 = 0;
 244             ret = sscanf(id2, "PCI:%d:%d:%d", &b2, &d2, &f2);
 245             if (ret != 3)
 246                 return 0;
 247         }
 248
 249         if ((o1 != o2) || (b1 != b2) || (d1 != d2) || (f1 != f2))
 250             return 0;
 251         else
 252             return 1;
 253     }
 254     return 0;
 255 }
 256
 257 /**
 258  * Open the DRM device, creating it if necessary.
 259  *
 260  * \param dev major and minor numbers of the device.
 261  * \param minor minor number of the device.
 262  *
 263  * \return a file descriptor on success, or a negative value on error.
 264  *
 265  * \internal
 266  * Assembles the device name from \p minor and opens it, creating the device
 267  * special file node with the major and minor numbers specified by \p dev and
 268  * parent directory if necessary and was called by root.
 269  */
 270 static int drmOpenDevice(long dev, int minor, int type)
 271 {
 272     stat_t          st;
 273     char            buf[64];
 274     int             fd;
 275     mode_t          devmode = DRM_DEV_MODE, serv_mode;
 276     int             isroot  = !geteuid();
 277     uid_t           user    = DRM_DEV_UID;
 278     gid_t           group   = DRM_DEV_GID, serv_group;
 279
 280     sprintf(buf, type ? DRM_DEV_NAME : DRM_CONTROL_DEV_NAME, DRM_DIR_NAME, minor);
 281     drmMsg("drmOpenDevice: node name is %s\n", buf);
 282
 283     if (drm_server_info) {
 284         drm_server_info->get_perms(&serv_group, &serv_mode);
 285         devmode  = serv_mode ? serv_mode : DRM_DEV_MODE;
 286         devmode &= ~(S_IXUSR|S_IXGRP|S_IXOTH);
 287         group = (serv_group >= 0) ? serv_group : DRM_DEV_GID;
 288     }
 289
 290     if (stat(DRM_DIR_NAME, &st)) {
 291         if (!isroot)
 292             return DRM_ERR_NOT_ROOT;
 293         mkdir(DRM_DIR_NAME, DRM_DEV_DIRMODE);
 294         chown(DRM_DIR_NAME, 0, 0); /* root:root */
 295         chmod(DRM_DIR_NAME, DRM_DEV_DIRMODE);
 296     }
 297
 298     /* Check if the device node exists and create it if necessary. */
 299     if (stat(buf, &st)) {
 300         if (!isroot)
 301             return DRM_ERR_NOT_ROOT;
 302         remove(buf);
 303         mknod(buf, S_IFCHR | devmode, dev);
 304     }
 305
 306     if (drm_server_info) {
 307         chown(buf, user, group);
 308         chmod(buf, devmode);
 309     }
 310
 311     fd = open(buf, O_RDWR, 0);
 312     drmMsg("drmOpenDevice: open result is %d, (%s)\n",
 313                 fd, fd < 0 ? strerror(errno) : "OK");
 314     if (fd >= 0)
 315         return fd;
 316
 317     /* Check if the device node is not what we expect it to be, and recreate it
 318      * and try again if so.
 319      */
 320     if (st.st_rdev != dev) {
 321         if (!isroot)
 322             return DRM_ERR_NOT_ROOT;
 323         remove(buf);
 324         mknod(buf, S_IFCHR | devmode, dev);
 325         if (drm_server_info) {
 326             chown(buf, user, group);
 327             chmod(buf, devmode);
 328         }
 329     }
 330     fd = open(buf, O_RDWR, 0);
 331     drmMsg("drmOpenDevice: open result is %d, (%s)\n",
 332                 fd, fd < 0 ? strerror(errno) : "OK");
 333     if (fd >= 0)
 334         return fd;
 335
 336     drmMsg("drmOpenDevice: Open failed\n");
 337     remove(buf);
 338     return -errno;
 339 }
 340
 341
 342 /**
 343  * Open the DRM device
 344  *
 345  * \param minor device minor number.
 346  * \param create allow to create the device if set.
 347  *
 348  * \return a file descriptor on success, or a negative value on error.
 349  *
 350  * \internal
 351  * Calls drmOpenDevice() if \p create is set, otherwise assembles the device
 352  * name from \p minor and opens it.
 353  */
 354 static int drmOpenMinor(int minor, int create, int type)
 355 {
 356     int  fd;
 357     char buf[64];
 358
 359     if (create)
 360       return drmOpenDevice(makedev(DRM_MAJOR, minor), minor, type);
 361
 362     sprintf(buf, type ? DRM_DEV_NAME : DRM_CONTROL_DEV_NAME, DRM_DIR_NAME, minor);
 363     if ((fd = open(buf, O_RDWR, 0)) >= 0)
 364         return fd;
 365     return -errno;
 366 }
 367
 368
 369 /**
 370  * Determine whether the DRM kernel driver has been loaded.
 371  *
 372  * \return 1 if the DRM driver is loaded, 0 otherwise.
 373  *
 374  * \internal
 375  * Determine the presence of the kernel driver by attempting to open the 0
 376  * minor and get version information.  For backward compatibility with older
 377  * Linux implementations, /proc/dri is also checked.
 378  */
 379 int drmAvailable(void)
 380 {
 381     drmVersionPtr version;
 382     int           retval = 0;
 383     int           fd;
 384
 385     if ((fd = drmOpenMinor(0, 1, DRM_NODE_RENDER)) < 0) {
 386 #ifdef __linux__
 387         /* Try proc for backward Linux compatibility */
 388         if (!access("/proc/dri/0", R_OK))
 389             return 1;
 390 #endif
 391         return 0;
 392     }
 393
 394     if ((version = drmGetVersion(fd))) {
 395         retval = 1;
 396         drmFreeVersion(version);
 397     }
 398     close(fd);
 399
 400     return retval;
 401 }
 402
 403
 404 /**
 405  * Open the device by bus ID.
 406  *
 407  * \param busid bus ID.
 408  *
 409  * \return a file descriptor on success, or a negative value on error.
 410  *
 411  * \internal
 412  * This function attempts to open every possible minor (up to DRM_MAX_MINOR),
 413  * comparing the device bus ID with the one supplied.
 414  *
 415  * \sa drmOpenMinor() and drmGetBusid().
 416  */
 417 static int drmOpenByBusid(const char *busid)
 418 {
 419     int        i;
 420     int        fd;
 421     const char *buf;
 422     drmSetVersion sv;
 423
 424     /*
 425      * Open the first minor number that matches the driver name and isn't
 426      * already in use.  If it's in use it will have a busid assigned already.
 427      *
 428      * start at 1, as 0 is the control node, and we should use drmOpenControl
 429      * for that.
 430      */
 431     drmMsg("drmOpenByBusid: Searching for BusID %s\n", busid);
 432     for (i = 1; i < DRM_MAX_MINOR; i++) {
 433         fd = drmOpenMinor(i, 1, DRM_NODE_RENDER);
 434         drmMsg("drmOpenByBusid: drmOpenMinor returns %d\n", fd);
 435         if (fd >= 0) {
 436             sv.drm_di_major = 1;
 437             sv.drm_di_minor = 1;
 438             sv.drm_dd_major = -1;       /* Don't care */
 439             sv.drm_dd_minor = -1;       /* Don't care */
 440             drmSetInterfaceVersion(fd, &sv);
 441             buf = drmGetBusid(fd);
 442             drmMsg("drmOpenByBusid: drmGetBusid reports %s\n", buf);
 443             if (buf && drmMatchBusID(buf, busid)) {
 444                 drmFreeBusid(buf);
 445                 return fd;
 446             }
 447             if (buf)
 448                 drmFreeBusid(buf);
 449             close(fd);
 450         }
 451     }
 452     return -1;
 453 }
 454
 455
 456 /**
 457  * Open the device by name.
 458  *
 459  * \param name driver name.
 460  *
 461  * \return a file descriptor on success, or a negative value on error.
 462  *
 463  * \internal
 464  * This function opens the first minor number that matches the driver name and
 465  * isn't already in use.  If it's in use it then it will already have a bus ID
 466  * assigned.
 467  *
 468  * \sa drmOpenMinor(), drmGetVersion() and drmGetBusid().
 469  */
 470 static int drmOpenByName(const char *name)
 471 {
 472     int           i;
 473     int           fd;
 474     drmVersionPtr version;
 475     char *        id;
 476
 477     /*
 478      * Open the first minor number that matches the driver name and isn't
 479      * already in use.  If it's in use it will have a busid assigned already.
 480      *
 481      * start at 1, as 0 is the control node, and we should use drmOpenControl
 482      * for that.
 483      */
 484     for (i = 1; i < DRM_MAX_MINOR; i++) {
 485         if ((fd = drmOpenMinor(i, 1, DRM_NODE_RENDER)) >= 0) {
 486             if ((version = drmGetVersion(fd))) {
 487                 if (!strcmp(version->name, name)) {
 488                     drmFreeVersion(version);
 489                     id = drmGetBusid(fd);
 490                     drmMsg("drmGetBusid returned '%s'\n", id ? id : "NULL");
 491                     if (!id || !*id) {
 492                         if (id)
 493                             drmFreeBusid(id);
 494                         return fd;
 495                     } else {
 496                         drmFreeBusid(id);
 497                     }
 498                 } else {
 499                     drmFreeVersion(version);
 500                 }
 501             }
 502             close(fd);
 503         }
 504     }
 505
 506 #ifdef __linux__
 507     /* Backward-compatibility /proc support */
 508     for (i = 0; i < 8; i++) {
 509         char proc_name[64], buf[512];
 510         char *driver, *pt, *devstring;
 511         int  retcode;
 512
 513         sprintf(proc_name, "/proc/dri/%d/name", i);
 514         if ((fd = open(proc_name, 0, 0)) >= 0) {
 515             retcode = read(fd, buf, sizeof(buf)-1);
 516             close(fd);
 517             if (retcode) {
 518                 buf[retcode-1] = '\0';
 519                 for (driver = pt = buf; *pt && *pt != ' '; ++pt)
 520                     ;
 521                 if (*pt) { /* Device is next */
 522                     *pt = '\0';
 523                     if (!strcmp(driver, name)) { /* Match */
 524                         for (devstring = ++pt; *pt && *pt != ' '; ++pt)
 525                             ;
 526                         if (*pt) { /* Found busid */
 527                             return drmOpenByBusid(++pt);
 528                         } else { /* No busid */
 529                             return drmOpenDevice(strtol(devstring, NULL, 0),i, DRM_NODE_RENDER);
 530                         }
 531                     }
 532                 }
 533             }
 534         }
 535     }
 536 #endif
 537
 538     return -1;
 539 }
 540
 541
 542 /**
 543  * Open the DRM device.
 544  *
 545  * Looks up the specified name and bus ID, and opens the device found.  The
 546  * entry in /dev/dri is created if necessary and if called by root.
 547  *
 548  * \param name driver name. Not referenced if bus ID is supplied.
 549  * \param busid bus ID. Zero if not known.
 550  *
 551  * \return a file descriptor on success, or a negative value on error.
 552  *
 553  * \internal
 554  * It calls drmOpenByBusid() if \p busid is specified or drmOpenByName()
 555  * otherwise.
 556  */
 557 int drmOpen(const char *name, const char *busid)
 558 {
 559     if (!drmAvailable() && name != NULL && drm_server_info) {
 560         /* try to load the kernel */
 561         if (!drm_server_info->load_module(name)) {
 562             drmMsg("[drm] failed to load kernel module \"%s\"\n", name);
 563             return -1;
 564         }
 565     }
 566
 567     if (busid) {
 568         int fd = drmOpenByBusid(busid);
 569         if (fd >= 0)
 570             return fd;
 571     }
 572
 573     if (name)
 574         return drmOpenByName(name);
 575
 576     return -1;
 577 }
 578
 579 int drmOpenControl(int minor)
 580 {
 581     return drmOpenMinor(minor, 0, DRM_NODE_CONTROL);
 582 }
 583
 584 /**
 585  * Free the version information returned by drmGetVersion().
 586  *
 587  * \param v pointer to the version information.
 588  *
 589  * \internal
 590  * It frees the memory pointed by \p %v as well as all the non-null strings
 591  * pointers in it.
 592  */
 593 void drmFreeVersion(drmVersionPtr v)
 594 {
 595     if (!v)
 596         return;
 597     drmFree(v->name);
 598     drmFree(v->date);
 599     drmFree(v->desc);
 600     drmFree(v);
 601 }
 602
 603
 604 /**
 605  * Free the non-public version information returned by the kernel.
 606  *
 607  * \param v pointer to the version information.
 608  *
 609  * \internal
 610  * Used by drmGetVersion() to free the memory pointed by \p %v as well as all
 611  * the non-null strings pointers in it.
 612  */
 613 static void drmFreeKernelVersion(drm_version_t *v)
 614 {
 615     if (!v)
 616         return;
 617     drmFree(v->name);
 618     drmFree(v->date);
 619     drmFree(v->desc);
 620     drmFree(v);
 621 }
 622
 623
 624 /**
 625  * Copy version information.
 626  *
 627  * \param d destination pointer.
 628  * \param s source pointer.
 629  *
 630  * \internal
 631  * Used by drmGetVersion() to translate the information returned by the ioctl
 632  * interface in a private structure into the public structure counterpart.
 633  */
 634 static void drmCopyVersion(drmVersionPtr d, const drm_version_t *s)
 635 {
 636     d->version_major      = s->version_major;
 637     d->version_minor      = s->version_minor;
 638     d->version_patchlevel = s->version_patchlevel;
 639     d->name_len           = s->name_len;
 640     d->name               = drmStrdup(s->name);
 641     d->date_len           = s->date_len;
 642     d->date               = drmStrdup(s->date);
 643     d->desc_len           = s->desc_len;
 644     d->desc               = drmStrdup(s->desc);
 645 }
 646
 647
 648 /**
 649  * Query the driver version information.
 650  *
 651  * \param fd file descriptor.
 652  *
 653  * \return pointer to a drmVersion structure which should be freed with
 654  * drmFreeVersion().
 655  *
 656  * \note Similar information is available via /proc/dri.
 657  *
 658  * \internal
 659  * It gets the version information via successive DRM_IOCTL_VERSION ioctls,
 660  * first with zeros to get the string lengths, and then the actually strings.
 661  * It also null-terminates them since they might not be already.
 662  */
 663 drmVersionPtr drmGetVersion(int fd)
 664 {
 665     drmVersionPtr retval;
 666     drm_version_t *version = drmMalloc(sizeof(*version));
 667
 668     version->name_len    = 0;
 669     version->name        = NULL;
 670     version->date_len    = 0;
 671     version->date        = NULL;
 672     version->desc_len    = 0;
 673     version->desc        = NULL;
 674
 675     if (ioctl(fd, DRM_IOCTL_VERSION, version)) {
 676         drmFreeKernelVersion(version);
 677         return NULL;
 678     }
 679
 680     if (version->name_len)
 681         version->name    = drmMalloc(version->name_len + 1);
 682     if (version->date_len)
 683         version->date    = drmMalloc(version->date_len + 1);
 684     if (version->desc_len)
 685         version->desc    = drmMalloc(version->desc_len + 1);
 686
 687     if (ioctl(fd, DRM_IOCTL_VERSION, version)) {
 688         drmMsg("DRM_IOCTL_VERSION: %s\n", strerror(errno));
 689         drmFreeKernelVersion(version);
 690         return NULL;
 691     }
 692
 693     /* The results might not be null-terminated strings, so terminate them. */
 694     if (version->name_len) version->name[version->name_len] = '\0';
 695     if (version->date_len) version->date[version->date_len] = '\0';
 696     if (version->desc_len) version->desc[version->desc_len] = '\0';
 697
 698     retval = drmMalloc(sizeof(*retval));
 699     drmCopyVersion(retval, version);
 700     drmFreeKernelVersion(version);
 701     return retval;
 702 }
 703
 704
 705 /**
 706  * Get version information for the DRM user space library.
 707  *
 708  * This version number is driver independent.
 709  *
 710  * \param fd file descriptor.
 711  *
 712  * \return version information.
 713  *
 714  * \internal
 715  * This function allocates and fills a drm_version structure with a hard coded
 716  * version number.
 717  */
 718 drmVersionPtr drmGetLibVersion(int fd)
 719 {
 720     drm_version_t *version = drmMalloc(sizeof(*version));
 721
 722     /* Version history:
 723      *   NOTE THIS MUST NOT GO ABOVE VERSION 1.X due to drivers needing it
 724      *   revision 1.0.x = original DRM interface with no drmGetLibVersion
 725      *                    entry point and many drm<Device> extensions
 726      *   revision 1.1.x = added drmCommand entry points for device extensions
 727      *                    added drmGetLibVersion to identify libdrm.a version
 728      *   revision 1.2.x = added drmSetInterfaceVersion
 729      *                    modified drmOpen to handle both busid and name
 730      *   revision 1.3.x = added server + memory manager
 731      */
 732     version->version_major      = 1;
 733     version->version_minor      = 3;
 734     version->version_patchlevel = 0;
 735
 736     return (drmVersionPtr)version;
 737 }
 738
 739
 740 /**
 741  * Free the bus ID information.
 742  *
 743  * \param busid bus ID information string as given by drmGetBusid().
 744  *
 745  * \internal
 746  * This function is just frees the memory pointed by \p busid.
 747  */
 748 void drmFreeBusid(const char *busid)
 749 {
 750     drmFree((void *)busid);
 751 }
 752
 753
 754 /**
 755  * Get the bus ID of the device.
 756  *
 757  * \param fd file descriptor.
 758  *
 759  * \return bus ID string.
 760  *
 761  * \internal
 762  * This function gets the bus ID via successive DRM_IOCTL_GET_UNIQUE ioctls to
 763  * get the string length and data, passing the arguments in a drm_unique
 764  * structure.
 765  */
 766 char *drmGetBusid(int fd)
 767 {
 768     drm_unique_t u;
 769
 770     u.unique_len = 0;
 771     u.unique     = NULL;
 772
 773     if (ioctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
 774         return NULL;
 775     u.unique = drmMalloc(u.unique_len + 1);
 776     if (ioctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
 777         return NULL;
 778     u.unique[u.unique_len] = '\0';
 779
 780     return u.unique;
 781 }
 782
 783
 784 /**
 785  * Set the bus ID of the device.
 786  *
 787  * \param fd file descriptor.
 788  * \param busid bus ID string.
 789  *
 790  * \return zero on success, negative on failure.
 791  *
 792  * \internal
 793  * This function is a wrapper around the DRM_IOCTL_SET_UNIQUE ioctl, passing
 794  * the arguments in a drm_unique structure.
 795  */
 796 int drmSetBusid(int fd, const char *busid)
 797 {
 798     drm_unique_t u;
 799
 800     u.unique     = (char *)busid;
 801     u.unique_len = strlen(busid);
 802
 803     if (ioctl(fd, DRM_IOCTL_SET_UNIQUE, &u)) {
 804         return -errno;
 805     }
 806     return 0;
 807 }
 808
 809 int drmGetMagic(int fd, drm_magic_t * magic)
 810 {
 811     drm_auth_t auth;
 812
 813     *magic = 0;
 814     if (ioctl(fd, DRM_IOCTL_GET_MAGIC, &auth))
 815         return -errno;
 816     *magic = auth.magic;
 817     return 0;
 818 }
 819
 820 int drmAuthMagic(int fd, drm_magic_t magic)
 821 {
 822     drm_auth_t auth;
 823
 824     auth.magic = magic;
 825     if (ioctl(fd, DRM_IOCTL_AUTH_MAGIC, &auth))
 826         return -errno;
 827     return 0;
 828 }
 829
 830 /**
 831  * Specifies a range of memory that is available for mapping by a
 832  * non-root process.
 833  *
 834  * \param fd file descriptor.
 835  * \param offset usually the physical address. The actual meaning depends of
 836  * the \p type parameter. See below.
 837  * \param size of the memory in bytes.
 838  * \param type type of the memory to be mapped.
 839  * \param flags combination of several flags to modify the function actions.
 840  * \param handle will be set to a value that may be used as the offset
 841  * parameter for mmap().
 842  *
 843  * \return zero on success or a negative value on error.
 844  *
 845  * \par Mapping the frame buffer
 846  * For the frame buffer
 847  * - \p offset will be the physical address of the start of the frame buffer,
 848  * - \p size will be the size of the frame buffer in bytes, and
 849  * - \p type will be DRM_FRAME_BUFFER.
 850  *
 851  * \par
 852  * The area mapped will be uncached. If MTRR support is available in the
 853  * kernel, the frame buffer area will be set to write combining.
 854  *
 855  * \par Mapping the MMIO register area
 856  * For the MMIO register area,
 857  * - \p offset will be the physical address of the start of the register area,
 858  * - \p size will be the size of the register area bytes, and
 859  * - \p type will be DRM_REGISTERS.
 860  * \par
 861  * The area mapped will be uncached.
 862  *
 863  * \par Mapping the SAREA
 864  * For the SAREA,
 865  * - \p offset will be ignored and should be set to zero,
 866  * - \p size will be the desired size of the SAREA in bytes,
 867  * - \p type will be DRM_SHM.
 868  *
 869  * \par
 870  * A shared memory area of the requested size will be created and locked in
 871  * kernel memory. This area may be mapped into client-space by using the handle
 872  * returned.
 873  *
 874  * \note May only be called by root.
 875  *
 876  * \internal
 877  * This function is a wrapper around the DRM_IOCTL_ADD_MAP ioctl, passing
 878  * the arguments in a drm_map structure.
 879  */
 880 int drmAddMap(int fd, drm_handle_t offset, drmSize size, drmMapType type,
 881               drmMapFlags flags, drm_handle_t *handle)
 882 {
 883     drm_map_t map;
 884
 885     map.offset  = offset;
 886     map.size    = size;
 887     map.handle  = 0;
 888     map.type    = type;
 889     map.flags   = flags;
 890     if (ioctl(fd, DRM_IOCTL_ADD_MAP, &map))
 891         return -errno;
 892     if (handle)
 893         *handle = (drm_handle_t)map.handle;
 894     return 0;
 895 }
 896
 897 int drmRmMap(int fd, drm_handle_t handle)
 898 {
 899     drm_map_t map;
 900
 901     map.handle = (void *)handle;
 902
 903     if(ioctl(fd, DRM_IOCTL_RM_MAP, &map))
 904         return -errno;
 905     return 0;
 906 }
 907
 908 /**
 909  * Make buffers available for DMA transfers.
 910  *
 911  * \param fd file descriptor.
 912  * \param count number of buffers.
 913  * \param size size of each buffer.
 914  * \param flags buffer allocation flags.
 915  * \param agp_offset offset in the AGP aperture
 916  *
 917  * \return number of buffers allocated, negative on error.
 918  *
 919  * \internal
 920  * This function is a wrapper around DRM_IOCTL_ADD_BUFS ioctl.
 921  *
 922  * \sa drm_buf_desc.
 923  */
 924 int drmAddBufs(int fd, int count, int size, drmBufDescFlags flags,
 925                int agp_offset)
 926 {
 927     drm_buf_desc_t request;
 928
 929     request.count     = count;
 930     request.size      = size;
 931     request.low_mark  = 0;
 932     request.high_mark = 0;
 933     request.flags     = flags;
 934     request.agp_start = agp_offset;
 935
 936     if (ioctl(fd, DRM_IOCTL_ADD_BUFS, &request))
 937         return -errno;
 938     return request.count;
 939 }
 940
 941 int drmMarkBufs(int fd, double low, double high)
 942 {
 943     drm_buf_info_t info;
 944     int            i;
 945
 946     info.count = 0;
 947     info.list  = NULL;
 948
 949     if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info))
 950         return -EINVAL;
 951
 952     if (!info.count)
 953         return -EINVAL;
 954
 955     if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
 956         return -ENOMEM;
 957
 958     if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
 959         int retval = -errno;
 960         drmFree(info.list);
 961         return retval;
 962     }
 963
 964     for (i = 0; i < info.count; i++) {
 965         info.list[i].low_mark  = low  * info.list[i].count;
 966         info.list[i].high_mark = high * info.list[i].count;
 967         if (ioctl(fd, DRM_IOCTL_MARK_BUFS, &info.list[i])) {
 968             int retval = -errno;
 969             drmFree(info.list);
 970             return retval;
 971         }
 972     }
 973     drmFree(info.list);
 974
 975     return 0;
 976 }
 977
 978 /**
 979  * Free buffers.
 980  *
 981  * \param fd file descriptor.
 982  * \param count number of buffers to free.
 983  * \param list list of buffers to be freed.
 984  *
 985  * \return zero on success, or a negative value on failure.
 986  *
 987  * \note This function is primarily used for debugging.
 988  *
 989  * \internal
 990  * This function is a wrapper around the DRM_IOCTL_FREE_BUFS ioctl, passing
 991  * the arguments in a drm_buf_free structure.
 992  */
 993 int drmFreeBufs(int fd, int count, int *list)
 994 {
 995     drm_buf_free_t request;
 996
 997     request.count = count;
 998     request.list  = list;
 999     if (ioctl(fd, DRM_IOCTL_FREE_BUFS, &request))
1000         return -errno;
1001     return 0;
1002 }
1003
1004
1005 /**
1006  * Close the device.
1007  *
1008  * \param fd file descriptor.
1009  *
1010  * \internal
1011  * This function closes the file descriptor.
1012  */
1013 int drmClose(int fd)
1014 {
1015     unsigned long key    = drmGetKeyFromFd(fd);
1016     drmHashEntry  *entry = drmGetEntry(fd);
1017
1018     drmHashDestroy(entry->tagTable);
1019     entry->fd       = 0;
1020     entry->f        = NULL;
1021     entry->tagTable = NULL;
1022
1023     drmHashDelete(drmHashTable, key);
1024     drmFree(entry);
1025
1026     return close(fd);
1027 }
1028
1029
1030 /**
1031  * Map a region of memory.
1032  *
1033  * \param fd file descriptor.
1034  * \param handle handle returned by drmAddMap().
1035  * \param size size in bytes. Must match the size used by drmAddMap().
1036  * \param address will contain the user-space virtual address where the mapping
1037  * begins.
1038  *
1039  * \return zero on success, or a negative value on failure.
1040  *
1041  * \internal
1042  * This function is a wrapper for mmap().
1043  */
1044 int drmMap(int fd, drm_handle_t handle, drmSize size, drmAddressPtr address)
1045 {
1046     static unsigned long pagesize_mask = 0;
1047
1048     if (fd < 0)
1049         return -EINVAL;
1050
1051     if (!pagesize_mask)
1052         pagesize_mask = getpagesize() - 1;
1053
1054     size = (size + pagesize_mask) & ~pagesize_mask;
1055
1056     *address = mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, handle);
1057     if (*address == MAP_FAILED)
1058         return -errno;
1059     return 0;
1060 }
1061
1062
1063 /**
1064  * Unmap mappings obtained with drmMap().
1065  *
1066  * \param address address as given by drmMap().
1067  * \param size size in bytes. Must match the size used by drmMap().
1068  *
1069  * \return zero on success, or a negative value on failure.
1070  *
1071  * \internal
1072  * This function is a wrapper for munmap().
1073  */
1074 int drmUnmap(drmAddress address, drmSize size)
1075 {
1076     return munmap(address, size);
1077 }
1078
1079 drmBufInfoPtr drmGetBufInfo(int fd)
1080 {
1081     drm_buf_info_t info;
1082     drmBufInfoPtr  retval;
1083     int            i;
1084
1085     info.count = 0;
1086     info.list  = NULL;
1087
1088     if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info))
1089         return NULL;
1090
1091     if (info.count) {
1092         if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
1093             return NULL;
1094
1095         if (ioctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
1096             drmFree(info.list);
1097             return NULL;
1098         }
1099
1100         retval = drmMalloc(sizeof(*retval));
1101         retval->count = info.count;
1102         retval->list  = drmMalloc(info.count * sizeof(*retval->list));
1103         for (i = 0; i < info.count; i++) {
1104             retval->list[i].count     = info.list[i].count;
1105             retval->list[i].size      = info.list[i].size;
1106             retval->list[i].low_mark  = info.list[i].low_mark;
1107             retval->list[i].high_mark = info.list[i].high_mark;
1108         }
1109         drmFree(info.list);
1110         return retval;
1111     }
1112     return NULL;
1113 }
1114
1115 /**
1116  * Map all DMA buffers into client-virtual space.
1117  *
1118  * \param fd file descriptor.
1119  *
1120  * \return a pointer to a ::drmBufMap structure.
1121  *
1122  * \note The client may not use these buffers until obtaining buffer indices
1123  * with drmDMA().
1124  *
1125  * \internal
1126  * This function calls the DRM_IOCTL_MAP_BUFS ioctl and copies the returned
1127  * information about the buffers in a drm_buf_map structure into the
1128  * client-visible data structures.
1129  */
1130 drmBufMapPtr drmMapBufs(int fd)
1131 {
1132     drm_buf_map_t bufs;
1133     drmBufMapPtr  retval;
1134     int           i;
1135
1136     bufs.count = 0;
1137     bufs.list  = NULL;
1138     bufs.virtual = NULL;
1139     if (ioctl(fd, DRM_IOCTL_MAP_BUFS, &bufs))
1140         return NULL;
1141
1142     if (!bufs.count)
1143         return NULL;
1144
1145         if (!(bufs.list = drmMalloc(bufs.count * sizeof(*bufs.list))))
1146             return NULL;
1147
1148         if (ioctl(fd, DRM_IOCTL_MAP_BUFS, &bufs)) {
1149             drmFree(bufs.list);
1150             return NULL;
1151         }
1152
1153         retval = drmMalloc(sizeof(*retval));
1154         retval->count = bufs.count;
1155         retval->list  = drmMalloc(bufs.count * sizeof(*retval->list));
1156         for (i = 0; i < bufs.count; i++) {
1157             retval->list[i].idx     = bufs.list[i].idx;
1158             retval->list[i].total   = bufs.list[i].total;
1159             retval->list[i].used    = 0;
1160             retval->list[i].address = bufs.list[i].address;
1161         }
1162
1163         drmFree(bufs.list);
1164
1165         return retval;
1166 }
1167
1168
1169 /**
1170  * Unmap buffers allocated with drmMapBufs().
1171  *
1172  * \return zero on success, or negative value on failure.
1173  *
1174  * \internal
1175  * Calls munmap() for every buffer stored in \p bufs and frees the
1176  * memory allocated by drmMapBufs().
1177  */
1178 int drmUnmapBufs(drmBufMapPtr bufs)
1179 {
1180     int i;
1181
1182     for (i = 0; i < bufs->count; i++) {
1183         munmap(bufs->list[i].address, bufs->list[i].total);
1184     }
1185
1186     drmFree(bufs->list);
1187     drmFree(bufs);
1188
1189     return 0;
1190 }
1191
1192
1193 #define DRM_DMA_RETRY           16
1194
1195 /**
1196  * Reserve DMA buffers.
1197  *
1198  * \param fd file descriptor.
1199  * \param request
1200  *
1201  * \return zero on success, or a negative value on failure.
1202  *
1203  * \internal
1204  * Assemble the arguments into a drm_dma structure and keeps issuing the
1205  * DRM_IOCTL_DMA ioctl until success or until maximum number of retries.
1206  */
1207 int drmDMA(int fd, drmDMAReqPtr request)
1208 {
1209     drm_dma_t dma;
1210     int ret, i = 0;
1211
1212     dma.context         = request->context;
1213     dma.send_count      = request->send_count;
1214     dma.send_indices    = request->send_list;
1215     dma.send_sizes      = request->send_sizes;
1216     dma.flags           = request->flags;
1217     dma.request_count   = request->request_count;
1218     dma.request_size    = request->request_size;
1219     dma.request_indices = request->request_list;
1220     dma.request_sizes   = request->request_sizes;
1221     dma.granted_count   = 0;
1222
1223     do {
1224         ret = ioctl( fd, DRM_IOCTL_DMA, &dma );
1225     } while ( ret && errno == EAGAIN && i++ < DRM_DMA_RETRY );
1226
1227     if ( ret == 0 ) {
1228         request->granted_count = dma.granted_count;
1229         return 0;
1230     } else {
1231         return -errno;
1232     }
1233 }
1234
1235
1236 /**
1237  * Obtain heavyweight hardware lock.
1238  *
1239  * \param fd file descriptor.
1240  * \param context context.
1241  * \param flags flags that determine the sate of the hardware when the function
1242  * returns.
1243  *
1244  * \return always zero.
1245  *
1246  * \internal
1247  * This function translates the arguments into a drm_lock structure and issue
1248  * the DRM_IOCTL_LOCK ioctl until the lock is successfully acquired.
1249  */
1250 int drmGetLock(int fd, drm_context_t context, drmLockFlags flags)
1251 {
1252     drm_lock_t lock;
1253
1254     lock.context = context;
1255     lock.flags   = 0;
1256     if (flags & DRM_LOCK_READY)      lock.flags |= _DRM_LOCK_READY;
1257     if (flags & DRM_LOCK_QUIESCENT)  lock.flags |= _DRM_LOCK_QUIESCENT;
1258     if (flags & DRM_LOCK_FLUSH)      lock.flags |= _DRM_LOCK_FLUSH;
1259     if (flags & DRM_LOCK_FLUSH_ALL)  lock.flags |= _DRM_LOCK_FLUSH_ALL;
1260     if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
1261     if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
1262
1263     while (ioctl(fd, DRM_IOCTL_LOCK, &lock))
1264         ;
1265     return 0;
1266 }
1267
1268 /**
1269  * Release the hardware lock.
1270  *
1271  * \param fd file descriptor.
1272  * \param context context.
1273  *
1274  * \return zero on success, or a negative value on failure.
1275  *
1276  * \internal
1277  * This function is a wrapper around the DRM_IOCTL_UNLOCK ioctl, passing the
1278  * argument in a drm_lock structure.
1279  */
1280 int drmUnlock(int fd, drm_context_t context)
1281 {
1282     drm_lock_t lock;
1283
1284     lock.context = context;
1285     lock.flags   = 0;
1286     return ioctl(fd, DRM_IOCTL_UNLOCK, &lock);
1287 }
1288
1289 drm_context_t *drmGetReservedContextList(int fd, int *count)
1290 {
1291     drm_ctx_res_t res;
1292     drm_ctx_t     *list;
1293     drm_context_t * retval;
1294     int           i;
1295
1296     res.count    = 0;
1297     res.contexts = NULL;
1298     if (ioctl(fd, DRM_IOCTL_RES_CTX, &res))
1299         return NULL;
1300
1301     if (!res.count)
1302         return NULL;
1303
1304     if (!(list   = drmMalloc(res.count * sizeof(*list))))
1305         return NULL;
1306     if (!(retval = drmMalloc(res.count * sizeof(*retval)))) {
1307         drmFree(list);
1308         return NULL;
1309     }
1310
1311     res.contexts = list;
1312     if (ioctl(fd, DRM_IOCTL_RES_CTX, &res))
1313         return NULL;
1314
1315     for (i = 0; i < res.count; i++)
1316         retval[i] = list[i].handle;
1317     drmFree(list);
1318
1319     *count = res.count;
1320     return retval;
1321 }
1322
1323 void drmFreeReservedContextList(drm_context_t *pt)
1324 {
1325     drmFree(pt);
1326 }
1327
1328 /**
1329  * Create context.
1330  *
1331  * Used by the X server during GLXContext initialization. This causes
1332  * per-context kernel-level resources to be allocated.
1333  *
1334  * \param fd file descriptor.
1335  * \param handle is set on success. To be used by the client when requesting DMA
1336  * dispatch with drmDMA().
1337  *
1338  * \return zero on success, or a negative value on failure.
1339  *
1340  * \note May only be called by root.
1341  *
1342  * \internal
1343  * This function is a wrapper around the DRM_IOCTL_ADD_CTX ioctl, passing the
1344  * argument in a drm_ctx structure.
1345  */
1346 int drmCreateContext(int fd, drm_context_t *handle)
1347 {
1348     drm_ctx_t ctx;
1349
1350     ctx.flags = 0;      /* Modified with functions below */
1351     if (ioctl(fd, DRM_IOCTL_ADD_CTX, &ctx))
1352         return -errno;
1353     *handle = ctx.handle;
1354     return 0;
1355 }
1356
1357 int drmSwitchToContext(int fd, drm_context_t context)
1358 {
1359     drm_ctx_t ctx;
1360
1361     ctx.handle = context;
1362     if (ioctl(fd, DRM_IOCTL_SWITCH_CTX, &ctx))
1363         return -errno;
1364     return 0;
1365 }
1366
1367 int drmSetContextFlags(int fd, drm_context_t context, drm_context_tFlags flags)
1368 {
1369     drm_ctx_t ctx;
1370
1371     /*
1372      * Context preserving means that no context switches are done between DMA
1373      * buffers from one context and the next.  This is suitable for use in the
1374      * X server (which promises to maintain hardware context), or in the
1375      * client-side library when buffers are swapped on behalf of two threads.
1376      */
1377     ctx.handle = context;
1378     ctx.flags  = 0;
1379     if (flags & DRM_CONTEXT_PRESERVED)
1380         ctx.flags |= _DRM_CONTEXT_PRESERVED;
1381     if (flags & DRM_CONTEXT_2DONLY)
1382         ctx.flags |= _DRM_CONTEXT_2DONLY;
1383     if (ioctl(fd, DRM_IOCTL_MOD_CTX, &ctx))
1384         return -errno;
1385     return 0;
1386 }
1387
1388 int drmGetContextFlags(int fd, drm_context_t context,
1389                        drm_context_tFlagsPtr flags)
1390 {
1391     drm_ctx_t ctx;
1392
1393     ctx.handle = context;
1394     if (ioctl(fd, DRM_IOCTL_GET_CTX, &ctx))
1395         return -errno;
1396     *flags = 0;
1397     if (ctx.flags & _DRM_CONTEXT_PRESERVED)
1398         *flags |= DRM_CONTEXT_PRESERVED;
1399     if (ctx.flags & _DRM_CONTEXT_2DONLY)
1400         *flags |= DRM_CONTEXT_2DONLY;
1401     return 0;
1402 }
1403
1404 /**
1405  * Destroy context.
1406  *
1407  * Free any kernel-level resources allocated with drmCreateContext() associated
1408  * with the context.
1409  *
1410  * \param fd file descriptor.
1411  * \param handle handle given by drmCreateContext().
1412  *
1413  * \return zero on success, or a negative value on failure.
1414  *
1415  * \note May only be called by root.
1416  *
1417  * \internal
1418  * This function is a wrapper around the DRM_IOCTL_RM_CTX ioctl, passing the
1419  * argument in a drm_ctx structure.
1420  */
1421 int drmDestroyContext(int fd, drm_context_t handle)
1422 {
1423     drm_ctx_t ctx;
1424     ctx.handle = handle;
1425     if (ioctl(fd, DRM_IOCTL_RM_CTX, &ctx))
1426         return -errno;
1427     return 0;
1428 }
1429
1430 int drmCreateDrawable(int fd, drm_drawable_t *handle)
1431 {
1432     drm_draw_t draw;
1433     if (ioctl(fd, DRM_IOCTL_ADD_DRAW, &draw))
1434         return -errno;
1435     *handle = draw.handle;
1436     return 0;
1437 }
1438
1439 int drmDestroyDrawable(int fd, drm_drawable_t handle)
1440 {
1441     drm_draw_t draw;
1442     draw.handle = handle;
1443     if (ioctl(fd, DRM_IOCTL_RM_DRAW, &draw))
1444         return -errno;
1445     return 0;
1446 }
1447
1448 int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
1449                            drm_drawable_info_type_t type, unsigned int num,
1450                            void *data)
1451 {
1452     drm_update_draw_t update;
1453
1454     update.handle = handle;
1455     update.type = type;
1456     update.num = num;
1457     update.data = (unsigned long long)(unsigned long)data;
1458
1459     if (ioctl(fd, DRM_IOCTL_UPDATE_DRAW, &update))
1460         return -errno;
1461
1462     return 0;
1463 }
1464
1465 /**
1466  * Acquire the AGP device.
1467  *
1468  * Must be called before any of the other AGP related calls.
1469  *
1470  * \param fd file descriptor.
1471  *
1472  * \return zero on success, or a negative value on failure.
1473  *
1474  * \internal
1475  * This function is a wrapper around the DRM_IOCTL_AGP_ACQUIRE ioctl.
1476  */
1477 int drmAgpAcquire(int fd)
1478 {
1479     if (ioctl(fd, DRM_IOCTL_AGP_ACQUIRE, NULL))
1480         return -errno;
1481     return 0;
1482 }
1483
1484
1485 /**
1486  * Release the AGP device.
1487  *
1488  * \param fd file descriptor.
1489  *
1490  * \return zero on success, or a negative value on failure.
1491  *
1492  * \internal
1493  * This function is a wrapper around the DRM_IOCTL_AGP_RELEASE ioctl.
1494  */
1495 int drmAgpRelease(int fd)
1496 {
1497     if (ioctl(fd, DRM_IOCTL_AGP_RELEASE, NULL))
1498         return -errno;
1499     return 0;
1500 }
1501
1502
1503 /**
1504  * Set the AGP mode.
1505  *
1506  * \param fd file descriptor.
1507  * \param mode AGP mode.
1508  *
1509  * \return zero on success, or a negative value on failure.
1510  *
1511  * \internal
1512  * This function is a wrapper around the DRM_IOCTL_AGP_ENABLE ioctl, passing the
1513  * argument in a drm_agp_mode structure.
1514  */
1515 int drmAgpEnable(int fd, unsigned long mode)
1516 {
1517     drm_agp_mode_t m;
1518
1519     m.mode = mode;
1520     if (ioctl(fd, DRM_IOCTL_AGP_ENABLE, &m))
1521         return -errno;
1522     return 0;
1523 }
1524
1525
1526 /**
1527  * Allocate a chunk of AGP memory.
1528  *
1529  * \param fd file descriptor.
1530  * \param size requested memory size in bytes. Will be rounded to page boundary.
1531  * \param type type of memory to allocate.
1532  * \param address if not zero, will be set to the physical address of the
1533  * allocated memory.
1534  * \param handle on success will be set to a handle of the allocated memory.
1535  *
1536  * \return zero on success, or a negative value on failure.
1537  *
1538  * \internal
1539  * This function is a wrapper around the DRM_IOCTL_AGP_ALLOC ioctl, passing the
1540  * arguments in a drm_agp_buffer structure.
1541  */
1542 int drmAgpAlloc(int fd, unsigned long size, unsigned long type,
1543                 unsigned long *address, drm_handle_t *handle)
1544 {
1545     drm_agp_buffer_t b;
1546
1547     *handle = DRM_AGP_NO_HANDLE;
1548     b.size   = size;
1549     b.handle = 0;
1550     b.type   = type;
1551     if (ioctl(fd, DRM_IOCTL_AGP_ALLOC, &b))
1552         return -errno;
1553     if (address != 0UL)
1554         *address = b.physical;
1555     *handle = b.handle;
1556     return 0;
1557 }
1558
1559
1560 /**
1561  * Free a chunk of AGP memory.
1562  *
1563  * \param fd file descriptor.
1564  * \param handle handle to the allocated memory, as given by drmAgpAllocate().
1565  *
1566  * \return zero on success, or a negative value on failure.
1567  *
1568  * \internal
1569  * This function is a wrapper around the DRM_IOCTL_AGP_FREE ioctl, passing the
1570  * argument in a drm_agp_buffer structure.
1571  */
1572 int drmAgpFree(int fd, drm_handle_t handle)
1573 {
1574     drm_agp_buffer_t b;
1575
1576     b.size   = 0;
1577     b.handle = handle;
1578     if (ioctl(fd, DRM_IOCTL_AGP_FREE, &b))
1579         return -errno;
1580     return 0;
1581 }
1582
1583
1584 /**
1585  * Bind a chunk of AGP memory.
1586  *
1587  * \param fd file descriptor.
1588  * \param handle handle to the allocated memory, as given by drmAgpAllocate().
1589  * \param offset offset in bytes. It will round to page boundary.
1590  *
1591  * \return zero on success, or a negative value on failure.
1592  *
1593  * \internal
1594  * This function is a wrapper around the DRM_IOCTL_AGP_BIND ioctl, passing the
1595  * argument in a drm_agp_binding structure.
1596  */
1597 int drmAgpBind(int fd, drm_handle_t handle, unsigned long offset)
1598 {
1599     drm_agp_binding_t b;
1600
1601     b.handle = handle;
1602     b.offset = offset;
1603     if (ioctl(fd, DRM_IOCTL_AGP_BIND, &b))
1604         return -errno;
1605     return 0;
1606 }
1607
1608
1609 /**
1610  * Unbind a chunk of AGP memory.
1611  *
1612  * \param fd file descriptor.
1613  * \param handle handle to the allocated memory, as given by drmAgpAllocate().
1614  *
1615  * \return zero on success, or a negative value on failure.
1616  *
1617  * \internal
1618  * This function is a wrapper around the DRM_IOCTL_AGP_UNBIND ioctl, passing
1619  * the argument in a drm_agp_binding structure.
1620  */
1621 int drmAgpUnbind(int fd, drm_handle_t handle)
1622 {
1623     drm_agp_binding_t b;
1624
1625     b.handle = handle;
1626     b.offset = 0;
1627     if (ioctl(fd, DRM_IOCTL_AGP_UNBIND, &b))
1628         return -errno;
1629     return 0;
1630 }
1631
1632
1633 /**
1634  * Get AGP driver major version number.
1635  *
1636  * \param fd file descriptor.
1637  *
1638  * \return major version number on success, or a negative value on failure..
1639  *
1640  * \internal
1641  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1642  * necessary information in a drm_agp_info structure.
1643  */
1644 int drmAgpVersionMajor(int fd)
1645 {
1646     drm_agp_info_t i;
1647
1648     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1649         return -errno;
1650     return i.agp_version_major;
1651 }
1652
1653
1654 /**
1655  * Get AGP driver minor version number.
1656  *
1657  * \param fd file descriptor.
1658  *
1659  * \return minor version number on success, or a negative value on failure.
1660  *
1661  * \internal
1662  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1663  * necessary information in a drm_agp_info structure.
1664  */
1665 int drmAgpVersionMinor(int fd)
1666 {
1667     drm_agp_info_t i;
1668
1669     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1670         return -errno;
1671     return i.agp_version_minor;
1672 }
1673
1674
1675 /**
1676  * Get AGP mode.
1677  *
1678  * \param fd file descriptor.
1679  *
1680  * \return mode on success, or zero on failure.
1681  *
1682  * \internal
1683  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1684  * necessary information in a drm_agp_info structure.
1685  */
1686 unsigned long drmAgpGetMode(int fd)
1687 {
1688     drm_agp_info_t i;
1689
1690     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1691         return 0;
1692     return i.mode;
1693 }
1694
1695
1696 /**
1697  * Get AGP aperture base.
1698  *
1699  * \param fd file descriptor.
1700  *
1701  * \return aperture base on success, zero on failure.
1702  *
1703  * \internal
1704  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1705  * necessary information in a drm_agp_info structure.
1706  */
1707 unsigned long drmAgpBase(int fd)
1708 {
1709     drm_agp_info_t i;
1710
1711     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1712         return 0;
1713     return i.aperture_base;
1714 }
1715
1716
1717 /**
1718  * Get AGP aperture size.
1719  *
1720  * \param fd file descriptor.
1721  *
1722  * \return aperture size on success, zero on failure.
1723  *
1724  * \internal
1725  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1726  * necessary information in a drm_agp_info structure.
1727  */
1728 unsigned long drmAgpSize(int fd)
1729 {
1730     drm_agp_info_t i;
1731
1732     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1733         return 0;
1734     return i.aperture_size;
1735 }
1736
1737
1738 /**
1739  * Get used AGP memory.
1740  *
1741  * \param fd file descriptor.
1742  *
1743  * \return memory used on success, or zero on failure.
1744  *
1745  * \internal
1746  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1747  * necessary information in a drm_agp_info structure.
1748  */
1749 unsigned long drmAgpMemoryUsed(int fd)
1750 {
1751     drm_agp_info_t i;
1752
1753     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1754         return 0;
1755     return i.memory_used;
1756 }
1757
1758
1759 /**
1760  * Get available AGP memory.
1761  *
1762  * \param fd file descriptor.
1763  *
1764  * \return memory available on success, or zero on failure.
1765  *
1766  * \internal
1767  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1768  * necessary information in a drm_agp_info structure.
1769  */
1770 unsigned long drmAgpMemoryAvail(int fd)
1771 {
1772     drm_agp_info_t i;
1773
1774     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1775         return 0;
1776     return i.memory_allowed;
1777 }
1778
1779
1780 /**
1781  * Get hardware vendor ID.
1782  *
1783  * \param fd file descriptor.
1784  *
1785  * \return vendor ID on success, or zero on failure.
1786  *
1787  * \internal
1788  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1789  * necessary information in a drm_agp_info structure.
1790  */
1791 unsigned int drmAgpVendorId(int fd)
1792 {
1793     drm_agp_info_t i;
1794
1795     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1796         return 0;
1797     return i.id_vendor;
1798 }
1799
1800
1801 /**
1802  * Get hardware device ID.
1803  *
1804  * \param fd file descriptor.
1805  *
1806  * \return zero on success, or zero on failure.
1807  *
1808  * \internal
1809  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1810  * necessary information in a drm_agp_info structure.
1811  */
1812 unsigned int drmAgpDeviceId(int fd)
1813 {
1814     drm_agp_info_t i;
1815
1816     if (ioctl(fd, DRM_IOCTL_AGP_INFO, &i))
1817         return 0;
1818     return i.id_device;
1819 }
1820
1821 int drmScatterGatherAlloc(int fd, unsigned long size, drm_handle_t *handle)
1822 {
1823     drm_scatter_gather_t sg;
1824
1825     *handle = 0;
1826     sg.size   = size;
1827     sg.handle = 0;
1828     if (ioctl(fd, DRM_IOCTL_SG_ALLOC, &sg))
1829         return -errno;
1830     *handle = sg.handle;
1831     return 0;
1832 }
1833
1834 int drmScatterGatherFree(int fd, drm_handle_t handle)
1835 {
1836     drm_scatter_gather_t sg;
1837
1838     sg.size   = 0;
1839     sg.handle = handle;
1840     if (ioctl(fd, DRM_IOCTL_SG_FREE, &sg))
1841         return -errno;
1842     return 0;
1843 }
1844
1845 /**
1846  * Wait for VBLANK.
1847  *
1848  * \param fd file descriptor.
1849  * \param vbl pointer to a drmVBlank structure.
1850  *
1851  * \return zero on success, or a negative value on failure.
1852  *
1853  * \internal
1854  * This function is a wrapper around the DRM_IOCTL_WAIT_VBLANK ioctl.
1855  */
1856 int drmWaitVBlank(int fd, drmVBlankPtr vbl)
1857 {
1858     int ret;
1859
1860     do {
1861        ret = ioctl(fd, DRM_IOCTL_WAIT_VBLANK, vbl);
1862        vbl->request.type &= ~DRM_VBLANK_RELATIVE;
1863     } while (ret && errno == EINTR);
1864
1865     return ret;
1866 }
1867
1868 int drmError(int err, const char *label)
1869 {
1870     switch (err) {
1871     case DRM_ERR_NO_DEVICE:
1872         fprintf(stderr, "%s: no device\n", label);
1873         break;
1874     case DRM_ERR_NO_ACCESS:
1875         fprintf(stderr, "%s: no access\n", label);
1876         break;
1877     case DRM_ERR_NOT_ROOT:
1878         fprintf(stderr, "%s: not root\n", label);
1879         break;
1880     case DRM_ERR_INVALID:
1881         fprintf(stderr, "%s: invalid args\n", label);
1882         break;
1883     default:
1884         if (err < 0)
1885             err = -err;
1886         fprintf( stderr, "%s: error %d (%s)\n", label, err, strerror(err) );
1887         break;
1888     }
1889
1890     return 1;
1891 }
1892
1893 /**
1894  * Install IRQ handler.
1895  *
1896  * \param fd file descriptor.
1897  * \param irq IRQ number.
1898  *
1899  * \return zero on success, or a negative value on failure.
1900  *
1901  * \internal
1902  * This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the
1903  * argument in a drm_control structure.
1904  */
1905 int drmCtlInstHandler(int fd, int irq)
1906 {
1907     drm_control_t ctl;
1908
1909     ctl.func  = DRM_INST_HANDLER;
1910     ctl.irq   = irq;
1911     if (ioctl(fd, DRM_IOCTL_CONTROL, &ctl))
1912         return -errno;
1913     return 0;
1914 }
1915
1916
1917 /**
1918  * Uninstall IRQ handler.
1919  *
1920  * \param fd file descriptor.
1921  *
1922  * \return zero on success, or a negative value on failure.
1923  *
1924  * \internal
1925  * This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the
1926  * argument in a drm_control structure.
1927  */
1928 int drmCtlUninstHandler(int fd)
1929 {
1930     drm_control_t ctl;
1931
1932     ctl.func  = DRM_UNINST_HANDLER;
1933     ctl.irq   = 0;
1934     if (ioctl(fd, DRM_IOCTL_CONTROL, &ctl))
1935         return -errno;
1936     return 0;
1937 }
1938
1939 int drmFinish(int fd, int context, drmLockFlags flags)
1940 {
1941     drm_lock_t lock;
1942
1943     lock.context = context;
1944     lock.flags   = 0;
1945     if (flags & DRM_LOCK_READY)      lock.flags |= _DRM_LOCK_READY;
1946     if (flags & DRM_LOCK_QUIESCENT)  lock.flags |= _DRM_LOCK_QUIESCENT;
1947     if (flags & DRM_LOCK_FLUSH)      lock.flags |= _DRM_LOCK_FLUSH;
1948     if (flags & DRM_LOCK_FLUSH_ALL)  lock.flags |= _DRM_LOCK_FLUSH_ALL;
1949     if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
1950     if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
1951     if (ioctl(fd, DRM_IOCTL_FINISH, &lock))
1952         return -errno;
1953     return 0;
1954 }
1955
1956 /**
1957  * Get IRQ from bus ID.
1958  *
1959  * \param fd file descriptor.
1960  * \param busnum bus number.
1961  * \param devnum device number.
1962  * \param funcnum function number.
1963  *
1964  * \return IRQ number on success, or a negative value on failure.
1965  *
1966  * \internal
1967  * This function is a wrapper around the DRM_IOCTL_IRQ_BUSID ioctl, passing the
1968  * arguments in a drm_irq_busid structure.
1969  */
1970 int drmGetInterruptFromBusID(int fd, int busnum, int devnum, int funcnum)
1971 {
1972     drm_irq_busid_t p;
1973
1974     p.busnum  = busnum;
1975     p.devnum  = devnum;
1976     p.funcnum = funcnum;
1977     if (ioctl(fd, DRM_IOCTL_IRQ_BUSID, &p))
1978         return -errno;
1979     return p.irq;
1980 }
1981
1982 int drmAddContextTag(int fd, drm_context_t context, void *tag)
1983 {
1984     drmHashEntry  *entry = drmGetEntry(fd);
1985
1986     if (drmHashInsert(entry->tagTable, context, tag)) {
1987         drmHashDelete(entry->tagTable, context);
1988         drmHashInsert(entry->tagTable, context, tag);
1989     }
1990     return 0;
1991 }
1992
1993 int drmDelContextTag(int fd, drm_context_t context)
1994 {
1995     drmHashEntry  *entry = drmGetEntry(fd);
1996
1997     return drmHashDelete(entry->tagTable, context);
1998 }
1999
2000 void *drmGetContextTag(int fd, drm_context_t context)
2001 {
2002     drmHashEntry  *entry = drmGetEntry(fd);
2003     void          *value;
2004
2005     if (drmHashLookup(entry->tagTable, context, &value))
2006         return NULL;
2007
2008     return value;
2009 }
2010
2011 int drmAddContextPrivateMapping(int fd, drm_context_t ctx_id,
2012                                 drm_handle_t handle)
2013 {
2014     drm_ctx_priv_map_t map;
2015
2016     map.ctx_id = ctx_id;
2017     map.handle = (void *)handle;
2018
2019     if (ioctl(fd, DRM_IOCTL_SET_SAREA_CTX, &map))
2020         return -errno;
2021     return 0;
2022 }
2023
2024 int drmGetContextPrivateMapping(int fd, drm_context_t ctx_id,
2025                                 drm_handle_t *handle)
2026 {
2027     drm_ctx_priv_map_t map;
2028
2029     map.ctx_id = ctx_id;
2030
2031     if (ioctl(fd, DRM_IOCTL_GET_SAREA_CTX, &map))
2032         return -errno;
2033     if (handle)
2034         *handle = (drm_handle_t)map.handle;
2035
2036     return 0;
2037 }
2038
2039 int drmGetMap(int fd, int idx, drm_handle_t *offset, drmSize *size,
2040               drmMapType *type, drmMapFlags *flags, drm_handle_t *handle,
2041               int *mtrr)
2042 {
2043     drm_map_t map;
2044
2045     map.offset = idx;
2046     if (ioctl(fd, DRM_IOCTL_GET_MAP, &map))
2047         return -errno;
2048     *offset = map.offset;
2049     *size   = map.size;
2050     *type   = map.type;
2051     *flags  = map.flags;
2052     *handle = (unsigned long)map.handle;
2053     *mtrr   = map.mtrr;
2054     return 0;
2055 }
2056
2057 int drmGetClient(int fd, int idx, int *auth, int *pid, int *uid,
2058                  unsigned long *magic, unsigned long *iocs)
2059 {
2060     drm_client_t client;
2061
2062     client.idx = idx;
2063     if (ioctl(fd, DRM_IOCTL_GET_CLIENT, &client))
2064         return -errno;
2065     *auth      = client.auth;
2066     *pid       = client.pid;
2067     *uid       = client.uid;
2068     *magic     = client.magic;
2069     *iocs      = client.iocs;
2070     return 0;
2071 }
2072
2073 int drmGetStats(int fd, drmStatsT *stats)
2074 {
2075     drm_stats_t s;
2076     int         i;
2077
2078     if (ioctl(fd, DRM_IOCTL_GET_STATS, &s))
2079         return -errno;
2080
2081     stats->count = 0;
2082     memset(stats, 0, sizeof(*stats));
2083     if (s.count > sizeof(stats->data)/sizeof(stats->data[0]))
2084         return -1;
2085
2086 #define SET_VALUE                              \
2087     stats->data[i].long_format = "%-20.20s";   \
2088     stats->data[i].rate_format = "%8.8s";      \
2089     stats->data[i].isvalue     = 1;            \
2090     stats->data[i].verbose     = 0
2091
2092 #define SET_COUNT                              \
2093     stats->data[i].long_format = "%-20.20s";   \
2094     stats->data[i].rate_format = "%5.5s";      \
2095     stats->data[i].isvalue     = 0;            \
2096     stats->data[i].mult_names  = "kgm";        \
2097     stats->data[i].mult        = 1000;         \
2098     stats->data[i].verbose     = 0
2099
2100 #define SET_BYTE                               \
2101     stats->data[i].long_format = "%-20.20s";   \
2102     stats->data[i].rate_format = "%5.5s";      \
2103     stats->data[i].isvalue     = 0;            \
2104     stats->data[i].mult_names  = "KGM";        \
2105     stats->data[i].mult        = 1024;         \
2106     stats->data[i].verbose     = 0
2107
2108
2109     stats->count = s.count;
2110     for (i = 0; i < s.count; i++) {
2111         stats->data[i].value = s.data[i].value;
2112         switch (s.data[i].type) {
2113         case _DRM_STAT_LOCK:
2114             stats->data[i].long_name = "Lock";
2115             stats->data[i].rate_name = "Lock";
2116             SET_VALUE;
2117             break;
2118         case _DRM_STAT_OPENS:
2119             stats->data[i].long_name = "Opens";
2120             stats->data[i].rate_name = "O";
2121             SET_COUNT;
2122             stats->data[i].verbose   = 1;
2123             break;
2124         case _DRM_STAT_CLOSES:
2125             stats->data[i].long_name = "Closes";
2126             stats->data[i].rate_name = "Lock";
2127             SET_COUNT;
2128             stats->data[i].verbose   = 1;
2129             break;
2130         case _DRM_STAT_IOCTLS:
2131             stats->data[i].long_name = "Ioctls";
2132             stats->data[i].rate_name = "Ioc/s";
2133             SET_COUNT;
2134             break;
2135         case _DRM_STAT_LOCKS:
2136             stats->data[i].long_name = "Locks";
2137             stats->data[i].rate_name = "Lck/s";
2138             SET_COUNT;
2139             break;
2140         case _DRM_STAT_UNLOCKS:
2141             stats->data[i].long_name = "Unlocks";
2142             stats->data[i].rate_name = "Unl/s";
2143             SET_COUNT;
2144             break;
2145         case _DRM_STAT_IRQ:
2146             stats->data[i].long_name = "IRQs";
2147             stats->data[i].rate_name = "IRQ/s";
2148             SET_COUNT;
2149             break;
2150         case _DRM_STAT_PRIMARY:
2151             stats->data[i].long_name = "Primary Bytes";
2152             stats->data[i].rate_name = "PB/s";
2153             SET_BYTE;
2154             break;
2155         case _DRM_STAT_SECONDARY:
2156             stats->data[i].long_name = "Secondary Bytes";
2157             stats->data[i].rate_name = "SB/s";
2158             SET_BYTE;
2159             break;
2160         case _DRM_STAT_DMA:
2161             stats->data[i].long_name = "DMA";
2162             stats->data[i].rate_name = "DMA/s";
2163             SET_COUNT;
2164             break;
2165         case _DRM_STAT_SPECIAL:
2166             stats->data[i].long_name = "Special DMA";
2167             stats->data[i].rate_name = "dma/s";
2168             SET_COUNT;
2169             break;
2170         case _DRM_STAT_MISSED:
2171             stats->data[i].long_name = "Miss";
2172             stats->data[i].rate_name = "Ms/s";
2173             SET_COUNT;
2174             break;
2175         case _DRM_STAT_VALUE:
2176             stats->data[i].long_name = "Value";
2177             stats->data[i].rate_name = "Value";
2178             SET_VALUE;
2179             break;
2180         case _DRM_STAT_BYTE:
2181             stats->data[i].long_name = "Bytes";
2182             stats->data[i].rate_name = "B/s";
2183             SET_BYTE;
2184             break;
2185         case _DRM_STAT_COUNT:
2186         default:
2187             stats->data[i].long_name = "Count";
2188             stats->data[i].rate_name = "Cnt/s";
2189             SET_COUNT;
2190             break;
2191         }
2192     }
2193     return 0;
2194 }
2195
2196 /**
2197  * Issue a set-version ioctl.
2198  *
2199  * \param fd file descriptor.
2200  * \param drmCommandIndex command index
2201  * \param data source pointer of the data to be read and written.
2202  * \param size size of the data to be read and written.
2203  *
2204  * \return zero on success, or a negative value on failure.
2205  *
2206  * \internal
2207  * It issues a read-write ioctl given by
2208  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2209  */
2210 int drmSetInterfaceVersion(int fd, drmSetVersion *version)
2211 {
2212     int retcode = 0;
2213     drm_set_version_t sv;
2214
2215     sv.drm_di_major = version->drm_di_major;
2216     sv.drm_di_minor = version->drm_di_minor;
2217     sv.drm_dd_major = version->drm_dd_major;
2218     sv.drm_dd_minor = version->drm_dd_minor;
2219
2220     if (ioctl(fd, DRM_IOCTL_SET_VERSION, &sv)) {
2221         retcode = -errno;
2222     }
2223
2224     version->drm_di_major = sv.drm_di_major;
2225     version->drm_di_minor = sv.drm_di_minor;
2226     version->drm_dd_major = sv.drm_dd_major;
2227     version->drm_dd_minor = sv.drm_dd_minor;
2228
2229     return retcode;
2230 }
2231
2232 /**
2233  * Send a device-specific command.
2234  *
2235  * \param fd file descriptor.
2236  * \param drmCommandIndex command index
2237  *
2238  * \return zero on success, or a negative value on failure.
2239  *
2240  * \internal
2241  * It issues a ioctl given by
2242  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2243  */
2244 int drmCommandNone(int fd, unsigned long drmCommandIndex)
2245 {
2246     void *data = NULL; /* dummy */
2247     unsigned long request;
2248
2249     request = DRM_IO( DRM_COMMAND_BASE + drmCommandIndex);
2250
2251     if (ioctl(fd, request, data)) {
2252         return -errno;
2253     }
2254     return 0;
2255 }
2256
2257
2258 /**
2259  * Send a device-specific read command.
2260  *
2261  * \param fd file descriptor.
2262  * \param drmCommandIndex command index
2263  * \param data destination pointer of the data to be read.
2264  * \param size size of the data to be read.
2265  *
2266  * \return zero on success, or a negative value on failure.
2267  *
2268  * \internal
2269  * It issues a read ioctl given by
2270  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2271  */
2272 int drmCommandRead(int fd, unsigned long drmCommandIndex, void *data,
2273                    unsigned long size)
2274 {
2275     unsigned long request;
2276
2277     request = DRM_IOC( DRM_IOC_READ, DRM_IOCTL_BASE,
2278         DRM_COMMAND_BASE + drmCommandIndex, size);
2279
2280     if (ioctl(fd, request, data)) {
2281         return -errno;
2282     }
2283     return 0;
2284 }
2285
2286
2287 /**
2288  * Send a device-specific write command.
2289  *
2290  * \param fd file descriptor.
2291  * \param drmCommandIndex command index
2292  * \param data source pointer of the data to be written.
2293  * \param size size of the data to be written.
2294  *
2295  * \return zero on success, or a negative value on failure.
2296  *
2297  * \internal
2298  * It issues a write ioctl given by
2299  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2300  */
2301 int drmCommandWrite(int fd, unsigned long drmCommandIndex, void *data,
2302                     unsigned long size)
2303 {
2304     unsigned long request;
2305
2306     request = DRM_IOC( DRM_IOC_WRITE, DRM_IOCTL_BASE,
2307         DRM_COMMAND_BASE + drmCommandIndex, size);
2308
2309     if (ioctl(fd, request, data)) {
2310         return -errno;
2311     }
2312     return 0;
2313 }
2314
2315
2316 /**
2317  * Send a device-specific read-write command.
2318  *
2319  * \param fd file descriptor.
2320  * \param drmCommandIndex command index
2321  * \param data source pointer of the data to be read and written.
2322  * \param size size of the data to be read and written.
2323  *
2324  * \return zero on success, or a negative value on failure.
2325  *
2326  * \internal
2327  * It issues a read-write ioctl given by
2328  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2329  */
2330 int drmCommandWriteRead(int fd, unsigned long drmCommandIndex, void *data,
2331                         unsigned long size)
2332 {
2333     unsigned long request;
2334
2335     request = DRM_IOC( DRM_IOC_READ|DRM_IOC_WRITE, DRM_IOCTL_BASE,
2336         DRM_COMMAND_BASE + drmCommandIndex, size);
2337
2338     if (ioctl(fd, request, data)) {
2339         return -errno;
2340     }
2341     return 0;
2342 }
2343
2344
2345 /*
2346  * Valid flags are
2347  * DRM_FENCE_FLAG_EMIT
2348  * DRM_FENCE_FLAG_SHAREABLE
2349  * DRM_FENCE_MASK_DRIVER
2350  */
2351
2352 int drmFenceCreate(int fd, unsigned flags, int fence_class, unsigned type,
2353                    drmFence *fence)
2354 {
2355     drm_fence_arg_t arg;
2356
2357     memset(&arg, 0, sizeof(arg));
2358     arg.flags = flags;
2359     arg.type = type;
2360     arg.fence_class = fence_class;
2361
2362     if (ioctl(fd, DRM_IOCTL_FENCE_CREATE, &arg))
2363         return -errno;
2364     fence->handle = arg.handle;
2365     fence->fence_class = arg.fence_class;
2366     fence->type = arg.type;
2367     fence->flags = arg.flags;
2368     fence->signaled = 0;
2369     return 0;
2370 }
2371
2372 /*
2373  * Valid flags are
2374  * DRM_FENCE_FLAG_SHAREABLE
2375  * DRM_FENCE_MASK_DRIVER
2376  */
2377
2378 int drmFenceBuffers(int fd, unsigned flags, uint32_t fence_class, drmFence *fence)
2379 {
2380     drm_fence_arg_t arg;
2381
2382     memset(&arg, 0, sizeof(arg));
2383     arg.flags = flags;
2384     arg.fence_class = fence_class;
2385
2386     if (ioctl(fd, DRM_IOCTL_FENCE_BUFFERS, &arg))
2387         return -errno;
2388     fence->handle = arg.handle;
2389     fence->fence_class = arg.fence_class;
2390     fence->type = arg.type;
2391     fence->flags = arg.flags;
2392     fence->sequence = arg.sequence;
2393     fence->signaled = 0;
2394     return 0;
2395 }
2396
2397 int drmFenceReference(int fd, unsigned handle, drmFence *fence)
2398 {
2399     drm_fence_arg_t arg;
2400
2401     memset(&arg, 0, sizeof(arg));
2402     arg.handle = handle;
2403
2404     if (ioctl(fd, DRM_IOCTL_FENCE_REFERENCE, &arg))
2405         return -errno;
2406     fence->handle = arg.handle;
2407     fence->fence_class = arg.fence_class;
2408     fence->type = arg.type;
2409     fence->flags = arg.flags;
2410     fence->signaled = arg.signaled;
2411     return 0;
2412 }
2413
2414 int drmFenceUnreference(int fd, const drmFence *fence)
2415 {
2416     drm_fence_arg_t arg;
2417
2418     memset(&arg, 0, sizeof(arg));
2419     arg.handle = fence->handle;
2420
2421     if (ioctl(fd, DRM_IOCTL_FENCE_UNREFERENCE, &arg))
2422         return -errno;
2423     return 0;
2424 }
2425
2426 int drmFenceFlush(int fd, drmFence *fence, unsigned flush_type)
2427 {
2428     drm_fence_arg_t arg;
2429
2430     memset(&arg, 0, sizeof(arg));
2431     arg.handle = fence->handle;
2432     arg.type = flush_type;
2433
2434     if (ioctl(fd, DRM_IOCTL_FENCE_FLUSH, &arg))
2435         return -errno;
2436     fence->fence_class = arg.fence_class;
2437     fence->type = arg.type;
2438     fence->signaled = arg.signaled;
2439     return arg.error;
2440 }
2441
2442 int drmFenceUpdate(int fd, drmFence *fence)
2443 {
2444     drm_fence_arg_t arg;
2445
2446     memset(&arg, 0, sizeof(arg));
2447     arg.handle = fence->handle;
2448
2449     if (ioctl(fd, DRM_IOCTL_FENCE_SIGNALED, &arg))
2450         return -errno;
2451     fence->fence_class = arg.fence_class;
2452     fence->type = arg.type;
2453     fence->signaled = arg.signaled;
2454     return 0;
2455 }
2456
2457 int drmFenceSignaled(int fd, drmFence *fence, unsigned fenceType,
2458                      int *signaled)
2459 {
2460     if ((fence->flags & DRM_FENCE_FLAG_SHAREABLE) ||
2461         ((fenceType & fence->signaled) != fenceType)) {
2462         int ret = drmFenceFlush(fd, fence, fenceType);
2463         if (ret)
2464             return ret;
2465     }
2466
2467     *signaled = ((fenceType & fence->signaled) == fenceType);
2468
2469     return 0;
2470 }
2471
2472 /*
2473  * Valid flags are
2474  * DRM_FENCE_FLAG_SHAREABLE
2475  * DRM_FENCE_MASK_DRIVER
2476  */
2477
2478
2479 int drmFenceEmit(int fd, unsigned flags, drmFence *fence, unsigned emit_type)
2480 {
2481     drm_fence_arg_t arg;
2482
2483     memset(&arg, 0, sizeof(arg));
2484     arg.fence_class = fence->fence_class;
2485     arg.flags = flags;
2486     arg.handle = fence->handle;
2487     arg.type = emit_type;
2488
2489     if (ioctl(fd, DRM_IOCTL_FENCE_EMIT, &arg))
2490         return -errno;
2491     fence->fence_class = arg.fence_class;
2492     fence->type = arg.type;
2493     fence->signaled = arg.signaled;
2494     fence->sequence = arg.sequence;
2495     return 0;
2496 }
2497
2498 /*
2499  * Valid flags are
2500  * DRM_FENCE_FLAG_WAIT_LAZY
2501  * DRM_FENCE_FLAG_WAIT_IGNORE_SIGNALS
2502  */
2503
2504 #define DRM_IOCTL_TIMEOUT_USEC 3000000UL
2505
2506 static unsigned long
2507 drmTimeDiff(struct timeval *now, struct timeval *then)
2508 {
2509     uint64_t val;
2510
2511     val = now->tv_sec - then->tv_sec;
2512     val *= 1000000LL;
2513     val += now->tv_usec;
2514     val -= then->tv_usec;
2515
2516     return (unsigned long) val;
2517 }
2518
2519 static int
2520 drmIoctlTimeout(int fd, unsigned long request, void *argp)
2521 {
2522     int haveThen = 0;
2523     struct timeval then, now;
2524     int ret;
2525
2526     do {
2527         ret = ioctl(fd, request, argp);
2528         if (ret != 0 && errno == EAGAIN) {
2529             if (!haveThen) {
2530                 gettimeofday(&then, NULL);
2531                 haveThen = 1;
2532             }
2533             gettimeofday(&now, NULL);
2534         }
2535     } while (ret != 0 && errno == EAGAIN &&
2536              drmTimeDiff(&now, &then) < DRM_IOCTL_TIMEOUT_USEC);
2537
2538     if (ret != 0)
2539         return ((errno == EAGAIN) ? -EBUSY : -errno);
2540
2541     return 0;
2542 }
2543
2544
2545
2546
2547 int drmFenceWait(int fd, unsigned flags, drmFence *fence, unsigned flush_type)
2548 {
2549     drm_fence_arg_t arg;
2550     int ret;
2551
2552     if (flush_type == 0) {
2553         flush_type = fence->type;
2554     }
2555
2556     if (!(fence->flags & DRM_FENCE_FLAG_SHAREABLE)) {
2557         if ((flush_type & fence->signaled) == flush_type) {
2558             return 0;
2559         }
2560     }
2561
2562     memset(&arg, 0, sizeof(arg));
2563     arg.handle = fence->handle;
2564     arg.type = flush_type;
2565     arg.flags = flags;
2566
2567
2568     ret = drmIoctlTimeout(fd, DRM_IOCTL_FENCE_WAIT, &arg);
2569     if (ret)
2570         return ret;
2571
2572     fence->fence_class = arg.fence_class;
2573     fence->type = arg.type;
2574     fence->signaled = arg.signaled;
2575     return arg.error;
2576 }
2577
2578 static void drmBOCopyReply(const struct drm_bo_info_rep *rep, drmBO *buf)
2579 {
2580     buf->handle = rep->handle;
2581     buf->flags = rep->flags;
2582     buf->size = rep->size;
2583     buf->offset = rep->offset;
2584     buf->mapHandle = rep->arg_handle;
2585     buf->proposedFlags = rep->proposed_flags;
2586     buf->start = rep->buffer_start;
2587     buf->fenceFlags = rep->fence_flags;
2588     buf->replyFlags = rep->rep_flags;
2589     buf->pageAlignment = rep->page_alignment;
2590     buf->tileInfo = rep->tile_info;
2591     buf->hwTileStride = rep->hw_tile_stride;
2592     buf->desiredTileStride = rep->desired_tile_stride;
2593 }
2594
2595
2596
2597 int drmBOCreate(int fd, unsigned long size,
2598                 unsigned pageAlignment, void *user_buffer,
2599                 uint64_t flags,
2600                 unsigned hint, drmBO *buf)
2601 {
2602     struct drm_bo_create_arg arg;
2603     struct drm_bo_create_req *req = &arg.d.req;
2604     struct drm_bo_info_rep *rep = &arg.d.rep;
2605     int ret;
2606
2607     memset(buf, 0, sizeof(*buf));
2608     memset(&arg, 0, sizeof(arg));
2609     req->flags = flags;
2610     req->hint = hint;
2611     req->size = size;
2612     req->page_alignment = pageAlignment;
2613     req->buffer_start = (unsigned long) user_buffer;
2614
2615     buf->virtual = NULL;
2616
2617     ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_CREATE, &arg);
2618     if (ret)
2619         return ret;
2620
2621     drmBOCopyReply(rep, buf);
2622     buf->virtual = user_buffer;
2623     buf->mapCount = 0;
2624
2625     return 0;
2626 }
2627
2628 int drmBOReference(int fd, unsigned handle, drmBO *buf)
2629 {
2630     struct drm_bo_reference_info_arg arg;
2631     struct drm_bo_handle_arg *req = &arg.d.req;
2632     struct drm_bo_info_rep *rep = &arg.d.rep;
2633
2634     memset(&arg, 0, sizeof(arg));
2635     req->handle = handle;
2636
2637     if (ioctl(fd, DRM_IOCTL_BO_REFERENCE, &arg))
2638         return -errno;
2639
2640     drmBOCopyReply(rep, buf);
2641     buf->mapVirtual = NULL;
2642     buf->mapCount = 0;
2643     buf->virtual = NULL;
2644
2645     return 0;
2646 }
2647
2648 int drmBOUnreference(int fd, drmBO *buf)
2649 {
2650     struct drm_bo_handle_arg arg;
2651
2652     if (buf->mapVirtual && buf->mapHandle) {
2653         (void) munmap(buf->mapVirtual, buf->start + buf->size);
2654         buf->mapVirtual = NULL;
2655         buf->virtual = NULL;
2656     }
2657
2658     memset(&arg, 0, sizeof(arg));
2659     arg.handle = buf->handle;
2660
2661     if (ioctl(fd, DRM_IOCTL_BO_UNREFERENCE, &arg))
2662         return -errno;
2663
2664     buf->handle = 0;
2665     return 0;
2666 }
2667
2668
2669 /*
2670  * Flags can be  DRM_BO_FLAG_READ, DRM_BO_FLAG_WRITE or'ed together
2671  * Hint currently be DRM_BO_HINT_DONT_BLOCK, which makes the
2672  * call return an -EBUSY if it can' immediately honor the mapping request.
2673  */
2674
2675 int drmBOMap(int fd, drmBO *buf, unsigned mapFlags, unsigned mapHint,
2676              void **address)
2677 {
2678     struct drm_bo_map_wait_idle_arg arg;
2679     struct drm_bo_info_req *req = &arg.d.req;
2680     struct drm_bo_info_rep *rep = &arg.d.rep;
2681     int ret = 0;
2682
2683     /*
2684      * Make sure we have a virtual address of the buffer.
2685      */
2686
2687     if (!buf->virtual) {
2688         drmAddress virtual;
2689         virtual = mmap(0, buf->size + buf->start,
2690                        PROT_READ | PROT_WRITE, MAP_SHARED,
2691                        fd, buf->mapHandle);
2692         if (virtual == MAP_FAILED) {
2693             ret = -errno;
2694         }
2695         if (ret)
2696             return ret;
2697         buf->mapVirtual = virtual;
2698         buf->virtual = ((char *) virtual) + buf->start;
2699     }
2700
2701     memset(&arg, 0, sizeof(arg));
2702     req->handle = buf->handle;
2703     req->mask = mapFlags;
2704     req->hint = mapHint;
2705
2706     /*
2707      * May hang if the buffer object is busy.
2708      * This IOCTL synchronizes the buffer.
2709      */
2710
2711     ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_MAP, &arg);
2712     if (ret)
2713         return ret;
2714
2715     drmBOCopyReply(rep, buf);
2716     buf->mapFlags = mapFlags;
2717     ++buf->mapCount;
2718     *address = buf->virtual;
2719
2720     return 0;
2721 }
2722
2723
2724 int drmBOUnmap(int fd, drmBO *buf)
2725 {
2726     struct drm_bo_handle_arg arg;
2727
2728     memset(&arg, 0, sizeof(arg));
2729     arg.handle = buf->handle;
2730
2731     if (ioctl(fd, DRM_IOCTL_BO_UNMAP, &arg)) {
2732         return -errno;
2733     }
2734     buf->mapCount--;
2735     return 0;
2736 }
2737
2738 int drmBOSetStatus(int fd, drmBO *buf,
2739                    uint64_t flags, uint64_t mask,
2740                    unsigned int hint,
2741                    unsigned int desired_tile_stride,
2742                    unsigned int tile_info)
2743 {
2744
2745     struct drm_bo_map_wait_idle_arg arg;
2746     struct drm_bo_info_req *req = &arg.d.req;
2747     struct drm_bo_info_rep *rep = &arg.d.rep;
2748     int ret = 0;
2749
2750     memset(&arg, 0, sizeof(arg));
2751     req->mask = mask;
2752     req->flags = flags;
2753     req->handle = buf->handle;
2754     req->hint = hint;
2755     req->desired_tile_stride = desired_tile_stride;
2756     req->tile_info = tile_info;
2757
2758     ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_SETSTATUS, &arg);
2759     if (ret)
2760             return ret;
2761
2762     drmBOCopyReply(rep, buf);
2763     return 0;
2764 }
2765
2766
2767 int drmBOInfo(int fd, drmBO *buf)
2768 {
2769     struct drm_bo_reference_info_arg arg;
2770     struct drm_bo_handle_arg *req = &arg.d.req;
2771     struct drm_bo_info_rep *rep = &arg.d.rep;
2772     int ret = 0;
2773
2774     memset(&arg, 0, sizeof(arg));
2775     req->handle = buf->handle;
2776
2777     ret = ioctl(fd, DRM_IOCTL_BO_INFO, &arg);
2778     if (ret)
2779         return -errno;
2780
2781     drmBOCopyReply(rep, buf);
2782     return 0;
2783 }
2784
2785 int drmBOWaitIdle(int fd, drmBO *buf, unsigned hint)
2786 {
2787     struct drm_bo_map_wait_idle_arg arg;
2788     struct drm_bo_info_req *req = &arg.d.req;
2789     struct drm_bo_info_rep *rep = &arg.d.rep;
2790     int ret = 0;
2791
2792     if ((buf->flags & DRM_BO_FLAG_SHAREABLE) ||
2793         (buf->replyFlags & DRM_BO_REP_BUSY)) {
2794         memset(&arg, 0, sizeof(arg));
2795         req->handle = buf->handle;
2796         req->hint = hint;
2797
2798         ret = drmIoctlTimeout(fd, DRM_IOCTL_BO_WAIT_IDLE, &arg);
2799         if (ret)
2800             return ret;
2801
2802         drmBOCopyReply(rep, buf);
2803     }
2804     return 0;
2805 }
2806
2807 int drmBOBusy(int fd, drmBO *buf, int *busy)
2808 {
2809     if (!(buf->flags & DRM_BO_FLAG_SHAREABLE) &&
2810         !(buf->replyFlags & DRM_BO_REP_BUSY)) {
2811         *busy = 0;
2812         return 0;
2813     }
2814     else {
2815         int ret = drmBOInfo(fd, buf);
2816         if (ret)
2817             return ret;
2818         *busy = (buf->replyFlags & DRM_BO_REP_BUSY);
2819         return 0;
2820     }
2821 }
2822
2823 int drmMMInit(int fd, unsigned long pOffset, unsigned long pSize,
2824               unsigned memType)
2825 {
2826     struct drm_mm_init_arg arg;
2827
2828     memset(&arg, 0, sizeof(arg));
2829
2830     arg.magic = DRM_BO_INIT_MAGIC;
2831     arg.major = DRM_BO_INIT_MAJOR;
2832     arg.minor = DRM_BO_INIT_MINOR;
2833     arg.p_offset = pOffset;
2834     arg.p_size = pSize;
2835     arg.mem_type = memType;
2836
2837     if (ioctl(fd, DRM_IOCTL_MM_INIT, &arg))
2838         return -errno;
2839     return 0;
2840 }
2841
2842 int drmMMTakedown(int fd, unsigned memType)
2843 {
2844     struct drm_mm_type_arg arg;
2845
2846     memset(&arg, 0, sizeof(arg));
2847     arg.mem_type = memType;
2848
2849     if (ioctl(fd, DRM_IOCTL_MM_TAKEDOWN, &arg))
2850         return -errno;
2851     return 0;
2852 }
2853
2854 /*
2855  * If this function returns an error, and lockBM was set to 1,
2856  * the buffer manager is NOT locked.
2857  */
2858
2859 int drmMMLock(int fd, unsigned memType, int lockBM, int ignoreNoEvict)
2860 {
2861     struct drm_mm_type_arg arg;
2862
2863     memset(&arg, 0, sizeof(arg));
2864     arg.mem_type = memType;
2865     arg.lock_flags |= (lockBM) ? DRM_BO_LOCK_UNLOCK_BM : 0;
2866     arg.lock_flags |= (ignoreNoEvict) ? DRM_BO_LOCK_IGNORE_NO_EVICT : 0;
2867
2868     return drmIoctlTimeout(fd, DRM_IOCTL_MM_LOCK, &arg);
2869 }
2870
2871 int drmMMUnlock(int fd, unsigned memType, int unlockBM)
2872 {
2873     struct drm_mm_type_arg arg;
2874
2875     memset(&arg, 0, sizeof(arg));
2876
2877     arg.mem_type = memType;
2878     arg.lock_flags |= (unlockBM) ? DRM_BO_LOCK_UNLOCK_BM : 0;
2879
2880     return drmIoctlTimeout(fd, DRM_IOCTL_MM_UNLOCK, &arg);
2881 }
2882
2883 int drmBOVersion(int fd, unsigned int *major,
2884                  unsigned int *minor,
2885                  unsigned int *patchlevel)
2886 {
2887     struct drm_bo_version_arg arg;
2888     int ret;
2889
2890     memset(&arg, 0, sizeof(arg));
2891     ret = ioctl(fd, DRM_IOCTL_BO_VERSION, &arg);
2892     if (ret)
2893         return -errno;
2894
2895     if (major)
2896         *major = arg.major;
2897     if (minor)
2898         *minor = arg.minor;
2899     if (patchlevel)
2900         *patchlevel = arg.patchlevel;
2901
2902     return 0;
2903 }
2904
2905
2906
2907 #define DRM_MAX_FDS 16
2908 static struct {
2909     char *BusID;
2910     int fd;
2911     int refcount;
2912 } connection[DRM_MAX_FDS];
2913
2914 static int nr_fds = 0;
2915
2916 int drmOpenOnce(void *unused,
2917                 const char *BusID,
2918                 int *newlyopened)
2919 {
2920     int i;
2921     int fd;
2922
2923     for (i = 0; i < nr_fds; i++)
2924         if (strcmp(BusID, connection[i].BusID) == 0) {
2925             connection[i].refcount++;
2926             *newlyopened = 0;
2927             return connection[i].fd;
2928         }
2929
2930     fd = drmOpen(unused, BusID);
2931     if (fd <= 0 || nr_fds == DRM_MAX_FDS)
2932         return fd;
2933
2934     connection[nr_fds].BusID = strdup(BusID);
2935     connection[nr_fds].fd = fd;
2936     connection[nr_fds].refcount = 1;
2937     *newlyopened = 1;
2938
2939     if (0)
2940         fprintf(stderr, "saved connection %d for %s %d\n",
2941                 nr_fds, connection[nr_fds].BusID,
2942                 strcmp(BusID, connection[nr_fds].BusID));
2943
2944     nr_fds++;
2945
2946     return fd;
2947 }
2948
2949 void drmCloseOnce(int fd)
2950 {
2951     int i;
2952
2953     for (i = 0; i < nr_fds; i++) {
2954         if (fd == connection[i].fd) {
2955             if (--connection[i].refcount == 0) {
2956                 drmClose(connection[i].fd);
2957                 free(connection[i].BusID);
2958
2959                 if (i < --nr_fds)
2960                     connection[i] = connection[nr_fds];
2961
2962                 return;
2963             }
2964         }
2965     }
2966 }