icd/intel/intel.c

/*
 * XGL 3-D graphics library
 *
 * Copyright (C) 2014 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:
 *   Courtney Goeltzenleuchter <courtney@lunarg.com>
 *   Chia-I Wu <olv@lunarg.com>
 */

#include "icd-enumerate-drm.h"
#include "gpu.h"
#include "intel.h"

static int intel_devid_override;
int intel_debug = -1;

static void intel_debug_init(void)
{
    const char *env;

    if (intel_debug >= 0)
        return;

    intel_debug = 0;

    /* parse comma-separated debug options */
    env = getenv("INTEL_DEBUG");
    while (env) {
        const char *p = strchr(env, ',');
        size_t len;

        if (p)
            len = p - env;
        else
            len = strlen(env);

        if (len > 0) {
            if (strncmp(env, "batch", len) == 0) {
                intel_debug |= INTEL_DEBUG_BATCH;
            } else if (strncmp(env, "nohw", len) == 0) {
                intel_debug |= INTEL_DEBUG_NOHW;
            } else if (strncmp(env, "nocache", len) == 0) {
                intel_debug |= INTEL_DEBUG_NOCACHE;
            } else if (strncmp(env, "0x", 2) == 0) {
                intel_debug |= INTEL_DEBUG_NOHW;
                intel_devid_override = strtol(env, NULL, 16);
            }
        }

        if (!p)
            break;

        env = p + 1;
    }
}

ICD_EXPORT XGL_RESULT XGLAPI xglInitAndEnumerateGpus(
    const XGL_APPLICATION_INFO*                 pAppInfo,
    const XGL_ALLOC_CALLBACKS*                  pAllocCb,
    uint32_t                                    maxGpus,
    uint32_t*                                   pGpuCount,
    XGL_PHYSICAL_GPU*                           pGpus)
{
    struct icd_drm_device *devices, *dev;
    XGL_RESULT ret;
    uint32_t count;

    intel_debug_init();

    ret = icd_allocator_init(pAllocCb);
    if (ret != XGL_SUCCESS)
        return ret;

    /*
     * xglInitAndEnumerateGpus() can be called multiple times. Calling it more
     * than once forces driver reinitialization.
     */
    intel_gpu_remove_all();

    if (!maxGpus) {
        *pGpuCount = 0;
        return XGL_SUCCESS;
    }

    devices = icd_drm_enumerate(0x8086);

    count = 0;
    dev = devices;
    while (dev) {
        const char *primary_node, *render_node;
        int devid;
        struct intel_gpu *gpu;

        primary_node = icd_drm_get_devnode(dev, ICD_DRM_MINOR_LEGACY);
        if (!primary_node)
            continue;

        render_node = icd_drm_get_devnode(dev, ICD_DRM_MINOR_RENDER);

        devid = (intel_devid_override) ? intel_devid_override : dev->devid;
        ret = intel_gpu_add(devid, primary_node, render_node, &gpu);
        if (ret == XGL_SUCCESS) {
            pGpus[count++] = (XGL_PHYSICAL_GPU) gpu;
            if (count >= maxGpus)
                break;
        }

        dev = dev->next;
    }

    icd_drm_release(devices);

    *pGpuCount = count;

    return (count > 0) ? XGL_SUCCESS : XGL_ERROR_UNAVAILABLE;
}

static XGL_RESULT intel_instance_destroy(struct intel_instance *inst)
{
    intel_base_destroy(&inst->obj.base);
    intel_gpu_remove_all();
    return XGL_SUCCESS;
}

static void inst_destroy(struct intel_obj *obj)
{
    struct intel_instance *inst = intel_instance_from_obj(obj);

    intel_instance_destroy(inst);
}

static XGL_RESULT intel_instance_create(
    const XGL_APPLICATION_INFO*                 info,
    const XGL_ALLOC_CALLBACKS*                  cb,
    struct intel_instance**                         inst_ret)
{
    struct intel_instance *inst;
    XGL_RESULT ret;

    inst = (struct intel_instance *) intel_base_create(NULL, sizeof(*inst), false,
                XGL_DBG_OBJECT_INSTANCE, info, 0);
    if (!inst)
        return XGL_ERROR_OUT_OF_MEMORY;

    inst->obj.destroy = inst_destroy;
    inst->obj.base.get_info = intel_base_get_info;

    *inst_ret = inst;

    intel_debug_init();

    ret = icd_allocator_init(cb);
    return ret;
}

ICD_EXPORT XGL_RESULT XGLAPI xglCreateInstance(
    const XGL_APPLICATION_INFO*                 pAppInfo,
    const XGL_ALLOC_CALLBACKS*                  pAllocCb,
    XGL_INSTANCE*                               pInstance)
{
    return intel_instance_create(pAppInfo, pAllocCb, (struct intel_instance **) pInstance);
}

ICD_EXPORT XGL_RESULT XGLAPI xglDestroyInstance(
    XGL_INSTANCE                                pInstance)
{
    return intel_instance_destroy((struct intel_instance *) pInstance);
}

ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateGpus(
    XGL_INSTANCE                                instance,
    uint32_t                                    maxGpus,
    uint32_t*                                   pGpuCount,
    XGL_PHYSICAL_GPU*                           pGpus)
{
    return XGL_SUCCESS;
}

ICD_EXPORT XGL_RESULT XGLAPI xglEnumerateLayers(
    XGL_PHYSICAL_GPU                            gpu,
    size_t                                      maxLayerCount,
    size_t                                      maxStringSize,
    size_t*                                     pOutLayerCount,
    char* const*                                pOutLayers,
    void*                                       pReserved)
{
    if (!pOutLayerCount)
        return XGL_ERROR_INVALID_POINTER;

    *pOutLayerCount = 0;

    return XGL_SUCCESS;
}

ICD_EXPORT XGL_RESULT XGLAPI xglDbgRegisterMsgCallback(
    XGL_DBG_MSG_CALLBACK_FUNCTION               pfnMsgCallback,
    void*                                       pUserData)
{
    return icd_logger_add_callback(pfnMsgCallback, pUserData);
}

ICD_EXPORT XGL_RESULT XGLAPI xglDbgUnregisterMsgCallback(
    XGL_DBG_MSG_CALLBACK_FUNCTION               pfnMsgCallback)
{
    return icd_logger_remove_callback(pfnMsgCallback);
}

ICD_EXPORT XGL_RESULT XGLAPI xglDbgSetGlobalOption(
    XGL_DBG_GLOBAL_OPTION                       dbgOption,
    size_t                                      dataSize,
    const void*                                 pData)
{
    XGL_RESULT res = XGL_SUCCESS;

    if (dataSize == 0)
        return XGL_ERROR_INVALID_VALUE;

    switch (dbgOption) {
    case XGL_DBG_OPTION_DEBUG_ECHO_ENABLE:
    case XGL_DBG_OPTION_BREAK_ON_ERROR:
    case XGL_DBG_OPTION_BREAK_ON_WARNING:
        res = icd_logger_set_bool(dbgOption, *((const bool *) pData));
        break;
    default:
        res = XGL_ERROR_INVALID_VALUE;
        break;
    }

    return res;
}