src/freedreno/vulkan/tu_drm.c - platform/external/mesa3d - Git at Google

 /*
  * Copyright © 2018 Google, Inc.
  * Copyright © 2015 Intel Corporation
  *
  * 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 (including the next
  * paragraph) 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.
  */

 #include "tu_private.h"

 #include <errno.h>
 #include <fcntl.h>
 #include <stdint.h>
 #include <sys/ioctl.h>
 #include <xf86drm.h>

 #include "drm-uapi/msm_drm.h"

 static int
 tu_drm_get_param(const struct tu_physical_device *dev,
                  uint32_t param,
                  uint64_t *value)
 {
    /* Technically this requires a pipe, but the kernel only supports one pipe
     * anyway at the time of writing and most of these are clearly pipe
     * independent. */
    struct drm_msm_param req = {
       .pipe = MSM_PIPE_3D0,
       .param = param,
    };

    int ret = drmCommandWriteRead(dev->local_fd, DRM_MSM_GET_PARAM, &req,
                                  sizeof(req));
    if (ret)
       return ret;

    *value = req.value;

    return 0;
 }

 static int
 tu_drm_get_gpu_id(const struct tu_physical_device *dev, uint32_t *id)
 {
    uint64_t value;
    int ret = tu_drm_get_param(dev, MSM_PARAM_GPU_ID, &value);
    if (ret)
       return ret;

    *id = value;
    return 0;
 }

 static int
 tu_drm_get_gmem_size(const struct tu_physical_device *dev, uint32_t *size)
 {
    uint64_t value;
    int ret = tu_drm_get_param(dev, MSM_PARAM_GMEM_SIZE, &value);
    if (ret)
       return ret;

    *size = value;
    return 0;
 }

 static int
 tu_drm_get_gmem_base(const struct tu_physical_device *dev, uint64_t *base)
 {
    return tu_drm_get_param(dev, MSM_PARAM_GMEM_BASE, base);
 }

 int
 tu_drm_submitqueue_new(const struct tu_device *dev,
                        int priority,
                        uint32_t *queue_id)
 {
    struct drm_msm_submitqueue req = {
       .flags = 0,
       .prio = priority,
    };

    int ret = drmCommandWriteRead(dev->physical_device->local_fd,
                                  DRM_MSM_SUBMITQUEUE_NEW, &req, sizeof(req));
    if (ret)
       return ret;

    *queue_id = req.id;
    return 0;
 }

 void
 tu_drm_submitqueue_close(const struct tu_device *dev, uint32_t queue_id)
 {
    drmCommandWrite(dev->physical_device->local_fd, DRM_MSM_SUBMITQUEUE_CLOSE,
                    &queue_id, sizeof(uint32_t));
 }

 /**
  * Return gem handle on success. Return 0 on failure.
  */
 uint32_t
 tu_gem_new(const struct tu_device *dev, uint64_t size, uint32_t flags)
 {
    struct drm_msm_gem_new req = {
       .size = size,
       .flags = flags,
    };

    int ret = drmCommandWriteRead(dev->physical_device->local_fd,
                                  DRM_MSM_GEM_NEW, &req, sizeof(req));
    if (ret)
       return 0;

    return req.handle;
 }

 uint32_t
 tu_gem_import_dmabuf(const struct tu_device *dev, int prime_fd, uint64_t size)
 {
    /* lseek() to get the real size */
    off_t real_size = lseek(prime_fd, 0, SEEK_END);
    lseek(prime_fd, 0, SEEK_SET);
    if (real_size < 0 || (uint64_t) real_size < size)
       return 0;

    uint32_t gem_handle;
    int ret = drmPrimeFDToHandle(dev->physical_device->local_fd, prime_fd,
                                 &gem_handle);
    if (ret)
       return 0;

    return gem_handle;
 }

 int
 tu_gem_export_dmabuf(const struct tu_device *dev, uint32_t gem_handle)
 {
    int prime_fd;
    int ret = drmPrimeHandleToFD(dev->physical_device->local_fd, gem_handle,
                                 DRM_CLOEXEC, &prime_fd);

    return ret == 0 ? prime_fd : -1;
 }

 void
 tu_gem_close(const struct tu_device *dev, uint32_t gem_handle)
 {
    struct drm_gem_close req = {
       .handle = gem_handle,
    };

    drmIoctl(dev->physical_device->local_fd, DRM_IOCTL_GEM_CLOSE, &req);
 }

 /** Helper for DRM_MSM_GEM_INFO, returns 0 on error. */
 static uint64_t
 tu_gem_info(const struct tu_device *dev, uint32_t gem_handle, uint32_t info)
 {
    struct drm_msm_gem_info req = {
       .handle = gem_handle,
       .info = info,
    };

    int ret = drmCommandWriteRead(dev->physical_device->local_fd,
                                  DRM_MSM_GEM_INFO, &req, sizeof(req));
    if (ret < 0)
       return 0;

    return req.value;
 }

 /** Returns the offset for CPU-side mmap of the gem handle.
  *
  * Returns 0 on error (an invalid mmap offset in the DRM UBI).
  */
 uint64_t
 tu_gem_info_offset(const struct tu_device *dev, uint32_t gem_handle)
 {
    return tu_gem_info(dev, gem_handle, MSM_INFO_GET_OFFSET);
 }

 /** Returns the the iova of the BO in GPU memory.
  *
  * Returns 0 on error (an invalid iova in the MSM DRM UABI).
  */
 uint64_t
 tu_gem_info_iova(const struct tu_device *dev, uint32_t gem_handle)
 {
    return tu_gem_info(dev, gem_handle, MSM_INFO_GET_IOVA);
 }

 static VkResult
 tu_drm_device_init(struct tu_physical_device *device,
                    struct tu_instance *instance,
                    drmDevicePtr drm_device)
 {
    const char *path = drm_device->nodes[DRM_NODE_RENDER];
    VkResult result = VK_SUCCESS;
    drmVersionPtr version;
    int fd;
    int master_fd = -1;

    fd = open(path, O_RDWR | O_CLOEXEC);
    if (fd < 0) {
       return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
                        "failed to open device %s", path);
    }

    /* Version 1.3 added MSM_INFO_IOVA. */
    const int min_version_major = 1;
    const int min_version_minor = 3;

    version = drmGetVersion(fd);
    if (!version) {
       close(fd);
       return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
                        "failed to query kernel driver version for device %s",
                        path);
    }

    if (strcmp(version->name, "msm")) {
       drmFreeVersion(version);
       close(fd);
       return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
                        "device %s does not use the msm kernel driver", path);
    }

    if (version->version_major != min_version_major ||
        version->version_minor < min_version_minor) {
       result = vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
                          "kernel driver for device %s has version %d.%d, "
                          "but Vulkan requires version >= %d.%d",
                          path, version->version_major, version->version_minor,
                          min_version_major, min_version_minor);
       drmFreeVersion(version);
       close(fd);
       return result;
    }

    device->msm_major_version = version->version_major;
    device->msm_minor_version = version->version_minor;

    drmFreeVersion(version);

    if (instance->debug_flags & TU_DEBUG_STARTUP)
       tu_logi("Found compatible device '%s'.", path);

    vk_object_base_init(NULL, &device->base, VK_OBJECT_TYPE_PHYSICAL_DEVICE);
    device->instance = instance;
    assert(strlen(path) < ARRAY_SIZE(device->path));
    strncpy(device->path, path, ARRAY_SIZE(device->path));

    if (instance->enabled_extensions.KHR_display) {
       master_fd =
          open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR | O_CLOEXEC);
       if (master_fd >= 0) {
          /* TODO: free master_fd is accel is not working? */
       }
    }

    device->master_fd = master_fd;
    device->local_fd = fd;

    if (tu_drm_get_gpu_id(device, &device->gpu_id)) {
       if (instance->debug_flags & TU_DEBUG_STARTUP)
          tu_logi("Could not query the GPU ID");
       result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
                          "could not get GPU ID");
       goto fail;
    }

    if (tu_drm_get_gmem_size(device, &device->gmem_size)) {
       if (instance->debug_flags & TU_DEBUG_STARTUP)
          tu_logi("Could not query the GMEM size");
       result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
                          "could not get GMEM size");
       goto fail;
    }

    if (tu_drm_get_gmem_base(device, &device->gmem_base)) {
       if (instance->debug_flags & TU_DEBUG_STARTUP)
          tu_logi("Could not query the GMEM size");
       result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
                          "could not get GMEM size");
       goto fail;
    }

    return tu_physical_device_init(device, instance);

 fail:
    close(fd);
    if (master_fd != -1)
       close(master_fd);
    return result;
 }

 VkResult
 tu_enumerate_devices(struct tu_instance *instance)
 {
    /* TODO: Check for more devices ? */
    drmDevicePtr devices[8];
    VkResult result = VK_ERROR_INCOMPATIBLE_DRIVER;
    int max_devices;

    instance->physical_device_count = 0;

    max_devices = drmGetDevices2(0, devices, ARRAY_SIZE(devices));

    if (instance->debug_flags & TU_DEBUG_STARTUP) {
       if (max_devices < 0)
          tu_logi("drmGetDevices2 returned error: %s\n", strerror(max_devices));
       else
          tu_logi("Found %d drm nodes", max_devices);
    }

    if (max_devices < 1)
       return vk_error(instance, VK_ERROR_INCOMPATIBLE_DRIVER);

    for (unsigned i = 0; i < (unsigned) max_devices; i++) {
       if (devices[i]->available_nodes & 1 << DRM_NODE_RENDER &&
           devices[i]->bustype == DRM_BUS_PLATFORM) {

          result = tu_drm_device_init(
             instance->physical_devices + instance->physical_device_count,
             instance, devices[i]);
          if (result == VK_SUCCESS)
             ++instance->physical_device_count;
          else if (result != VK_ERROR_INCOMPATIBLE_DRIVER)
             break;
       }
    }
    drmFreeDevices(devices, max_devices);

    return result;
 }
	/*
	* Copyright © 2018 Google, Inc.
	* Copyright © 2015 Intel Corporation
	*
	* 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 (including the next
	* paragraph) 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.
	*/

	#include "tu_private.h"

	#include <errno.h>
	#include <fcntl.h>
	#include <stdint.h>
	#include <sys/ioctl.h>
	#include <xf86drm.h>

	#include "drm-uapi/msm_drm.h"

	static int
	tu_drm_get_param(const struct tu_physical_device *dev,
	uint32_t param,
	uint64_t *value)
	{
	/* Technically this requires a pipe, but the kernel only supports one pipe
	* anyway at the time of writing and most of these are clearly pipe
	* independent. */
	struct drm_msm_param req = {
	.pipe = MSM_PIPE_3D0,
	.param = param,
	};

	int ret = drmCommandWriteRead(dev->local_fd, DRM_MSM_GET_PARAM, &req,
	sizeof(req));
	if (ret)
	return ret;

	*value = req.value;

	return 0;
	}

	static int
	tu_drm_get_gpu_id(const struct tu_physical_device dev, uint32_t id)
	{
	uint64_t value;
	int ret = tu_drm_get_param(dev, MSM_PARAM_GPU_ID, &value);
	if (ret)
	return ret;

	*id = value;
	return 0;
	}

	static int
	tu_drm_get_gmem_size(const struct tu_physical_device dev, uint32_t size)
	{
	uint64_t value;
	int ret = tu_drm_get_param(dev, MSM_PARAM_GMEM_SIZE, &value);
	if (ret)
	return ret;

	*size = value;
	return 0;
	}

	static int
	tu_drm_get_gmem_base(const struct tu_physical_device dev, uint64_t base)
	{
	return tu_drm_get_param(dev, MSM_PARAM_GMEM_BASE, base);
	}

	int
	tu_drm_submitqueue_new(const struct tu_device *dev,
	int priority,
	uint32_t *queue_id)
	{
	struct drm_msm_submitqueue req = {
	.flags = 0,
	.prio = priority,
	};

	int ret = drmCommandWriteRead(dev->physical_device->local_fd,
	DRM_MSM_SUBMITQUEUE_NEW, &req, sizeof(req));
	if (ret)
	return ret;

	*queue_id = req.id;
	return 0;
	}

	void
	tu_drm_submitqueue_close(const struct tu_device *dev, uint32_t queue_id)
	{
	drmCommandWrite(dev->physical_device->local_fd, DRM_MSM_SUBMITQUEUE_CLOSE,
	&queue_id, sizeof(uint32_t));
	}

	/**
	* Return gem handle on success. Return 0 on failure.
	*/
	uint32_t
	tu_gem_new(const struct tu_device *dev, uint64_t size, uint32_t flags)
	{
	struct drm_msm_gem_new req = {
	.size = size,
	.flags = flags,
	};

	int ret = drmCommandWriteRead(dev->physical_device->local_fd,
	DRM_MSM_GEM_NEW, &req, sizeof(req));
	if (ret)
	return 0;

	return req.handle;
	}

	uint32_t
	tu_gem_import_dmabuf(const struct tu_device *dev, int prime_fd, uint64_t size)
	{
	/* lseek() to get the real size */
	off_t real_size = lseek(prime_fd, 0, SEEK_END);
	lseek(prime_fd, 0, SEEK_SET);
	if (real_size < 0 \|\| (uint64_t) real_size < size)
	return 0;

	uint32_t gem_handle;
	int ret = drmPrimeFDToHandle(dev->physical_device->local_fd, prime_fd,
	&gem_handle);
	if (ret)
	return 0;

	return gem_handle;
	}

	int
	tu_gem_export_dmabuf(const struct tu_device *dev, uint32_t gem_handle)
	{
	int prime_fd;
	int ret = drmPrimeHandleToFD(dev->physical_device->local_fd, gem_handle,
	DRM_CLOEXEC, &prime_fd);

	return ret == 0 ? prime_fd : -1;
	}

	void
	tu_gem_close(const struct tu_device *dev, uint32_t gem_handle)
	{
	struct drm_gem_close req = {
	.handle = gem_handle,
	};

	drmIoctl(dev->physical_device->local_fd, DRM_IOCTL_GEM_CLOSE, &req);
	}

	/** Helper for DRM_MSM_GEM_INFO, returns 0 on error. */
	static uint64_t
	tu_gem_info(const struct tu_device *dev, uint32_t gem_handle, uint32_t info)
	{
	struct drm_msm_gem_info req = {
	.handle = gem_handle,
	.info = info,
	};

	int ret = drmCommandWriteRead(dev->physical_device->local_fd,
	DRM_MSM_GEM_INFO, &req, sizeof(req));
	if (ret < 0)
	return 0;

	return req.value;
	}

	/** Returns the offset for CPU-side mmap of the gem handle.
	*
	* Returns 0 on error (an invalid mmap offset in the DRM UBI).
	*/
	uint64_t
	tu_gem_info_offset(const struct tu_device *dev, uint32_t gem_handle)
	{
	return tu_gem_info(dev, gem_handle, MSM_INFO_GET_OFFSET);
	}

	/** Returns the the iova of the BO in GPU memory.
	*
	* Returns 0 on error (an invalid iova in the MSM DRM UABI).
	*/
	uint64_t
	tu_gem_info_iova(const struct tu_device *dev, uint32_t gem_handle)
	{
	return tu_gem_info(dev, gem_handle, MSM_INFO_GET_IOVA);
	}

	static VkResult
	tu_drm_device_init(struct tu_physical_device *device,
	struct tu_instance *instance,
	drmDevicePtr drm_device)
	{
	const char *path = drm_device->nodes[DRM_NODE_RENDER];
	VkResult result = VK_SUCCESS;
	drmVersionPtr version;
	int fd;
	int master_fd = -1;

	fd = open(path, O_RDWR \| O_CLOEXEC);
	if (fd < 0) {
	return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
	"failed to open device %s", path);
	}

	/* Version 1.3 added MSM_INFO_IOVA. */
	const int min_version_major = 1;
	const int min_version_minor = 3;

	version = drmGetVersion(fd);
	if (!version) {
	close(fd);
	return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
	"failed to query kernel driver version for device %s",
	path);
	}

	if (strcmp(version->name, "msm")) {
	drmFreeVersion(version);
	close(fd);
	return vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
	"device %s does not use the msm kernel driver", path);
	}

	if (version->version_major != min_version_major \|\|
	version->version_minor < min_version_minor) {
	result = vk_errorf(instance, VK_ERROR_INCOMPATIBLE_DRIVER,
	"kernel driver for device %s has version %d.%d, "
	"but Vulkan requires version >= %d.%d",
	path, version->version_major, version->version_minor,
	min_version_major, min_version_minor);
	drmFreeVersion(version);
	close(fd);
	return result;
	}

	device->msm_major_version = version->version_major;
	device->msm_minor_version = version->version_minor;

	drmFreeVersion(version);

	if (instance->debug_flags & TU_DEBUG_STARTUP)
	tu_logi("Found compatible device '%s'.", path);

	vk_object_base_init(NULL, &device->base, VK_OBJECT_TYPE_PHYSICAL_DEVICE);
	device->instance = instance;
	assert(strlen(path) < ARRAY_SIZE(device->path));
	strncpy(device->path, path, ARRAY_SIZE(device->path));

	if (instance->enabled_extensions.KHR_display) {
	master_fd =
	open(drm_device->nodes[DRM_NODE_PRIMARY], O_RDWR \| O_CLOEXEC);
	if (master_fd >= 0) {
	/* TODO: free master_fd is accel is not working? */
	}
	}

	device->master_fd = master_fd;
	device->local_fd = fd;

	if (tu_drm_get_gpu_id(device, &device->gpu_id)) {
	if (instance->debug_flags & TU_DEBUG_STARTUP)
	tu_logi("Could not query the GPU ID");
	result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
	"could not get GPU ID");
	goto fail;
	}

	if (tu_drm_get_gmem_size(device, &device->gmem_size)) {
	if (instance->debug_flags & TU_DEBUG_STARTUP)
	tu_logi("Could not query the GMEM size");
	result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
	"could not get GMEM size");
	goto fail;
	}

	if (tu_drm_get_gmem_base(device, &device->gmem_base)) {
	if (instance->debug_flags & TU_DEBUG_STARTUP)
	tu_logi("Could not query the GMEM size");
	result = vk_errorf(instance, VK_ERROR_INITIALIZATION_FAILED,
	"could not get GMEM size");
	goto fail;
	}

	return tu_physical_device_init(device, instance);

	fail:
	close(fd);
	if (master_fd != -1)
	close(master_fd);
	return result;
	}

	VkResult
	tu_enumerate_devices(struct tu_instance *instance)
	{
	/* TODO: Check for more devices ? */
	drmDevicePtr devices[8];
	VkResult result = VK_ERROR_INCOMPATIBLE_DRIVER;
	int max_devices;

	instance->physical_device_count = 0;

	max_devices = drmGetDevices2(0, devices, ARRAY_SIZE(devices));

	if (instance->debug_flags & TU_DEBUG_STARTUP) {
	if (max_devices < 0)
	tu_logi("drmGetDevices2 returned error: %s\n", strerror(max_devices));
	else
	tu_logi("Found %d drm nodes", max_devices);
	}

	if (max_devices < 1)
	return vk_error(instance, VK_ERROR_INCOMPATIBLE_DRIVER);

	for (unsigned i = 0; i < (unsigned) max_devices; i++) {
	if (devices[i]->available_nodes & 1 << DRM_NODE_RENDER &&
	devices[i]->bustype == DRM_BUS_PLATFORM) {

	result = tu_drm_device_init(
	instance->physical_devices + instance->physical_device_count,
	instance, devices[i]);
	if (result == VK_SUCCESS)
	++instance->physical_device_count;
	else if (result != VK_ERROR_INCOMPATIBLE_DRIVER)
	break;
	}
	}
	drmFreeDevices(devices, max_devices);

	return result;
	}