Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 69b005be authored by Gurchetan Singh's avatar Gurchetan Singh Committed by Lingfeng Yang
Browse files

ANDROID: drm/virtio: rebase to latest virgl/drm-misc-next (take 2) 



So ToT + v4.14 can share same hypercall interface.

TEST=compile

Signed-off-by: default avatarGurchetan Singh <gurchetansingh@google.com>
Signed-off-by: default avatarLingfeng Yang <lfy@google.com>
Bug: 153580313
Change-Id: Ifd6d8d50983461380f24988cef5a0435a2ecc59b
parent 8654841a

drivers/gpu/drm/virtio/virtgpu_drv.h

+5 −5
Original line number Diff line number Diff line
@@ -59,7 +59,7 @@ struct virtio_gpu_object_params { 
	/* 3d */

	bool virgl;

	bool blob;

	uint32_t blob_flags;

	uint32_t blob_mem;

	uint32_t target;

	uint32_t bind;

	uint32_t depth;
@@ -90,7 +90,7 @@ struct virtio_gpu_object { 
	struct ttm_buffer_object	tbo;

	struct ttm_bo_kmap_obj		kmap;

	bool created;

	uint32_t blob_flags;

	uint32_t blob_mem;

};

#define gem_to_virtio_gpu_obj(gobj) \

	container_of((gobj), struct virtio_gpu_object, gem_base)
@@ -369,9 +369,9 @@ virtio_gpu_cmd_resource_create_3d(struct virtio_gpu_device *vgdev, 
void

virtio_gpu_cmd_resource_create_blob(struct virtio_gpu_device *vgdev,

				    struct virtio_gpu_object *bo,

				    uint32_t ctx_id, uint32_t flags,

				    uint64_t size, uint64_t memory_id,

				    uint32_t nents,

				    uint32_t ctx_id, uint32_t blob_mem,

				    uint32_t blob_flags, uint64_t blob_id,

				    uint64_t size, uint32_t nents,

				    struct virtio_gpu_mem_entry *ents);



void virtio_gpu_cmd_map(struct virtio_gpu_device *vgdev,

drivers/gpu/drm/virtio/virtgpu_ioctl.c

+28 −10
Original line number Diff line number Diff line
@@ -585,6 +585,7 @@ static int virtio_gpu_resource_create_blob_ioctl(struct drm_device *dev, 
				void *data, struct drm_file *file)

{

	void *buf;

	uint32_t device_blob_mem = 0;

	int ret, si, nents;

	uint32_t handle = 0;

	struct scatterlist *sg;
@@ -596,13 +597,29 @@ static int virtio_gpu_resource_create_blob_ioctl(struct drm_device *dev, 
	struct virtio_gpu_device *vgdev = dev->dev_private;

	struct virtio_gpu_fpriv *vfpriv = file->driver_priv;

	bool use_dma_api = !virtio_has_iommu_quirk(vgdev->vdev);

	bool mappable = rc_blob->flags & VIRTGPU_RES_BLOB_USE_MAPPABLE;

	bool guest = rc_blob->flags & VIRTGPU_RES_BLOB_GUEST_MASK;

	bool mappable = rc_blob->blob_flags & VIRTGPU_BLOB_FLAG_MAPPABLE;

	bool has_guest = (rc_blob->blob_mem == VIRTGPU_BLOB_MEM_GUEST ||

		rc_blob->blob_mem == VIRTGPU_BLOB_MEM_HOST_GUEST);



	params.size = rc_blob->size;

	params.blob_flags = rc_blob->flags;

	params.blob_mem = rc_blob->blob_mem;

	params.blob = true;



	if (rc_blob->blob_mem == VIRTGPU_BLOB_MEM_GUEST)

		device_blob_mem = VIRTIO_GPU_BLOB_MEM_GUEST;



	if (vgdev->has_virgl_3d) {

		if (rc_blob->blob_mem == VIRTGPU_BLOB_MEM_HOST)

			device_blob_mem = VIRTIO_GPU_BLOB_MEM_HOST3D;

		else if (rc_blob->blob_mem == VIRTGPU_BLOB_MEM_HOST_GUEST)

			device_blob_mem = VIRTIO_GPU_BLOB_MEM_HOST3D_GUEST;

	} else {

		if (rc_blob->blob_mem == VIRTGPU_BLOB_MEM_HOST)

			device_blob_mem = VIRTIO_GPU_BLOB_MEM_HOSTSYS;

		else if (rc_blob->blob_mem == VIRTGPU_BLOB_MEM_HOST_GUEST)

			device_blob_mem = VIRTIO_GPU_BLOB_MEM_HOSTSYS_GUEST;

	}



	if (rc_blob->cmd_size && vfpriv) {

		void *buf;

		void __user *cmd = u64_to_user_ptr(rc_blob->cmd);
@@ -630,7 +647,7 @@ static int virtio_gpu_resource_create_blob_ioctl(struct drm_device *dev, 
			goto err_free_obj;

        }



	if (!guest) {

	if (!has_guest) {

		nents = 0;

	} else if (use_dma_api) {

                obj->mapped = dma_map_sg(vgdev->vdev->dev.parent,
@@ -642,7 +659,7 @@ static int virtio_gpu_resource_create_blob_ioctl(struct drm_device *dev, 
        }



	ents = kzalloc(nents * sizeof(struct virtio_gpu_mem_entry), GFP_KERNEL);

	if (guest) {

	if (has_guest) {

		for_each_sg(obj->pages->sgl, sg, nents, si) {

			ents[si].addr = cpu_to_le64(use_dma_api

						    ? sg_dma_address(sg)
@@ -659,17 +676,18 @@ static int virtio_gpu_resource_create_blob_ioctl(struct drm_device *dev, 
	}



	virtio_gpu_cmd_resource_create_blob(vgdev, obj, vfpriv->ctx_id,

					    rc_blob->flags, rc_blob->size,

					    rc_blob->memory_id, nents,

					    ents);

		device_blob_mem,

		rc_blob->blob_flags,

		rc_blob->blob_id,

		rc_blob->size,

		nents, ents);



	ret = drm_gem_handle_create(file, &obj->gem_base, &handle);

	if (ret)

		goto err_fence_put;



	if (!guest && mappable) {

	if (!has_guest && mappable)

		virtio_gpu_cmd_map(vgdev, obj, obj->tbo.offset, fence);

	}



	/*

	 * No need to call virtio_gpu_object_reserve since the buffer is not

drivers/gpu/drm/virtio/virtgpu_kms.c

+18 −14
Original line number Diff line number Diff line
@@ -185,21 +185,25 @@ int virtio_gpu_init(struct drm_device *dev) 
	}



	if (virtio_has_feature(vgdev->vdev, VIRTIO_GPU_F_RESOURCE_BLOB)) {

		if (virtio_has_feature(vgdev->vdev, VIRTIO_GPU_F_HOST_VISIBLE)) {

		vgdev->cbar = 4;

		vgdev->caddr = pci_resource_start(dev->pdev, vgdev->cbar);

		vgdev->csize = pci_resource_len(dev->pdev, vgdev->cbar);

			ret = pci_request_region(dev->pdev, vgdev->cbar, "virtio-gpu-coherent");

		ret = pci_request_region(

			dev->pdev,

			vgdev->cbar,

			"virtio-gpu-coherent");

		if (ret != 0) {

			DRM_WARN("Cannot request coherent memory bar\n");

		} else {

				DRM_INFO("coherent host resources enabled, using %s bar %d,"

					 "at 0x%lx, size %ld MB", dev_name(&dev->pdev->dev),

					vgdev->cbar, vgdev->caddr, vgdev->csize >> 20);



			DRM_INFO("coherent host resources enabled\n");

			DRM_INFO(

				"using %s bar %d, at 0x%lx, size %ld MB\n",

				dev_name(&dev->pdev->dev),

				vgdev->cbar,

				vgdev->caddr,

				vgdev->csize >> 20);

			vgdev->has_host_visible = true;

		}

		}



		vgdev->has_resource_blob = true;

		DRM_INFO("resource_v2: %u, host visible %u\n",

drivers/gpu/drm/virtio/virtgpu_object.c

+13 −12
Original line number Diff line number Diff line
@@ -95,18 +95,19 @@ static void virtio_gpu_ttm_bo_destroy(struct ttm_buffer_object *tbo) 
}



// define internally for testing purposes

#define VIRTGPU_RESOURCE_CACHE_MASK      0xf000

#define VIRTGPU_RESOURCE_CACHE_CACHED    0x1000

#define VIRTGPU_RESOURCE_CACHE_UNCACHED  0x2000

#define VIRTGPU_RESOURCE_CACHE_WC        0x3000

#define VIRTGPU_BLOB_MEM_CACHE_MASK      0xf000

#define VIRTGPU_BLOB_MEM_CACHE_CACHED    0x1000

#define VIRTGPU_BLOB_MEM_CACHE_UNCACHED  0x2000

#define VIRTGPU_BLOB_MEM_CACHE_WC        0x3000



static void virtio_gpu_init_ttm_placement(struct virtio_gpu_object *vgbo)

{

	u32 c = 1;

	u32 ttm_caching_flags = 0;



	u32 cache_type = (vgbo->blob_flags & VIRTGPU_RESOURCE_CACHE_MASK);

	u32 guest = (vgbo->blob_flags & VIRTGPU_RES_BLOB_GUEST_MASK);

	u32 cache_type = (vgbo->blob_mem & VIRTGPU_BLOB_MEM_CACHE_MASK);

	bool has_guest = (vgbo->blob_mem == VIRTGPU_BLOB_MEM_GUEST ||

			  vgbo->blob_mem == VIRTGPU_BLOB_MEM_HOST_GUEST);



	vgbo->placement.placement = &vgbo->placement_code;

	vgbo->placement.busy_placement = &vgbo->placement_code;
@@ -114,20 +115,20 @@ static void virtio_gpu_init_ttm_placement(struct virtio_gpu_object *vgbo) 
	vgbo->placement_code.lpfn = 0;



	switch (cache_type) {

	case VIRTGPU_RESOURCE_CACHE_CACHED:

	case VIRTGPU_BLOB_MEM_CACHE_CACHED:

		ttm_caching_flags = TTM_PL_FLAG_CACHED;

		break;

	case VIRTGPU_RESOURCE_CACHE_WC:

	case VIRTGPU_BLOB_MEM_CACHE_WC:

		ttm_caching_flags = TTM_PL_FLAG_WC;

		break;

	case VIRTGPU_RESOURCE_CACHE_UNCACHED:

	case VIRTGPU_BLOB_MEM_CACHE_UNCACHED:

		ttm_caching_flags = TTM_PL_FLAG_UNCACHED;

		break;

	default:

		ttm_caching_flags = TTM_PL_MASK_CACHING;

	}



	if (!guest && vgbo->blob) {

	if (!has_guest && vgbo->blob) {

		vgbo->placement_code.flags =

			ttm_caching_flags | TTM_PL_FLAG_VRAM |

			TTM_PL_FLAG_NO_EVICT;
@@ -172,11 +173,11 @@ int virtio_gpu_object_create(struct virtio_gpu_device *vgdev, 
	}

	bo->dumb = params->dumb;

	bo->blob = params->blob;

	bo->blob_flags = params->blob_flags;

	bo->blob_mem = params->blob_mem;



	if (params->virgl) {

		virtio_gpu_cmd_resource_create_3d(vgdev, bo, params, fence);

	} else {

	} else if (params->dumb) {

		virtio_gpu_cmd_create_resource(vgdev, bo, params, fence);

	}

drivers/gpu/drm/virtio/virtgpu_ttm.c

+4 −3
Original line number Diff line number Diff line
@@ -349,7 +349,7 @@ static struct ttm_tt *virtio_gpu_ttm_tt_create2(struct ttm_buffer_object *bo, 
	struct virtio_gpu_device *vgdev;

	struct virtio_gpu_object *obj;

	struct virtio_gpu_ttm_tt *gtt;

	uint32_t guest;

	uint32_t has_guest;



	vgdev = virtio_gpu_get_vgdev(bo->bdev);

	obj = container_of(bo, struct virtio_gpu_object, tbo);
@@ -358,9 +358,10 @@ static struct ttm_tt *virtio_gpu_ttm_tt_create2(struct ttm_buffer_object *bo, 
	if (gtt == NULL)

		return NULL;

	gtt->obj = obj;

	guest = (obj->blob_flags & VIRTGPU_RES_BLOB_GUEST_MASK);

	has_guest = (obj->blob_mem == VIRTGPU_BLOB_MEM_GUEST ||

		     obj->blob_mem == VIRTGPU_BLOB_MEM_HOST_GUEST);



	if (!guest && obj->blob) {

	if (!has_guest && obj->blob) {

		gtt->ttm.ttm.func = &virtio_gpu_vram_func;

		if (ttm_tt_init(&gtt->ttm.ttm, bo->bdev, size, page_flags,

				dummy_read_page)) {