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 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <stdbool.h>
  37 #include <unistd.h>
  38 #include <string.h>
  39 #include <strings.h>
  40 #include <ctype.h>
  41 #include <dirent.h>
  42 #include <stddef.h>
  43 #include <fcntl.h>
  44 #include <errno.h>
  45 #include <limits.h>
  46 #include <signal.h>
  47 #include <time.h>
  48 #include <sys/types.h>
  49 #include <sys/stat.h>
  50 #define stat_t struct stat
  51 #include <sys/ioctl.h>
  52 #include <sys/time.h>
  53 #include <stdarg.h>
  54 #ifdef MAJOR_IN_MKDEV
  55 #include <sys/mkdev.h>
  56 #endif
  57 #ifdef MAJOR_IN_SYSMACROS
  58 #include <sys/sysmacros.h>
  59 #endif
  60 #include <math.h>
  61
  62 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  63
  64 /* Not all systems have MAP_FAILED defined */
  65 #ifndef MAP_FAILED
  66 #define MAP_FAILED ((void *)-1)
  67 #endif
  68
  69 #include "xf86drm.h"
  70 #include "libdrm_macros.h"
  71
  72 #include "util_math.h"
  73
  74 #ifdef __OpenBSD__
  75 #define DRM_PRIMARY_MINOR_NAME  "drm"
  76 #define DRM_CONTROL_MINOR_NAME  "drmC"
  77 #define DRM_RENDER_MINOR_NAME   "drmR"
  78 #else
  79 #define DRM_PRIMARY_MINOR_NAME  "card"
  80 #define DRM_CONTROL_MINOR_NAME  "controlD"
  81 #define DRM_RENDER_MINOR_NAME   "renderD"
  82 #endif
  83
  84 #if defined(__FreeBSD__) || defined(__FreeBSD_kernel__) || defined(__DragonFly__)
  85 #define DRM_MAJOR 145
  86 #endif
  87
  88 #ifdef __NetBSD__
  89 #define DRM_MAJOR 34
  90 #endif
  91
  92 #ifdef __OpenBSD__
  93 #ifdef __i386__
  94 #define DRM_MAJOR 88
  95 #else
  96 #define DRM_MAJOR 87
  97 #endif
  98 #endif /* __OpenBSD__ */
  99
 100 #ifndef DRM_MAJOR
 101 #define DRM_MAJOR 226 /* Linux */
 102 #endif
 103
 104 #if defined(__OpenBSD__) || defined(__DragonFly__)
 105 struct drm_pciinfo {
 106         uint16_t        domain;
 107         uint8_t         bus;
 108         uint8_t         dev;
 109         uint8_t         func;
 110         uint16_t        vendor_id;
 111         uint16_t        device_id;
 112         uint16_t        subvendor_id;
 113         uint16_t        subdevice_id;
 114         uint8_t         revision_id;
 115 };
 116
 117 #define DRM_IOCTL_GET_PCIINFO   DRM_IOR(0x15, struct drm_pciinfo)
 118 #endif
 119
 120 #define DRM_MSG_VERBOSITY 3
 121
 122 #define memclear(s) memset(&s, 0, sizeof(s))
 123
 124 static drmServerInfoPtr drm_server_info;
 125
 126 drm_public void drmSetServerInfo(drmServerInfoPtr info)
 127 {
 128     drm_server_info = info;
 129 }
 130
 131 /**
 132  * Output a message to stderr.
 133  *
 134  * \param format printf() like format string.
 135  *
 136  * \internal
 137  * This function is a wrapper around vfprintf().
 138  */
 139
 140 static int DRM_PRINTFLIKE(1, 0)
 141 drmDebugPrint(const char *format, va_list ap)
 142 {
 143     return vfprintf(stderr, format, ap);
 144 }
 145
 146 drm_public void
 147 drmMsg(const char *format, ...)
 148 {
 149     va_list ap;
 150     const char *env;
 151     if (((env = getenv("LIBGL_DEBUG")) && strstr(env, "verbose")) ||
 152         (drm_server_info && drm_server_info->debug_print))
 153     {
 154         va_start(ap, format);
 155         if (drm_server_info) {
 156             drm_server_info->debug_print(format,ap);
 157         } else {
 158             drmDebugPrint(format, ap);
 159         }
 160         va_end(ap);
 161     }
 162 }
 163
 164 static void *drmHashTable = NULL; /* Context switch callbacks */
 165
 166 drm_public void *drmGetHashTable(void)
 167 {
 168     return drmHashTable;
 169 }
 170
 171 drm_public void *drmMalloc(int size)
 172 {
 173     return calloc(1, size);
 174 }
 175
 176 drm_public void drmFree(void *pt)
 177 {
 178     free(pt);
 179 }
 180
 181 /**
 182  * Call ioctl, restarting if it is interrupted
 183  */
 184 drm_public int
 185 drmIoctl(int fd, unsigned long request, void *arg)
 186 {
 187     int ret;
 188
 189     do {
 190         ret = ioctl(fd, request, arg);
 191     } while (ret == -1 && (errno == EINTR || errno == EAGAIN));
 192     return ret;
 193 }
 194
 195 static unsigned long drmGetKeyFromFd(int fd)
 196 {
 197     stat_t     st;
 198
 199     st.st_rdev = 0;
 200     fstat(fd, &st);
 201     return st.st_rdev;
 202 }
 203
 204 drm_public drmHashEntry *drmGetEntry(int fd)
 205 {
 206     unsigned long key = drmGetKeyFromFd(fd);
 207     void          *value;
 208     drmHashEntry  *entry;
 209
 210     if (!drmHashTable)
 211         drmHashTable = drmHashCreate();
 212
 213     if (drmHashLookup(drmHashTable, key, &value)) {
 214         entry           = drmMalloc(sizeof(*entry));
 215         entry->fd       = fd;
 216         entry->f        = NULL;
 217         entry->tagTable = drmHashCreate();
 218         drmHashInsert(drmHashTable, key, entry);
 219     } else {
 220         entry = value;
 221     }
 222     return entry;
 223 }
 224
 225 /**
 226  * Compare two busid strings
 227  *
 228  * \param first
 229  * \param second
 230  *
 231  * \return 1 if matched.
 232  *
 233  * \internal
 234  * This function compares two bus ID strings.  It understands the older
 235  * PCI:b:d:f format and the newer pci:oooo:bb:dd.f format.  In the format, o is
 236  * domain, b is bus, d is device, f is function.
 237  */
 238 static int drmMatchBusID(const char *id1, const char *id2, int pci_domain_ok)
 239 {
 240     /* First, check if the IDs are exactly the same */
 241     if (strcasecmp(id1, id2) == 0)
 242         return 1;
 243
 244     /* Try to match old/new-style PCI bus IDs. */
 245     if (strncasecmp(id1, "pci", 3) == 0) {
 246         unsigned int o1, b1, d1, f1;
 247         unsigned int o2, b2, d2, f2;
 248         int ret;
 249
 250         ret = sscanf(id1, "pci:%04x:%02x:%02x.%u", &o1, &b1, &d1, &f1);
 251         if (ret != 4) {
 252             o1 = 0;
 253             ret = sscanf(id1, "PCI:%u:%u:%u", &b1, &d1, &f1);
 254             if (ret != 3)
 255                 return 0;
 256         }
 257
 258         ret = sscanf(id2, "pci:%04x:%02x:%02x.%u", &o2, &b2, &d2, &f2);
 259         if (ret != 4) {
 260             o2 = 0;
 261             ret = sscanf(id2, "PCI:%u:%u:%u", &b2, &d2, &f2);
 262             if (ret != 3)
 263                 return 0;
 264         }
 265
 266         /* If domains aren't properly supported by the kernel interface,
 267          * just ignore them, which sucks less than picking a totally random
 268          * card with "open by name"
 269          */
 270         if (!pci_domain_ok)
 271             o1 = o2 = 0;
 272
 273         if ((o1 != o2) || (b1 != b2) || (d1 != d2) || (f1 != f2))
 274             return 0;
 275         else
 276             return 1;
 277     }
 278     return 0;
 279 }
 280
 281 /**
 282  * Handles error checking for chown call.
 283  *
 284  * \param path to file.
 285  * \param id of the new owner.
 286  * \param id of the new group.
 287  *
 288  * \return zero if success or -1 if failure.
 289  *
 290  * \internal
 291  * Checks for failure. If failure was caused by signal call chown again.
 292  * If any other failure happened then it will output error message using
 293  * drmMsg() call.
 294  */
 295 #if !UDEV
 296 static int chown_check_return(const char *path, uid_t owner, gid_t group)
 297 {
 298         int rv;
 299
 300         do {
 301             rv = chown(path, owner, group);
 302         } while (rv != 0 && errno == EINTR);
 303
 304         if (rv == 0)
 305             return 0;
 306
 307         drmMsg("Failed to change owner or group for file %s! %d: %s\n",
 308                path, errno, strerror(errno));
 309         return -1;
 310 }
 311 #endif
 312
 313 /**
 314  * Open the DRM device, creating it if necessary.
 315  *
 316  * \param dev major and minor numbers of the device.
 317  * \param minor minor number of the device.
 318  *
 319  * \return a file descriptor on success, or a negative value on error.
 320  *
 321  * \internal
 322  * Assembles the device name from \p minor and opens it, creating the device
 323  * special file node with the major and minor numbers specified by \p dev and
 324  * parent directory if necessary and was called by root.
 325  */
 326 static int drmOpenDevice(dev_t dev, int minor, int type)
 327 {
 328     stat_t          st;
 329     const char      *dev_name;
 330     char            buf[64];
 331     int             fd;
 332     mode_t          devmode = DRM_DEV_MODE, serv_mode;
 333     gid_t           serv_group;
 334 #if !UDEV
 335     int             isroot  = !geteuid();
 336     uid_t           user    = DRM_DEV_UID;
 337     gid_t           group   = DRM_DEV_GID;
 338 #endif
 339
 340     switch (type) {
 341     case DRM_NODE_PRIMARY:
 342         dev_name = DRM_DEV_NAME;
 343         break;
 344     case DRM_NODE_CONTROL:
 345         dev_name = DRM_CONTROL_DEV_NAME;
 346         break;
 347     case DRM_NODE_RENDER:
 348         dev_name = DRM_RENDER_DEV_NAME;
 349         break;
 350     default:
 351         return -EINVAL;
 352     };
 353
 354     sprintf(buf, dev_name, DRM_DIR_NAME, minor);
 355     drmMsg("drmOpenDevice: node name is %s\n", buf);
 356
 357     if (drm_server_info && drm_server_info->get_perms) {
 358         drm_server_info->get_perms(&serv_group, &serv_mode);
 359         devmode  = serv_mode ? serv_mode : DRM_DEV_MODE;
 360         devmode &= ~(S_IXUSR|S_IXGRP|S_IXOTH);
 361     }
 362
 363 #if !UDEV
 364     if (stat(DRM_DIR_NAME, &st)) {
 365         if (!isroot)
 366             return DRM_ERR_NOT_ROOT;
 367         mkdir(DRM_DIR_NAME, DRM_DEV_DIRMODE);
 368         chown_check_return(DRM_DIR_NAME, 0, 0); /* root:root */
 369         chmod(DRM_DIR_NAME, DRM_DEV_DIRMODE);
 370     }
 371
 372     /* Check if the device node exists and create it if necessary. */
 373     if (stat(buf, &st)) {
 374         if (!isroot)
 375             return DRM_ERR_NOT_ROOT;
 376         remove(buf);
 377         mknod(buf, S_IFCHR | devmode, dev);
 378     }
 379
 380     if (drm_server_info && drm_server_info->get_perms) {
 381         group = ((int)serv_group >= 0) ? serv_group : DRM_DEV_GID;
 382         chown_check_return(buf, user, group);
 383         chmod(buf, devmode);
 384     }
 385 #else
 386     /* if we modprobed then wait for udev */
 387     {
 388         int udev_count = 0;
 389 wait_for_udev:
 390         if (stat(DRM_DIR_NAME, &st)) {
 391             usleep(20);
 392             udev_count++;
 393
 394             if (udev_count == 50)
 395                 return -1;
 396             goto wait_for_udev;
 397         }
 398
 399         if (stat(buf, &st)) {
 400             usleep(20);
 401             udev_count++;
 402
 403             if (udev_count == 50)
 404                 return -1;
 405             goto wait_for_udev;
 406         }
 407     }
 408 #endif
 409
 410     fd = open(buf, O_RDWR | O_CLOEXEC, 0);
 411     drmMsg("drmOpenDevice: open result is %d, (%s)\n",
 412            fd, fd < 0 ? strerror(errno) : "OK");
 413     if (fd >= 0)
 414         return fd;
 415
 416 #if !UDEV
 417     /* Check if the device node is not what we expect it to be, and recreate it
 418      * and try again if so.
 419      */
 420     if (st.st_rdev != dev) {
 421         if (!isroot)
 422             return DRM_ERR_NOT_ROOT;
 423         remove(buf);
 424         mknod(buf, S_IFCHR | devmode, dev);
 425         if (drm_server_info && drm_server_info->get_perms) {
 426             chown_check_return(buf, user, group);
 427             chmod(buf, devmode);
 428         }
 429     }
 430     fd = open(buf, O_RDWR | O_CLOEXEC, 0);
 431     drmMsg("drmOpenDevice: open result is %d, (%s)\n",
 432            fd, fd < 0 ? strerror(errno) : "OK");
 433     if (fd >= 0)
 434         return fd;
 435
 436     drmMsg("drmOpenDevice: Open failed\n");
 437     remove(buf);
 438 #endif
 439     return -errno;
 440 }
 441
 442
 443 /**
 444  * Open the DRM device
 445  *
 446  * \param minor device minor number.
 447  * \param create allow to create the device if set.
 448  *
 449  * \return a file descriptor on success, or a negative value on error.
 450  *
 451  * \internal
 452  * Calls drmOpenDevice() if \p create is set, otherwise assembles the device
 453  * name from \p minor and opens it.
 454  */
 455 static int drmOpenMinor(int minor, int create, int type)
 456 {
 457     int  fd;
 458     char buf[64];
 459     const char *dev_name;
 460
 461     if (create)
 462         return drmOpenDevice(makedev(DRM_MAJOR, minor), minor, type);
 463
 464     switch (type) {
 465     case DRM_NODE_PRIMARY:
 466         dev_name = DRM_DEV_NAME;
 467         break;
 468     case DRM_NODE_CONTROL:
 469         dev_name = DRM_CONTROL_DEV_NAME;
 470         break;
 471     case DRM_NODE_RENDER:
 472         dev_name = DRM_RENDER_DEV_NAME;
 473         break;
 474     default:
 475         return -EINVAL;
 476     };
 477
 478     sprintf(buf, dev_name, DRM_DIR_NAME, minor);
 479     if ((fd = open(buf, O_RDWR | O_CLOEXEC, 0)) >= 0)
 480         return fd;
 481     return -errno;
 482 }
 483
 484
 485 /**
 486  * Determine whether the DRM kernel driver has been loaded.
 487  *
 488  * \return 1 if the DRM driver is loaded, 0 otherwise.
 489  *
 490  * \internal
 491  * Determine the presence of the kernel driver by attempting to open the 0
 492  * minor and get version information.  For backward compatibility with older
 493  * Linux implementations, /proc/dri is also checked.
 494  */
 495 drm_public int drmAvailable(void)
 496 {
 497     drmVersionPtr version;
 498     int           retval = 0;
 499     int           fd;
 500
 501     if ((fd = drmOpenMinor(0, 1, DRM_NODE_PRIMARY)) < 0) {
 502 #ifdef __linux__
 503         /* Try proc for backward Linux compatibility */
 504         if (!access("/proc/dri/0", R_OK))
 505             return 1;
 506 #endif
 507         return 0;
 508     }
 509
 510     if ((version = drmGetVersion(fd))) {
 511         retval = 1;
 512         drmFreeVersion(version);
 513     }
 514     close(fd);
 515
 516     return retval;
 517 }
 518
 519 static int drmGetMinorBase(int type)
 520 {
 521     switch (type) {
 522     case DRM_NODE_PRIMARY:
 523         return 0;
 524     case DRM_NODE_CONTROL:
 525         return 64;
 526     case DRM_NODE_RENDER:
 527         return 128;
 528     default:
 529         return -1;
 530     };
 531 }
 532
 533 static int drmGetMinorType(int minor)
 534 {
 535     int type = minor >> 6;
 536
 537     if (minor < 0)
 538         return -1;
 539
 540     switch (type) {
 541     case DRM_NODE_PRIMARY:
 542     case DRM_NODE_CONTROL:
 543     case DRM_NODE_RENDER:
 544         return type;
 545     default:
 546         return -1;
 547     }
 548 }
 549
 550 static const char *drmGetMinorName(int type)
 551 {
 552     switch (type) {
 553     case DRM_NODE_PRIMARY:
 554         return DRM_PRIMARY_MINOR_NAME;
 555     case DRM_NODE_CONTROL:
 556         return DRM_CONTROL_MINOR_NAME;
 557     case DRM_NODE_RENDER:
 558         return DRM_RENDER_MINOR_NAME;
 559     default:
 560         return NULL;
 561     }
 562 }
 563
 564 /**
 565  * Open the device by bus ID.
 566  *
 567  * \param busid bus ID.
 568  * \param type device node type.
 569  *
 570  * \return a file descriptor on success, or a negative value on error.
 571  *
 572  * \internal
 573  * This function attempts to open every possible minor (up to DRM_MAX_MINOR),
 574  * comparing the device bus ID with the one supplied.
 575  *
 576  * \sa drmOpenMinor() and drmGetBusid().
 577  */
 578 static int drmOpenByBusid(const char *busid, int type)
 579 {
 580     int        i, pci_domain_ok = 1;
 581     int        fd;
 582     const char *buf;
 583     drmSetVersion sv;
 584     int        base = drmGetMinorBase(type);
 585
 586     if (base < 0)
 587         return -1;
 588
 589     drmMsg("drmOpenByBusid: Searching for BusID %s\n", busid);
 590     for (i = base; i < base + DRM_MAX_MINOR; i++) {
 591         fd = drmOpenMinor(i, 1, type);
 592         drmMsg("drmOpenByBusid: drmOpenMinor returns %d\n", fd);
 593         if (fd >= 0) {
 594             /* We need to try for 1.4 first for proper PCI domain support
 595              * and if that fails, we know the kernel is busted
 596              */
 597             sv.drm_di_major = 1;
 598             sv.drm_di_minor = 4;
 599             sv.drm_dd_major = -1;        /* Don't care */
 600             sv.drm_dd_minor = -1;        /* Don't care */
 601             if (drmSetInterfaceVersion(fd, &sv)) {
 602 #ifndef __alpha__
 603                 pci_domain_ok = 0;
 604 #endif
 605                 sv.drm_di_major = 1;
 606                 sv.drm_di_minor = 1;
 607                 sv.drm_dd_major = -1;       /* Don't care */
 608                 sv.drm_dd_minor = -1;       /* Don't care */
 609                 drmMsg("drmOpenByBusid: Interface 1.4 failed, trying 1.1\n");
 610                 drmSetInterfaceVersion(fd, &sv);
 611             }
 612             buf = drmGetBusid(fd);
 613             drmMsg("drmOpenByBusid: drmGetBusid reports %s\n", buf);
 614             if (buf && drmMatchBusID(buf, busid, pci_domain_ok)) {
 615                 drmFreeBusid(buf);
 616                 return fd;
 617             }
 618             if (buf)
 619                 drmFreeBusid(buf);
 620             close(fd);
 621         }
 622     }
 623     return -1;
 624 }
 625
 626
 627 /**
 628  * Open the device by name.
 629  *
 630  * \param name driver name.
 631  * \param type the device node type.
 632  *
 633  * \return a file descriptor on success, or a negative value on error.
 634  *
 635  * \internal
 636  * This function opens the first minor number that matches the driver name and
 637  * isn't already in use.  If it's in use it then it will already have a bus ID
 638  * assigned.
 639  *
 640  * \sa drmOpenMinor(), drmGetVersion() and drmGetBusid().
 641  */
 642 static int drmOpenByName(const char *name, int type)
 643 {
 644     int           i;
 645     int           fd;
 646     drmVersionPtr version;
 647     char *        id;
 648     int           base = drmGetMinorBase(type);
 649
 650     if (base < 0)
 651         return -1;
 652
 653     /*
 654      * Open the first minor number that matches the driver name and isn't
 655      * already in use.  If it's in use it will have a busid assigned already.
 656      */
 657     for (i = base; i < base + DRM_MAX_MINOR; i++) {
 658         if ((fd = drmOpenMinor(i, 1, type)) >= 0) {
 659             if ((version = drmGetVersion(fd))) {
 660                 if (!strcmp(version->name, name)) {
 661                     drmFreeVersion(version);
 662                     id = drmGetBusid(fd);
 663                     drmMsg("drmGetBusid returned '%s'\n", id ? id : "NULL");
 664                     if (!id || !*id) {
 665                         if (id)
 666                             drmFreeBusid(id);
 667                         return fd;
 668                     } else {
 669                         drmFreeBusid(id);
 670                     }
 671                 } else {
 672                     drmFreeVersion(version);
 673                 }
 674             }
 675             close(fd);
 676         }
 677     }
 678
 679 #ifdef __linux__
 680     /* Backward-compatibility /proc support */
 681     for (i = 0; i < 8; i++) {
 682         char proc_name[64], buf[512];
 683         char *driver, *pt, *devstring;
 684         int  retcode;
 685
 686         sprintf(proc_name, "/proc/dri/%d/name", i);
 687         if ((fd = open(proc_name, 0, 0)) >= 0) {
 688             retcode = read(fd, buf, sizeof(buf)-1);
 689             close(fd);
 690             if (retcode) {
 691                 buf[retcode-1] = '\0';
 692                 for (driver = pt = buf; *pt && *pt != ' '; ++pt)
 693                     ;
 694                 if (*pt) { /* Device is next */
 695                     *pt = '\0';
 696                     if (!strcmp(driver, name)) { /* Match */
 697                         for (devstring = ++pt; *pt && *pt != ' '; ++pt)
 698                             ;
 699                         if (*pt) { /* Found busid */
 700                             return drmOpenByBusid(++pt, type);
 701                         } else { /* No busid */
 702                             return drmOpenDevice(strtol(devstring, NULL, 0),i, type);
 703                         }
 704                     }
 705                 }
 706             }
 707         }
 708     }
 709 #endif
 710
 711     return -1;
 712 }
 713
 714
 715 /**
 716  * Open the DRM device.
 717  *
 718  * Looks up the specified name and bus ID, and opens the device found.  The
 719  * entry in /dev/dri is created if necessary and if called by root.
 720  *
 721  * \param name driver name. Not referenced if bus ID is supplied.
 722  * \param busid bus ID. Zero if not known.
 723  *
 724  * \return a file descriptor on success, or a negative value on error.
 725  *
 726  * \internal
 727  * It calls drmOpenByBusid() if \p busid is specified or drmOpenByName()
 728  * otherwise.
 729  */
 730 drm_public int drmOpen(const char *name, const char *busid)
 731 {
 732     return drmOpenWithType(name, busid, DRM_NODE_PRIMARY);
 733 }
 734
 735 /**
 736  * Open the DRM device with specified type.
 737  *
 738  * Looks up the specified name and bus ID, and opens the device found.  The
 739  * entry in /dev/dri is created if necessary and if called by root.
 740  *
 741  * \param name driver name. Not referenced if bus ID is supplied.
 742  * \param busid bus ID. Zero if not known.
 743  * \param type the device node type to open, PRIMARY, CONTROL or RENDER
 744  *
 745  * \return a file descriptor on success, or a negative value on error.
 746  *
 747  * \internal
 748  * It calls drmOpenByBusid() if \p busid is specified or drmOpenByName()
 749  * otherwise.
 750  */
 751 drm_public int drmOpenWithType(const char *name, const char *busid, int type)
 752 {
 753     if (name != NULL && drm_server_info &&
 754         drm_server_info->load_module && !drmAvailable()) {
 755         /* try to load the kernel module */
 756         if (!drm_server_info->load_module(name)) {
 757             drmMsg("[drm] failed to load kernel module \"%s\"\n", name);
 758             return -1;
 759         }
 760     }
 761
 762     if (busid) {
 763         int fd = drmOpenByBusid(busid, type);
 764         if (fd >= 0)
 765             return fd;
 766     }
 767
 768     if (name)
 769         return drmOpenByName(name, type);
 770
 771     return -1;
 772 }
 773
 774 drm_public int drmOpenControl(int minor)
 775 {
 776     return drmOpenMinor(minor, 0, DRM_NODE_CONTROL);
 777 }
 778
 779 drm_public int drmOpenRender(int minor)
 780 {
 781     return drmOpenMinor(minor, 0, DRM_NODE_RENDER);
 782 }
 783
 784 /**
 785  * Free the version information returned by drmGetVersion().
 786  *
 787  * \param v pointer to the version information.
 788  *
 789  * \internal
 790  * It frees the memory pointed by \p %v as well as all the non-null strings
 791  * pointers in it.
 792  */
 793 drm_public void drmFreeVersion(drmVersionPtr v)
 794 {
 795     if (!v)
 796         return;
 797     drmFree(v->name);
 798     drmFree(v->date);
 799     drmFree(v->desc);
 800     drmFree(v);
 801 }
 802
 803
 804 /**
 805  * Free the non-public version information returned by the kernel.
 806  *
 807  * \param v pointer to the version information.
 808  *
 809  * \internal
 810  * Used by drmGetVersion() to free the memory pointed by \p %v as well as all
 811  * the non-null strings pointers in it.
 812  */
 813 static void drmFreeKernelVersion(drm_version_t *v)
 814 {
 815     if (!v)
 816         return;
 817     drmFree(v->name);
 818     drmFree(v->date);
 819     drmFree(v->desc);
 820     drmFree(v);
 821 }
 822
 823
 824 /**
 825  * Copy version information.
 826  *
 827  * \param d destination pointer.
 828  * \param s source pointer.
 829  *
 830  * \internal
 831  * Used by drmGetVersion() to translate the information returned by the ioctl
 832  * interface in a private structure into the public structure counterpart.
 833  */
 834 static void drmCopyVersion(drmVersionPtr d, const drm_version_t *s)
 835 {
 836     d->version_major      = s->version_major;
 837     d->version_minor      = s->version_minor;
 838     d->version_patchlevel = s->version_patchlevel;
 839     d->name_len           = s->name_len;
 840     d->name               = strdup(s->name);
 841     d->date_len           = s->date_len;
 842     d->date               = strdup(s->date);
 843     d->desc_len           = s->desc_len;
 844     d->desc               = strdup(s->desc);
 845 }
 846
 847
 848 /**
 849  * Query the driver version information.
 850  *
 851  * \param fd file descriptor.
 852  *
 853  * \return pointer to a drmVersion structure which should be freed with
 854  * drmFreeVersion().
 855  *
 856  * \note Similar information is available via /proc/dri.
 857  *
 858  * \internal
 859  * It gets the version information via successive DRM_IOCTL_VERSION ioctls,
 860  * first with zeros to get the string lengths, and then the actually strings.
 861  * It also null-terminates them since they might not be already.
 862  */
 863 drm_public drmVersionPtr drmGetVersion(int fd)
 864 {
 865     drmVersionPtr retval;
 866     drm_version_t *version = drmMalloc(sizeof(*version));
 867
 868     if (drmIoctl(fd, DRM_IOCTL_VERSION, version)) {
 869         drmFreeKernelVersion(version);
 870         return NULL;
 871     }
 872
 873     if (version->name_len)
 874         version->name    = drmMalloc(version->name_len + 1);
 875     if (version->date_len)
 876         version->date    = drmMalloc(version->date_len + 1);
 877     if (version->desc_len)
 878         version->desc    = drmMalloc(version->desc_len + 1);
 879
 880     if (drmIoctl(fd, DRM_IOCTL_VERSION, version)) {
 881         drmMsg("DRM_IOCTL_VERSION: %s\n", strerror(errno));
 882         drmFreeKernelVersion(version);
 883         return NULL;
 884     }
 885
 886     /* The results might not be null-terminated strings, so terminate them. */
 887     if (version->name_len) version->name[version->name_len] = '\0';
 888     if (version->date_len) version->date[version->date_len] = '\0';
 889     if (version->desc_len) version->desc[version->desc_len] = '\0';
 890
 891     retval = drmMalloc(sizeof(*retval));
 892     drmCopyVersion(retval, version);
 893     drmFreeKernelVersion(version);
 894     return retval;
 895 }
 896
 897
 898 /**
 899  * Get version information for the DRM user space library.
 900  *
 901  * This version number is driver independent.
 902  *
 903  * \param fd file descriptor.
 904  *
 905  * \return version information.
 906  *
 907  * \internal
 908  * This function allocates and fills a drm_version structure with a hard coded
 909  * version number.
 910  */
 911 drm_public drmVersionPtr drmGetLibVersion(int fd)
 912 {
 913     drm_version_t *version = drmMalloc(sizeof(*version));
 914
 915     /* Version history:
 916      *   NOTE THIS MUST NOT GO ABOVE VERSION 1.X due to drivers needing it
 917      *   revision 1.0.x = original DRM interface with no drmGetLibVersion
 918      *                    entry point and many drm<Device> extensions
 919      *   revision 1.1.x = added drmCommand entry points for device extensions
 920      *                    added drmGetLibVersion to identify libdrm.a version
 921      *   revision 1.2.x = added drmSetInterfaceVersion
 922      *                    modified drmOpen to handle both busid and name
 923      *   revision 1.3.x = added server + memory manager
 924      */
 925     version->version_major      = 1;
 926     version->version_minor      = 3;
 927     version->version_patchlevel = 0;
 928
 929     return (drmVersionPtr)version;
 930 }
 931
 932 drm_public int drmGetCap(int fd, uint64_t capability, uint64_t *value)
 933 {
 934     struct drm_get_cap cap;
 935     int ret;
 936
 937     memclear(cap);
 938     cap.capability = capability;
 939
 940     ret = drmIoctl(fd, DRM_IOCTL_GET_CAP, &cap);
 941     if (ret)
 942         return ret;
 943
 944     *value = cap.value;
 945     return 0;
 946 }
 947
 948 drm_public int drmSetClientCap(int fd, uint64_t capability, uint64_t value)
 949 {
 950     struct drm_set_client_cap cap;
 951
 952     memclear(cap);
 953     cap.capability = capability;
 954     cap.value = value;
 955
 956     return drmIoctl(fd, DRM_IOCTL_SET_CLIENT_CAP, &cap);
 957 }
 958
 959 /**
 960  * Free the bus ID information.
 961  *
 962  * \param busid bus ID information string as given by drmGetBusid().
 963  *
 964  * \internal
 965  * This function is just frees the memory pointed by \p busid.
 966  */
 967 drm_public void drmFreeBusid(const char *busid)
 968 {
 969     drmFree((void *)busid);
 970 }
 971
 972
 973 /**
 974  * Get the bus ID of the device.
 975  *
 976  * \param fd file descriptor.
 977  *
 978  * \return bus ID string.
 979  *
 980  * \internal
 981  * This function gets the bus ID via successive DRM_IOCTL_GET_UNIQUE ioctls to
 982  * get the string length and data, passing the arguments in a drm_unique
 983  * structure.
 984  */
 985 drm_public char *drmGetBusid(int fd)
 986 {
 987     drm_unique_t u;
 988
 989     memclear(u);
 990
 991     if (drmIoctl(fd, DRM_IOCTL_GET_UNIQUE, &u))
 992         return NULL;
 993     u.unique = drmMalloc(u.unique_len + 1);
 994     if (drmIoctl(fd, DRM_IOCTL_GET_UNIQUE, &u)) {
 995         drmFree(u.unique);
 996         return NULL;
 997     }
 998     u.unique[u.unique_len] = '\0';
 999
1000     return u.unique;
1001 }
1002
1003
1004 /**
1005  * Set the bus ID of the device.
1006  *
1007  * \param fd file descriptor.
1008  * \param busid bus ID string.
1009  *
1010  * \return zero on success, negative on failure.
1011  *
1012  * \internal
1013  * This function is a wrapper around the DRM_IOCTL_SET_UNIQUE ioctl, passing
1014  * the arguments in a drm_unique structure.
1015  */
1016 drm_public int drmSetBusid(int fd, const char *busid)
1017 {
1018     drm_unique_t u;
1019
1020     memclear(u);
1021     u.unique     = (char *)busid;
1022     u.unique_len = strlen(busid);
1023
1024     if (drmIoctl(fd, DRM_IOCTL_SET_UNIQUE, &u)) {
1025         return -errno;
1026     }
1027     return 0;
1028 }
1029
1030 drm_public int drmGetMagic(int fd, drm_magic_t * magic)
1031 {
1032     drm_auth_t auth;
1033
1034     memclear(auth);
1035
1036     *magic = 0;
1037     if (drmIoctl(fd, DRM_IOCTL_GET_MAGIC, &auth))
1038         return -errno;
1039     *magic = auth.magic;
1040     return 0;
1041 }
1042
1043 drm_public int drmAuthMagic(int fd, drm_magic_t magic)
1044 {
1045     drm_auth_t auth;
1046
1047     memclear(auth);
1048     auth.magic = magic;
1049     if (drmIoctl(fd, DRM_IOCTL_AUTH_MAGIC, &auth))
1050         return -errno;
1051     return 0;
1052 }
1053
1054 /**
1055  * Specifies a range of memory that is available for mapping by a
1056  * non-root process.
1057  *
1058  * \param fd file descriptor.
1059  * \param offset usually the physical address. The actual meaning depends of
1060  * the \p type parameter. See below.
1061  * \param size of the memory in bytes.
1062  * \param type type of the memory to be mapped.
1063  * \param flags combination of several flags to modify the function actions.
1064  * \param handle will be set to a value that may be used as the offset
1065  * parameter for mmap().
1066  *
1067  * \return zero on success or a negative value on error.
1068  *
1069  * \par Mapping the frame buffer
1070  * For the frame buffer
1071  * - \p offset will be the physical address of the start of the frame buffer,
1072  * - \p size will be the size of the frame buffer in bytes, and
1073  * - \p type will be DRM_FRAME_BUFFER.
1074  *
1075  * \par
1076  * The area mapped will be uncached. If MTRR support is available in the
1077  * kernel, the frame buffer area will be set to write combining.
1078  *
1079  * \par Mapping the MMIO register area
1080  * For the MMIO register area,
1081  * - \p offset will be the physical address of the start of the register area,
1082  * - \p size will be the size of the register area bytes, and
1083  * - \p type will be DRM_REGISTERS.
1084  * \par
1085  * The area mapped will be uncached.
1086  *
1087  * \par Mapping the SAREA
1088  * For the SAREA,
1089  * - \p offset will be ignored and should be set to zero,
1090  * - \p size will be the desired size of the SAREA in bytes,
1091  * - \p type will be DRM_SHM.
1092  *
1093  * \par
1094  * A shared memory area of the requested size will be created and locked in
1095  * kernel memory. This area may be mapped into client-space by using the handle
1096  * returned.
1097  *
1098  * \note May only be called by root.
1099  *
1100  * \internal
1101  * This function is a wrapper around the DRM_IOCTL_ADD_MAP ioctl, passing
1102  * the arguments in a drm_map structure.
1103  */
1104 drm_public int drmAddMap(int fd, drm_handle_t offset, drmSize size, drmMapType type,
1105                          drmMapFlags flags, drm_handle_t *handle)
1106 {
1107     drm_map_t map;
1108
1109     memclear(map);
1110     map.offset  = offset;
1111     map.size    = size;
1112     map.type    = type;
1113     map.flags   = flags;
1114     if (drmIoctl(fd, DRM_IOCTL_ADD_MAP, &map))
1115         return -errno;
1116     if (handle)
1117         *handle = (drm_handle_t)(uintptr_t)map.handle;
1118     return 0;
1119 }
1120
1121 drm_public int drmRmMap(int fd, drm_handle_t handle)
1122 {
1123     drm_map_t map;
1124
1125     memclear(map);
1126     map.handle = (void *)(uintptr_t)handle;
1127
1128     if(drmIoctl(fd, DRM_IOCTL_RM_MAP, &map))
1129         return -errno;
1130     return 0;
1131 }
1132
1133 /**
1134  * Make buffers available for DMA transfers.
1135  *
1136  * \param fd file descriptor.
1137  * \param count number of buffers.
1138  * \param size size of each buffer.
1139  * \param flags buffer allocation flags.
1140  * \param agp_offset offset in the AGP aperture
1141  *
1142  * \return number of buffers allocated, negative on error.
1143  *
1144  * \internal
1145  * This function is a wrapper around DRM_IOCTL_ADD_BUFS ioctl.
1146  *
1147  * \sa drm_buf_desc.
1148  */
1149 drm_public int drmAddBufs(int fd, int count, int size, drmBufDescFlags flags,
1150                           int agp_offset)
1151 {
1152     drm_buf_desc_t request;
1153
1154     memclear(request);
1155     request.count     = count;
1156     request.size      = size;
1157     request.flags     = flags;
1158     request.agp_start = agp_offset;
1159
1160     if (drmIoctl(fd, DRM_IOCTL_ADD_BUFS, &request))
1161         return -errno;
1162     return request.count;
1163 }
1164
1165 drm_public int drmMarkBufs(int fd, double low, double high)
1166 {
1167     drm_buf_info_t info;
1168     int            i;
1169
1170     memclear(info);
1171
1172     if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info))
1173         return -EINVAL;
1174
1175     if (!info.count)
1176         return -EINVAL;
1177
1178     if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
1179         return -ENOMEM;
1180
1181     if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
1182         int retval = -errno;
1183         drmFree(info.list);
1184         return retval;
1185     }
1186
1187     for (i = 0; i < info.count; i++) {
1188         info.list[i].low_mark  = low  * info.list[i].count;
1189         info.list[i].high_mark = high * info.list[i].count;
1190         if (drmIoctl(fd, DRM_IOCTL_MARK_BUFS, &info.list[i])) {
1191             int retval = -errno;
1192             drmFree(info.list);
1193             return retval;
1194         }
1195     }
1196     drmFree(info.list);
1197
1198     return 0;
1199 }
1200
1201 /**
1202  * Free buffers.
1203  *
1204  * \param fd file descriptor.
1205  * \param count number of buffers to free.
1206  * \param list list of buffers to be freed.
1207  *
1208  * \return zero on success, or a negative value on failure.
1209  *
1210  * \note This function is primarily used for debugging.
1211  *
1212  * \internal
1213  * This function is a wrapper around the DRM_IOCTL_FREE_BUFS ioctl, passing
1214  * the arguments in a drm_buf_free structure.
1215  */
1216 drm_public int drmFreeBufs(int fd, int count, int *list)
1217 {
1218     drm_buf_free_t request;
1219
1220     memclear(request);
1221     request.count = count;
1222     request.list  = list;
1223     if (drmIoctl(fd, DRM_IOCTL_FREE_BUFS, &request))
1224         return -errno;
1225     return 0;
1226 }
1227
1228
1229 /**
1230  * Close the device.
1231  *
1232  * \param fd file descriptor.
1233  *
1234  * \internal
1235  * This function closes the file descriptor.
1236  */
1237 drm_public int drmClose(int fd)
1238 {
1239     unsigned long key    = drmGetKeyFromFd(fd);
1240     drmHashEntry  *entry = drmGetEntry(fd);
1241
1242     drmHashDestroy(entry->tagTable);
1243     entry->fd       = 0;
1244     entry->f        = NULL;
1245     entry->tagTable = NULL;
1246
1247     drmHashDelete(drmHashTable, key);
1248     drmFree(entry);
1249
1250     return close(fd);
1251 }
1252
1253
1254 /**
1255  * Map a region of memory.
1256  *
1257  * \param fd file descriptor.
1258  * \param handle handle returned by drmAddMap().
1259  * \param size size in bytes. Must match the size used by drmAddMap().
1260  * \param address will contain the user-space virtual address where the mapping
1261  * begins.
1262  *
1263  * \return zero on success, or a negative value on failure.
1264  *
1265  * \internal
1266  * This function is a wrapper for mmap().
1267  */
1268 drm_public int drmMap(int fd, drm_handle_t handle, drmSize size,
1269                       drmAddressPtr address)
1270 {
1271     static unsigned long pagesize_mask = 0;
1272
1273     if (fd < 0)
1274         return -EINVAL;
1275
1276     if (!pagesize_mask)
1277         pagesize_mask = getpagesize() - 1;
1278
1279     size = (size + pagesize_mask) & ~pagesize_mask;
1280
1281     *address = drm_mmap(0, size, PROT_READ|PROT_WRITE, MAP_SHARED, fd, handle);
1282     if (*address == MAP_FAILED)
1283         return -errno;
1284     return 0;
1285 }
1286
1287
1288 /**
1289  * Unmap mappings obtained with drmMap().
1290  *
1291  * \param address address as given by drmMap().
1292  * \param size size in bytes. Must match the size used by drmMap().
1293  *
1294  * \return zero on success, or a negative value on failure.
1295  *
1296  * \internal
1297  * This function is a wrapper for munmap().
1298  */
1299 drm_public int drmUnmap(drmAddress address, drmSize size)
1300 {
1301     return drm_munmap(address, size);
1302 }
1303
1304 drm_public drmBufInfoPtr drmGetBufInfo(int fd)
1305 {
1306     drm_buf_info_t info;
1307     drmBufInfoPtr  retval;
1308     int            i;
1309
1310     memclear(info);
1311
1312     if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info))
1313         return NULL;
1314
1315     if (info.count) {
1316         if (!(info.list = drmMalloc(info.count * sizeof(*info.list))))
1317             return NULL;
1318
1319         if (drmIoctl(fd, DRM_IOCTL_INFO_BUFS, &info)) {
1320             drmFree(info.list);
1321             return NULL;
1322         }
1323
1324         retval = drmMalloc(sizeof(*retval));
1325         retval->count = info.count;
1326         retval->list  = drmMalloc(info.count * sizeof(*retval->list));
1327         for (i = 0; i < info.count; i++) {
1328             retval->list[i].count     = info.list[i].count;
1329             retval->list[i].size      = info.list[i].size;
1330             retval->list[i].low_mark  = info.list[i].low_mark;
1331             retval->list[i].high_mark = info.list[i].high_mark;
1332         }
1333         drmFree(info.list);
1334         return retval;
1335     }
1336     return NULL;
1337 }
1338
1339 /**
1340  * Map all DMA buffers into client-virtual space.
1341  *
1342  * \param fd file descriptor.
1343  *
1344  * \return a pointer to a ::drmBufMap structure.
1345  *
1346  * \note The client may not use these buffers until obtaining buffer indices
1347  * with drmDMA().
1348  *
1349  * \internal
1350  * This function calls the DRM_IOCTL_MAP_BUFS ioctl and copies the returned
1351  * information about the buffers in a drm_buf_map structure into the
1352  * client-visible data structures.
1353  */
1354 drm_public drmBufMapPtr drmMapBufs(int fd)
1355 {
1356     drm_buf_map_t bufs;
1357     drmBufMapPtr  retval;
1358     int           i;
1359
1360     memclear(bufs);
1361     if (drmIoctl(fd, DRM_IOCTL_MAP_BUFS, &bufs))
1362         return NULL;
1363
1364     if (!bufs.count)
1365         return NULL;
1366
1367     if (!(bufs.list = drmMalloc(bufs.count * sizeof(*bufs.list))))
1368         return NULL;
1369
1370     if (drmIoctl(fd, DRM_IOCTL_MAP_BUFS, &bufs)) {
1371         drmFree(bufs.list);
1372         return NULL;
1373     }
1374
1375     retval = drmMalloc(sizeof(*retval));
1376     retval->count = bufs.count;
1377     retval->list  = drmMalloc(bufs.count * sizeof(*retval->list));
1378     for (i = 0; i < bufs.count; i++) {
1379         retval->list[i].idx     = bufs.list[i].idx;
1380         retval->list[i].total   = bufs.list[i].total;
1381         retval->list[i].used    = 0;
1382         retval->list[i].address = bufs.list[i].address;
1383     }
1384
1385     drmFree(bufs.list);
1386     return retval;
1387 }
1388
1389
1390 /**
1391  * Unmap buffers allocated with drmMapBufs().
1392  *
1393  * \return zero on success, or negative value on failure.
1394  *
1395  * \internal
1396  * Calls munmap() for every buffer stored in \p bufs and frees the
1397  * memory allocated by drmMapBufs().
1398  */
1399 drm_public int drmUnmapBufs(drmBufMapPtr bufs)
1400 {
1401     int i;
1402
1403     for (i = 0; i < bufs->count; i++) {
1404         drm_munmap(bufs->list[i].address, bufs->list[i].total);
1405     }
1406
1407     drmFree(bufs->list);
1408     drmFree(bufs);
1409     return 0;
1410 }
1411
1412
1413 #define DRM_DMA_RETRY  16
1414
1415 /**
1416  * Reserve DMA buffers.
1417  *
1418  * \param fd file descriptor.
1419  * \param request
1420  *
1421  * \return zero on success, or a negative value on failure.
1422  *
1423  * \internal
1424  * Assemble the arguments into a drm_dma structure and keeps issuing the
1425  * DRM_IOCTL_DMA ioctl until success or until maximum number of retries.
1426  */
1427 drm_public int drmDMA(int fd, drmDMAReqPtr request)
1428 {
1429     drm_dma_t dma;
1430     int ret, i = 0;
1431
1432     dma.context         = request->context;
1433     dma.send_count      = request->send_count;
1434     dma.send_indices    = request->send_list;
1435     dma.send_sizes      = request->send_sizes;
1436     dma.flags           = request->flags;
1437     dma.request_count   = request->request_count;
1438     dma.request_size    = request->request_size;
1439     dma.request_indices = request->request_list;
1440     dma.request_sizes   = request->request_sizes;
1441     dma.granted_count   = 0;
1442
1443     do {
1444         ret = ioctl( fd, DRM_IOCTL_DMA, &dma );
1445     } while ( ret && errno == EAGAIN && i++ < DRM_DMA_RETRY );
1446
1447     if ( ret == 0 ) {
1448         request->granted_count = dma.granted_count;
1449         return 0;
1450     } else {
1451         return -errno;
1452     }
1453 }
1454
1455
1456 /**
1457  * Obtain heavyweight hardware lock.
1458  *
1459  * \param fd file descriptor.
1460  * \param context context.
1461  * \param flags flags that determine the state of the hardware when the function
1462  * returns.
1463  *
1464  * \return always zero.
1465  *
1466  * \internal
1467  * This function translates the arguments into a drm_lock structure and issue
1468  * the DRM_IOCTL_LOCK ioctl until the lock is successfully acquired.
1469  */
1470 drm_public int drmGetLock(int fd, drm_context_t context, drmLockFlags flags)
1471 {
1472     drm_lock_t lock;
1473
1474     memclear(lock);
1475     lock.context = context;
1476     lock.flags   = 0;
1477     if (flags & DRM_LOCK_READY)      lock.flags |= _DRM_LOCK_READY;
1478     if (flags & DRM_LOCK_QUIESCENT)  lock.flags |= _DRM_LOCK_QUIESCENT;
1479     if (flags & DRM_LOCK_FLUSH)      lock.flags |= _DRM_LOCK_FLUSH;
1480     if (flags & DRM_LOCK_FLUSH_ALL)  lock.flags |= _DRM_LOCK_FLUSH_ALL;
1481     if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
1482     if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
1483
1484     while (drmIoctl(fd, DRM_IOCTL_LOCK, &lock))
1485         ;
1486     return 0;
1487 }
1488
1489 /**
1490  * Release the hardware lock.
1491  *
1492  * \param fd file descriptor.
1493  * \param context context.
1494  *
1495  * \return zero on success, or a negative value on failure.
1496  *
1497  * \internal
1498  * This function is a wrapper around the DRM_IOCTL_UNLOCK ioctl, passing the
1499  * argument in a drm_lock structure.
1500  */
1501 drm_public int drmUnlock(int fd, drm_context_t context)
1502 {
1503     drm_lock_t lock;
1504
1505     memclear(lock);
1506     lock.context = context;
1507     return drmIoctl(fd, DRM_IOCTL_UNLOCK, &lock);
1508 }
1509
1510 drm_public drm_context_t *drmGetReservedContextList(int fd, int *count)
1511 {
1512     drm_ctx_res_t res;
1513     drm_ctx_t     *list;
1514     drm_context_t * retval;
1515     int           i;
1516
1517     memclear(res);
1518     if (drmIoctl(fd, DRM_IOCTL_RES_CTX, &res))
1519         return NULL;
1520
1521     if (!res.count)
1522         return NULL;
1523
1524     if (!(list   = drmMalloc(res.count * sizeof(*list))))
1525         return NULL;
1526     if (!(retval = drmMalloc(res.count * sizeof(*retval))))
1527         goto err_free_list;
1528
1529     res.contexts = list;
1530     if (drmIoctl(fd, DRM_IOCTL_RES_CTX, &res))
1531         goto err_free_context;
1532
1533     for (i = 0; i < res.count; i++)
1534         retval[i] = list[i].handle;
1535     drmFree(list);
1536
1537     *count = res.count;
1538     return retval;
1539
1540 err_free_list:
1541     drmFree(list);
1542 err_free_context:
1543     drmFree(retval);
1544     return NULL;
1545 }
1546
1547 drm_public void drmFreeReservedContextList(drm_context_t *pt)
1548 {
1549     drmFree(pt);
1550 }
1551
1552 /**
1553  * Create context.
1554  *
1555  * Used by the X server during GLXContext initialization. This causes
1556  * per-context kernel-level resources to be allocated.
1557  *
1558  * \param fd file descriptor.
1559  * \param handle is set on success. To be used by the client when requesting DMA
1560  * dispatch with drmDMA().
1561  *
1562  * \return zero on success, or a negative value on failure.
1563  *
1564  * \note May only be called by root.
1565  *
1566  * \internal
1567  * This function is a wrapper around the DRM_IOCTL_ADD_CTX ioctl, passing the
1568  * argument in a drm_ctx structure.
1569  */
1570 drm_public int drmCreateContext(int fd, drm_context_t *handle)
1571 {
1572     drm_ctx_t ctx;
1573
1574     memclear(ctx);
1575     if (drmIoctl(fd, DRM_IOCTL_ADD_CTX, &ctx))
1576         return -errno;
1577     *handle = ctx.handle;
1578     return 0;
1579 }
1580
1581 drm_public int drmSwitchToContext(int fd, drm_context_t context)
1582 {
1583     drm_ctx_t ctx;
1584
1585     memclear(ctx);
1586     ctx.handle = context;
1587     if (drmIoctl(fd, DRM_IOCTL_SWITCH_CTX, &ctx))
1588         return -errno;
1589     return 0;
1590 }
1591
1592 drm_public int drmSetContextFlags(int fd, drm_context_t context,
1593                                   drm_context_tFlags flags)
1594 {
1595     drm_ctx_t ctx;
1596
1597     /*
1598      * Context preserving means that no context switches are done between DMA
1599      * buffers from one context and the next.  This is suitable for use in the
1600      * X server (which promises to maintain hardware context), or in the
1601      * client-side library when buffers are swapped on behalf of two threads.
1602      */
1603     memclear(ctx);
1604     ctx.handle = context;
1605     if (flags & DRM_CONTEXT_PRESERVED)
1606         ctx.flags |= _DRM_CONTEXT_PRESERVED;
1607     if (flags & DRM_CONTEXT_2DONLY)
1608         ctx.flags |= _DRM_CONTEXT_2DONLY;
1609     if (drmIoctl(fd, DRM_IOCTL_MOD_CTX, &ctx))
1610         return -errno;
1611     return 0;
1612 }
1613
1614 drm_public int drmGetContextFlags(int fd, drm_context_t context,
1615                                   drm_context_tFlagsPtr flags)
1616 {
1617     drm_ctx_t ctx;
1618
1619     memclear(ctx);
1620     ctx.handle = context;
1621     if (drmIoctl(fd, DRM_IOCTL_GET_CTX, &ctx))
1622         return -errno;
1623     *flags = 0;
1624     if (ctx.flags & _DRM_CONTEXT_PRESERVED)
1625         *flags |= DRM_CONTEXT_PRESERVED;
1626     if (ctx.flags & _DRM_CONTEXT_2DONLY)
1627         *flags |= DRM_CONTEXT_2DONLY;
1628     return 0;
1629 }
1630
1631 /**
1632  * Destroy context.
1633  *
1634  * Free any kernel-level resources allocated with drmCreateContext() associated
1635  * with the context.
1636  *
1637  * \param fd file descriptor.
1638  * \param handle handle given by drmCreateContext().
1639  *
1640  * \return zero on success, or a negative value on failure.
1641  *
1642  * \note May only be called by root.
1643  *
1644  * \internal
1645  * This function is a wrapper around the DRM_IOCTL_RM_CTX ioctl, passing the
1646  * argument in a drm_ctx structure.
1647  */
1648 drm_public int drmDestroyContext(int fd, drm_context_t handle)
1649 {
1650     drm_ctx_t ctx;
1651
1652     memclear(ctx);
1653     ctx.handle = handle;
1654     if (drmIoctl(fd, DRM_IOCTL_RM_CTX, &ctx))
1655         return -errno;
1656     return 0;
1657 }
1658
1659 drm_public int drmCreateDrawable(int fd, drm_drawable_t *handle)
1660 {
1661     drm_draw_t draw;
1662
1663     memclear(draw);
1664     if (drmIoctl(fd, DRM_IOCTL_ADD_DRAW, &draw))
1665         return -errno;
1666     *handle = draw.handle;
1667     return 0;
1668 }
1669
1670 drm_public int drmDestroyDrawable(int fd, drm_drawable_t handle)
1671 {
1672     drm_draw_t draw;
1673
1674     memclear(draw);
1675     draw.handle = handle;
1676     if (drmIoctl(fd, DRM_IOCTL_RM_DRAW, &draw))
1677         return -errno;
1678     return 0;
1679 }
1680
1681 drm_public int drmUpdateDrawableInfo(int fd, drm_drawable_t handle,
1682                                      drm_drawable_info_type_t type,
1683                                      unsigned int num, void *data)
1684 {
1685     drm_update_draw_t update;
1686
1687     memclear(update);
1688     update.handle = handle;
1689     update.type = type;
1690     update.num = num;
1691     update.data = (unsigned long long)(unsigned long)data;
1692
1693     if (drmIoctl(fd, DRM_IOCTL_UPDATE_DRAW, &update))
1694         return -errno;
1695
1696     return 0;
1697 }
1698
1699 drm_public int drmCrtcGetSequence(int fd, uint32_t crtcId, uint64_t *sequence,
1700                                   uint64_t *ns)
1701 {
1702     struct drm_crtc_get_sequence get_seq;
1703     int ret;
1704
1705     memclear(get_seq);
1706     get_seq.crtc_id = crtcId;
1707     ret = drmIoctl(fd, DRM_IOCTL_CRTC_GET_SEQUENCE, &get_seq);
1708     if (ret)
1709         return ret;
1710
1711     if (sequence)
1712         *sequence = get_seq.sequence;
1713     if (ns)
1714         *ns = get_seq.sequence_ns;
1715     return 0;
1716 }
1717
1718 drm_public int drmCrtcQueueSequence(int fd, uint32_t crtcId, uint32_t flags,
1719                                     uint64_t sequence,
1720                                     uint64_t *sequence_queued,
1721                                     uint64_t user_data)
1722 {
1723     struct drm_crtc_queue_sequence queue_seq;
1724     int ret;
1725
1726     memclear(queue_seq);
1727     queue_seq.crtc_id = crtcId;
1728     queue_seq.flags = flags;
1729     queue_seq.sequence = sequence;
1730     queue_seq.user_data = user_data;
1731
1732     ret = drmIoctl(fd, DRM_IOCTL_CRTC_QUEUE_SEQUENCE, &queue_seq);
1733     if (ret == 0 && sequence_queued)
1734         *sequence_queued = queue_seq.sequence;
1735
1736     return ret;
1737 }
1738
1739 /**
1740  * Acquire the AGP device.
1741  *
1742  * Must be called before any of the other AGP related calls.
1743  *
1744  * \param fd file descriptor.
1745  *
1746  * \return zero on success, or a negative value on failure.
1747  *
1748  * \internal
1749  * This function is a wrapper around the DRM_IOCTL_AGP_ACQUIRE ioctl.
1750  */
1751 drm_public int drmAgpAcquire(int fd)
1752 {
1753     if (drmIoctl(fd, DRM_IOCTL_AGP_ACQUIRE, NULL))
1754         return -errno;
1755     return 0;
1756 }
1757
1758
1759 /**
1760  * Release the AGP device.
1761  *
1762  * \param fd file descriptor.
1763  *
1764  * \return zero on success, or a negative value on failure.
1765  *
1766  * \internal
1767  * This function is a wrapper around the DRM_IOCTL_AGP_RELEASE ioctl.
1768  */
1769 drm_public int drmAgpRelease(int fd)
1770 {
1771     if (drmIoctl(fd, DRM_IOCTL_AGP_RELEASE, NULL))
1772         return -errno;
1773     return 0;
1774 }
1775
1776
1777 /**
1778  * Set the AGP mode.
1779  *
1780  * \param fd file descriptor.
1781  * \param mode AGP mode.
1782  *
1783  * \return zero on success, or a negative value on failure.
1784  *
1785  * \internal
1786  * This function is a wrapper around the DRM_IOCTL_AGP_ENABLE ioctl, passing the
1787  * argument in a drm_agp_mode structure.
1788  */
1789 drm_public int drmAgpEnable(int fd, unsigned long mode)
1790 {
1791     drm_agp_mode_t m;
1792
1793     memclear(m);
1794     m.mode = mode;
1795     if (drmIoctl(fd, DRM_IOCTL_AGP_ENABLE, &m))
1796         return -errno;
1797     return 0;
1798 }
1799
1800
1801 /**
1802  * Allocate a chunk of AGP memory.
1803  *
1804  * \param fd file descriptor.
1805  * \param size requested memory size in bytes. Will be rounded to page boundary.
1806  * \param type type of memory to allocate.
1807  * \param address if not zero, will be set to the physical address of the
1808  * allocated memory.
1809  * \param handle on success will be set to a handle of the allocated memory.
1810  *
1811  * \return zero on success, or a negative value on failure.
1812  *
1813  * \internal
1814  * This function is a wrapper around the DRM_IOCTL_AGP_ALLOC ioctl, passing the
1815  * arguments in a drm_agp_buffer structure.
1816  */
1817 drm_public int drmAgpAlloc(int fd, unsigned long size, unsigned long type,
1818                            unsigned long *address, drm_handle_t *handle)
1819 {
1820     drm_agp_buffer_t b;
1821
1822     memclear(b);
1823     *handle = DRM_AGP_NO_HANDLE;
1824     b.size   = size;
1825     b.type   = type;
1826     if (drmIoctl(fd, DRM_IOCTL_AGP_ALLOC, &b))
1827         return -errno;
1828     if (address != 0UL)
1829         *address = b.physical;
1830     *handle = b.handle;
1831     return 0;
1832 }
1833
1834
1835 /**
1836  * Free a chunk of AGP memory.
1837  *
1838  * \param fd file descriptor.
1839  * \param handle handle to the allocated memory, as given by drmAgpAllocate().
1840  *
1841  * \return zero on success, or a negative value on failure.
1842  *
1843  * \internal
1844  * This function is a wrapper around the DRM_IOCTL_AGP_FREE ioctl, passing the
1845  * argument in a drm_agp_buffer structure.
1846  */
1847 drm_public int drmAgpFree(int fd, drm_handle_t handle)
1848 {
1849     drm_agp_buffer_t b;
1850
1851     memclear(b);
1852     b.handle = handle;
1853     if (drmIoctl(fd, DRM_IOCTL_AGP_FREE, &b))
1854         return -errno;
1855     return 0;
1856 }
1857
1858
1859 /**
1860  * Bind a chunk of AGP memory.
1861  *
1862  * \param fd file descriptor.
1863  * \param handle handle to the allocated memory, as given by drmAgpAllocate().
1864  * \param offset offset in bytes. It will round to page boundary.
1865  *
1866  * \return zero on success, or a negative value on failure.
1867  *
1868  * \internal
1869  * This function is a wrapper around the DRM_IOCTL_AGP_BIND ioctl, passing the
1870  * argument in a drm_agp_binding structure.
1871  */
1872 drm_public int drmAgpBind(int fd, drm_handle_t handle, unsigned long offset)
1873 {
1874     drm_agp_binding_t b;
1875
1876     memclear(b);
1877     b.handle = handle;
1878     b.offset = offset;
1879     if (drmIoctl(fd, DRM_IOCTL_AGP_BIND, &b))
1880         return -errno;
1881     return 0;
1882 }
1883
1884
1885 /**
1886  * Unbind a chunk of AGP memory.
1887  *
1888  * \param fd file descriptor.
1889  * \param handle handle to the allocated memory, as given by drmAgpAllocate().
1890  *
1891  * \return zero on success, or a negative value on failure.
1892  *
1893  * \internal
1894  * This function is a wrapper around the DRM_IOCTL_AGP_UNBIND ioctl, passing
1895  * the argument in a drm_agp_binding structure.
1896  */
1897 drm_public int drmAgpUnbind(int fd, drm_handle_t handle)
1898 {
1899     drm_agp_binding_t b;
1900
1901     memclear(b);
1902     b.handle = handle;
1903     if (drmIoctl(fd, DRM_IOCTL_AGP_UNBIND, &b))
1904         return -errno;
1905     return 0;
1906 }
1907
1908
1909 /**
1910  * Get AGP driver major version number.
1911  *
1912  * \param fd file descriptor.
1913  *
1914  * \return major version number on success, or a negative value on failure..
1915  *
1916  * \internal
1917  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1918  * necessary information in a drm_agp_info structure.
1919  */
1920 drm_public int drmAgpVersionMajor(int fd)
1921 {
1922     drm_agp_info_t i;
1923
1924     memclear(i);
1925
1926     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
1927         return -errno;
1928     return i.agp_version_major;
1929 }
1930
1931
1932 /**
1933  * Get AGP driver minor version number.
1934  *
1935  * \param fd file descriptor.
1936  *
1937  * \return minor version number on success, or a negative value on failure.
1938  *
1939  * \internal
1940  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1941  * necessary information in a drm_agp_info structure.
1942  */
1943 drm_public int drmAgpVersionMinor(int fd)
1944 {
1945     drm_agp_info_t i;
1946
1947     memclear(i);
1948
1949     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
1950         return -errno;
1951     return i.agp_version_minor;
1952 }
1953
1954
1955 /**
1956  * Get AGP mode.
1957  *
1958  * \param fd file descriptor.
1959  *
1960  * \return mode on success, or zero on failure.
1961  *
1962  * \internal
1963  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1964  * necessary information in a drm_agp_info structure.
1965  */
1966 drm_public unsigned long drmAgpGetMode(int fd)
1967 {
1968     drm_agp_info_t i;
1969
1970     memclear(i);
1971
1972     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
1973         return 0;
1974     return i.mode;
1975 }
1976
1977
1978 /**
1979  * Get AGP aperture base.
1980  *
1981  * \param fd file descriptor.
1982  *
1983  * \return aperture base on success, zero on failure.
1984  *
1985  * \internal
1986  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
1987  * necessary information in a drm_agp_info structure.
1988  */
1989 drm_public unsigned long drmAgpBase(int fd)
1990 {
1991     drm_agp_info_t i;
1992
1993     memclear(i);
1994
1995     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
1996         return 0;
1997     return i.aperture_base;
1998 }
1999
2000
2001 /**
2002  * Get AGP aperture size.
2003  *
2004  * \param fd file descriptor.
2005  *
2006  * \return aperture size on success, zero on failure.
2007  *
2008  * \internal
2009  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
2010  * necessary information in a drm_agp_info structure.
2011  */
2012 drm_public unsigned long drmAgpSize(int fd)
2013 {
2014     drm_agp_info_t i;
2015
2016     memclear(i);
2017
2018     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
2019         return 0;
2020     return i.aperture_size;
2021 }
2022
2023
2024 /**
2025  * Get used AGP memory.
2026  *
2027  * \param fd file descriptor.
2028  *
2029  * \return memory used on success, or zero on failure.
2030  *
2031  * \internal
2032  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
2033  * necessary information in a drm_agp_info structure.
2034  */
2035 drm_public unsigned long drmAgpMemoryUsed(int fd)
2036 {
2037     drm_agp_info_t i;
2038
2039     memclear(i);
2040
2041     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
2042         return 0;
2043     return i.memory_used;
2044 }
2045
2046
2047 /**
2048  * Get available AGP memory.
2049  *
2050  * \param fd file descriptor.
2051  *
2052  * \return memory available on success, or zero on failure.
2053  *
2054  * \internal
2055  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
2056  * necessary information in a drm_agp_info structure.
2057  */
2058 drm_public unsigned long drmAgpMemoryAvail(int fd)
2059 {
2060     drm_agp_info_t i;
2061
2062     memclear(i);
2063
2064     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
2065         return 0;
2066     return i.memory_allowed;
2067 }
2068
2069
2070 /**
2071  * Get hardware vendor ID.
2072  *
2073  * \param fd file descriptor.
2074  *
2075  * \return vendor ID on success, or zero on failure.
2076  *
2077  * \internal
2078  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
2079  * necessary information in a drm_agp_info structure.
2080  */
2081 drm_public unsigned int drmAgpVendorId(int fd)
2082 {
2083     drm_agp_info_t i;
2084
2085     memclear(i);
2086
2087     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
2088         return 0;
2089     return i.id_vendor;
2090 }
2091
2092
2093 /**
2094  * Get hardware device ID.
2095  *
2096  * \param fd file descriptor.
2097  *
2098  * \return zero on success, or zero on failure.
2099  *
2100  * \internal
2101  * This function is a wrapper around the DRM_IOCTL_AGP_INFO ioctl, getting the
2102  * necessary information in a drm_agp_info structure.
2103  */
2104 drm_public unsigned int drmAgpDeviceId(int fd)
2105 {
2106     drm_agp_info_t i;
2107
2108     memclear(i);
2109
2110     if (drmIoctl(fd, DRM_IOCTL_AGP_INFO, &i))
2111         return 0;
2112     return i.id_device;
2113 }
2114
2115 drm_public int drmScatterGatherAlloc(int fd, unsigned long size,
2116                                      drm_handle_t *handle)
2117 {
2118     drm_scatter_gather_t sg;
2119
2120     memclear(sg);
2121
2122     *handle = 0;
2123     sg.size   = size;
2124     if (drmIoctl(fd, DRM_IOCTL_SG_ALLOC, &sg))
2125         return -errno;
2126     *handle = sg.handle;
2127     return 0;
2128 }
2129
2130 drm_public int drmScatterGatherFree(int fd, drm_handle_t handle)
2131 {
2132     drm_scatter_gather_t sg;
2133
2134     memclear(sg);
2135     sg.handle = handle;
2136     if (drmIoctl(fd, DRM_IOCTL_SG_FREE, &sg))
2137         return -errno;
2138     return 0;
2139 }
2140
2141 /**
2142  * Wait for VBLANK.
2143  *
2144  * \param fd file descriptor.
2145  * \param vbl pointer to a drmVBlank structure.
2146  *
2147  * \return zero on success, or a negative value on failure.
2148  *
2149  * \internal
2150  * This function is a wrapper around the DRM_IOCTL_WAIT_VBLANK ioctl.
2151  */
2152 drm_public int drmWaitVBlank(int fd, drmVBlankPtr vbl)
2153 {
2154     struct timespec timeout, cur;
2155     int ret;
2156
2157     ret = clock_gettime(CLOCK_MONOTONIC, &timeout);
2158     if (ret < 0) {
2159         fprintf(stderr, "clock_gettime failed: %s\n", strerror(errno));
2160         goto out;
2161     }
2162     timeout.tv_sec++;
2163
2164     do {
2165        ret = ioctl(fd, DRM_IOCTL_WAIT_VBLANK, vbl);
2166        vbl->request.type &= ~DRM_VBLANK_RELATIVE;
2167        if (ret && errno == EINTR) {
2168            clock_gettime(CLOCK_MONOTONIC, &cur);
2169            /* Timeout after 1s */
2170            if (cur.tv_sec > timeout.tv_sec + 1 ||
2171                (cur.tv_sec == timeout.tv_sec && cur.tv_nsec >=
2172                 timeout.tv_nsec)) {
2173                    errno = EBUSY;
2174                    ret = -1;
2175                    break;
2176            }
2177        }
2178     } while (ret && errno == EINTR);
2179
2180 out:
2181     return ret;
2182 }
2183
2184 drm_public int drmError(int err, const char *label)
2185 {
2186     switch (err) {
2187     case DRM_ERR_NO_DEVICE:
2188         fprintf(stderr, "%s: no device\n", label);
2189         break;
2190     case DRM_ERR_NO_ACCESS:
2191         fprintf(stderr, "%s: no access\n", label);
2192         break;
2193     case DRM_ERR_NOT_ROOT:
2194         fprintf(stderr, "%s: not root\n", label);
2195         break;
2196     case DRM_ERR_INVALID:
2197         fprintf(stderr, "%s: invalid args\n", label);
2198         break;
2199     default:
2200         if (err < 0)
2201             err = -err;
2202         fprintf( stderr, "%s: error %d (%s)\n", label, err, strerror(err) );
2203         break;
2204     }
2205
2206     return 1;
2207 }
2208
2209 /**
2210  * Install IRQ handler.
2211  *
2212  * \param fd file descriptor.
2213  * \param irq IRQ number.
2214  *
2215  * \return zero on success, or a negative value on failure.
2216  *
2217  * \internal
2218  * This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the
2219  * argument in a drm_control structure.
2220  */
2221 drm_public int drmCtlInstHandler(int fd, int irq)
2222 {
2223     drm_control_t ctl;
2224
2225     memclear(ctl);
2226     ctl.func  = DRM_INST_HANDLER;
2227     ctl.irq   = irq;
2228     if (drmIoctl(fd, DRM_IOCTL_CONTROL, &ctl))
2229         return -errno;
2230     return 0;
2231 }
2232
2233
2234 /**
2235  * Uninstall IRQ handler.
2236  *
2237  * \param fd file descriptor.
2238  *
2239  * \return zero on success, or a negative value on failure.
2240  *
2241  * \internal
2242  * This function is a wrapper around the DRM_IOCTL_CONTROL ioctl, passing the
2243  * argument in a drm_control structure.
2244  */
2245 drm_public int drmCtlUninstHandler(int fd)
2246 {
2247     drm_control_t ctl;
2248
2249     memclear(ctl);
2250     ctl.func  = DRM_UNINST_HANDLER;
2251     ctl.irq   = 0;
2252     if (drmIoctl(fd, DRM_IOCTL_CONTROL, &ctl))
2253         return -errno;
2254     return 0;
2255 }
2256
2257 drm_public int drmFinish(int fd, int context, drmLockFlags flags)
2258 {
2259     drm_lock_t lock;
2260
2261     memclear(lock);
2262     lock.context = context;
2263     if (flags & DRM_LOCK_READY)      lock.flags |= _DRM_LOCK_READY;
2264     if (flags & DRM_LOCK_QUIESCENT)  lock.flags |= _DRM_LOCK_QUIESCENT;
2265     if (flags & DRM_LOCK_FLUSH)      lock.flags |= _DRM_LOCK_FLUSH;
2266     if (flags & DRM_LOCK_FLUSH_ALL)  lock.flags |= _DRM_LOCK_FLUSH_ALL;
2267     if (flags & DRM_HALT_ALL_QUEUES) lock.flags |= _DRM_HALT_ALL_QUEUES;
2268     if (flags & DRM_HALT_CUR_QUEUES) lock.flags |= _DRM_HALT_CUR_QUEUES;
2269     if (drmIoctl(fd, DRM_IOCTL_FINISH, &lock))
2270         return -errno;
2271     return 0;
2272 }
2273
2274 /**
2275  * Get IRQ from bus ID.
2276  *
2277  * \param fd file descriptor.
2278  * \param busnum bus number.
2279  * \param devnum device number.
2280  * \param funcnum function number.
2281  *
2282  * \return IRQ number on success, or a negative value on failure.
2283  *
2284  * \internal
2285  * This function is a wrapper around the DRM_IOCTL_IRQ_BUSID ioctl, passing the
2286  * arguments in a drm_irq_busid structure.
2287  */
2288 drm_public int drmGetInterruptFromBusID(int fd, int busnum, int devnum,
2289                                         int funcnum)
2290 {
2291     drm_irq_busid_t p;
2292
2293     memclear(p);
2294     p.busnum  = busnum;
2295     p.devnum  = devnum;
2296     p.funcnum = funcnum;
2297     if (drmIoctl(fd, DRM_IOCTL_IRQ_BUSID, &p))
2298         return -errno;
2299     return p.irq;
2300 }
2301
2302 drm_public int drmAddContextTag(int fd, drm_context_t context, void *tag)
2303 {
2304     drmHashEntry  *entry = drmGetEntry(fd);
2305
2306     if (drmHashInsert(entry->tagTable, context, tag)) {
2307         drmHashDelete(entry->tagTable, context);
2308         drmHashInsert(entry->tagTable, context, tag);
2309     }
2310     return 0;
2311 }
2312
2313 drm_public int drmDelContextTag(int fd, drm_context_t context)
2314 {
2315     drmHashEntry  *entry = drmGetEntry(fd);
2316
2317     return drmHashDelete(entry->tagTable, context);
2318 }
2319
2320 drm_public void *drmGetContextTag(int fd, drm_context_t context)
2321 {
2322     drmHashEntry  *entry = drmGetEntry(fd);
2323     void          *value;
2324
2325     if (drmHashLookup(entry->tagTable, context, &value))
2326         return NULL;
2327
2328     return value;
2329 }
2330
2331 drm_public int drmAddContextPrivateMapping(int fd, drm_context_t ctx_id,
2332                                            drm_handle_t handle)
2333 {
2334     drm_ctx_priv_map_t map;
2335
2336     memclear(map);
2337     map.ctx_id = ctx_id;
2338     map.handle = (void *)(uintptr_t)handle;
2339
2340     if (drmIoctl(fd, DRM_IOCTL_SET_SAREA_CTX, &map))
2341         return -errno;
2342     return 0;
2343 }
2344
2345 drm_public int drmGetContextPrivateMapping(int fd, drm_context_t ctx_id,
2346                                            drm_handle_t *handle)
2347 {
2348     drm_ctx_priv_map_t map;
2349
2350     memclear(map);
2351     map.ctx_id = ctx_id;
2352
2353     if (drmIoctl(fd, DRM_IOCTL_GET_SAREA_CTX, &map))
2354         return -errno;
2355     if (handle)
2356         *handle = (drm_handle_t)(uintptr_t)map.handle;
2357
2358     return 0;
2359 }
2360
2361 drm_public int drmGetMap(int fd, int idx, drm_handle_t *offset, drmSize *size,
2362                          drmMapType *type, drmMapFlags *flags,
2363                          drm_handle_t *handle, int *mtrr)
2364 {
2365     drm_map_t map;
2366
2367     memclear(map);
2368     map.offset = idx;
2369     if (drmIoctl(fd, DRM_IOCTL_GET_MAP, &map))
2370         return -errno;
2371     *offset = map.offset;
2372     *size   = map.size;
2373     *type   = map.type;
2374     *flags  = map.flags;
2375     *handle = (unsigned long)map.handle;
2376     *mtrr   = map.mtrr;
2377     return 0;
2378 }
2379
2380 drm_public int drmGetClient(int fd, int idx, int *auth, int *pid, int *uid,
2381                             unsigned long *magic, unsigned long *iocs)
2382 {
2383     drm_client_t client;
2384
2385     memclear(client);
2386     client.idx = idx;
2387     if (drmIoctl(fd, DRM_IOCTL_GET_CLIENT, &client))
2388         return -errno;
2389     *auth      = client.auth;
2390     *pid       = client.pid;
2391     *uid       = client.uid;
2392     *magic     = client.magic;
2393     *iocs      = client.iocs;
2394     return 0;
2395 }
2396
2397 drm_public int drmGetStats(int fd, drmStatsT *stats)
2398 {
2399     drm_stats_t s;
2400     unsigned    i;
2401
2402     memclear(s);
2403     if (drmIoctl(fd, DRM_IOCTL_GET_STATS, &s))
2404         return -errno;
2405
2406     stats->count = 0;
2407     memset(stats, 0, sizeof(*stats));
2408     if (s.count > sizeof(stats->data)/sizeof(stats->data[0]))
2409         return -1;
2410
2411 #define SET_VALUE                              \
2412     stats->data[i].long_format = "%-20.20s";   \
2413     stats->data[i].rate_format = "%8.8s";      \
2414     stats->data[i].isvalue     = 1;            \
2415     stats->data[i].verbose     = 0
2416
2417 #define SET_COUNT                              \
2418     stats->data[i].long_format = "%-20.20s";   \
2419     stats->data[i].rate_format = "%5.5s";      \
2420     stats->data[i].isvalue     = 0;            \
2421     stats->data[i].mult_names  = "kgm";        \
2422     stats->data[i].mult        = 1000;         \
2423     stats->data[i].verbose     = 0
2424
2425 #define SET_BYTE                               \
2426     stats->data[i].long_format = "%-20.20s";   \
2427     stats->data[i].rate_format = "%5.5s";      \
2428     stats->data[i].isvalue     = 0;            \
2429     stats->data[i].mult_names  = "KGM";        \
2430     stats->data[i].mult        = 1024;         \
2431     stats->data[i].verbose     = 0
2432
2433
2434     stats->count = s.count;
2435     for (i = 0; i < s.count; i++) {
2436         stats->data[i].value = s.data[i].value;
2437         switch (s.data[i].type) {
2438         case _DRM_STAT_LOCK:
2439             stats->data[i].long_name = "Lock";
2440             stats->data[i].rate_name = "Lock";
2441             SET_VALUE;
2442             break;
2443         case _DRM_STAT_OPENS:
2444             stats->data[i].long_name = "Opens";
2445             stats->data[i].rate_name = "O";
2446             SET_COUNT;
2447             stats->data[i].verbose   = 1;
2448             break;
2449         case _DRM_STAT_CLOSES:
2450             stats->data[i].long_name = "Closes";
2451             stats->data[i].rate_name = "Lock";
2452             SET_COUNT;
2453             stats->data[i].verbose   = 1;
2454             break;
2455         case _DRM_STAT_IOCTLS:
2456             stats->data[i].long_name = "Ioctls";
2457             stats->data[i].rate_name = "Ioc/s";
2458             SET_COUNT;
2459             break;
2460         case _DRM_STAT_LOCKS:
2461             stats->data[i].long_name = "Locks";
2462             stats->data[i].rate_name = "Lck/s";
2463             SET_COUNT;
2464             break;
2465         case _DRM_STAT_UNLOCKS:
2466             stats->data[i].long_name = "Unlocks";
2467             stats->data[i].rate_name = "Unl/s";
2468             SET_COUNT;
2469             break;
2470         case _DRM_STAT_IRQ:
2471             stats->data[i].long_name = "IRQs";
2472             stats->data[i].rate_name = "IRQ/s";
2473             SET_COUNT;
2474             break;
2475         case _DRM_STAT_PRIMARY:
2476             stats->data[i].long_name = "Primary Bytes";
2477             stats->data[i].rate_name = "PB/s";
2478             SET_BYTE;
2479             break;
2480         case _DRM_STAT_SECONDARY:
2481             stats->data[i].long_name = "Secondary Bytes";
2482             stats->data[i].rate_name = "SB/s";
2483             SET_BYTE;
2484             break;
2485         case _DRM_STAT_DMA:
2486             stats->data[i].long_name = "DMA";
2487             stats->data[i].rate_name = "DMA/s";
2488             SET_COUNT;
2489             break;
2490         case _DRM_STAT_SPECIAL:
2491             stats->data[i].long_name = "Special DMA";
2492             stats->data[i].rate_name = "dma/s";
2493             SET_COUNT;
2494             break;
2495         case _DRM_STAT_MISSED:
2496             stats->data[i].long_name = "Miss";
2497             stats->data[i].rate_name = "Ms/s";
2498             SET_COUNT;
2499             break;
2500         case _DRM_STAT_VALUE:
2501             stats->data[i].long_name = "Value";
2502             stats->data[i].rate_name = "Value";
2503             SET_VALUE;
2504             break;
2505         case _DRM_STAT_BYTE:
2506             stats->data[i].long_name = "Bytes";
2507             stats->data[i].rate_name = "B/s";
2508             SET_BYTE;
2509             break;
2510         case _DRM_STAT_COUNT:
2511         default:
2512             stats->data[i].long_name = "Count";
2513             stats->data[i].rate_name = "Cnt/s";
2514             SET_COUNT;
2515             break;
2516         }
2517     }
2518     return 0;
2519 }
2520
2521 /**
2522  * Issue a set-version ioctl.
2523  *
2524  * \param fd file descriptor.
2525  * \param drmCommandIndex command index
2526  * \param data source pointer of the data to be read and written.
2527  * \param size size of the data to be read and written.
2528  *
2529  * \return zero on success, or a negative value on failure.
2530  *
2531  * \internal
2532  * It issues a read-write ioctl given by
2533  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2534  */
2535 drm_public int drmSetInterfaceVersion(int fd, drmSetVersion *version)
2536 {
2537     int retcode = 0;
2538     drm_set_version_t sv;
2539
2540     memclear(sv);
2541     sv.drm_di_major = version->drm_di_major;
2542     sv.drm_di_minor = version->drm_di_minor;
2543     sv.drm_dd_major = version->drm_dd_major;
2544     sv.drm_dd_minor = version->drm_dd_minor;
2545
2546     if (drmIoctl(fd, DRM_IOCTL_SET_VERSION, &sv)) {
2547         retcode = -errno;
2548     }
2549
2550     version->drm_di_major = sv.drm_di_major;
2551     version->drm_di_minor = sv.drm_di_minor;
2552     version->drm_dd_major = sv.drm_dd_major;
2553     version->drm_dd_minor = sv.drm_dd_minor;
2554
2555     return retcode;
2556 }
2557
2558 /**
2559  * Send a device-specific command.
2560  *
2561  * \param fd file descriptor.
2562  * \param drmCommandIndex command index
2563  *
2564  * \return zero on success, or a negative value on failure.
2565  *
2566  * \internal
2567  * It issues a ioctl given by
2568  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2569  */
2570 drm_public int drmCommandNone(int fd, unsigned long drmCommandIndex)
2571 {
2572     unsigned long request;
2573
2574     request = DRM_IO( DRM_COMMAND_BASE + drmCommandIndex);
2575
2576     if (drmIoctl(fd, request, NULL)) {
2577         return -errno;
2578     }
2579     return 0;
2580 }
2581
2582
2583 /**
2584  * Send a device-specific read command.
2585  *
2586  * \param fd file descriptor.
2587  * \param drmCommandIndex command index
2588  * \param data destination pointer of the data to be read.
2589  * \param size size of the data to be read.
2590  *
2591  * \return zero on success, or a negative value on failure.
2592  *
2593  * \internal
2594  * It issues a read ioctl given by
2595  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2596  */
2597 drm_public int drmCommandRead(int fd, unsigned long drmCommandIndex,
2598                               void *data, unsigned long size)
2599 {
2600     unsigned long request;
2601
2602     request = DRM_IOC( DRM_IOC_READ, DRM_IOCTL_BASE,
2603         DRM_COMMAND_BASE + drmCommandIndex, size);
2604
2605     if (drmIoctl(fd, request, data)) {
2606         return -errno;
2607     }
2608     return 0;
2609 }
2610
2611
2612 /**
2613  * Send a device-specific write command.
2614  *
2615  * \param fd file descriptor.
2616  * \param drmCommandIndex command index
2617  * \param data source pointer of the data to be written.
2618  * \param size size of the data to be written.
2619  *
2620  * \return zero on success, or a negative value on failure.
2621  *
2622  * \internal
2623  * It issues a write ioctl given by
2624  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2625  */
2626 drm_public int drmCommandWrite(int fd, unsigned long drmCommandIndex,
2627                                void *data, unsigned long size)
2628 {
2629     unsigned long request;
2630
2631     request = DRM_IOC( DRM_IOC_WRITE, DRM_IOCTL_BASE,
2632         DRM_COMMAND_BASE + drmCommandIndex, size);
2633
2634     if (drmIoctl(fd, request, data)) {
2635         return -errno;
2636     }
2637     return 0;
2638 }
2639
2640
2641 /**
2642  * Send a device-specific read-write command.
2643  *
2644  * \param fd file descriptor.
2645  * \param drmCommandIndex command index
2646  * \param data source pointer of the data to be read and written.
2647  * \param size size of the data to be read and written.
2648  *
2649  * \return zero on success, or a negative value on failure.
2650  *
2651  * \internal
2652  * It issues a read-write ioctl given by
2653  * \code DRM_COMMAND_BASE + drmCommandIndex \endcode.
2654  */
2655 drm_public int drmCommandWriteRead(int fd, unsigned long drmCommandIndex,
2656                                    void *data, unsigned long size)
2657 {
2658     unsigned long request;
2659
2660     request = DRM_IOC( DRM_IOC_READ|DRM_IOC_WRITE, DRM_IOCTL_BASE,
2661         DRM_COMMAND_BASE + drmCommandIndex, size);
2662
2663     if (drmIoctl(fd, request, data))
2664         return -errno;
2665     return 0;
2666 }
2667
2668 #define DRM_MAX_FDS 16
2669 static struct {
2670     char *BusID;
2671     int fd;
2672     int refcount;
2673     int type;
2674 } connection[DRM_MAX_FDS];
2675
2676 static int nr_fds = 0;
2677
2678 drm_public int drmOpenOnce(void *unused, const char *BusID, int *newlyopened)
2679 {
2680     return drmOpenOnceWithType(BusID, newlyopened, DRM_NODE_PRIMARY);
2681 }
2682
2683 drm_public int drmOpenOnceWithType(const char *BusID, int *newlyopened,
2684                                    int type)
2685 {
2686     int i;
2687     int fd;
2688
2689     for (i = 0; i < nr_fds; i++)
2690         if ((strcmp(BusID, connection[i].BusID) == 0) &&
2691             (connection[i].type == type)) {
2692             connection[i].refcount++;
2693             *newlyopened = 0;
2694             return connection[i].fd;
2695         }
2696
2697     fd = drmOpenWithType(NULL, BusID, type);
2698     if (fd < 0 || nr_fds == DRM_MAX_FDS)
2699         return fd;
2700
2701     connection[nr_fds].BusID = strdup(BusID);
2702     connection[nr_fds].fd = fd;
2703     connection[nr_fds].refcount = 1;
2704     connection[nr_fds].type = type;
2705     *newlyopened = 1;
2706
2707     if (0)
2708         fprintf(stderr, "saved connection %d for %s %d\n",
2709                 nr_fds, connection[nr_fds].BusID,
2710                 strcmp(BusID, connection[nr_fds].BusID));
2711
2712     nr_fds++;
2713
2714     return fd;
2715 }
2716
2717 drm_public void drmCloseOnce(int fd)
2718 {
2719     int i;
2720
2721     for (i = 0; i < nr_fds; i++) {
2722         if (fd == connection[i].fd) {
2723             if (--connection[i].refcount == 0) {
2724                 drmClose(connection[i].fd);
2725                 free(connection[i].BusID);
2726
2727                 if (i < --nr_fds)
2728                     connection[i] = connection[nr_fds];
2729
2730                 return;
2731             }
2732         }
2733     }
2734 }
2735
2736 drm_public int drmSetMaster(int fd)
2737 {
2738         return drmIoctl(fd, DRM_IOCTL_SET_MASTER, NULL);
2739 }
2740
2741 drm_public int drmDropMaster(int fd)
2742 {
2743         return drmIoctl(fd, DRM_IOCTL_DROP_MASTER, NULL);
2744 }
2745
2746 drm_public int drmIsMaster(int fd)
2747 {
2748         /* Detect master by attempting something that requires master.
2749          *
2750          * Authenticating magic tokens requires master and 0 is an
2751          * internal kernel detail which we could use. Attempting this on
2752          * a master fd would fail therefore fail with EINVAL because 0
2753          * is invalid.
2754          *
2755          * A non-master fd will fail with EACCES, as the kernel checks
2756          * for master before attempting to do anything else.
2757          *
2758          * Since we don't want to leak implementation details, use
2759          * EACCES.
2760          */
2761         return drmAuthMagic(fd, 0) != -EACCES;
2762 }
2763
2764 drm_public char *drmGetDeviceNameFromFd(int fd)
2765 {
2766     char name[128];
2767     struct stat sbuf;
2768     dev_t d;
2769     int i;
2770
2771     /* The whole drmOpen thing is a fiasco and we need to find a way
2772      * back to just using open(2).  For now, however, lets just make
2773      * things worse with even more ad hoc directory walking code to
2774      * discover the device file name. */
2775
2776     fstat(fd, &sbuf);
2777     d = sbuf.st_rdev;
2778
2779     for (i = 0; i < DRM_MAX_MINOR; i++) {
2780         snprintf(name, sizeof name, DRM_DEV_NAME, DRM_DIR_NAME, i);
2781         if (stat(name, &sbuf) == 0 && sbuf.st_rdev == d)
2782             break;
2783     }
2784     if (i == DRM_MAX_MINOR)
2785         return NULL;
2786
2787     return strdup(name);
2788 }
2789
2790 static bool drmNodeIsDRM(int maj, int min)
2791 {
2792 #ifdef __linux__
2793     char path[64];
2794     struct stat sbuf;
2795
2796     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device/drm",
2797              maj, min);
2798     return stat(path, &sbuf) == 0;
2799 #else
2800     return maj == DRM_MAJOR;
2801 #endif
2802 }
2803
2804 drm_public int drmGetNodeTypeFromFd(int fd)
2805 {
2806     struct stat sbuf;
2807     int maj, min, type;
2808
2809     if (fstat(fd, &sbuf))
2810         return -1;
2811
2812     maj = major(sbuf.st_rdev);
2813     min = minor(sbuf.st_rdev);
2814
2815     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode)) {
2816         errno = EINVAL;
2817         return -1;
2818     }
2819
2820     type = drmGetMinorType(min);
2821     if (type == -1)
2822         errno = ENODEV;
2823     return type;
2824 }
2825
2826 drm_public int drmPrimeHandleToFD(int fd, uint32_t handle, uint32_t flags,
2827                                   int *prime_fd)
2828 {
2829     struct drm_prime_handle args;
2830     int ret;
2831
2832     memclear(args);
2833     args.fd = -1;
2834     args.handle = handle;
2835     args.flags = flags;
2836     ret = drmIoctl(fd, DRM_IOCTL_PRIME_HANDLE_TO_FD, &args);
2837     if (ret)
2838         return ret;
2839
2840     *prime_fd = args.fd;
2841     return 0;
2842 }
2843
2844 drm_public int drmPrimeFDToHandle(int fd, int prime_fd, uint32_t *handle)
2845 {
2846     struct drm_prime_handle args;
2847     int ret;
2848
2849     memclear(args);
2850     args.fd = prime_fd;
2851     ret = drmIoctl(fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &args);
2852     if (ret)
2853         return ret;
2854
2855     *handle = args.handle;
2856     return 0;
2857 }
2858
2859 static char *drmGetMinorNameForFD(int fd, int type)
2860 {
2861 #ifdef __linux__
2862     DIR *sysdir;
2863     struct dirent *ent;
2864     struct stat sbuf;
2865     const char *name = drmGetMinorName(type);
2866     int len;
2867     char dev_name[64], buf[64];
2868     int maj, min;
2869
2870     if (!name)
2871         return NULL;
2872
2873     len = strlen(name);
2874
2875     if (fstat(fd, &sbuf))
2876         return NULL;
2877
2878     maj = major(sbuf.st_rdev);
2879     min = minor(sbuf.st_rdev);
2880
2881     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
2882         return NULL;
2883
2884     snprintf(buf, sizeof(buf), "/sys/dev/char/%d:%d/device/drm", maj, min);
2885
2886     sysdir = opendir(buf);
2887     if (!sysdir)
2888         return NULL;
2889
2890     while ((ent = readdir(sysdir))) {
2891         if (strncmp(ent->d_name, name, len) == 0) {
2892             snprintf(dev_name, sizeof(dev_name), DRM_DIR_NAME "/%s",
2893                  ent->d_name);
2894
2895             closedir(sysdir);
2896             return strdup(dev_name);
2897         }
2898     }
2899
2900     closedir(sysdir);
2901     return NULL;
2902 #else
2903     struct stat sbuf;
2904     char buf[PATH_MAX + 1];
2905     const char *dev_name;
2906     unsigned int maj, min;
2907     int n, base;
2908
2909     if (fstat(fd, &sbuf))
2910         return NULL;
2911
2912     maj = major(sbuf.st_rdev);
2913     min = minor(sbuf.st_rdev);
2914
2915     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
2916         return NULL;
2917
2918     switch (type) {
2919     case DRM_NODE_PRIMARY:
2920         dev_name = DRM_DEV_NAME;
2921         break;
2922     case DRM_NODE_CONTROL:
2923         dev_name = DRM_CONTROL_DEV_NAME;
2924         break;
2925     case DRM_NODE_RENDER:
2926         dev_name = DRM_RENDER_DEV_NAME;
2927         break;
2928     default:
2929         return NULL;
2930     };
2931
2932     base = drmGetMinorBase(type);
2933     if (base < 0)
2934         return NULL;
2935
2936     n = snprintf(buf, sizeof(buf), dev_name, DRM_DIR_NAME, min - base);
2937     if (n == -1 || n >= sizeof(buf))
2938         return NULL;
2939
2940     return strdup(buf);
2941 #endif
2942 }
2943
2944 drm_public char *drmGetPrimaryDeviceNameFromFd(int fd)
2945 {
2946     return drmGetMinorNameForFD(fd, DRM_NODE_PRIMARY);
2947 }
2948
2949 drm_public char *drmGetRenderDeviceNameFromFd(int fd)
2950 {
2951     return drmGetMinorNameForFD(fd, DRM_NODE_RENDER);
2952 }
2953
2954 #ifdef __linux__
2955 static char * DRM_PRINTFLIKE(2, 3)
2956 sysfs_uevent_get(const char *path, const char *fmt, ...)
2957 {
2958     char filename[PATH_MAX + 1], *key, *line = NULL, *value = NULL;
2959     size_t size = 0, len;
2960     ssize_t num;
2961     va_list ap;
2962     FILE *fp;
2963
2964     va_start(ap, fmt);
2965     num = vasprintf(&key, fmt, ap);
2966     va_end(ap);
2967     len = num;
2968
2969     snprintf(filename, sizeof(filename), "%s/uevent", path);
2970
2971     fp = fopen(filename, "r");
2972     if (!fp) {
2973         free(key);
2974         return NULL;
2975     }
2976
2977     while ((num = getline(&line, &size, fp)) >= 0) {
2978         if ((strncmp(line, key, len) == 0) && (line[len] == '=')) {
2979             char *start = line + len + 1, *end = line + num - 1;
2980
2981             if (*end != '\n')
2982                 end++;
2983
2984             value = strndup(start, end - start);
2985             break;
2986         }
2987     }
2988
2989     free(line);
2990     fclose(fp);
2991
2992     free(key);
2993
2994     return value;
2995 }
2996 #endif
2997
2998 /* Little white lie to avoid major rework of the existing code */
2999 #define DRM_BUS_VIRTIO 0x10
3000
3001 static int drmParseSubsystemType(int maj, int min)
3002 {
3003 #ifdef __linux__
3004     char path[PATH_MAX + 1];
3005     char link[PATH_MAX + 1] = "";
3006     char *name;
3007     struct {
3008         const char *name;
3009         int bus_type;
3010     } bus_types[] = {
3011         { "/pci", DRM_BUS_PCI },
3012         { "/usb", DRM_BUS_USB },
3013         { "/platform", DRM_BUS_PLATFORM },
3014         { "/spi", DRM_BUS_PLATFORM },
3015         { "/host1x", DRM_BUS_HOST1X },
3016         { "/virtio", DRM_BUS_VIRTIO },
3017     };
3018
3019     snprintf(path, PATH_MAX, "/sys/dev/char/%d:%d/device/subsystem",
3020              maj, min);
3021
3022     if (readlink(path, link, PATH_MAX) < 0)
3023         return -errno;
3024
3025     name = strrchr(link, '/');
3026     if (!name)
3027         return -EINVAL;
3028
3029     for (unsigned i = 0; i < ARRAY_SIZE(bus_types); i++) {
3030         if (strncmp(name, bus_types[i].name, strlen(bus_types[i].name)) == 0)
3031             return bus_types[i].bus_type;
3032     }
3033
3034     return -EINVAL;
3035 #elif defined(__OpenBSD__) || defined(__DragonFly__)
3036     return DRM_BUS_PCI;
3037 #else
3038 #warning "Missing implementation of drmParseSubsystemType"
3039     return -EINVAL;
3040 #endif
3041 }
3042
3043 static void
3044 get_pci_path(int maj, int min, char *pci_path)
3045 {
3046     char path[PATH_MAX + 1], *term;
3047
3048     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min);
3049     if (!realpath(path, pci_path)) {
3050         strcpy(pci_path, path);
3051         return;
3052     }
3053
3054     term = strrchr(pci_path, '/');
3055     if (term && strncmp(term, "/virtio", 7) == 0)
3056         *term = 0;
3057 }
3058
3059 static int drmParsePciBusInfo(int maj, int min, drmPciBusInfoPtr info)
3060 {
3061 #ifdef __linux__
3062     unsigned int domain, bus, dev, func;
3063     char pci_path[PATH_MAX + 1], *value;
3064     int num;
3065
3066     get_pci_path(maj, min, pci_path);
3067
3068     value = sysfs_uevent_get(pci_path, "PCI_SLOT_NAME");
3069     if (!value)
3070         return -ENOENT;
3071
3072     num = sscanf(value, "%04x:%02x:%02x.%1u", &domain, &bus, &dev, &func);
3073     free(value);
3074
3075     if (num != 4)
3076         return -EINVAL;
3077
3078     info->domain = domain;
3079     info->bus = bus;
3080     info->dev = dev;
3081     info->func = func;
3082
3083     return 0;
3084 #elif defined(__OpenBSD__) || defined(__DragonFly__)
3085     struct drm_pciinfo pinfo;
3086     int fd, type;
3087
3088     type = drmGetMinorType(min);
3089     if (type == -1)
3090         return -ENODEV;
3091
3092     fd = drmOpenMinor(min, 0, type);
3093     if (fd < 0)
3094         return -errno;
3095
3096     if (drmIoctl(fd, DRM_IOCTL_GET_PCIINFO, &pinfo)) {
3097         close(fd);
3098         return -errno;
3099     }
3100     close(fd);
3101
3102     info->domain = pinfo.domain;
3103     info->bus = pinfo.bus;
3104     info->dev = pinfo.dev;
3105     info->func = pinfo.func;
3106
3107     return 0;
3108 #else
3109 #warning "Missing implementation of drmParsePciBusInfo"
3110     return -EINVAL;
3111 #endif
3112 }
3113
3114 drm_public int drmDevicesEqual(drmDevicePtr a, drmDevicePtr b)
3115 {
3116     if (a == NULL || b == NULL)
3117         return 0;
3118
3119     if (a->bustype != b->bustype)
3120         return 0;
3121
3122     switch (a->bustype) {
3123     case DRM_BUS_PCI:
3124         return memcmp(a->businfo.pci, b->businfo.pci, sizeof(drmPciBusInfo)) == 0;
3125
3126     case DRM_BUS_USB:
3127         return memcmp(a->businfo.usb, b->businfo.usb, sizeof(drmUsbBusInfo)) == 0;
3128
3129     case DRM_BUS_PLATFORM:
3130         return memcmp(a->businfo.platform, b->businfo.platform, sizeof(drmPlatformBusInfo)) == 0;
3131
3132     case DRM_BUS_HOST1X:
3133         return memcmp(a->businfo.host1x, b->businfo.host1x, sizeof(drmHost1xBusInfo)) == 0;
3134
3135     default:
3136         break;
3137     }
3138
3139     return 0;
3140 }
3141
3142 static int drmGetNodeType(const char *name)
3143 {
3144     if (strncmp(name, DRM_PRIMARY_MINOR_NAME,
3145         sizeof(DRM_PRIMARY_MINOR_NAME) - 1) == 0)
3146         return DRM_NODE_PRIMARY;
3147
3148     if (strncmp(name, DRM_CONTROL_MINOR_NAME,
3149         sizeof(DRM_CONTROL_MINOR_NAME ) - 1) == 0)
3150         return DRM_NODE_CONTROL;
3151
3152     if (strncmp(name, DRM_RENDER_MINOR_NAME,
3153         sizeof(DRM_RENDER_MINOR_NAME) - 1) == 0)
3154         return DRM_NODE_RENDER;
3155
3156     return -EINVAL;
3157 }
3158
3159 static int drmGetMaxNodeName(void)
3160 {
3161     return sizeof(DRM_DIR_NAME) +
3162            MAX3(sizeof(DRM_PRIMARY_MINOR_NAME),
3163                 sizeof(DRM_CONTROL_MINOR_NAME),
3164                 sizeof(DRM_RENDER_MINOR_NAME)) +
3165            3 /* length of the node number */;
3166 }
3167
3168 #ifdef __linux__
3169 static int parse_separate_sysfs_files(int maj, int min,
3170                                       drmPciDeviceInfoPtr device,
3171                                       bool ignore_revision)
3172 {
3173     static const char *attrs[] = {
3174       "revision", /* Older kernels are missing the file, so check for it first */
3175       "vendor",
3176       "device",
3177       "subsystem_vendor",
3178       "subsystem_device",
3179     };
3180     char path[PATH_MAX + 1], pci_path[PATH_MAX + 1];
3181     unsigned int data[ARRAY_SIZE(attrs)];
3182     FILE *fp;
3183     int ret;
3184
3185     get_pci_path(maj, min, pci_path);
3186
3187     for (unsigned i = ignore_revision ? 1 : 0; i < ARRAY_SIZE(attrs); i++) {
3188         snprintf(path, PATH_MAX, "%s/%s", pci_path, attrs[i]);
3189         fp = fopen(path, "r");
3190         if (!fp)
3191             return -errno;
3192
3193         ret = fscanf(fp, "%x", &data[i]);
3194         fclose(fp);
3195         if (ret != 1)
3196             return -errno;
3197
3198     }
3199
3200     device->revision_id = ignore_revision ? 0xff : data[0] & 0xff;
3201     device->vendor_id = data[1] & 0xffff;
3202     device->device_id = data[2] & 0xffff;
3203     device->subvendor_id = data[3] & 0xffff;
3204     device->subdevice_id = data[4] & 0xffff;
3205
3206     return 0;
3207 }
3208
3209 static int parse_config_sysfs_file(int maj, int min,
3210                                    drmPciDeviceInfoPtr device)
3211 {
3212     char path[PATH_MAX + 1], pci_path[PATH_MAX + 1];
3213     unsigned char config[64];
3214     int fd, ret;
3215
3216     get_pci_path(maj, min, pci_path);
3217
3218     snprintf(path, PATH_MAX, "%s/config", pci_path);
3219     fd = open(path, O_RDONLY);
3220     if (fd < 0)
3221         return -errno;
3222
3223     ret = read(fd, config, sizeof(config));
3224     close(fd);
3225     if (ret < 0)
3226         return -errno;
3227
3228     device->vendor_id = config[0] | (config[1] << 8);
3229     device->device_id = config[2] | (config[3] << 8);
3230     device->revision_id = config[8];
3231     device->subvendor_id = config[44] | (config[45] << 8);
3232     device->subdevice_id = config[46] | (config[47] << 8);
3233
3234     return 0;
3235 }
3236 #endif
3237
3238 static int drmParsePciDeviceInfo(int maj, int min,
3239                                  drmPciDeviceInfoPtr device,
3240                                  uint32_t flags)
3241 {
3242 #ifdef __linux__
3243     if (!(flags & DRM_DEVICE_GET_PCI_REVISION))
3244         return parse_separate_sysfs_files(maj, min, device, true);
3245
3246     if (parse_separate_sysfs_files(maj, min, device, false))
3247         return parse_config_sysfs_file(maj, min, device);
3248
3249     return 0;
3250 #elif defined(__OpenBSD__) || defined(__DragonFly__)
3251     struct drm_pciinfo pinfo;
3252     int fd, type;
3253
3254     type = drmGetMinorType(min);
3255     if (type == -1)
3256         return -ENODEV;
3257
3258     fd = drmOpenMinor(min, 0, type);
3259     if (fd < 0)
3260         return -errno;
3261
3262     if (drmIoctl(fd, DRM_IOCTL_GET_PCIINFO, &pinfo)) {
3263         close(fd);
3264         return -errno;
3265     }
3266     close(fd);
3267
3268     device->vendor_id = pinfo.vendor_id;
3269     device->device_id = pinfo.device_id;
3270     device->revision_id = pinfo.revision_id;
3271     device->subvendor_id = pinfo.subvendor_id;
3272     device->subdevice_id = pinfo.subdevice_id;
3273
3274     return 0;
3275 #else
3276 #warning "Missing implementation of drmParsePciDeviceInfo"
3277     return -EINVAL;
3278 #endif
3279 }
3280
3281 static void drmFreePlatformDevice(drmDevicePtr device)
3282 {
3283     if (device->deviceinfo.platform) {
3284         if (device->deviceinfo.platform->compatible) {
3285             char **compatible = device->deviceinfo.platform->compatible;
3286
3287             while (*compatible) {
3288                 free(*compatible);
3289                 compatible++;
3290             }
3291
3292             free(device->deviceinfo.platform->compatible);
3293         }
3294     }
3295 }
3296
3297 static void drmFreeHost1xDevice(drmDevicePtr device)
3298 {
3299     if (device->deviceinfo.host1x) {
3300         if (device->deviceinfo.host1x->compatible) {
3301             char **compatible = device->deviceinfo.host1x->compatible;
3302
3303             while (*compatible) {
3304                 free(*compatible);
3305                 compatible++;
3306             }
3307
3308             free(device->deviceinfo.host1x->compatible);
3309         }
3310     }
3311 }
3312
3313 drm_public void drmFreeDevice(drmDevicePtr *device)
3314 {
3315     if (device == NULL)
3316         return;
3317
3318     if (*device) {
3319         switch ((*device)->bustype) {
3320         case DRM_BUS_PLATFORM:
3321             drmFreePlatformDevice(*device);
3322             break;
3323
3324         case DRM_BUS_HOST1X:
3325             drmFreeHost1xDevice(*device);
3326             break;
3327         }
3328     }
3329
3330     free(*device);
3331     *device = NULL;
3332 }
3333
3334 drm_public void drmFreeDevices(drmDevicePtr devices[], int count)
3335 {
3336     int i;
3337
3338     if (devices == NULL)
3339         return;
3340
3341     for (i = 0; i < count; i++)
3342         if (devices[i])
3343             drmFreeDevice(&devices[i]);
3344 }
3345
3346 static drmDevicePtr drmDeviceAlloc(unsigned int type, const char *node,
3347                                    size_t bus_size, size_t device_size,
3348                                    char **ptrp)
3349 {
3350     size_t max_node_length, extra, size;
3351     drmDevicePtr device;
3352     unsigned int i;
3353     char *ptr;
3354
3355     max_node_length = ALIGN(drmGetMaxNodeName(), sizeof(void *));
3356     extra = DRM_NODE_MAX * (sizeof(void *) + max_node_length);
3357
3358     size = sizeof(*device) + extra + bus_size + device_size;
3359
3360     device = calloc(1, size);
3361     if (!device)
3362         return NULL;
3363
3364     device->available_nodes = 1 << type;
3365
3366     ptr = (char *)device + sizeof(*device);
3367     device->nodes = (char **)ptr;
3368
3369     ptr += DRM_NODE_MAX * sizeof(void *);
3370
3371     for (i = 0; i < DRM_NODE_MAX; i++) {
3372         device->nodes[i] = ptr;
3373         ptr += max_node_length;
3374     }
3375
3376     memcpy(device->nodes[type], node, max_node_length);
3377
3378     *ptrp = ptr;
3379
3380     return device;
3381 }
3382
3383 static int drmProcessPciDevice(drmDevicePtr *device,
3384                                const char *node, int node_type,
3385                                int maj, int min, bool fetch_deviceinfo,
3386                                uint32_t flags)
3387 {
3388     drmDevicePtr dev;
3389     char *addr;
3390     int ret;
3391
3392     dev = drmDeviceAlloc(node_type, node, sizeof(drmPciBusInfo),
3393                          sizeof(drmPciDeviceInfo), &addr);
3394     if (!dev)
3395         return -ENOMEM;
3396
3397     dev->bustype = DRM_BUS_PCI;
3398
3399     dev->businfo.pci = (drmPciBusInfoPtr)addr;
3400
3401     ret = drmParsePciBusInfo(maj, min, dev->businfo.pci);
3402     if (ret)
3403         goto free_device;
3404
3405     // Fetch the device info if the user has requested it
3406     if (fetch_deviceinfo) {
3407         addr += sizeof(drmPciBusInfo);
3408         dev->deviceinfo.pci = (drmPciDeviceInfoPtr)addr;
3409
3410         ret = drmParsePciDeviceInfo(maj, min, dev->deviceinfo.pci, flags);
3411         if (ret)
3412             goto free_device;
3413     }
3414
3415     *device = dev;
3416
3417     return 0;
3418
3419 free_device:
3420     free(dev);
3421     return ret;
3422 }
3423
3424 static int drmParseUsbBusInfo(int maj, int min, drmUsbBusInfoPtr info)
3425 {
3426 #ifdef __linux__
3427     char path[PATH_MAX + 1], *value;
3428     unsigned int bus, dev;
3429     int ret;
3430
3431     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min);
3432
3433     value = sysfs_uevent_get(path, "BUSNUM");
3434     if (!value)
3435         return -ENOENT;
3436
3437     ret = sscanf(value, "%03u", &bus);
3438     free(value);
3439
3440     if (ret <= 0)
3441         return -errno;
3442
3443     value = sysfs_uevent_get(path, "DEVNUM");
3444     if (!value)
3445         return -ENOENT;
3446
3447     ret = sscanf(value, "%03u", &dev);
3448     free(value);
3449
3450     if (ret <= 0)
3451         return -errno;
3452
3453     info->bus = bus;
3454     info->dev = dev;
3455
3456     return 0;
3457 #else
3458 #warning "Missing implementation of drmParseUsbBusInfo"
3459     return -EINVAL;
3460 #endif
3461 }
3462
3463 static int drmParseUsbDeviceInfo(int maj, int min, drmUsbDeviceInfoPtr info)
3464 {
3465 #ifdef __linux__
3466     char path[PATH_MAX + 1], *value;
3467     unsigned int vendor, product;
3468     int ret;
3469
3470     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min);
3471
3472     value = sysfs_uevent_get(path, "PRODUCT");
3473     if (!value)
3474         return -ENOENT;
3475
3476     ret = sscanf(value, "%x/%x", &vendor, &product);
3477     free(value);
3478
3479     if (ret <= 0)
3480         return -errno;
3481
3482     info->vendor = vendor;
3483     info->product = product;
3484
3485     return 0;
3486 #else
3487 #warning "Missing implementation of drmParseUsbDeviceInfo"
3488     return -EINVAL;
3489 #endif
3490 }
3491
3492 static int drmProcessUsbDevice(drmDevicePtr *device, const char *node,
3493                                int node_type, int maj, int min,
3494                                bool fetch_deviceinfo, uint32_t flags)
3495 {
3496     drmDevicePtr dev;
3497     char *ptr;
3498     int ret;
3499
3500     dev = drmDeviceAlloc(node_type, node, sizeof(drmUsbBusInfo),
3501                          sizeof(drmUsbDeviceInfo), &ptr);
3502     if (!dev)
3503         return -ENOMEM;
3504
3505     dev->bustype = DRM_BUS_USB;
3506
3507     dev->businfo.usb = (drmUsbBusInfoPtr)ptr;
3508
3509     ret = drmParseUsbBusInfo(maj, min, dev->businfo.usb);
3510     if (ret < 0)
3511         goto free_device;
3512
3513     if (fetch_deviceinfo) {
3514         ptr += sizeof(drmUsbBusInfo);
3515         dev->deviceinfo.usb = (drmUsbDeviceInfoPtr)ptr;
3516
3517         ret = drmParseUsbDeviceInfo(maj, min, dev->deviceinfo.usb);
3518         if (ret < 0)
3519             goto free_device;
3520     }
3521
3522     *device = dev;
3523
3524     return 0;
3525
3526 free_device:
3527     free(dev);
3528     return ret;
3529 }
3530
3531 static int drmParseOFBusInfo(int maj, int min, char *fullname)
3532 {
3533 #ifdef __linux__
3534     char path[PATH_MAX + 1], *name, *tmp_name;
3535
3536     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min);
3537
3538     name = sysfs_uevent_get(path, "OF_FULLNAME");
3539     tmp_name = name;
3540     if (!name) {
3541         /* If the device lacks OF data, pick the MODALIAS info */
3542         name = sysfs_uevent_get(path, "MODALIAS");
3543         if (!name)
3544             return -ENOENT;
3545
3546         /* .. and strip the MODALIAS=[platform,usb...]: part. */
3547         tmp_name = strrchr(name, ':');
3548         if (!tmp_name) {
3549             free(name);
3550             return -ENOENT;
3551         }
3552         tmp_name++;
3553     }
3554
3555     strncpy(fullname, tmp_name, DRM_PLATFORM_DEVICE_NAME_LEN);
3556     fullname[DRM_PLATFORM_DEVICE_NAME_LEN - 1] = '\0';
3557     free(name);
3558
3559     return 0;
3560 #else
3561 #warning "Missing implementation of drmParseOFBusInfo"
3562     return -EINVAL;
3563 #endif
3564 }
3565
3566 static int drmParseOFDeviceInfo(int maj, int min, char ***compatible)
3567 {
3568 #ifdef __linux__
3569     char path[PATH_MAX + 1], *value, *tmp_name;
3570     unsigned int count, i;
3571     int err;
3572
3573     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d/device", maj, min);
3574
3575     value = sysfs_uevent_get(path, "OF_COMPATIBLE_N");
3576     if (value) {
3577         sscanf(value, "%u", &count);
3578         free(value);
3579     } else {
3580         /* Assume one entry if the device lack OF data */
3581         count = 1;
3582     }
3583
3584     *compatible = calloc(count + 1, sizeof(char *));
3585     if (!*compatible)
3586         return -ENOMEM;
3587
3588     for (i = 0; i < count; i++) {
3589         value = sysfs_uevent_get(path, "OF_COMPATIBLE_%u", i);
3590         tmp_name = value;
3591         if (!value) {
3592             /* If the device lacks OF data, pick the MODALIAS info */
3593             value = sysfs_uevent_get(path, "MODALIAS");
3594             if (!value) {
3595                 err = -ENOENT;
3596                 goto free;
3597             }
3598
3599             /* .. and strip the MODALIAS=[platform,usb...]: part. */
3600             tmp_name = strrchr(value, ':');
3601             if (!tmp_name) {
3602                 free(value);
3603                 return -ENOENT;
3604             }
3605             tmp_name = strdup(tmp_name + 1);
3606             free(value);
3607         }
3608
3609         (*compatible)[i] = tmp_name;
3610     }
3611
3612     return 0;
3613
3614 free:
3615     while (i--)
3616         free((*compatible)[i]);
3617
3618     free(*compatible);
3619     return err;
3620 #else
3621 #warning "Missing implementation of drmParseOFDeviceInfo"
3622     return -EINVAL;
3623 #endif
3624 }
3625
3626 static int drmProcessPlatformDevice(drmDevicePtr *device,
3627                                     const char *node, int node_type,
3628                                     int maj, int min, bool fetch_deviceinfo,
3629                                     uint32_t flags)
3630 {
3631     drmDevicePtr dev;
3632     char *ptr;
3633     int ret;
3634
3635     dev = drmDeviceAlloc(node_type, node, sizeof(drmPlatformBusInfo),
3636                          sizeof(drmPlatformDeviceInfo), &ptr);
3637     if (!dev)
3638         return -ENOMEM;
3639
3640     dev->bustype = DRM_BUS_PLATFORM;
3641
3642     dev->businfo.platform = (drmPlatformBusInfoPtr)ptr;
3643
3644     ret = drmParseOFBusInfo(maj, min, dev->businfo.platform->fullname);
3645     if (ret < 0)
3646         goto free_device;
3647
3648     if (fetch_deviceinfo) {
3649         ptr += sizeof(drmPlatformBusInfo);
3650         dev->deviceinfo.platform = (drmPlatformDeviceInfoPtr)ptr;
3651
3652         ret = drmParseOFDeviceInfo(maj, min, &dev->deviceinfo.platform->compatible);
3653         if (ret < 0)
3654             goto free_device;
3655     }
3656
3657     *device = dev;
3658
3659     return 0;
3660
3661 free_device:
3662     free(dev);
3663     return ret;
3664 }
3665
3666 static int drmProcessHost1xDevice(drmDevicePtr *device,
3667                                   const char *node, int node_type,
3668                                   int maj, int min, bool fetch_deviceinfo,
3669                                   uint32_t flags)
3670 {
3671     drmDevicePtr dev;
3672     char *ptr;
3673     int ret;
3674
3675     dev = drmDeviceAlloc(node_type, node, sizeof(drmHost1xBusInfo),
3676                          sizeof(drmHost1xDeviceInfo), &ptr);
3677     if (!dev)
3678         return -ENOMEM;
3679
3680     dev->bustype = DRM_BUS_HOST1X;
3681
3682     dev->businfo.host1x = (drmHost1xBusInfoPtr)ptr;
3683
3684     ret = drmParseOFBusInfo(maj, min, dev->businfo.host1x->fullname);
3685     if (ret < 0)
3686         goto free_device;
3687
3688     if (fetch_deviceinfo) {
3689         ptr += sizeof(drmHost1xBusInfo);
3690         dev->deviceinfo.host1x = (drmHost1xDeviceInfoPtr)ptr;
3691
3692         ret = drmParseOFDeviceInfo(maj, min, &dev->deviceinfo.host1x->compatible);
3693         if (ret < 0)
3694             goto free_device;
3695     }
3696
3697     *device = dev;
3698
3699     return 0;
3700
3701 free_device:
3702     free(dev);
3703     return ret;
3704 }
3705
3706 static int
3707 process_device(drmDevicePtr *device, const char *d_name,
3708                int req_subsystem_type,
3709                bool fetch_deviceinfo, uint32_t flags)
3710 {
3711     struct stat sbuf;
3712     char node[PATH_MAX + 1];
3713     int node_type, subsystem_type;
3714     unsigned int maj, min;
3715
3716     node_type = drmGetNodeType(d_name);
3717     if (node_type < 0)
3718         return -1;
3719
3720     snprintf(node, PATH_MAX, "%s/%s", DRM_DIR_NAME, d_name);
3721     if (stat(node, &sbuf))
3722         return -1;
3723
3724     maj = major(sbuf.st_rdev);
3725     min = minor(sbuf.st_rdev);
3726
3727     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
3728         return -1;
3729
3730     subsystem_type = drmParseSubsystemType(maj, min);
3731     if (req_subsystem_type != -1 && req_subsystem_type != subsystem_type)
3732         return -1;
3733
3734     switch (subsystem_type) {
3735     case DRM_BUS_PCI:
3736     case DRM_BUS_VIRTIO:
3737         return drmProcessPciDevice(device, node, node_type, maj, min,
3738                                    fetch_deviceinfo, flags);
3739     case DRM_BUS_USB:
3740         return drmProcessUsbDevice(device, node, node_type, maj, min,
3741                                    fetch_deviceinfo, flags);
3742     case DRM_BUS_PLATFORM:
3743         return drmProcessPlatformDevice(device, node, node_type, maj, min,
3744                                         fetch_deviceinfo, flags);
3745     case DRM_BUS_HOST1X:
3746         return drmProcessHost1xDevice(device, node, node_type, maj, min,
3747                                       fetch_deviceinfo, flags);
3748     default:
3749         return -1;
3750    }
3751 }
3752
3753 /* Consider devices located on the same bus as duplicate and fold the respective
3754  * entries into a single one.
3755  *
3756  * Note: this leaves "gaps" in the array, while preserving the length.
3757  */
3758 static void drmFoldDuplicatedDevices(drmDevicePtr local_devices[], int count)
3759 {
3760     int node_type, i, j;
3761
3762     for (i = 0; i < count; i++) {
3763         for (j = i + 1; j < count; j++) {
3764             if (drmDevicesEqual(local_devices[i], local_devices[j])) {
3765                 local_devices[i]->available_nodes |= local_devices[j]->available_nodes;
3766                 node_type = log2(local_devices[j]->available_nodes);
3767                 memcpy(local_devices[i]->nodes[node_type],
3768                        local_devices[j]->nodes[node_type], drmGetMaxNodeName());
3769                 drmFreeDevice(&local_devices[j]);
3770             }
3771         }
3772     }
3773 }
3774
3775 /* Check that the given flags are valid returning 0 on success */
3776 static int
3777 drm_device_validate_flags(uint32_t flags)
3778 {
3779         return (flags & ~DRM_DEVICE_GET_PCI_REVISION);
3780 }
3781
3782 static bool
3783 drm_device_has_rdev(drmDevicePtr device, dev_t find_rdev)
3784 {
3785     struct stat sbuf;
3786
3787     for (int i = 0; i < DRM_NODE_MAX; i++) {
3788         if (device->available_nodes & 1 << i) {
3789             if (stat(device->nodes[i], &sbuf) == 0 &&
3790                 sbuf.st_rdev == find_rdev)
3791                 return true;
3792         }
3793     }
3794     return false;
3795 }
3796
3797 /*
3798  * The kernel drm core has a number of places that assume maximum of
3799  * 3x64 devices nodes. That's 64 for each of primary, control and
3800  * render nodes. Rounded it up to 256 for simplicity.
3801  */
3802 #define MAX_DRM_NODES 256
3803
3804 /**
3805  * Get information about the opened drm device
3806  *
3807  * \param fd file descriptor of the drm device
3808  * \param flags feature/behaviour bitmask
3809  * \param device the address of a drmDevicePtr where the information
3810  *               will be allocated in stored
3811  *
3812  * \return zero on success, negative error code otherwise.
3813  *
3814  * \note Unlike drmGetDevice it does not retrieve the pci device revision field
3815  * unless the DRM_DEVICE_GET_PCI_REVISION \p flag is set.
3816  */
3817 drm_public int drmGetDevice2(int fd, uint32_t flags, drmDevicePtr *device)
3818 {
3819 #ifdef __OpenBSD__
3820     /*
3821      * DRI device nodes on OpenBSD are not in their own directory, they reside
3822      * in /dev along with a large number of statically generated /dev nodes.
3823      * Avoid stat'ing all of /dev needlessly by implementing this custom path.
3824      */
3825     drmDevicePtr     d;
3826     struct stat      sbuf;
3827     char             node[PATH_MAX + 1];
3828     const char      *dev_name;
3829     int              node_type, subsystem_type;
3830     int              maj, min, n, ret, base;
3831
3832     if (fd == -1 || device == NULL)
3833         return -EINVAL;
3834
3835     if (fstat(fd, &sbuf))
3836         return -errno;
3837
3838     maj = major(sbuf.st_rdev);
3839     min = minor(sbuf.st_rdev);
3840
3841     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
3842         return -EINVAL;
3843
3844     node_type = drmGetMinorType(min);
3845     if (node_type == -1)
3846         return -ENODEV;
3847
3848     switch (node_type) {
3849     case DRM_NODE_PRIMARY:
3850         dev_name = DRM_DEV_NAME;
3851         break;
3852     case DRM_NODE_CONTROL:
3853         dev_name = DRM_CONTROL_DEV_NAME;
3854         break;
3855     case DRM_NODE_RENDER:
3856         dev_name = DRM_RENDER_DEV_NAME;
3857         break;
3858     default:
3859         return -EINVAL;
3860     };
3861
3862     base = drmGetMinorBase(node_type);
3863     if (base < 0)
3864         return -EINVAL;
3865
3866     n = snprintf(node, PATH_MAX, dev_name, DRM_DIR_NAME, min - base);
3867     if (n == -1 || n >= PATH_MAX)
3868       return -errno;
3869     if (stat(node, &sbuf))
3870         return -EINVAL;
3871
3872     subsystem_type = drmParseSubsystemType(maj, min);
3873     if (subsystem_type != DRM_BUS_PCI)
3874         return -ENODEV;
3875
3876     ret = drmProcessPciDevice(&d, node, node_type, maj, min, true, flags);
3877     if (ret)
3878         return ret;
3879
3880     *device = d;
3881
3882     return 0;
3883 #else
3884     drmDevicePtr local_devices[MAX_DRM_NODES];
3885     drmDevicePtr d;
3886     DIR *sysdir;
3887     struct dirent *dent;
3888     struct stat sbuf;
3889     int subsystem_type;
3890     int maj, min;
3891     int ret, i, node_count;
3892     dev_t find_rdev;
3893
3894     if (drm_device_validate_flags(flags))
3895         return -EINVAL;
3896
3897     if (fd == -1 || device == NULL)
3898         return -EINVAL;
3899
3900     if (fstat(fd, &sbuf))
3901         return -errno;
3902
3903     find_rdev = sbuf.st_rdev;
3904     maj = major(sbuf.st_rdev);
3905     min = minor(sbuf.st_rdev);
3906
3907     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
3908         return -EINVAL;
3909
3910     subsystem_type = drmParseSubsystemType(maj, min);
3911     if (subsystem_type < 0)
3912         return subsystem_type;
3913
3914     sysdir = opendir(DRM_DIR_NAME);
3915     if (!sysdir)
3916         return -errno;
3917
3918     i = 0;
3919     while ((dent = readdir(sysdir))) {
3920         ret = process_device(&d, dent->d_name, subsystem_type, true, flags);
3921         if (ret)
3922             continue;
3923
3924         if (i >= MAX_DRM_NODES) {
3925             fprintf(stderr, "More than %d drm nodes detected. "
3926                     "Please report a bug - that should not happen.\n"
3927                     "Skipping extra nodes\n", MAX_DRM_NODES);
3928             break;
3929         }
3930         local_devices[i] = d;
3931         i++;
3932     }
3933     node_count = i;
3934
3935     drmFoldDuplicatedDevices(local_devices, node_count);
3936
3937     *device = NULL;
3938
3939     for (i = 0; i < node_count; i++) {
3940         if (!local_devices[i])
3941             continue;
3942
3943         if (drm_device_has_rdev(local_devices[i], find_rdev))
3944             *device = local_devices[i];
3945         else
3946             drmFreeDevice(&local_devices[i]);
3947     }
3948
3949     closedir(sysdir);
3950     if (*device == NULL)
3951         return -ENODEV;
3952     return 0;
3953 #endif
3954 }
3955
3956 /**
3957  * Get information about the opened drm device
3958  *
3959  * \param fd file descriptor of the drm device
3960  * \param device the address of a drmDevicePtr where the information
3961  *               will be allocated in stored
3962  *
3963  * \return zero on success, negative error code otherwise.
3964  */
3965 drm_public int drmGetDevice(int fd, drmDevicePtr *device)
3966 {
3967     return drmGetDevice2(fd, DRM_DEVICE_GET_PCI_REVISION, device);
3968 }
3969
3970 /**
3971  * Get drm devices on the system
3972  *
3973  * \param flags feature/behaviour bitmask
3974  * \param devices the array of devices with drmDevicePtr elements
3975  *                can be NULL to get the device number first
3976  * \param max_devices the maximum number of devices for the array
3977  *
3978  * \return on error - negative error code,
3979  *         if devices is NULL - total number of devices available on the system,
3980  *         alternatively the number of devices stored in devices[], which is
3981  *         capped by the max_devices.
3982  *
3983  * \note Unlike drmGetDevices it does not retrieve the pci device revision field
3984  * unless the DRM_DEVICE_GET_PCI_REVISION \p flag is set.
3985  */
3986 drm_public int drmGetDevices2(uint32_t flags, drmDevicePtr devices[],
3987                               int max_devices)
3988 {
3989     drmDevicePtr local_devices[MAX_DRM_NODES];
3990     drmDevicePtr device;
3991     DIR *sysdir;
3992     struct dirent *dent;
3993     int ret, i, node_count, device_count;
3994
3995     if (drm_device_validate_flags(flags))
3996         return -EINVAL;
3997
3998     sysdir = opendir(DRM_DIR_NAME);
3999     if (!sysdir)
4000         return -errno;
4001
4002     i = 0;
4003     while ((dent = readdir(sysdir))) {
4004         ret = process_device(&device, dent->d_name, -1, devices != NULL, flags);
4005         if (ret)
4006             continue;
4007
4008         if (i >= MAX_DRM_NODES) {
4009             fprintf(stderr, "More than %d drm nodes detected. "
4010                     "Please report a bug - that should not happen.\n"
4011                     "Skipping extra nodes\n", MAX_DRM_NODES);
4012             break;
4013         }
4014         local_devices[i] = device;
4015         i++;
4016     }
4017     node_count = i;
4018
4019     drmFoldDuplicatedDevices(local_devices, node_count);
4020
4021     device_count = 0;
4022     for (i = 0; i < node_count; i++) {
4023         if (!local_devices[i])
4024             continue;
4025
4026         if ((devices != NULL) && (device_count < max_devices))
4027             devices[device_count] = local_devices[i];
4028         else
4029             drmFreeDevice(&local_devices[i]);
4030
4031         device_count++;
4032     }
4033
4034     closedir(sysdir);
4035     return device_count;
4036 }
4037
4038 /**
4039  * Get drm devices on the system
4040  *
4041  * \param devices the array of devices with drmDevicePtr elements
4042  *                can be NULL to get the device number first
4043  * \param max_devices the maximum number of devices for the array
4044  *
4045  * \return on error - negative error code,
4046  *         if devices is NULL - total number of devices available on the system,
4047  *         alternatively the number of devices stored in devices[], which is
4048  *         capped by the max_devices.
4049  */
4050 drm_public int drmGetDevices(drmDevicePtr devices[], int max_devices)
4051 {
4052     return drmGetDevices2(DRM_DEVICE_GET_PCI_REVISION, devices, max_devices);
4053 }
4054
4055 drm_public char *drmGetDeviceNameFromFd2(int fd)
4056 {
4057 #ifdef __linux__
4058     struct stat sbuf;
4059     char path[PATH_MAX + 1], *value;
4060     unsigned int maj, min;
4061
4062     if (fstat(fd, &sbuf))
4063         return NULL;
4064
4065     maj = major(sbuf.st_rdev);
4066     min = minor(sbuf.st_rdev);
4067
4068     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
4069         return NULL;
4070
4071     snprintf(path, sizeof(path), "/sys/dev/char/%d:%d", maj, min);
4072
4073     value = sysfs_uevent_get(path, "DEVNAME");
4074     if (!value)
4075         return NULL;
4076
4077     snprintf(path, sizeof(path), "/dev/%s", value);
4078     free(value);
4079
4080     return strdup(path);
4081 #else
4082     struct stat      sbuf;
4083     char             node[PATH_MAX + 1];
4084     const char      *dev_name;
4085     int              node_type;
4086     int              maj, min, n, base;
4087
4088     if (fstat(fd, &sbuf))
4089         return NULL;
4090
4091     maj = major(sbuf.st_rdev);
4092     min = minor(sbuf.st_rdev);
4093
4094     if (!drmNodeIsDRM(maj, min) || !S_ISCHR(sbuf.st_mode))
4095         return NULL;
4096
4097     node_type = drmGetMinorType(min);
4098     if (node_type == -1)
4099         return NULL;
4100
4101     switch (node_type) {
4102     case DRM_NODE_PRIMARY:
4103         dev_name = DRM_DEV_NAME;
4104         break;
4105     case DRM_NODE_CONTROL:
4106         dev_name = DRM_CONTROL_DEV_NAME;
4107         break;
4108     case DRM_NODE_RENDER:
4109         dev_name = DRM_RENDER_DEV_NAME;
4110         break;
4111     default:
4112         return NULL;
4113     };
4114
4115     base = drmGetMinorBase(node_type);
4116     if (base < 0)
4117         return NULL;
4118
4119     n = snprintf(node, PATH_MAX, dev_name, DRM_DIR_NAME, min - base);
4120     if (n == -1 || n >= PATH_MAX)
4121       return NULL;
4122
4123     return strdup(node);
4124 #endif
4125 }
4126
4127 drm_public int drmSyncobjCreate(int fd, uint32_t flags, uint32_t *handle)
4128 {
4129     struct drm_syncobj_create args;
4130     int ret;
4131
4132     memclear(args);
4133     args.flags = flags;
4134     args.handle = 0;
4135     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_CREATE, &args);
4136     if (ret)
4137         return ret;
4138     *handle = args.handle;
4139     return 0;
4140 }
4141
4142 drm_public int drmSyncobjDestroy(int fd, uint32_t handle)
4143 {
4144     struct drm_syncobj_destroy args;
4145
4146     memclear(args);
4147     args.handle = handle;
4148     return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_DESTROY, &args);
4149 }
4150
4151 drm_public int drmSyncobjHandleToFD(int fd, uint32_t handle, int *obj_fd)
4152 {
4153     struct drm_syncobj_handle args;
4154     int ret;
4155
4156     memclear(args);
4157     args.fd = -1;
4158     args.handle = handle;
4159     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, &args);
4160     if (ret)
4161         return ret;
4162     *obj_fd = args.fd;
4163     return 0;
4164 }
4165
4166 drm_public int drmSyncobjFDToHandle(int fd, int obj_fd, uint32_t *handle)
4167 {
4168     struct drm_syncobj_handle args;
4169     int ret;
4170
4171     memclear(args);
4172     args.fd = obj_fd;
4173     args.handle = 0;
4174     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, &args);
4175     if (ret)
4176         return ret;
4177     *handle = args.handle;
4178     return 0;
4179 }
4180
4181 drm_public int drmSyncobjImportSyncFile(int fd, uint32_t handle,
4182                                         int sync_file_fd)
4183 {
4184     struct drm_syncobj_handle args;
4185
4186     memclear(args);
4187     args.fd = sync_file_fd;
4188     args.handle = handle;
4189     args.flags = DRM_SYNCOBJ_FD_TO_HANDLE_FLAGS_IMPORT_SYNC_FILE;
4190     return drmIoctl(fd, DRM_IOCTL_SYNCOBJ_FD_TO_HANDLE, &args);
4191 }
4192
4193 drm_public int drmSyncobjExportSyncFile(int fd, uint32_t handle,
4194                                         int *sync_file_fd)
4195 {
4196     struct drm_syncobj_handle args;
4197     int ret;
4198
4199     memclear(args);
4200     args.fd = -1;
4201     args.handle = handle;
4202     args.flags = DRM_SYNCOBJ_HANDLE_TO_FD_FLAGS_EXPORT_SYNC_FILE;
4203     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_HANDLE_TO_FD, &args);
4204     if (ret)
4205         return ret;
4206     *sync_file_fd = args.fd;
4207     return 0;
4208 }
4209
4210 drm_public int drmSyncobjWait(int fd, uint32_t *handles, unsigned num_handles,
4211                               int64_t timeout_nsec, unsigned flags,
4212                               uint32_t *first_signaled)
4213 {
4214     struct drm_syncobj_wait args;
4215     int ret;
4216
4217     memclear(args);
4218     args.handles = (uintptr_t)handles;
4219     args.timeout_nsec = timeout_nsec;
4220     args.count_handles = num_handles;
4221     args.flags = flags;
4222
4223     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_WAIT, &args);
4224     if (ret < 0)
4225         return -errno;
4226
4227     if (first_signaled)
4228         *first_signaled = args.first_signaled;
4229     return ret;
4230 }
4231
4232 drm_public int drmSyncobjReset(int fd, const uint32_t *handles,
4233                                uint32_t handle_count)
4234 {
4235     struct drm_syncobj_array args;
4236     int ret;
4237
4238     memclear(args);
4239     args.handles = (uintptr_t)handles;
4240     args.count_handles = handle_count;
4241
4242     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_RESET, &args);
4243     return ret;
4244 }
4245
4246 drm_public int drmSyncobjSignal(int fd, const uint32_t *handles,
4247                                 uint32_t handle_count)
4248 {
4249     struct drm_syncobj_array args;
4250     int ret;
4251
4252     memclear(args);
4253     args.handles = (uintptr_t)handles;
4254     args.count_handles = handle_count;
4255
4256     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_SIGNAL, &args);
4257     return ret;
4258 }
4259
4260 drm_public int drmSyncobjTimelineWait(int fd, uint32_t *handles, uint64_t *points,
4261                                       unsigned num_handles,
4262                                       int64_t timeout_nsec, unsigned flags,
4263                                       uint32_t *first_signaled)
4264 {
4265     struct drm_syncobj_timeline_wait args;
4266     int ret;
4267
4268     memclear(args);
4269     args.handles = (uintptr_t)handles;
4270     args.points = (uintptr_t)points;
4271     args.timeout_nsec = timeout_nsec;
4272     args.count_handles = num_handles;
4273     args.flags = flags;
4274
4275     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_TIMELINE_WAIT, &args);
4276     if (ret < 0)
4277         return -errno;
4278
4279     if (first_signaled)
4280         *first_signaled = args.first_signaled;
4281     return ret;
4282 }
4283
4284
4285 drm_public int drmSyncobjQuery(int fd, uint32_t *handles, uint64_t *points,
4286                                uint32_t handle_count)
4287 {
4288     struct drm_syncobj_timeline_array args;
4289     int ret;
4290
4291     memclear(args);
4292     args.handles = (uintptr_t)handles;
4293     args.points = (uintptr_t)points;
4294     args.count_handles = handle_count;
4295
4296     ret = drmIoctl(fd, DRM_IOCTL_SYNCOBJ_QUERY, &args);
4297     if (ret)
4298         return ret;
4299     return 0;
4300 }
4301
4302