#include <xcb/dri2.h>

static void

pipe_loader_drm_x_auth(int fd)

{

   /* Try authenticate with the X server to give us access to devices that X

    * is running on. */

   xcb_connection_t *xcb_conn;

   const xcb_setup_t *xcb_setup;

   xcb_screen_iterator_t s;

   xcb_dri2_connect_cookie_t connect_cookie;

   xcb_dri2_connect_reply_t *connect;

   drm_magic_t magic;

   xcb_dri2_authenticate_cookie_t authenticate_cookie;

   xcb_dri2_authenticate_reply_t *authenticate;

   xcb_conn = xcb_connect(NULL,  NULL);

   if(!xcb_conn)

      return;

   xcb_setup = xcb_get_setup(xcb_conn);

  if (!xcb_setup)

    goto disconnect;

   s = xcb_setup_roots_iterator(xcb_setup);

   connect_cookie = xcb_dri2_connect_unchecked(xcb_conn, s.data->root,

                                               XCB_DRI2_DRIVER_TYPE_DRI);

   connect = xcb_dri2_connect_reply(xcb_conn, connect_cookie, NULL);

   if (!connect || connect->driver_name_length

                   + connect->device_name_length == 0) {

      goto disconnect;

   }

   if (drmGetMagic(fd, &magic))

      goto disconnect;

   authenticate_cookie = xcb_dri2_authenticate_unchecked(xcb_conn,

                                                         s.data->root,

                                                         magic);

   authenticate = xcb_dri2_authenticate_reply(xcb_conn,

                                              authenticate_cookie,

                                              NULL);

   FREE(authenticate);

disconnect:

   xcb_disconnect(xcb_conn);

}

   pipe_loader_drm_x_auth(fd);

open_drm_minor(int minor)

{

   char path[PATH_MAX];

   snprintf(path, sizeof(path), DRM_DEV_NAME, DRM_DIR_NAME, minor);

   return open(path, O_RDWR, 0);

}

static int

   struct {

      unsigned vendor_id;

      unsigned chip_id;

   } render_node_devs[DRM_RENDER_NODE_MAX_NODES];

   /* Look for render nodes first */

      render_node_devs[j].vendor_id = dev->u.pci.vendor_id;

      render_node_devs[j].chip_id = dev->u.pci.chip_id;

   num_render_node_devs = j;

   /* Next look for drm devices. */

   for (i = 0; i < DRM_MAX_MINOR; i++) {

      struct pipe_loader_device *dev;

      boolean duplicate = FALSE;

      fd = open_drm_minor(i);

      if (fd < 0)

         continue;

      if (!pipe_loader_drm_probe_fd(&dev, fd)) {

         close(fd);

         continue;

      }

      /* Check to make sure we aren't already accessing this device via

       * render nodes.

       */

      for (k = 0; k < num_render_node_devs; k++) {

         if (dev->u.pci.vendor_id == render_node_devs[k].vendor_id &&

             dev->u.pci.chip_id == render_node_devs[k].chip_id) {

            close(fd);

            dev->ops->release(&dev);

            duplicate = TRUE;

            break;

         }

      }

      if (duplicate)

         continue;

      if (j < ndev) {

         devs[j] = dev;

      } else {

         dev->ops->release(&dev);

      }

      j++;

   }