2012-06-27 13:30:18 +00:00
|
|
|
/*
|
|
|
|
* drm gem CMA (contiguous memory allocator) helper functions
|
|
|
|
*
|
|
|
|
* Copyright (C) 2012 Sascha Hauer, Pengutronix
|
|
|
|
*
|
|
|
|
* Based on Samsung Exynos code
|
|
|
|
*
|
|
|
|
* Copyright (c) 2011 Samsung Electronics Co., Ltd.
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include <linux/mm.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/mutex.h>
|
|
|
|
#include <linux/export.h>
|
2013-02-17 00:57:30 +00:00
|
|
|
#include <linux/dma-buf.h>
|
2012-06-27 13:30:18 +00:00
|
|
|
#include <linux/dma-mapping.h>
|
|
|
|
|
|
|
|
#include <drm/drmP.h>
|
|
|
|
#include <drm/drm.h>
|
|
|
|
#include <drm/drm_gem_cma_helper.h>
|
2013-07-24 19:07:52 +00:00
|
|
|
#include <drm/drm_vma_manager.h>
|
2012-06-27 13:30:18 +00:00
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* DOC: cma helpers
|
|
|
|
*
|
|
|
|
* The Contiguous Memory Allocator reserves a pool of memory at early boot
|
|
|
|
* that is used to service requests for large blocks of contiguous memory.
|
|
|
|
*
|
|
|
|
* The DRM GEM/CMA helpers use this allocator as a means to provide buffer
|
|
|
|
* objects that are physically contiguous in memory. This is useful for
|
|
|
|
* display drivers that are unable to map scattered buffers via an IOMMU.
|
|
|
|
*/
|
|
|
|
|
|
|
|
/**
|
2013-02-17 00:54:26 +00:00
|
|
|
* __drm_gem_cma_create - Create a GEM CMA object without allocating memory
|
2014-11-03 12:56:55 +00:00
|
|
|
* @drm: DRM device
|
|
|
|
* @size: size of the object to allocate
|
2012-06-27 13:30:18 +00:00
|
|
|
*
|
2014-11-03 12:56:55 +00:00
|
|
|
* This function creates and initializes a GEM CMA object of the given size,
|
|
|
|
* but doesn't allocate any memory to back the object.
|
2013-02-17 00:54:26 +00:00
|
|
|
*
|
2014-11-03 12:56:55 +00:00
|
|
|
* Returns:
|
|
|
|
* A struct drm_gem_cma_object * on success or an ERR_PTR()-encoded negative
|
|
|
|
* error code on failure.
|
2012-06-27 13:30:18 +00:00
|
|
|
*/
|
2013-02-17 00:54:26 +00:00
|
|
|
static struct drm_gem_cma_object *
|
2014-11-03 12:56:55 +00:00
|
|
|
__drm_gem_cma_create(struct drm_device *drm, size_t size)
|
2012-06-27 13:30:18 +00:00
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
struct drm_gem_object *gem_obj;
|
|
|
|
int ret;
|
|
|
|
|
2015-11-30 18:55:13 +00:00
|
|
|
if (drm->driver->gem_create_object)
|
|
|
|
gem_obj = drm->driver->gem_create_object(drm, size);
|
|
|
|
else
|
|
|
|
gem_obj = kzalloc(sizeof(*cma_obj), GFP_KERNEL);
|
|
|
|
if (!gem_obj)
|
2012-06-27 13:30:18 +00:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2015-11-30 18:55:13 +00:00
|
|
|
cma_obj = container_of(gem_obj, struct drm_gem_cma_object, base);
|
2012-06-27 13:30:18 +00:00
|
|
|
|
|
|
|
ret = drm_gem_object_init(drm, gem_obj, size);
|
|
|
|
if (ret)
|
2013-02-17 00:54:26 +00:00
|
|
|
goto error;
|
2012-06-27 13:30:18 +00:00
|
|
|
|
|
|
|
ret = drm_gem_create_mmap_offset(gem_obj);
|
2013-02-17 00:54:26 +00:00
|
|
|
if (ret) {
|
|
|
|
drm_gem_object_release(gem_obj);
|
|
|
|
goto error;
|
|
|
|
}
|
2012-06-27 13:30:18 +00:00
|
|
|
|
|
|
|
return cma_obj;
|
|
|
|
|
2013-02-17 00:54:26 +00:00
|
|
|
error:
|
|
|
|
kfree(cma_obj);
|
|
|
|
return ERR_PTR(ret);
|
|
|
|
}
|
2012-06-27 13:30:18 +00:00
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
2013-02-17 00:54:26 +00:00
|
|
|
* drm_gem_cma_create - allocate an object with the given size
|
2014-11-03 12:56:55 +00:00
|
|
|
* @drm: DRM device
|
|
|
|
* @size: size of the object to allocate
|
|
|
|
*
|
|
|
|
* This function creates a CMA GEM object and allocates a contiguous chunk of
|
|
|
|
* memory as backing store. The backing memory has the writecombine attribute
|
|
|
|
* set.
|
2013-02-17 00:54:26 +00:00
|
|
|
*
|
2014-11-03 12:56:55 +00:00
|
|
|
* Returns:
|
|
|
|
* A struct drm_gem_cma_object * on success or an ERR_PTR()-encoded negative
|
|
|
|
* error code on failure.
|
2013-02-17 00:54:26 +00:00
|
|
|
*/
|
|
|
|
struct drm_gem_cma_object *drm_gem_cma_create(struct drm_device *drm,
|
2014-11-03 12:56:55 +00:00
|
|
|
size_t size)
|
2013-02-17 00:54:26 +00:00
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
2013-02-17 00:57:30 +00:00
|
|
|
int ret;
|
2012-06-27 13:30:18 +00:00
|
|
|
|
2013-02-17 00:54:26 +00:00
|
|
|
size = round_up(size, PAGE_SIZE);
|
2012-06-27 13:30:18 +00:00
|
|
|
|
2013-02-17 00:54:26 +00:00
|
|
|
cma_obj = __drm_gem_cma_create(drm, size);
|
|
|
|
if (IS_ERR(cma_obj))
|
|
|
|
return cma_obj;
|
|
|
|
|
dma, mm/pat: Rename dma_*_writecombine() to dma_*_wc()
Rename dma_*_writecombine() to dma_*_wc(), so that the naming
is coherent across the various write-combining APIs. Keep the
old names for compatibility for a while, these can be removed
at a later time. A guard is left to enable backporting of the
rename, and later remove of the old mapping defines seemlessly.
Build tested successfully with allmodconfig.
The following Coccinelle SmPL patch was used for this simple
transformation:
@ rename_dma_alloc_writecombine @
expression dev, size, dma_addr, gfp;
@@
-dma_alloc_writecombine(dev, size, dma_addr, gfp)
+dma_alloc_wc(dev, size, dma_addr, gfp)
@ rename_dma_free_writecombine @
expression dev, size, cpu_addr, dma_addr;
@@
-dma_free_writecombine(dev, size, cpu_addr, dma_addr)
+dma_free_wc(dev, size, cpu_addr, dma_addr)
@ rename_dma_mmap_writecombine @
expression dev, vma, cpu_addr, dma_addr, size;
@@
-dma_mmap_writecombine(dev, vma, cpu_addr, dma_addr, size)
+dma_mmap_wc(dev, vma, cpu_addr, dma_addr, size)
We also keep the old names as compatibility helpers, and
guard against their definition to make backporting easier.
Generated-by: Coccinelle SmPL
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: airlied@linux.ie
Cc: akpm@linux-foundation.org
Cc: benh@kernel.crashing.org
Cc: bhelgaas@google.com
Cc: bp@suse.de
Cc: dan.j.williams@intel.com
Cc: daniel.vetter@ffwll.ch
Cc: dhowells@redhat.com
Cc: julia.lawall@lip6.fr
Cc: konrad.wilk@oracle.com
Cc: linux-fbdev@vger.kernel.org
Cc: linux-pci@vger.kernel.org
Cc: luto@amacapital.net
Cc: mst@redhat.com
Cc: tomi.valkeinen@ti.com
Cc: toshi.kani@hp.com
Cc: vinod.koul@intel.com
Cc: xen-devel@lists.xensource.com
Link: http://lkml.kernel.org/r/1453516462-4844-1-git-send-email-mcgrof@do-not-panic.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-23 02:34:22 +00:00
|
|
|
cma_obj->vaddr = dma_alloc_wc(drm->dev, size, &cma_obj->paddr,
|
|
|
|
GFP_KERNEL | __GFP_NOWARN);
|
2013-02-17 00:54:26 +00:00
|
|
|
if (!cma_obj->vaddr) {
|
2015-05-04 14:16:19 +00:00
|
|
|
dev_err(drm->dev, "failed to allocate buffer with size %zu\n",
|
2013-02-17 00:54:26 +00:00
|
|
|
size);
|
2013-02-17 00:57:30 +00:00
|
|
|
ret = -ENOMEM;
|
|
|
|
goto error;
|
|
|
|
}
|
|
|
|
|
2013-02-17 00:54:26 +00:00
|
|
|
return cma_obj;
|
2013-02-17 00:57:30 +00:00
|
|
|
|
|
|
|
error:
|
2016-05-31 21:25:52 +00:00
|
|
|
drm_gem_object_unreference_unlocked(&cma_obj->base);
|
2013-02-17 00:57:30 +00:00
|
|
|
return ERR_PTR(ret);
|
2012-06-27 13:30:18 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_create);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_create_with_handle - allocate an object with the given size and
|
|
|
|
* return a GEM handle to it
|
|
|
|
* @file_priv: DRM file-private structure to register the handle for
|
|
|
|
* @drm: DRM device
|
|
|
|
* @size: size of the object to allocate
|
|
|
|
* @handle: return location for the GEM handle
|
|
|
|
*
|
|
|
|
* This function creates a CMA GEM object, allocating a physically contiguous
|
|
|
|
* chunk of memory as backing store. The GEM object is then added to the list
|
|
|
|
* of object associated with the given file and a handle to it is returned.
|
2012-06-27 13:30:18 +00:00
|
|
|
*
|
2014-11-03 12:56:55 +00:00
|
|
|
* Returns:
|
|
|
|
* A struct drm_gem_cma_object * on success or an ERR_PTR()-encoded negative
|
|
|
|
* error code on failure.
|
2012-06-27 13:30:18 +00:00
|
|
|
*/
|
2014-11-03 12:56:55 +00:00
|
|
|
static struct drm_gem_cma_object *
|
|
|
|
drm_gem_cma_create_with_handle(struct drm_file *file_priv,
|
|
|
|
struct drm_device *drm, size_t size,
|
|
|
|
uint32_t *handle)
|
2012-06-27 13:30:18 +00:00
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
struct drm_gem_object *gem_obj;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
cma_obj = drm_gem_cma_create(drm, size);
|
|
|
|
if (IS_ERR(cma_obj))
|
|
|
|
return cma_obj;
|
|
|
|
|
|
|
|
gem_obj = &cma_obj->base;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* allocate a id of idr table where the obj is registered
|
|
|
|
* and handle has the id what user can see.
|
|
|
|
*/
|
|
|
|
ret = drm_gem_handle_create(file_priv, gem_obj, handle);
|
|
|
|
/* drop reference from allocate - handle holds it now. */
|
|
|
|
drm_gem_object_unreference_unlocked(gem_obj);
|
2016-05-31 21:25:52 +00:00
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
2012-06-27 13:30:18 +00:00
|
|
|
|
|
|
|
return cma_obj;
|
|
|
|
}
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_free_object - free resources associated with a CMA GEM object
|
|
|
|
* @gem_obj: GEM object to free
|
|
|
|
*
|
|
|
|
* This function frees the backing memory of the CMA GEM object, cleans up the
|
|
|
|
* GEM object state and frees the memory used to store the object itself.
|
2016-12-29 20:48:34 +00:00
|
|
|
* Drivers using the CMA helpers should set this as their
|
|
|
|
* &drm_driver.gem_free_object callback.
|
2012-06-27 13:30:18 +00:00
|
|
|
*/
|
|
|
|
void drm_gem_cma_free_object(struct drm_gem_object *gem_obj)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
|
|
|
|
cma_obj = to_drm_gem_cma_obj(gem_obj);
|
|
|
|
|
2013-02-17 00:57:30 +00:00
|
|
|
if (cma_obj->vaddr) {
|
dma, mm/pat: Rename dma_*_writecombine() to dma_*_wc()
Rename dma_*_writecombine() to dma_*_wc(), so that the naming
is coherent across the various write-combining APIs. Keep the
old names for compatibility for a while, these can be removed
at a later time. A guard is left to enable backporting of the
rename, and later remove of the old mapping defines seemlessly.
Build tested successfully with allmodconfig.
The following Coccinelle SmPL patch was used for this simple
transformation:
@ rename_dma_alloc_writecombine @
expression dev, size, dma_addr, gfp;
@@
-dma_alloc_writecombine(dev, size, dma_addr, gfp)
+dma_alloc_wc(dev, size, dma_addr, gfp)
@ rename_dma_free_writecombine @
expression dev, size, cpu_addr, dma_addr;
@@
-dma_free_writecombine(dev, size, cpu_addr, dma_addr)
+dma_free_wc(dev, size, cpu_addr, dma_addr)
@ rename_dma_mmap_writecombine @
expression dev, vma, cpu_addr, dma_addr, size;
@@
-dma_mmap_writecombine(dev, vma, cpu_addr, dma_addr, size)
+dma_mmap_wc(dev, vma, cpu_addr, dma_addr, size)
We also keep the old names as compatibility helpers, and
guard against their definition to make backporting easier.
Generated-by: Coccinelle SmPL
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: airlied@linux.ie
Cc: akpm@linux-foundation.org
Cc: benh@kernel.crashing.org
Cc: bhelgaas@google.com
Cc: bp@suse.de
Cc: dan.j.williams@intel.com
Cc: daniel.vetter@ffwll.ch
Cc: dhowells@redhat.com
Cc: julia.lawall@lip6.fr
Cc: konrad.wilk@oracle.com
Cc: linux-fbdev@vger.kernel.org
Cc: linux-pci@vger.kernel.org
Cc: luto@amacapital.net
Cc: mst@redhat.com
Cc: tomi.valkeinen@ti.com
Cc: toshi.kani@hp.com
Cc: vinod.koul@intel.com
Cc: xen-devel@lists.xensource.com
Link: http://lkml.kernel.org/r/1453516462-4844-1-git-send-email-mcgrof@do-not-panic.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-23 02:34:22 +00:00
|
|
|
dma_free_wc(gem_obj->dev->dev, cma_obj->base.size,
|
|
|
|
cma_obj->vaddr, cma_obj->paddr);
|
2013-02-17 00:57:30 +00:00
|
|
|
} else if (gem_obj->import_attach) {
|
|
|
|
drm_prime_gem_destroy(gem_obj, cma_obj->sgt);
|
|
|
|
}
|
2013-02-17 00:54:26 +00:00
|
|
|
|
|
|
|
drm_gem_object_release(gem_obj);
|
2012-06-27 13:30:18 +00:00
|
|
|
|
|
|
|
kfree(cma_obj);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_free_object);
|
|
|
|
|
2014-11-03 10:48:49 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_dumb_create_internal - create a dumb buffer object
|
|
|
|
* @file_priv: DRM file-private structure to create the dumb buffer for
|
|
|
|
* @drm: DRM device
|
|
|
|
* @args: IOCTL data
|
|
|
|
*
|
|
|
|
* This aligns the pitch and size arguments to the minimum required. This is
|
|
|
|
* an internal helper that can be wrapped by a driver to account for hardware
|
|
|
|
* with more specific alignment requirements. It should not be used directly
|
2016-12-29 20:48:34 +00:00
|
|
|
* as their &drm_driver.dumb_create callback.
|
2014-11-03 10:48:49 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
int drm_gem_cma_dumb_create_internal(struct drm_file *file_priv,
|
|
|
|
struct drm_device *drm,
|
|
|
|
struct drm_mode_create_dumb *args)
|
|
|
|
{
|
|
|
|
unsigned int min_pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
|
|
|
|
if (args->pitch < min_pitch)
|
|
|
|
args->pitch = min_pitch;
|
|
|
|
|
|
|
|
if (args->size < args->pitch * args->height)
|
|
|
|
args->size = args->pitch * args->height;
|
|
|
|
|
|
|
|
cma_obj = drm_gem_cma_create_with_handle(file_priv, drm, args->size,
|
|
|
|
&args->handle);
|
|
|
|
return PTR_ERR_OR_ZERO(cma_obj);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_dumb_create_internal);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_dumb_create - create a dumb buffer object
|
|
|
|
* @file_priv: DRM file-private structure to create the dumb buffer for
|
|
|
|
* @drm: DRM device
|
|
|
|
* @args: IOCTL data
|
|
|
|
*
|
|
|
|
* This function computes the pitch of the dumb buffer and rounds it up to an
|
|
|
|
* integer number of bytes per pixel. Drivers for hardware that doesn't have
|
|
|
|
* any additional restrictions on the pitch can directly use this function as
|
2016-12-29 20:48:34 +00:00
|
|
|
* their &drm_driver.dumb_create callback.
|
2012-06-27 13:30:18 +00:00
|
|
|
*
|
2014-11-03 10:48:49 +00:00
|
|
|
* For hardware with additional restrictions, drivers can adjust the fields
|
|
|
|
* set up by userspace and pass the IOCTL data along to the
|
|
|
|
* drm_gem_cma_dumb_create_internal() function.
|
|
|
|
*
|
2014-11-03 12:56:55 +00:00
|
|
|
* Returns:
|
|
|
|
* 0 on success or a negative error code on failure.
|
2012-06-27 13:30:18 +00:00
|
|
|
*/
|
|
|
|
int drm_gem_cma_dumb_create(struct drm_file *file_priv,
|
2014-11-03 12:56:55 +00:00
|
|
|
struct drm_device *drm,
|
|
|
|
struct drm_mode_create_dumb *args)
|
2012-06-27 13:30:18 +00:00
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
|
2014-11-03 10:48:49 +00:00
|
|
|
args->pitch = DIV_ROUND_UP(args->width * args->bpp, 8);
|
|
|
|
args->size = args->pitch * args->height;
|
2012-06-27 13:30:18 +00:00
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
cma_obj = drm_gem_cma_create_with_handle(file_priv, drm, args->size,
|
|
|
|
&args->handle);
|
2013-07-15 10:34:46 +00:00
|
|
|
return PTR_ERR_OR_ZERO(cma_obj);
|
2012-06-27 13:30:18 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_dumb_create);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_dumb_map_offset - return the fake mmap offset for a CMA GEM
|
|
|
|
* object
|
|
|
|
* @file_priv: DRM file-private structure containing the GEM object
|
|
|
|
* @drm: DRM device
|
|
|
|
* @handle: GEM object handle
|
|
|
|
* @offset: return location for the fake mmap offset
|
|
|
|
*
|
|
|
|
* This function look up an object by its handle and returns the fake mmap
|
|
|
|
* offset associated with it. Drivers using the CMA helpers should set this
|
2016-12-29 20:48:34 +00:00
|
|
|
* as their &drm_driver.dumb_map_offset callback.
|
2014-11-03 12:56:55 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 on success or a negative error code on failure.
|
2012-06-27 13:30:18 +00:00
|
|
|
*/
|
|
|
|
int drm_gem_cma_dumb_map_offset(struct drm_file *file_priv,
|
2014-11-03 12:56:55 +00:00
|
|
|
struct drm_device *drm, u32 handle,
|
|
|
|
u64 *offset)
|
2012-06-27 13:30:18 +00:00
|
|
|
{
|
|
|
|
struct drm_gem_object *gem_obj;
|
|
|
|
|
2016-05-09 10:04:54 +00:00
|
|
|
gem_obj = drm_gem_object_lookup(file_priv, handle);
|
2012-06-27 13:30:18 +00:00
|
|
|
if (!gem_obj) {
|
2014-11-03 12:56:55 +00:00
|
|
|
dev_err(drm->dev, "failed to lookup GEM object\n");
|
2012-06-27 13:30:18 +00:00
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2013-07-24 19:07:52 +00:00
|
|
|
*offset = drm_vma_node_offset_addr(&gem_obj->vma_node);
|
2012-06-27 13:30:18 +00:00
|
|
|
|
2015-07-09 21:32:41 +00:00
|
|
|
drm_gem_object_unreference_unlocked(gem_obj);
|
2012-06-27 13:30:18 +00:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_dumb_map_offset);
|
|
|
|
|
|
|
|
const struct vm_operations_struct drm_gem_cma_vm_ops = {
|
|
|
|
.open = drm_gem_vm_open,
|
|
|
|
.close = drm_gem_vm_close,
|
|
|
|
};
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_vm_ops);
|
|
|
|
|
2013-04-16 12:32:34 +00:00
|
|
|
static int drm_gem_cma_mmap_obj(struct drm_gem_cma_object *cma_obj,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
2014-03-02 19:09:48 +00:00
|
|
|
/*
|
|
|
|
* Clear the VM_PFNMAP flag that was set by drm_gem_mmap(), and set the
|
|
|
|
* vm_pgoff (used as a fake buffer offset by DRM) to 0 as we want to map
|
|
|
|
* the whole buffer.
|
|
|
|
*/
|
|
|
|
vma->vm_flags &= ~VM_PFNMAP;
|
|
|
|
vma->vm_pgoff = 0;
|
|
|
|
|
dma, mm/pat: Rename dma_*_writecombine() to dma_*_wc()
Rename dma_*_writecombine() to dma_*_wc(), so that the naming
is coherent across the various write-combining APIs. Keep the
old names for compatibility for a while, these can be removed
at a later time. A guard is left to enable backporting of the
rename, and later remove of the old mapping defines seemlessly.
Build tested successfully with allmodconfig.
The following Coccinelle SmPL patch was used for this simple
transformation:
@ rename_dma_alloc_writecombine @
expression dev, size, dma_addr, gfp;
@@
-dma_alloc_writecombine(dev, size, dma_addr, gfp)
+dma_alloc_wc(dev, size, dma_addr, gfp)
@ rename_dma_free_writecombine @
expression dev, size, cpu_addr, dma_addr;
@@
-dma_free_writecombine(dev, size, cpu_addr, dma_addr)
+dma_free_wc(dev, size, cpu_addr, dma_addr)
@ rename_dma_mmap_writecombine @
expression dev, vma, cpu_addr, dma_addr, size;
@@
-dma_mmap_writecombine(dev, vma, cpu_addr, dma_addr, size)
+dma_mmap_wc(dev, vma, cpu_addr, dma_addr, size)
We also keep the old names as compatibility helpers, and
guard against their definition to make backporting easier.
Generated-by: Coccinelle SmPL
Suggested-by: Ingo Molnar <mingo@kernel.org>
Signed-off-by: Luis R. Rodriguez <mcgrof@suse.com>
Cc: Linus Torvalds <torvalds@linux-foundation.org>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: airlied@linux.ie
Cc: akpm@linux-foundation.org
Cc: benh@kernel.crashing.org
Cc: bhelgaas@google.com
Cc: bp@suse.de
Cc: dan.j.williams@intel.com
Cc: daniel.vetter@ffwll.ch
Cc: dhowells@redhat.com
Cc: julia.lawall@lip6.fr
Cc: konrad.wilk@oracle.com
Cc: linux-fbdev@vger.kernel.org
Cc: linux-pci@vger.kernel.org
Cc: luto@amacapital.net
Cc: mst@redhat.com
Cc: tomi.valkeinen@ti.com
Cc: toshi.kani@hp.com
Cc: vinod.koul@intel.com
Cc: xen-devel@lists.xensource.com
Link: http://lkml.kernel.org/r/1453516462-4844-1-git-send-email-mcgrof@do-not-panic.com
Signed-off-by: Ingo Molnar <mingo@kernel.org>
2016-01-23 02:34:22 +00:00
|
|
|
ret = dma_mmap_wc(cma_obj->base.dev->dev, vma, cma_obj->vaddr,
|
|
|
|
cma_obj->paddr, vma->vm_end - vma->vm_start);
|
2013-04-16 12:32:34 +00:00
|
|
|
if (ret)
|
|
|
|
drm_gem_vm_close(vma);
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_mmap - memory-map a CMA GEM object
|
|
|
|
* @filp: file object
|
|
|
|
* @vma: VMA for the area to be mapped
|
|
|
|
*
|
|
|
|
* This function implements an augmented version of the GEM DRM file mmap
|
|
|
|
* operation for CMA objects: In addition to the usual GEM VMA setup it
|
|
|
|
* immediately faults in the entire object instead of using on-demaind
|
|
|
|
* faulting. Drivers which employ the CMA helpers should use this function
|
|
|
|
* as their ->mmap() handler in the DRM device file's file_operations
|
|
|
|
* structure.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 on success or a negative error code on failure.
|
2012-06-27 13:30:18 +00:00
|
|
|
*/
|
|
|
|
int drm_gem_cma_mmap(struct file *filp, struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
2013-04-16 12:32:34 +00:00
|
|
|
struct drm_gem_object *gem_obj;
|
2012-06-27 13:30:18 +00:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = drm_gem_mmap(filp, vma);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
gem_obj = vma->vm_private_data;
|
|
|
|
cma_obj = to_drm_gem_cma_obj(gem_obj);
|
|
|
|
|
2013-04-16 12:32:34 +00:00
|
|
|
return drm_gem_cma_mmap_obj(cma_obj, vma);
|
2012-06-27 13:30:18 +00:00
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_mmap);
|
|
|
|
|
2017-01-04 09:12:57 +00:00
|
|
|
#ifndef CONFIG_MMU
|
|
|
|
/**
|
|
|
|
* drm_gem_cma_get_unmapped_area - propose address for mapping in noMMU cases
|
|
|
|
* @filp: file object
|
|
|
|
* @addr: memory address
|
|
|
|
* @len: buffer size
|
|
|
|
* @pgoff: page offset
|
|
|
|
* @flags: memory flags
|
|
|
|
*
|
|
|
|
* This function is used in noMMU platforms to propose address mapping
|
|
|
|
* for a given buffer.
|
|
|
|
* It's intended to be used as a direct handler for the struct
|
|
|
|
* &file_operations.get_unmapped_area operation.
|
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* mapping address on success or a negative error code on failure.
|
|
|
|
*/
|
|
|
|
unsigned long drm_gem_cma_get_unmapped_area(struct file *filp,
|
|
|
|
unsigned long addr,
|
|
|
|
unsigned long len,
|
|
|
|
unsigned long pgoff,
|
|
|
|
unsigned long flags)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
struct drm_gem_object *obj = NULL;
|
|
|
|
struct drm_file *priv = filp->private_data;
|
|
|
|
struct drm_device *dev = priv->minor->dev;
|
|
|
|
struct drm_vma_offset_node *node;
|
|
|
|
|
|
|
|
if (drm_device_is_unplugged(dev))
|
|
|
|
return -ENODEV;
|
|
|
|
|
|
|
|
drm_vma_offset_lock_lookup(dev->vma_offset_manager);
|
|
|
|
node = drm_vma_offset_exact_lookup_locked(dev->vma_offset_manager,
|
|
|
|
pgoff,
|
|
|
|
len >> PAGE_SHIFT);
|
|
|
|
if (likely(node)) {
|
|
|
|
obj = container_of(node, struct drm_gem_object, vma_node);
|
|
|
|
/*
|
|
|
|
* When the object is being freed, after it hits 0-refcnt it
|
|
|
|
* proceeds to tear down the object. In the process it will
|
|
|
|
* attempt to remove the VMA offset and so acquire this
|
|
|
|
* mgr->vm_lock. Therefore if we find an object with a 0-refcnt
|
|
|
|
* that matches our range, we know it is in the process of being
|
|
|
|
* destroyed and will be freed as soon as we release the lock -
|
|
|
|
* so we have to check for the 0-refcnted object and treat it as
|
|
|
|
* invalid.
|
|
|
|
*/
|
|
|
|
if (!kref_get_unless_zero(&obj->refcount))
|
|
|
|
obj = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
drm_vma_offset_unlock_lookup(dev->vma_offset_manager);
|
|
|
|
|
|
|
|
if (!obj)
|
|
|
|
return -EINVAL;
|
|
|
|
|
|
|
|
if (!drm_vma_node_is_allowed(node, priv)) {
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
return -EACCES;
|
|
|
|
}
|
|
|
|
|
|
|
|
cma_obj = to_drm_gem_cma_obj(obj);
|
|
|
|
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
|
|
|
return cma_obj->vaddr ? (unsigned long)cma_obj->vaddr : -EINVAL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_get_unmapped_area);
|
|
|
|
#endif
|
|
|
|
|
2012-12-10 16:46:43 +00:00
|
|
|
#ifdef CONFIG_DEBUG_FS
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_describe - describe a CMA GEM object for debugfs
|
|
|
|
* @cma_obj: CMA GEM object
|
|
|
|
* @m: debugfs file handle
|
|
|
|
*
|
|
|
|
* This function can be used to dump a human-readable representation of the
|
|
|
|
* CMA GEM object into a synthetic file.
|
|
|
|
*/
|
|
|
|
void drm_gem_cma_describe(struct drm_gem_cma_object *cma_obj,
|
|
|
|
struct seq_file *m)
|
2012-12-10 16:46:43 +00:00
|
|
|
{
|
|
|
|
struct drm_gem_object *obj = &cma_obj->base;
|
2013-07-24 19:07:52 +00:00
|
|
|
uint64_t off;
|
2012-12-10 16:46:43 +00:00
|
|
|
|
2013-07-24 19:07:52 +00:00
|
|
|
off = drm_vma_node_start(&obj->vma_node);
|
2012-12-10 16:46:43 +00:00
|
|
|
|
2015-05-04 14:16:19 +00:00
|
|
|
seq_printf(m, "%2d (%2d) %08llx %pad %p %zu",
|
2016-11-14 16:29:48 +00:00
|
|
|
obj->name, kref_read(&obj->refcount),
|
2014-03-04 18:10:17 +00:00
|
|
|
off, &cma_obj->paddr, cma_obj->vaddr, obj->size);
|
2012-12-10 16:46:43 +00:00
|
|
|
|
|
|
|
seq_printf(m, "\n");
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_describe);
|
|
|
|
#endif
|
2013-02-17 00:57:30 +00:00
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_prime_get_sg_table - provide a scatter/gather table of pinned
|
|
|
|
* pages for a CMA GEM object
|
|
|
|
* @obj: GEM object
|
|
|
|
*
|
|
|
|
* This function exports a scatter/gather table suitable for PRIME usage by
|
|
|
|
* calling the standard DMA mapping API. Drivers using the CMA helpers should
|
2016-12-29 20:48:34 +00:00
|
|
|
* set this as their &drm_driver.gem_prime_get_sg_table callback.
|
2014-11-03 12:56:55 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to the scatter/gather table of pinned pages or NULL on failure.
|
|
|
|
*/
|
2013-06-28 05:24:54 +00:00
|
|
|
struct sg_table *drm_gem_cma_prime_get_sg_table(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj = to_drm_gem_cma_obj(obj);
|
|
|
|
struct sg_table *sgt;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
sgt = kzalloc(sizeof(*sgt), GFP_KERNEL);
|
|
|
|
if (!sgt)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
ret = dma_get_sgtable(obj->dev->dev, sgt, cma_obj->vaddr,
|
|
|
|
cma_obj->paddr, obj->size);
|
|
|
|
if (ret < 0)
|
|
|
|
goto out;
|
|
|
|
|
|
|
|
return sgt;
|
|
|
|
|
|
|
|
out:
|
|
|
|
kfree(sgt);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_prime_get_sg_table);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_prime_import_sg_table - produce a CMA GEM object from another
|
|
|
|
* driver's scatter/gather table of pinned pages
|
|
|
|
* @dev: device to import into
|
|
|
|
* @attach: DMA-BUF attachment
|
|
|
|
* @sgt: scatter/gather table of pinned pages
|
|
|
|
*
|
|
|
|
* This function imports a scatter/gather table exported via DMA-BUF by
|
|
|
|
* another driver. Imported buffers must be physically contiguous in memory
|
|
|
|
* (i.e. the scatter/gather table must contain a single entry). Drivers that
|
2016-12-29 20:48:34 +00:00
|
|
|
* use the CMA helpers should set this as their
|
|
|
|
* &drm_driver.gem_prime_import_sg_table callback.
|
2014-11-03 12:56:55 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* A pointer to a newly created GEM object or an ERR_PTR-encoded negative
|
|
|
|
* error code on failure.
|
|
|
|
*/
|
2013-06-28 05:24:54 +00:00
|
|
|
struct drm_gem_object *
|
2014-01-09 10:03:14 +00:00
|
|
|
drm_gem_cma_prime_import_sg_table(struct drm_device *dev,
|
|
|
|
struct dma_buf_attachment *attach,
|
2013-06-28 05:24:54 +00:00
|
|
|
struct sg_table *sgt)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
|
|
|
|
if (sgt->nents != 1)
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
|
|
|
|
/* Create a CMA GEM buffer. */
|
2014-01-09 10:03:14 +00:00
|
|
|
cma_obj = __drm_gem_cma_create(dev, attach->dmabuf->size);
|
2013-06-28 05:24:54 +00:00
|
|
|
if (IS_ERR(cma_obj))
|
2014-07-03 12:03:33 +00:00
|
|
|
return ERR_CAST(cma_obj);
|
2013-06-28 05:24:54 +00:00
|
|
|
|
|
|
|
cma_obj->paddr = sg_dma_address(sgt->sgl);
|
|
|
|
cma_obj->sgt = sgt;
|
|
|
|
|
2014-01-09 10:03:14 +00:00
|
|
|
DRM_DEBUG_PRIME("dma_addr = %pad, size = %zu\n", &cma_obj->paddr, attach->dmabuf->size);
|
2013-06-28 05:24:54 +00:00
|
|
|
|
|
|
|
return &cma_obj->base;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_prime_import_sg_table);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_prime_mmap - memory-map an exported CMA GEM object
|
|
|
|
* @obj: GEM object
|
|
|
|
* @vma: VMA for the area to be mapped
|
|
|
|
*
|
|
|
|
* This function maps a buffer imported via DRM PRIME into a userspace
|
|
|
|
* process's address space. Drivers that use the CMA helpers should set this
|
2016-12-29 20:48:34 +00:00
|
|
|
* as their &drm_driver.gem_prime_mmap callback.
|
2014-11-03 12:56:55 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* 0 on success or a negative error code on failure.
|
|
|
|
*/
|
2013-06-28 05:24:54 +00:00
|
|
|
int drm_gem_cma_prime_mmap(struct drm_gem_object *obj,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
ret = drm_gem_mmap_obj(obj, obj->size, vma);
|
|
|
|
if (ret < 0)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
cma_obj = to_drm_gem_cma_obj(obj);
|
|
|
|
return drm_gem_cma_mmap_obj(cma_obj, vma);
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_prime_mmap);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_prime_vmap - map a CMA GEM object into the kernel's virtual
|
|
|
|
* address space
|
|
|
|
* @obj: GEM object
|
|
|
|
*
|
|
|
|
* This function maps a buffer exported via DRM PRIME into the kernel's
|
|
|
|
* virtual address space. Since the CMA buffers are already mapped into the
|
|
|
|
* kernel virtual address space this simply returns the cached virtual
|
|
|
|
* address. Drivers using the CMA helpers should set this as their DRM
|
2016-12-29 20:48:34 +00:00
|
|
|
* driver's &drm_driver.gem_prime_vmap callback.
|
2014-11-03 12:56:55 +00:00
|
|
|
*
|
|
|
|
* Returns:
|
|
|
|
* The kernel virtual address of the CMA GEM object's backing store.
|
|
|
|
*/
|
2013-06-28 05:24:54 +00:00
|
|
|
void *drm_gem_cma_prime_vmap(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
struct drm_gem_cma_object *cma_obj = to_drm_gem_cma_obj(obj);
|
|
|
|
|
|
|
|
return cma_obj->vaddr;
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_prime_vmap);
|
|
|
|
|
2014-11-03 12:56:55 +00:00
|
|
|
/**
|
|
|
|
* drm_gem_cma_prime_vunmap - unmap a CMA GEM object from the kernel's virtual
|
|
|
|
* address space
|
|
|
|
* @obj: GEM object
|
|
|
|
* @vaddr: kernel virtual address where the CMA GEM object was mapped
|
|
|
|
*
|
|
|
|
* This function removes a buffer exported via DRM PRIME from the kernel's
|
|
|
|
* virtual address space. This is a no-op because CMA buffers cannot be
|
|
|
|
* unmapped from kernel space. Drivers using the CMA helpers should set this
|
2016-12-29 20:48:34 +00:00
|
|
|
* as their &drm_driver.gem_prime_vunmap callback.
|
2014-11-03 12:56:55 +00:00
|
|
|
*/
|
2013-06-28 05:24:54 +00:00
|
|
|
void drm_gem_cma_prime_vunmap(struct drm_gem_object *obj, void *vaddr)
|
|
|
|
{
|
|
|
|
/* Nothing to do */
|
|
|
|
}
|
|
|
|
EXPORT_SYMBOL_GPL(drm_gem_cma_prime_vunmap);
|