Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 2010-2011 LunarG Inc.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 *

 * Authors:

 *    Chia-I Wu 

 */

#include "common/egl_g3d_loader.h"

#include "egldriver.h"

#include "egllog.h"

#ifdef HAVE_LIBUDEV

#include  /* for sscanf */

#include 

#endif

#define DRIVER_MAP_GALLIUM_ONLY

#include "pci_ids/pci_id_driver_map.h"

#include "egl_pipe.h"

#include "egl_st.h"

static struct egl_g3d_loader egl_g3d_loader;

static struct st_module {

   boolean initialized;

   struct st_api *stapi;

} st_modules[ST_API_COUNT];

static struct st_api *

get_st_api(enum st_api_type api)

{

   struct st_module *stmod = &st_modules[api];

   if (!stmod->initialized) {

      stmod->stapi = egl_st_create_api(api);

      stmod->initialized = TRUE;

   }

   return stmod->stapi;

}

#ifdef HAVE_LIBUDEV

static boolean

drm_fd_get_pci_id(int fd, int *vendor_id, int *chip_id)

{

   struct udev *udev = NULL;

   struct udev_device *device = NULL, *parent;

   struct stat buf;

   const char *pci_id;

   *chip_id = -1;

   udev = udev_new();

   if (fstat(fd, &buf) < 0) {

      _eglLog(_EGL_WARNING, "failed to stat fd %d", fd);

      goto out;

   }

   device = udev_device_new_from_devnum(udev, 'c', buf.st_rdev);

   if (device == NULL) {

      _eglLog(_EGL_WARNING,

              "could not create udev device for fd %d", fd);

      goto out;

   }

   parent = udev_device_get_parent(device);

   if (parent == NULL) {

      _eglLog(_EGL_WARNING, "could not get parent device");

      goto out;

   }

   pci_id = udev_device_get_property_value(parent, "PCI_ID");

   if (pci_id == NULL ||

       sscanf(pci_id, "%x:%x", vendor_id, chip_id) != 2) {

      _eglLog(_EGL_WARNING, "malformed or no PCI ID");

      *chip_id = -1;

      goto out;

   }

out:

   if (device)

      udev_device_unref(device);

   if (udev)

      udev_unref(udev);

   return (*chip_id >= 0);

}

#elif defined(PIPE_OS_ANDROID) && !defined(_EGL_NO_DRM)

#include 

/* for i915 */

#include 

/* for radeon */

#include 

/* for util_strcmp */

#include "util/u_string.h"

static boolean

drm_fd_get_pci_id(int fd, int *vendor_id, int *chip_id)

{

   drmVersionPtr version;

   *chip_id = -1;

   version = drmGetVersion(fd);

   if (!version) {

      _eglLog(_EGL_WARNING, "invalid drm fd");

      return FALSE;

   }

   if (!version->name) {

      _eglLog(_EGL_WARNING, "unable to determine the driver name");

      drmFreeVersion(version);

      return FALSE;

   }

   if (util_strcmp(version->name, "i915") == 0) {

      struct drm_i915_getparam gp;

      int ret;

      *vendor_id = 0x8086;

      memset(&gp, 0, sizeof(gp));

      gp.param = I915_PARAM_CHIPSET_ID;

      gp.value = chip_id;

      ret = drmCommandWriteRead(fd, DRM_I915_GETPARAM, &gp, sizeof(gp));

      if (ret) {

         _eglLog(_EGL_WARNING, "failed to get param for i915");

	 *chip_id = -1;

      }

   }

   else if (util_strcmp(version->name, "radeon") == 0) {

      struct drm_radeon_info info;

      int ret;

      *vendor_id = 0x1002;

      memset(&info, 0, sizeof(info));

      info.request = RADEON_INFO_DEVICE_ID;

      info.value = (unsigned long) chip_id;

      ret = drmCommandWriteRead(fd, DRM_RADEON_INFO, &info, sizeof(info));

      if (ret) {

         _eglLog(_EGL_WARNING, "failed to get info for radeon");

	 *chip_id = -1;

      }

   }

   else if (util_strcmp(version->name, "nouveau") == 0) {

      *vendor_id = 0x10de;

      /* not used */

      *chip_id = 0;

   }

   else if (util_strcmp(version->name, "vmwgfx") == 0) {

      *vendor_id = 0x15ad;

      /* assume SVGA II */

      *chip_id = 0x0405;

   }

   drmFreeVersion(version);

   return (*chip_id >= 0);

}

#else

static boolean

drm_fd_get_pci_id(int fd, int *vendor_id, int *chip_id)

{

   return FALSE;

}

#endif /* HAVE_LIBUDEV */

static const char *

drm_fd_get_screen_name(int fd)

{

   int vendor_id, chip_id;

   int idx, i;

   if (!drm_fd_get_pci_id(fd, &vendor_id, &chip_id)) {

      _eglLog(_EGL_WARNING, "failed to get driver name for fd %d", fd);

      return NULL;

   }

   for (idx = 0; driver_map[idx].driver; idx++) {

      if (vendor_id != driver_map[idx].vendor_id)

         continue;

      /* done if no chip id */

      if (driver_map[idx].num_chips_ids == -1)

         break;

      for (i = 0; i < driver_map[idx].num_chips_ids; i++) {

         if (driver_map[idx].chip_ids[i] == chip_id)

            break;

      }

      /* matched! */

      if (i < driver_map[idx].num_chips_ids)

         break;

   }

   _eglLog((driver_map[idx].driver) ? _EGL_INFO : _EGL_WARNING,

         "pci id for fd %d: %04x:%04x, driver %s",

         fd, vendor_id, chip_id, driver_map[idx].driver);

   return driver_map[idx].driver;

}

