drm/vmwgfx: Use the linux DMA api to get valid device addresses of pages (d92d9851) · Commits · 戴 / test

drivers/gpu/drm/vmwgfx/vmwgfx_buffer.c

+362 −17

Original line number	Diff line number	Diff line
		@@ -141,37 +141,374 @@ struct ttm_placement vmw_srf_placement = {
		};

		struct vmw_ttm_tt {
		struct ttm_tt ttm;
		struct ttm_dma_tt dma_ttm;
		struct vmw_private *dev_priv;
		int gmr_id;
		struct sg_table sgt;
		struct vmw_sg_table vsgt;
		uint64_t sg_alloc_size;
		bool mapped;
		};

		/**
		* Helper functions to advance a struct vmw_piter iterator.
		*
		* @viter: Pointer to the iterator.
		*
		* These functions return false if past the end of the list,
		* true otherwise. Functions are selected depending on the current
		* DMA mapping mode.
		*/
		static bool __vmw_piter_non_sg_next(struct vmw_piter *viter)
		{
		return ++(viter->i) < viter->num_pages;
		}

		static bool __vmw_piter_sg_next(struct vmw_piter *viter)
		{
		return __sg_page_iter_next(&viter->iter);
		}


		/**
		* Helper functions to return a pointer to the current page.
		*
		* @viter: Pointer to the iterator
		*
		* These functions return a pointer to the page currently
		* pointed to by @viter. Functions are selected depending on the
		* current mapping mode.
		*/
		static struct page __vmw_piter_non_sg_page(struct vmw_piter viter)
		{
		return viter->pages[viter->i];
		}

		static struct page __vmw_piter_sg_page(struct vmw_piter viter)
		{
		return sg_page_iter_page(&viter->iter);
		}


		/**
		* Helper functions to return the DMA address of the current page.
		*
		* @viter: Pointer to the iterator
		*
		* These functions return the DMA address of the page currently
		* pointed to by @viter. Functions are selected depending on the
		* current mapping mode.
		*/
		static dma_addr_t __vmw_piter_phys_addr(struct vmw_piter *viter)
		{
		return page_to_phys(viter->pages[viter->i]);
		}

		static dma_addr_t __vmw_piter_dma_addr(struct vmw_piter *viter)
		{
		return viter->addrs[viter->i];
		}

		static dma_addr_t __vmw_piter_sg_addr(struct vmw_piter *viter)
		{
		return sg_page_iter_dma_address(&viter->iter);
		}


		/**
		* vmw_piter_start - Initialize a struct vmw_piter.
		*
		* @viter: Pointer to the iterator to initialize
		* @vsgt: Pointer to a struct vmw_sg_table to initialize from
		*
		* Note that we're following the convention of __sg_page_iter_start, so that
		* the iterator doesn't point to a valid page after initialization; it has
		* to be advanced one step first.
		*/
		void vmw_piter_start(struct vmw_piter viter, const struct vmw_sg_table vsgt,
		unsigned long p_offset)
		{
		viter->i = p_offset - 1;
		viter->num_pages = vsgt->num_pages;
		switch (vsgt->mode) {
		case vmw_dma_phys:
		viter->next = &__vmw_piter_non_sg_next;
		viter->dma_address = &__vmw_piter_phys_addr;
		viter->page = &__vmw_piter_non_sg_page;
		viter->pages = vsgt->pages;
		break;
		case vmw_dma_alloc_coherent:
		viter->next = &__vmw_piter_non_sg_next;
		viter->dma_address = &__vmw_piter_dma_addr;
		viter->page = &__vmw_piter_non_sg_page;
		viter->addrs = vsgt->addrs;
		break;
		case vmw_dma_map_populate:
		case vmw_dma_map_bind:
		viter->next = &__vmw_piter_sg_next;
		viter->dma_address = &__vmw_piter_sg_addr;
		viter->page = &__vmw_piter_sg_page;
		__sg_page_iter_start(&viter->iter, vsgt->sgt->sgl,
		vsgt->sgt->orig_nents, p_offset);
		break;
		default:
		BUG();
		}
		}

		/**
		* vmw_ttm_unmap_from_dma - unmap device addresses previsouly mapped for
		* TTM pages
		*
		* @vmw_tt: Pointer to a struct vmw_ttm_backend
		*
		* Used to free dma mappings previously mapped by vmw_ttm_map_for_dma.
		*/
		static void vmw_ttm_unmap_from_dma(struct vmw_ttm_tt *vmw_tt)
		{
		struct device *dev = vmw_tt->dev_priv->dev->dev;

		dma_unmap_sg(dev, vmw_tt->sgt.sgl, vmw_tt->sgt.nents,
		DMA_BIDIRECTIONAL);
		vmw_tt->sgt.nents = vmw_tt->sgt.orig_nents;
		}

		/**
		* vmw_ttm_map_for_dma - map TTM pages to get device addresses
		*
		* @vmw_tt: Pointer to a struct vmw_ttm_backend
		*
		* This function is used to get device addresses from the kernel DMA layer.
		* However, it's violating the DMA API in that when this operation has been
		* performed, it's illegal for the CPU to write to the pages without first
		* unmapping the DMA mappings, or calling dma_sync_sg_for_cpu(). It is
		* therefore only legal to call this function if we know that the function
		* dma_sync_sg_for_cpu() is a NOP, and dma_sync_sg_for_device() is at most
		* a CPU write buffer flush.
		*/
		static int vmw_ttm_map_for_dma(struct vmw_ttm_tt *vmw_tt)
		{
		struct device *dev = vmw_tt->dev_priv->dev->dev;
		int ret;

		ret = dma_map_sg(dev, vmw_tt->sgt.sgl, vmw_tt->sgt.orig_nents,
		DMA_BIDIRECTIONAL);
		if (unlikely(ret == 0))
		return -ENOMEM;

		vmw_tt->sgt.nents = ret;

		return 0;
		}

		/**
		* vmw_ttm_map_dma - Make sure TTM pages are visible to the device
		*
		* @vmw_tt: Pointer to a struct vmw_ttm_tt
		*
		* Select the correct function for and make sure the TTM pages are
		* visible to the device. Allocate storage for the device mappings.
		* If a mapping has already been performed, indicated by the storage
		* pointer being non NULL, the function returns success.
		*/
		static int vmw_ttm_map_dma(struct vmw_ttm_tt *vmw_tt)
		{
		struct vmw_private *dev_priv = vmw_tt->dev_priv;
		struct ttm_mem_global *glob = vmw_mem_glob(dev_priv);
		struct vmw_sg_table *vsgt = &vmw_tt->vsgt;
		struct vmw_piter iter;
		dma_addr_t old;
		int ret = 0;
		static size_t sgl_size;
		static size_t sgt_size;

		if (vmw_tt->mapped)
		return 0;

		vsgt->mode = dev_priv->map_mode;
		vsgt->pages = vmw_tt->dma_ttm.ttm.pages;
		vsgt->num_pages = vmw_tt->dma_ttm.ttm.num_pages;
		vsgt->addrs = vmw_tt->dma_ttm.dma_address;
		vsgt->sgt = &vmw_tt->sgt;

		switch (dev_priv->map_mode) {
		case vmw_dma_map_bind:
		case vmw_dma_map_populate:
		if (unlikely(!sgl_size)) {
		sgl_size = ttm_round_pot(sizeof(struct scatterlist));
		sgt_size = ttm_round_pot(sizeof(struct sg_table));
		}
		vmw_tt->sg_alloc_size = sgt_size + sgl_size * vsgt->num_pages;
		ret = ttm_mem_global_alloc(glob, vmw_tt->sg_alloc_size, false,
		true);
		if (unlikely(ret != 0))
		return ret;

		ret = sg_alloc_table_from_pages(&vmw_tt->sgt, vsgt->pages,
		vsgt->num_pages, 0,
		(unsigned long)
		vsgt->num_pages << PAGE_SHIFT,
		GFP_KERNEL);
		if (unlikely(ret != 0))
		goto out_sg_alloc_fail;

		if (vsgt->num_pages > vmw_tt->sgt.nents) {
		uint64_t over_alloc =
		sgl_size * (vsgt->num_pages -
		vmw_tt->sgt.nents);

		ttm_mem_global_free(glob, over_alloc);
		vmw_tt->sg_alloc_size -= over_alloc;
		}

		ret = vmw_ttm_map_for_dma(vmw_tt);
		if (unlikely(ret != 0))
		goto out_map_fail;

		break;
		default:
		break;
		}

		old = ~((dma_addr_t) 0);
		vmw_tt->vsgt.num_regions = 0;
		for (vmw_piter_start(&iter, vsgt, 0); vmw_piter_next(&iter);) {
		dma_addr_t cur = vmw_piter_dma_addr(&iter);

		if (cur != old + PAGE_SIZE)
		vmw_tt->vsgt.num_regions++;
		old = cur;
		}

		vmw_tt->mapped = true;
		return 0;

		out_map_fail:
		sg_free_table(vmw_tt->vsgt.sgt);
		vmw_tt->vsgt.sgt = NULL;
		out_sg_alloc_fail:
		ttm_mem_global_free(glob, vmw_tt->sg_alloc_size);
		return ret;
		}

		/**
		* vmw_ttm_unmap_dma - Tear down any TTM page device mappings
		*
		* @vmw_tt: Pointer to a struct vmw_ttm_tt
		*
		* Tear down any previously set up device DMA mappings and free
		* any storage space allocated for them. If there are no mappings set up,
		* this function is a NOP.
		*/
		static void vmw_ttm_unmap_dma(struct vmw_ttm_tt *vmw_tt)
		{
		struct vmw_private *dev_priv = vmw_tt->dev_priv;

		if (!vmw_tt->vsgt.sgt)
		return;

		switch (dev_priv->map_mode) {
		case vmw_dma_map_bind:
		case vmw_dma_map_populate:
		vmw_ttm_unmap_from_dma(vmw_tt);
		sg_free_table(vmw_tt->vsgt.sgt);
		vmw_tt->vsgt.sgt = NULL;
		ttm_mem_global_free(vmw_mem_glob(dev_priv),
		vmw_tt->sg_alloc_size);
		break;
		default:
		break;
		}
		vmw_tt->mapped = false;
		}

		static int vmw_ttm_bind(struct ttm_tt ttm, struct ttm_mem_reg bo_mem)
		{
		struct vmw_ttm_tt *vmw_be = container_of(ttm, struct vmw_ttm_tt, ttm);
		struct vmw_ttm_tt *vmw_be =
		container_of(ttm, struct vmw_ttm_tt, dma_ttm.ttm);
		int ret;

		ret = vmw_ttm_map_dma(vmw_be);
		if (unlikely(ret != 0))
		return ret;

		vmw_be->gmr_id = bo_mem->start;

		return vmw_gmr_bind(vmw_be->dev_priv, ttm->pages,
		return vmw_gmr_bind(vmw_be->dev_priv, &vmw_be->vsgt,
		ttm->num_pages, vmw_be->gmr_id);
		}

		static int vmw_ttm_unbind(struct ttm_tt *ttm)
		{
		struct vmw_ttm_tt *vmw_be = container_of(ttm, struct vmw_ttm_tt, ttm);
		struct vmw_ttm_tt *vmw_be =
		container_of(ttm, struct vmw_ttm_tt, dma_ttm.ttm);

		vmw_gmr_unbind(vmw_be->dev_priv, vmw_be->gmr_id);

		if (vmw_be->dev_priv->map_mode == vmw_dma_map_bind)
		vmw_ttm_unmap_dma(vmw_be);

		return 0;
		}

		static void vmw_ttm_destroy(struct ttm_tt *ttm)
		{
		struct vmw_ttm_tt *vmw_be = container_of(ttm, struct vmw_ttm_tt, ttm);
		struct vmw_ttm_tt *vmw_be =
		container_of(ttm, struct vmw_ttm_tt, dma_ttm.ttm);

		vmw_ttm_unmap_dma(vmw_be);
		if (vmw_be->dev_priv->map_mode == vmw_dma_alloc_coherent)
		ttm_dma_tt_fini(&vmw_be->dma_ttm);
		else
		ttm_tt_fini(ttm);
		kfree(vmw_be);
		}

		static int vmw_ttm_populate(struct ttm_tt *ttm)
		{
		struct vmw_ttm_tt *vmw_tt =
		container_of(ttm, struct vmw_ttm_tt, dma_ttm.ttm);
		struct vmw_private *dev_priv = vmw_tt->dev_priv;
		struct ttm_mem_global *glob = vmw_mem_glob(dev_priv);
		int ret;

		if (ttm->state != tt_unpopulated)
		return 0;

		if (dev_priv->map_mode == vmw_dma_alloc_coherent) {
		size_t size =
		ttm_round_pot(ttm->num_pages * sizeof(dma_addr_t));
		ret = ttm_mem_global_alloc(glob, size, false, true);
		if (unlikely(ret != 0))
		return ret;

		ret = ttm_dma_populate(&vmw_tt->dma_ttm, dev_priv->dev->dev);
		if (unlikely(ret != 0))
		ttm_mem_global_free(glob, size);
		} else
		ret = ttm_pool_populate(ttm);

		return ret;
		}

		static void vmw_ttm_unpopulate(struct ttm_tt *ttm)
		{
		struct vmw_ttm_tt *vmw_tt = container_of(ttm, struct vmw_ttm_tt,
		dma_ttm.ttm);
		struct vmw_private *dev_priv = vmw_tt->dev_priv;
		struct ttm_mem_global *glob = vmw_mem_glob(dev_priv);

		vmw_ttm_unmap_dma(vmw_tt);
		if (dev_priv->map_mode == vmw_dma_alloc_coherent) {
		size_t size =
		ttm_round_pot(ttm->num_pages * sizeof(dma_addr_t));

		ttm_dma_unpopulate(&vmw_tt->dma_ttm, dev_priv->dev->dev);
		ttm_mem_global_free(glob, size);
		} else
		ttm_pool_unpopulate(ttm);
		}

		static struct ttm_backend_func vmw_ttm_func = {
		.bind = vmw_ttm_bind,
		.unbind = vmw_ttm_unbind,
		@@ -183,22 +520,30 @@ struct ttm_tt vmw_ttm_tt_create(struct ttm_bo_device bdev,
		struct page *dummy_read_page)
		{
		struct vmw_ttm_tt *vmw_be;
		int ret;

		vmw_be = kmalloc(sizeof(*vmw_be), GFP_KERNEL);
		vmw_be = kzalloc(sizeof(*vmw_be), GFP_KERNEL);
		if (!vmw_be)
		return NULL;

		vmw_be->ttm.func = &vmw_ttm_func;
		vmw_be->dma_ttm.ttm.func = &vmw_ttm_func;
		vmw_be->dev_priv = container_of(bdev, struct vmw_private, bdev);

		if (ttm_tt_init(&vmw_be->ttm, bdev, size, page_flags, dummy_read_page)) {
		if (vmw_be->dev_priv->map_mode == vmw_dma_alloc_coherent)
		ret = ttm_dma_tt_init(&vmw_be->dma_ttm, bdev, size, page_flags,
		dummy_read_page);
		else
		ret = ttm_tt_init(&vmw_be->dma_ttm.ttm, bdev, size, page_flags,
		dummy_read_page);
		if (unlikely(ret != 0))
		goto out_no_init;

		return &vmw_be->dma_ttm.ttm;
		out_no_init:
		kfree(vmw_be);
		return NULL;
		}

		return &vmw_be->ttm;
		}

		int vmw_invalidate_caches(struct ttm_bo_device *bdev, uint32_t flags)
		{
		return 0;
		@@ -332,8 +677,8 @@ static int vmw_sync_obj_wait(void *sync_obj, bool lazy, bool interruptible)

		struct ttm_bo_driver vmw_bo_driver = {
		.ttm_tt_create = &vmw_ttm_tt_create,
		.ttm_tt_populate = &ttm_pool_populate,
		.ttm_tt_unpopulate = &ttm_pool_unpopulate,
		.ttm_tt_populate = &vmw_ttm_populate,
		.ttm_tt_unpopulate = &vmw_ttm_unpopulate,
		.invalidate_caches = vmw_invalidate_caches,
		.init_mem_type = vmw_init_mem_type,
		.evict_flags = vmw_evict_flags,

drivers/gpu/drm/vmwgfx/vmwgfx_drv.c

+85 −2

Original line number	Diff line number	Diff line
		@@ -32,6 +32,7 @@
		#include <drm/ttm/ttm_bo_driver.h>
		#include <drm/ttm/ttm_object.h>
		#include <drm/ttm/ttm_module.h>
		#include <linux/dma_remapping.h>

		#define VMWGFX_DRIVER_NAME "vmwgfx"
		#define VMWGFX_DRIVER_DESC "Linux drm driver for VMware graphics devices"
		@@ -185,6 +186,9 @@ static struct pci_device_id vmw_pci_id_list[] = {
		MODULE_DEVICE_TABLE(pci, vmw_pci_id_list);

		static int enable_fbdev = IS_ENABLED(CONFIG_DRM_VMWGFX_FBCON);
		static int vmw_force_iommu;
		static int vmw_restrict_iommu;
		static int vmw_force_coherent;

		static int vmw_probe(struct pci_dev , const struct pci_device_id );
		static void vmw_master_init(struct vmw_master *);
		@@ -193,6 +197,13 @@ static int vmwgfx_pm_notifier(struct notifier_block *nb, unsigned long val,

		MODULE_PARM_DESC(enable_fbdev, "Enable vmwgfx fbdev");
		module_param_named(enable_fbdev, enable_fbdev, int, 0600);
		MODULE_PARM_DESC(force_dma_api, "Force using the DMA API for TTM pages");
		module_param_named(force_dma_api, vmw_force_iommu, int, 0600);
		MODULE_PARM_DESC(restrict_iommu, "Try to limit IOMMU usage for TTM pages");
		module_param_named(restrict_iommu, vmw_restrict_iommu, int, 0600);
		MODULE_PARM_DESC(force_coherent, "Force coherent TTM pages");
		module_param_named(force_coherent, vmw_force_coherent, int, 0600);


		static void vmw_print_capabilities(uint32_t capabilities)
		{
		@@ -427,12 +438,78 @@ static void vmw_get_initial_size(struct vmw_private *dev_priv)
		dev_priv->initial_height = height;
		}

		/**
		* vmw_dma_select_mode - Determine how DMA mappings should be set up for this
		* system.
		*
		* @dev_priv: Pointer to a struct vmw_private
		*
		* This functions tries to determine the IOMMU setup and what actions
		* need to be taken by the driver to make system pages visible to the
		* device.
		* If this function decides that DMA is not possible, it returns -EINVAL.
		* The driver may then try to disable features of the device that require
		* DMA.
		*/
		static int vmw_dma_select_mode(struct vmw_private *dev_priv)
		{
		const struct dma_map_ops *dma_ops = get_dma_ops(dev_priv->dev->dev);
		static const char *names[vmw_dma_map_max] = {
		[vmw_dma_phys] = "Using physical TTM page addresses.",
		[vmw_dma_alloc_coherent] = "Using coherent TTM pages.",
		[vmw_dma_map_populate] = "Keeping DMA mappings.",
		[vmw_dma_map_bind] = "Giving up DMA mappings early."};

		#ifdef CONFIG_INTEL_IOMMU
		if (intel_iommu_enabled) {
		dev_priv->map_mode = vmw_dma_map_populate;
		goto out_fixup;
		}
		#endif

		if (!(vmw_force_iommu \|\| vmw_force_coherent)) {
		dev_priv->map_mode = vmw_dma_phys;
		DRM_INFO("DMA map mode: %s\n", names[dev_priv->map_mode]);
		return 0;
		}

		dev_priv->map_mode = vmw_dma_map_populate;

		if (dma_ops->sync_single_for_cpu)
		dev_priv->map_mode = vmw_dma_alloc_coherent;
		#ifdef CONFIG_SWIOTLB
		if (swiotlb_nr_tbl() == 0)
		dev_priv->map_mode = vmw_dma_map_populate;
		#endif

		out_fixup:
		if (dev_priv->map_mode == vmw_dma_map_populate &&
		vmw_restrict_iommu)
		dev_priv->map_mode = vmw_dma_map_bind;

		if (vmw_force_coherent)
		dev_priv->map_mode = vmw_dma_alloc_coherent;

		#if !defined(CONFIG_SWIOTLB) && !defined(CONFIG_INTEL_IOMMU)
		/*
		* No coherent page pool
		*/
		if (dev_priv->map_mode == vmw_dma_alloc_coherent)
		return -EINVAL;
		#endif

		DRM_INFO("DMA map mode: %s\n", names[dev_priv->map_mode]);

		return 0;
		}

		static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
		{
		struct vmw_private *dev_priv;
		int ret;
		uint32_t svga_id;
		enum vmw_res_type i;
		bool refuse_dma = false;

		dev_priv = kzalloc(sizeof(*dev_priv), GFP_KERNEL);
		if (unlikely(dev_priv == NULL)) {
		@@ -481,6 +558,11 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
		}

		dev_priv->capabilities = vmw_read(dev_priv, SVGA_REG_CAPABILITIES);
		ret = vmw_dma_select_mode(dev_priv);
		if (unlikely(ret != 0)) {
		DRM_INFO("Restricting capabilities due to IOMMU setup.\n");
		refuse_dma = true;
		}

		dev_priv->vram_size = vmw_read(dev_priv, SVGA_REG_VRAM_SIZE);
		dev_priv->mmio_size = vmw_read(dev_priv, SVGA_REG_MEM_SIZE);
		@@ -558,7 +640,8 @@ static int vmw_driver_load(struct drm_device *dev, unsigned long chipset)
		}

		dev_priv->has_gmr = true;
		if (ttm_bo_init_mm(&dev_priv->bdev, VMW_PL_GMR,
		if (((dev_priv->capabilities & (SVGA_CAP_GMR \| SVGA_CAP_GMR2)) == 0) \|\|
		refuse_dma \|\| ttm_bo_init_mm(&dev_priv->bdev, VMW_PL_GMR,
		dev_priv->max_gmr_ids) != 0) {
		DRM_INFO("No GMR memory available. "
		"Graphics memory resources are very limited.\n");

drivers/gpu/drm/vmwgfx/vmwgfx_drv.h

+97 −1

Original line number	Diff line number	Diff line
		@@ -177,6 +177,58 @@ struct vmw_res_cache_entry {
		struct vmw_resource_val_node *node;
		};

		/**
		* enum vmw_dma_map_mode - indicate how to perform TTM page dma mappings.
		*/
		enum vmw_dma_map_mode {
		vmw_dma_phys, /* Use physical page addresses */
		vmw_dma_alloc_coherent, /* Use TTM coherent pages */
		vmw_dma_map_populate, /* Unmap from DMA just after unpopulate */
		vmw_dma_map_bind, /* Unmap from DMA just before unbind */
		vmw_dma_map_max
		};

		/**
		* struct vmw_sg_table - Scatter/gather table for binding, with additional
		* device-specific information.
		*
		* @sgt: Pointer to a struct sg_table with binding information
		* @num_regions: Number of regions with device-address contigous pages
		*/
		struct vmw_sg_table {
		enum vmw_dma_map_mode mode;
		struct page **pages;
		const dma_addr_t *addrs;
		struct sg_table *sgt;
		unsigned long num_regions;
		unsigned long num_pages;
		};

		/**
		* struct vmw_piter - Page iterator that iterates over a list of pages
		* and DMA addresses that could be either a scatter-gather list or
		* arrays
		*
		* @pages: Array of page pointers to the pages.
		* @addrs: DMA addresses to the pages if coherent pages are used.
		* @iter: Scatter-gather page iterator. Current position in SG list.
		* @i: Current position in arrays.
		* @num_pages: Number of pages total.
		* @next: Function to advance the iterator. Returns false if past the list
		* of pages, true otherwise.
		* @dma_address: Function to return the DMA address of the current page.
		*/
		struct vmw_piter {
		struct page **pages;
		const dma_addr_t *addrs;
		struct sg_page_iter iter;
		unsigned long i;
		unsigned long num_pages;
		bool (next)(struct vmw_piter );
		dma_addr_t (dma_address)(struct vmw_piter );
		struct page (page)(struct vmw_piter *);
		};

		struct vmw_sw_context{
		struct drm_open_hash res_ht;
		bool res_ht_initialized;
		@@ -358,6 +410,11 @@ struct vmw_private {

		struct list_head res_lru[vmw_res_max];
		uint32_t used_memory_size;

		/*
		* DMA mapping stuff.
		*/
		enum vmw_dma_map_mode map_mode;
		};

		static inline struct vmw_surface vmw_res_to_srf(struct vmw_resource res)
		@@ -405,7 +462,7 @@ void vmw_3d_resource_dec(struct vmw_private *dev_priv, bool hide_svga);
		*/

		extern int vmw_gmr_bind(struct vmw_private *dev_priv,
		struct page *pages[],
		const struct vmw_sg_table *vsgt,
		unsigned long num_pages,
		int gmr_id);
		extern void vmw_gmr_unbind(struct vmw_private *dev_priv, int gmr_id);
		@@ -568,6 +625,45 @@ extern struct ttm_placement vmw_evictable_placement;
		extern struct ttm_placement vmw_srf_placement;
		extern struct ttm_bo_driver vmw_bo_driver;
		extern int vmw_dma_quiescent(struct drm_device *dev);
		extern void vmw_piter_start(struct vmw_piter *viter,
		const struct vmw_sg_table *vsgt,
		unsigned long p_offs);

		/**
		* vmw_piter_next - Advance the iterator one page.
		*
		* @viter: Pointer to the iterator to advance.
		*
		* Returns false if past the list of pages, true otherwise.
		*/
		static inline bool vmw_piter_next(struct vmw_piter *viter)
		{
		return viter->next(viter);
		}

		/**
		* vmw_piter_dma_addr - Return the DMA address of the current page.
		*
		* @viter: Pointer to the iterator
		*
		* Returns the DMA address of the page pointed to by @viter.
		*/
		static inline dma_addr_t vmw_piter_dma_addr(struct vmw_piter *viter)
		{
		return viter->dma_address(viter);
		}

		/**
		* vmw_piter_page - Return a pointer to the current page.
		*
		* @viter: Pointer to the iterator
		*
		* Returns the DMA address of the page pointed to by @viter.
		*/
		static inline struct page vmw_piter_page(struct vmw_piter viter)
		{
		return viter->page(viter);
		}

		/**
		* Command submission - vmwgfx_execbuf.c

drivers/gpu/drm/vmwgfx/vmwgfx_gmr.c

+76 −74

File changed.

Preview size limit exceeded, changes collapsed.

Admin message