static struct pipe_screen *

create_drm_screen(const char *name, int fd)

{

   struct pipe_screen *screen;

   if (!name) {

      name = drm_fd_get_screen_name(fd);

      if (!name)

         return NULL;

   }

   screen = egl_pipe_create_drm_screen(name, fd);

   if (screen)

      _eglLog(_EGL_INFO, "created a pipe screen for %s", name);

   else

      _eglLog(_EGL_WARNING, "failed to create a pipe screen for %s", name);

   return screen;

}

static struct pipe_screen *

create_sw_screen(struct sw_winsys *ws)

{

   return egl_pipe_create_swrast_screen(ws);

}

static const struct egl_g3d_loader *

loader_init(void)

{

   int i;

   for (i = 0; i < ST_API_COUNT; i++)

      egl_g3d_loader.profile_masks[i] = egl_st_get_profile_mask(i);

   egl_g3d_loader.get_st_api = get_st_api;

   egl_g3d_loader.create_drm_screen = create_drm_screen;

   egl_g3d_loader.create_sw_screen = create_sw_screen;

   return &egl_g3d_loader;

}

static void

loader_fini(void)

{

   int i;

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

      struct st_module *stmod = &st_modules[i];

      if (stmod->stapi) {

         egl_st_destroy_api(stmod->stapi);

         stmod->stapi = NULL;

      }

      stmod->initialized = FALSE;

   }

}

static void

egl_g3d_unload(_EGLDriver *drv)

{

   egl_g3d_destroy_driver(drv);

   loader_fini();

}

_EGLDriver *

_EGL_MAIN(const char *args)

{

   const struct egl_g3d_loader *loader;

   _EGLDriver *drv;

   loader = loader_init();

   drv = egl_g3d_create_driver(loader);

   if (!drv) {

      loader_fini();

      return NULL;

   }

   drv->Name = "Gallium";

   drv->Unload = egl_g3d_unload;

   return drv;

}

EGLBoolean

_eglError(EGLint errCode, const char *msg)

{

    return EGL_FALSE;

}

void

_eglLog(EGLint level, const char *fmtStr, ...)

{

}

void

_eglDestroyArray(_EGLArray *array, void (*free_cb)(void *))

{

}

void

_eglInitScreen(_EGLScreen *screen, _EGLDisplay *dpy, EGLint num_modes)

{

}

void

_eglReleaseDisplayResources(_EGLDriver *drv, _EGLDisplay *display)

{

}

EGLScreenMESA

_eglLinkScreen(_EGLScreen *screen)

{

}

EGLBoolean

_eglValidateConfig(const _EGLConfig *conf, EGLBoolean for_matching)

{

    return EGL_FALSE;

}

void

_eglInitConfig(_EGLConfig *conf, _EGLDisplay *dpy, EGLint id)

{

}

void

_eglCleanupDisplay(_EGLDisplay *disp)

{

}

PUBLIC EGLConfig

_eglLinkConfig(_EGLConfig *conf)

{

}

EGLBoolean

_eglPutResource(_EGLResource *res)

{

   return EGL_FALSE;

}

_EGLContext *

_eglGetCurrentContext(void)

{

   return NULL;

}

EGLBoolean

_eglInitSurface(_EGLSurface *surf, _EGLDisplay *dpy, EGLint type,

                _EGLConfig *conf, const EGLint *attrib_list)

{

   return EGL_FALSE;

}

EGLBoolean

_eglBindContext(_EGLContext *ctx, _EGLSurface *draw, _EGLSurface *read,

                _EGLContext **old_ctx,

                _EGLSurface **old_draw, _EGLSurface **old_read)

{

   return EGL_FALSE;

}

PUBLIC _EGLContext *

_eglGetAPIContext(EGLenum api)

{

   return NULL;

}

EGLBoolean

_eglInitContext(_EGLContext *ctx, _EGLDisplay *dpy, _EGLConfig *conf,

                const EGLint *attrib_list)

{

   return EGL_FALSE;

}

EGLint

_eglCompareConfigs(const _EGLConfig *conf1, const _EGLConfig *conf2,

                   const _EGLConfig *criteria, EGLBoolean compare_id)

{

    return 0;

}

EGLBoolean

_eglMatchConfig(const _EGLConfig *conf, const _EGLConfig *criteria)

{

   return EGL_FALSE;

}

EGLBoolean

_eglParseConfigAttribList(_EGLConfig *conf, _EGLDisplay *dpy,

                          const EGLint *attrib_list)

{

   return EGL_FALSE;

}

EGLBoolean

_eglFilterConfigArray(_EGLArray *array, EGLConfig *configs,

                      EGLint config_size, EGLint *num_configs,

                      EGLBoolean (*match)(const _EGLConfig *, void *),

                      EGLint (*compare)(const _EGLConfig *, const _EGLConfig *,

                                        void *),

                      void *priv_data)

{

   return EGL_FALSE;

}

EGLBoolean

_eglInitImage(_EGLImage *img, _EGLDisplay *dpy)

{

   return EGL_TRUE;

}

EGLint

_eglParseImageAttribList(_EGLImageAttribs *attrs, _EGLDisplay *dpy,

                         const EGLint *attrib_list)

{

    return 0;

}

EGLBoolean

_eglInitSync(_EGLSync *sync, _EGLDisplay *dpy, EGLenum type,

             const EGLint *attrib_list)

{

   return EGL_TRUE;

}

void

_eglGetResource(_EGLResource *res)

{

}

EGLBoolean

_eglCheckResource(void *res, int type, _EGLDisplay *dpy)

{

   return EGL_TRUE;

}

void

_eglInitDriverFallbacks(_EGLDriver *drv)

{

}