2011-10-04 04:19:01 -06:00
|
|
|
/* exynos_drm_gem.c
|
|
|
|
*
|
|
|
|
* Copyright (c) 2011 Samsung Electronics Co., Ltd.
|
|
|
|
* Author: Inki Dae <inki.dae@samsung.com>
|
|
|
|
*
|
2012-12-17 10:30:17 -07:00
|
|
|
* 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.
|
2011-10-04 04:19:01 -06:00
|
|
|
*/
|
|
|
|
|
2012-10-02 11:01:07 -06:00
|
|
|
#include <drm/drmP.h>
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-03-16 03:47:05 -06:00
|
|
|
#include <linux/shmem_fs.h>
|
2011-10-04 04:19:01 -06:00
|
|
|
#include <drm/exynos_drm.h>
|
|
|
|
|
|
|
|
#include "exynos_drm_drv.h"
|
|
|
|
#include "exynos_drm_gem.h"
|
|
|
|
#include "exynos_drm_buf.h"
|
|
|
|
|
|
|
|
static unsigned int convert_to_vm_err_msg(int msg)
|
|
|
|
{
|
|
|
|
unsigned int out_msg;
|
|
|
|
|
|
|
|
switch (msg) {
|
|
|
|
case 0:
|
|
|
|
case -ERESTARTSYS:
|
|
|
|
case -EINTR:
|
|
|
|
out_msg = VM_FAULT_NOPAGE;
|
|
|
|
break;
|
|
|
|
|
|
|
|
case -ENOMEM:
|
|
|
|
out_msg = VM_FAULT_OOM;
|
|
|
|
break;
|
|
|
|
|
|
|
|
default:
|
|
|
|
out_msg = VM_FAULT_SIGBUS;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
return out_msg;
|
|
|
|
}
|
|
|
|
|
2012-04-03 06:27:58 -06:00
|
|
|
static int check_gem_flags(unsigned int flags)
|
2012-03-16 03:47:05 -06:00
|
|
|
{
|
2012-04-03 06:27:58 -06:00
|
|
|
if (flags & ~(EXYNOS_BO_MASK)) {
|
|
|
|
DRM_ERROR("invalid flags.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-04-23 04:26:34 -06:00
|
|
|
static void update_vm_cache_attr(struct exynos_drm_gem_obj *obj,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
DRM_DEBUG_KMS("flags = 0x%x\n", obj->flags);
|
|
|
|
|
|
|
|
/* non-cachable as default. */
|
|
|
|
if (obj->flags & EXYNOS_BO_CACHABLE)
|
|
|
|
vma->vm_page_prot = vm_get_page_prot(vma->vm_flags);
|
|
|
|
else if (obj->flags & EXYNOS_BO_WC)
|
|
|
|
vma->vm_page_prot =
|
|
|
|
pgprot_writecombine(vm_get_page_prot(vma->vm_flags));
|
|
|
|
else
|
|
|
|
vma->vm_page_prot =
|
|
|
|
pgprot_noncached(vm_get_page_prot(vma->vm_flags));
|
|
|
|
}
|
|
|
|
|
2012-04-03 06:27:58 -06:00
|
|
|
static unsigned long roundup_gem_size(unsigned long size, unsigned int flags)
|
|
|
|
{
|
2012-10-20 08:53:42 -06:00
|
|
|
/* TODO */
|
2012-03-16 03:47:05 -06:00
|
|
|
|
2012-10-20 08:53:42 -06:00
|
|
|
return roundup(size, PAGE_SIZE);
|
2012-03-16 03:47:05 -06:00
|
|
|
}
|
|
|
|
|
2012-10-20 08:53:42 -06:00
|
|
|
static int exynos_drm_gem_map_buf(struct drm_gem_object *obj,
|
2012-03-16 03:47:05 -06:00
|
|
|
struct vm_area_struct *vma,
|
|
|
|
unsigned long f_vaddr,
|
|
|
|
pgoff_t page_offset)
|
|
|
|
{
|
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
|
|
|
|
struct exynos_drm_gem_buf *buf = exynos_gem_obj->buffer;
|
2012-11-05 08:34:29 -07:00
|
|
|
struct scatterlist *sgl;
|
2012-03-16 03:47:05 -06:00
|
|
|
unsigned long pfn;
|
2012-11-05 08:34:29 -07:00
|
|
|
int i;
|
2012-03-16 03:47:05 -06:00
|
|
|
|
2012-11-20 03:32:56 -07:00
|
|
|
if (!buf->sgt)
|
|
|
|
return -EINTR;
|
|
|
|
|
|
|
|
if (page_offset >= (buf->size >> PAGE_SHIFT)) {
|
|
|
|
DRM_ERROR("invalid page offset\n");
|
|
|
|
return -EINVAL;
|
2012-11-05 08:34:29 -07:00
|
|
|
}
|
2012-03-16 03:47:05 -06:00
|
|
|
|
2012-11-20 03:32:56 -07:00
|
|
|
sgl = buf->sgt->sgl;
|
|
|
|
for_each_sg(buf->sgt->sgl, sgl, buf->sgt->nents, i) {
|
|
|
|
if (page_offset < (sgl->length >> PAGE_SHIFT))
|
|
|
|
break;
|
|
|
|
page_offset -= (sgl->length >> PAGE_SHIFT);
|
|
|
|
}
|
|
|
|
|
|
|
|
pfn = __phys_to_pfn(sg_phys(sgl)) + page_offset;
|
|
|
|
|
2012-03-16 03:47:05 -06:00
|
|
|
return vm_insert_mixed(vma, f_vaddr, pfn);
|
|
|
|
}
|
|
|
|
|
2011-12-12 22:39:13 -07:00
|
|
|
static int exynos_drm_gem_handle_create(struct drm_gem_object *obj,
|
|
|
|
struct drm_file *file_priv,
|
|
|
|
unsigned int *handle)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* 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, obj, handle);
|
|
|
|
if (ret)
|
2011-12-12 22:39:13 -07:00
|
|
|
return ret;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("gem handle = 0x%x\n", *handle);
|
|
|
|
|
|
|
|
/* drop reference from allocate - handle holds it now. */
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
2011-12-12 22:39:13 -07:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exynos_drm_gem_destroy(struct exynos_drm_gem_obj *exynos_gem_obj)
|
|
|
|
{
|
|
|
|
struct drm_gem_object *obj;
|
2012-04-23 04:26:34 -06:00
|
|
|
struct exynos_drm_gem_buf *buf;
|
2011-12-12 22:39:13 -07:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
obj = &exynos_gem_obj->base;
|
2012-04-23 04:26:34 -06:00
|
|
|
buf = exynos_gem_obj->buffer;
|
2011-12-12 22:39:13 -07:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("handle count = %d\n", atomic_read(&obj->handle_count));
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-06-12 01:52:54 -06:00
|
|
|
/*
|
|
|
|
* do not release memory region from exporter.
|
|
|
|
*
|
|
|
|
* the region will be released by exporter
|
|
|
|
* once dmabuf's refcount becomes 0.
|
|
|
|
*/
|
|
|
|
if (obj->import_attach)
|
|
|
|
goto out;
|
|
|
|
|
2012-10-20 08:53:42 -06:00
|
|
|
exynos_drm_free_buf(obj->dev, exynos_gem_obj->flags, buf);
|
2012-03-16 03:47:05 -06:00
|
|
|
|
2012-06-12 01:52:54 -06:00
|
|
|
out:
|
2012-04-23 04:26:34 -06:00
|
|
|
exynos_drm_fini_buf(obj->dev, buf);
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_gem_obj->buffer = NULL;
|
2011-12-12 22:39:13 -07:00
|
|
|
|
|
|
|
if (obj->map_list.map)
|
|
|
|
drm_gem_free_mmap_offset(obj);
|
|
|
|
|
|
|
|
/* release file pointer to gem object. */
|
2011-10-04 04:19:01 -06:00
|
|
|
drm_gem_object_release(obj);
|
|
|
|
|
|
|
|
kfree(exynos_gem_obj);
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_gem_obj = NULL;
|
2011-12-12 22:39:13 -07:00
|
|
|
}
|
|
|
|
|
2012-04-23 06:01:28 -06:00
|
|
|
struct exynos_drm_gem_obj *exynos_drm_gem_init(struct drm_device *dev,
|
2011-12-12 22:39:13 -07:00
|
|
|
unsigned long size)
|
|
|
|
{
|
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
exynos_gem_obj = kzalloc(sizeof(*exynos_gem_obj), GFP_KERNEL);
|
|
|
|
if (!exynos_gem_obj) {
|
|
|
|
DRM_ERROR("failed to allocate exynos gem object\n");
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_gem_obj->size = size;
|
2011-12-12 22:39:13 -07:00
|
|
|
obj = &exynos_gem_obj->base;
|
|
|
|
|
|
|
|
ret = drm_gem_object_init(dev, obj, size);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to initialize gem object\n");
|
|
|
|
kfree(exynos_gem_obj);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("created file object = 0x%x\n", (unsigned int)obj->filp);
|
|
|
|
|
|
|
|
return exynos_gem_obj;
|
2011-10-04 04:19:01 -06:00
|
|
|
}
|
|
|
|
|
2011-11-11 22:51:23 -07:00
|
|
|
struct exynos_drm_gem_obj *exynos_drm_gem_create(struct drm_device *dev,
|
2012-03-16 03:47:05 -06:00
|
|
|
unsigned int flags,
|
|
|
|
unsigned long size)
|
2011-11-11 22:51:23 -07:00
|
|
|
{
|
2011-12-12 22:39:13 -07:00
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
2012-03-16 03:47:05 -06:00
|
|
|
struct exynos_drm_gem_buf *buf;
|
|
|
|
int ret;
|
2011-11-11 22:51:23 -07:00
|
|
|
|
2012-04-03 06:27:58 -06:00
|
|
|
if (!size) {
|
|
|
|
DRM_ERROR("invalid size.\n");
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
size = roundup_gem_size(size, flags);
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
2011-11-11 22:51:23 -07:00
|
|
|
|
2012-04-03 06:27:58 -06:00
|
|
|
ret = check_gem_flags(flags);
|
|
|
|
if (ret)
|
|
|
|
return ERR_PTR(ret);
|
2012-03-16 03:47:05 -06:00
|
|
|
|
|
|
|
buf = exynos_drm_init_buf(dev, size);
|
|
|
|
if (!buf)
|
2011-12-12 22:20:23 -07:00
|
|
|
return ERR_PTR(-ENOMEM);
|
2011-11-11 22:51:23 -07:00
|
|
|
|
2011-12-12 22:39:13 -07:00
|
|
|
exynos_gem_obj = exynos_drm_gem_init(dev, size);
|
|
|
|
if (!exynos_gem_obj) {
|
2012-03-16 03:47:05 -06:00
|
|
|
ret = -ENOMEM;
|
2012-04-03 06:27:58 -06:00
|
|
|
goto err_fini_buf;
|
2011-11-11 22:51:23 -07:00
|
|
|
}
|
|
|
|
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_gem_obj->buffer = buf;
|
|
|
|
|
|
|
|
/* set memory type and cache attribute from user side. */
|
|
|
|
exynos_gem_obj->flags = flags;
|
|
|
|
|
2012-10-20 08:53:42 -06:00
|
|
|
ret = exynos_drm_alloc_buf(dev, buf, flags);
|
|
|
|
if (ret < 0) {
|
|
|
|
drm_gem_object_release(&exynos_gem_obj->base);
|
|
|
|
goto err_fini_buf;
|
2012-03-16 03:47:05 -06:00
|
|
|
}
|
2011-11-11 22:51:23 -07:00
|
|
|
|
|
|
|
return exynos_gem_obj;
|
2012-04-03 06:27:58 -06:00
|
|
|
|
|
|
|
err_fini_buf:
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_drm_fini_buf(dev, buf);
|
|
|
|
return ERR_PTR(ret);
|
2011-11-11 22:51:23 -07:00
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
int exynos_drm_gem_create_ioctl(struct drm_device *dev, void *data,
|
2011-12-12 22:20:23 -07:00
|
|
|
struct drm_file *file_priv)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
struct drm_exynos_gem_create *args = data;
|
2011-12-12 22:20:23 -07:00
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
2011-12-12 22:39:13 -07:00
|
|
|
int ret;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2011-11-11 22:51:23 -07:00
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
|
2011-10-04 04:19:01 -06:00
|
|
|
if (IS_ERR(exynos_gem_obj))
|
|
|
|
return PTR_ERR(exynos_gem_obj);
|
|
|
|
|
2011-12-12 22:39:13 -07:00
|
|
|
ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
|
|
|
|
&args->handle);
|
|
|
|
if (ret) {
|
|
|
|
exynos_drm_gem_destroy(exynos_gem_obj);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-11-03 22:53:24 -06:00
|
|
|
dma_addr_t *exynos_drm_gem_get_dma_addr(struct drm_device *dev,
|
2012-03-16 03:47:06 -06:00
|
|
|
unsigned int gem_handle,
|
2012-11-03 22:53:24 -06:00
|
|
|
struct drm_file *filp)
|
2012-03-16 03:47:06 -06:00
|
|
|
{
|
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
|
2012-11-03 22:53:24 -06:00
|
|
|
obj = drm_gem_object_lookup(dev, filp, gem_handle);
|
2012-03-16 03:47:06 -06:00
|
|
|
if (!obj) {
|
|
|
|
DRM_ERROR("failed to lookup gem object.\n");
|
|
|
|
return ERR_PTR(-EINVAL);
|
|
|
|
}
|
|
|
|
|
|
|
|
exynos_gem_obj = to_exynos_gem_obj(obj);
|
|
|
|
|
|
|
|
return &exynos_gem_obj->buffer->dma_addr;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exynos_drm_gem_put_dma_addr(struct drm_device *dev,
|
|
|
|
unsigned int gem_handle,
|
2012-11-03 22:53:24 -06:00
|
|
|
struct drm_file *filp)
|
2012-03-16 03:47:06 -06:00
|
|
|
{
|
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
|
2012-11-03 22:53:24 -06:00
|
|
|
obj = drm_gem_object_lookup(dev, filp, gem_handle);
|
2012-03-16 03:47:06 -06:00
|
|
|
if (!obj) {
|
|
|
|
DRM_ERROR("failed to lookup gem object.\n");
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
exynos_gem_obj = to_exynos_gem_obj(obj);
|
|
|
|
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* decrease obj->refcount one more time because we has already
|
|
|
|
* increased it at exynos_drm_gem_get_dma_addr().
|
|
|
|
*/
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
int exynos_drm_gem_map_offset_ioctl(struct drm_device *dev, void *data,
|
2011-12-12 22:20:23 -07:00
|
|
|
struct drm_file *file_priv)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
struct drm_exynos_gem_map_off *args = data;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("handle = 0x%x, offset = 0x%lx\n",
|
|
|
|
args->handle, (unsigned long)args->offset);
|
|
|
|
|
|
|
|
if (!(dev->driver->driver_features & DRIVER_GEM)) {
|
|
|
|
DRM_ERROR("does not support GEM.\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
return exynos_drm_gem_dumb_map_offset(file_priv, dev, args->handle,
|
|
|
|
&args->offset);
|
|
|
|
}
|
|
|
|
|
2012-11-08 05:52:54 -07:00
|
|
|
static struct drm_file *exynos_drm_find_drm_file(struct drm_device *drm_dev,
|
|
|
|
struct file *filp)
|
|
|
|
{
|
|
|
|
struct drm_file *file_priv;
|
|
|
|
|
|
|
|
mutex_lock(&drm_dev->struct_mutex);
|
|
|
|
|
|
|
|
/* find current process's drm_file from filelist. */
|
|
|
|
list_for_each_entry(file_priv, &drm_dev->filelist, lhead) {
|
|
|
|
if (file_priv->filp == filp) {
|
|
|
|
mutex_unlock(&drm_dev->struct_mutex);
|
|
|
|
return file_priv;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&drm_dev->struct_mutex);
|
|
|
|
WARN_ON(1);
|
|
|
|
|
|
|
|
return ERR_PTR(-EFAULT);
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
static int exynos_drm_gem_mmap_buffer(struct file *filp,
|
2011-12-12 22:20:23 -07:00
|
|
|
struct vm_area_struct *vma)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
struct drm_gem_object *obj = filp->private_data;
|
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj = to_exynos_gem_obj(obj);
|
2012-11-08 05:52:54 -07:00
|
|
|
struct drm_device *drm_dev = obj->dev;
|
2011-11-11 23:23:32 -07:00
|
|
|
struct exynos_drm_gem_buf *buffer;
|
2012-11-08 05:52:54 -07:00
|
|
|
struct drm_file *file_priv;
|
2012-10-20 08:53:42 -06:00
|
|
|
unsigned long vm_size;
|
2012-11-08 05:52:54 -07:00
|
|
|
int ret;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
mm: kill vma flag VM_RESERVED and mm->reserved_vm counter
A long time ago, in v2.4, VM_RESERVED kept swapout process off VMA,
currently it lost original meaning but still has some effects:
| effect | alternative flags
-+------------------------+---------------------------------------------
1| account as reserved_vm | VM_IO
2| skip in core dump | VM_IO, VM_DONTDUMP
3| do not merge or expand | VM_IO, VM_DONTEXPAND, VM_HUGETLB, VM_PFNMAP
4| do not mlock | VM_IO, VM_DONTEXPAND, VM_HUGETLB, VM_PFNMAP
This patch removes reserved_vm counter from mm_struct. Seems like nobody
cares about it, it does not exported into userspace directly, it only
reduces total_vm showed in proc.
Thus VM_RESERVED can be replaced with VM_IO or pair VM_DONTEXPAND | VM_DONTDUMP.
remap_pfn_range() and io_remap_pfn_range() set VM_IO|VM_DONTEXPAND|VM_DONTDUMP.
remap_vmalloc_range() set VM_DONTEXPAND | VM_DONTDUMP.
[akpm@linux-foundation.org: drivers/vfio/pci/vfio_pci.c fixup]
Signed-off-by: Konstantin Khlebnikov <khlebnikov@openvz.org>
Cc: Alexander Viro <viro@zeniv.linux.org.uk>
Cc: Carsten Otte <cotte@de.ibm.com>
Cc: Chris Metcalf <cmetcalf@tilera.com>
Cc: Cyrill Gorcunov <gorcunov@openvz.org>
Cc: Eric Paris <eparis@redhat.com>
Cc: H. Peter Anvin <hpa@zytor.com>
Cc: Hugh Dickins <hughd@google.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Morris <james.l.morris@oracle.com>
Cc: Jason Baron <jbaron@redhat.com>
Cc: Kentaro Takeda <takedakn@nttdata.co.jp>
Cc: Matt Helsley <matthltc@us.ibm.com>
Cc: Nick Piggin <npiggin@kernel.dk>
Cc: Oleg Nesterov <oleg@redhat.com>
Cc: Peter Zijlstra <a.p.zijlstra@chello.nl>
Cc: Robert Richter <robert.richter@amd.com>
Cc: Suresh Siddha <suresh.b.siddha@intel.com>
Cc: Tetsuo Handa <penguin-kernel@I-love.SAKURA.ne.jp>
Cc: Venkatesh Pallipadi <venki@google.com>
Acked-by: Linus Torvalds <torvalds@linux-foundation.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2012-10-08 17:29:02 -06:00
|
|
|
vma->vm_flags |= VM_IO | VM_DONTEXPAND | VM_DONTDUMP;
|
2012-11-08 05:52:54 -07:00
|
|
|
vma->vm_private_data = obj;
|
|
|
|
vma->vm_ops = drm_dev->driver->gem_vm_ops;
|
|
|
|
|
|
|
|
/* restore it to driver's fops. */
|
|
|
|
filp->f_op = fops_get(drm_dev->driver->fops);
|
|
|
|
|
|
|
|
file_priv = exynos_drm_find_drm_file(drm_dev, filp);
|
|
|
|
if (IS_ERR(file_priv))
|
|
|
|
return PTR_ERR(file_priv);
|
|
|
|
|
|
|
|
/* restore it to drm_file. */
|
|
|
|
filp->private_data = file_priv;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-04-23 04:26:34 -06:00
|
|
|
update_vm_cache_attr(exynos_gem_obj, vma);
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-10-20 08:53:42 -06:00
|
|
|
vm_size = vma->vm_end - vma->vm_start;
|
2012-03-16 03:47:05 -06:00
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
/*
|
2011-11-11 23:23:32 -07:00
|
|
|
* a buffer contains information to physically continuous memory
|
2011-10-04 04:19:01 -06:00
|
|
|
* allocated by user request or at framebuffer creation.
|
|
|
|
*/
|
2011-11-11 23:23:32 -07:00
|
|
|
buffer = exynos_gem_obj->buffer;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
/* check if user-requested size is valid. */
|
2011-11-11 23:23:32 -07:00
|
|
|
if (vm_size > buffer->size)
|
2011-10-04 04:19:01 -06:00
|
|
|
return -EINVAL;
|
|
|
|
|
2012-12-07 01:51:27 -07:00
|
|
|
ret = dma_mmap_attrs(drm_dev->dev, vma, buffer->pages,
|
2012-10-20 08:53:42 -06:00
|
|
|
buffer->dma_addr, buffer->size,
|
|
|
|
&buffer->dma_attrs);
|
2012-11-08 05:52:54 -07:00
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to mmap.\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* take a reference to this mapping of the object. And this reference
|
|
|
|
* is unreferenced by the corresponding vm_close call.
|
|
|
|
*/
|
|
|
|
drm_gem_object_reference(obj);
|
|
|
|
|
|
|
|
mutex_lock(&drm_dev->struct_mutex);
|
|
|
|
drm_vm_open_locked(drm_dev, vma);
|
|
|
|
mutex_unlock(&drm_dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
2011-10-04 04:19:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
static const struct file_operations exynos_drm_gem_fops = {
|
|
|
|
.mmap = exynos_drm_gem_mmap_buffer,
|
|
|
|
};
|
|
|
|
|
|
|
|
int exynos_drm_gem_mmap_ioctl(struct drm_device *dev, void *data,
|
2011-12-12 22:20:23 -07:00
|
|
|
struct drm_file *file_priv)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
struct drm_exynos_gem_mmap *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
unsigned int addr;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
if (!(dev->driver->driver_features & DRIVER_GEM)) {
|
|
|
|
DRM_ERROR("does not support GEM.\n");
|
|
|
|
return -ENODEV;
|
|
|
|
}
|
|
|
|
|
|
|
|
obj = drm_gem_object_lookup(dev, file_priv, args->handle);
|
|
|
|
if (!obj) {
|
|
|
|
DRM_ERROR("failed to lookup gem object.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
2012-11-08 05:52:54 -07:00
|
|
|
/*
|
|
|
|
* Set specific mmper's fops. And it will be restored by
|
|
|
|
* exynos_drm_gem_mmap_buffer to dev->driver->fops.
|
|
|
|
* This is used to call specific mapper temporarily.
|
|
|
|
*/
|
|
|
|
file_priv->filp->f_op = &exynos_drm_gem_fops;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-11-08 05:52:54 -07:00
|
|
|
/*
|
|
|
|
* Set gem object to private_data so that specific mmaper
|
|
|
|
* can get the gem object. And it will be restored by
|
|
|
|
* exynos_drm_gem_mmap_buffer to drm_file.
|
|
|
|
*/
|
|
|
|
file_priv->filp->private_data = obj;
|
|
|
|
|
|
|
|
addr = vm_mmap(file_priv->filp, 0, args->size,
|
2011-10-04 04:19:01 -06:00
|
|
|
PROT_READ | PROT_WRITE, MAP_SHARED, 0);
|
|
|
|
|
|
|
|
drm_gem_object_unreference_unlocked(obj);
|
|
|
|
|
2012-11-08 05:52:54 -07:00
|
|
|
if (IS_ERR((void *)addr)) {
|
|
|
|
file_priv->filp->private_data = file_priv;
|
2011-10-04 04:19:01 -06:00
|
|
|
return PTR_ERR((void *)addr);
|
2012-11-08 05:52:54 -07:00
|
|
|
}
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
args->mapped = addr;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("mapped = 0x%lx\n", (unsigned long)args->mapped);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2012-05-04 00:51:17 -06:00
|
|
|
int exynos_drm_gem_get_ioctl(struct drm_device *dev, void *data,
|
|
|
|
struct drm_file *file_priv)
|
|
|
|
{ struct exynos_drm_gem_obj *exynos_gem_obj;
|
|
|
|
struct drm_exynos_gem_info *args = data;
|
|
|
|
struct drm_gem_object *obj;
|
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
obj = drm_gem_object_lookup(dev, file_priv, args->handle);
|
|
|
|
if (!obj) {
|
|
|
|
DRM_ERROR("failed to lookup gem object.\n");
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
exynos_gem_obj = to_exynos_gem_obj(obj);
|
|
|
|
|
|
|
|
args->flags = exynos_gem_obj->flags;
|
|
|
|
args->size = exynos_gem_obj->size;
|
|
|
|
|
|
|
|
drm_gem_object_unreference(obj);
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
drm/exynos: add userptr feature for g2d module
This patch adds userptr feautre for G2D module.
The userptr means user space address allocated by malloc().
And the purpose of this feature is to make G2D's dma able
to access the user space region.
To user this feature, user should flag G2D_BUF_USRPTR to
offset variable of struct drm_exynos_g2d_cmd and fill
struct drm_exynos_g2d_userptr with user space address
and size for it and then should set a pointer to
drm_exynos_g2d_userptr object to data variable of struct
drm_exynos_g2d_cmd. The last bit of offset variable is used
to check if the cmdlist's buffer type is userptr or not.
If userptr, the g2d driver gets user space address and size
and then gets pages through get_user_pages().
(another case is counted as gem handle)
Below is sample codes:
static void set_cmd(struct drm_exynos_g2d_cmd *cmd,
unsigned long offset, unsigned long data)
{
cmd->offset = offset;
cmd->data = data;
}
static int solid_fill_test(int x, int y, unsigned long userptr)
{
struct drm_exynos_g2d_cmd cmd_gem[5];
struct drm_exynos_g2d_userptr g2d_userptr;
unsigned int gem_nr = 0;
...
g2d_userptr.userptr = userptr;
g2d_userptr.size = x * y * 4;
set_cmd(&cmd_gem[gem_nr++], DST_BASE_ADDR_REG |
G2D_BUF_USERPTR,
(unsigned long)&g2d_userptr);
...
}
int main(int argc, char **argv)
{
unsigned long addr;
...
addr = malloc(x * y * 4);
...
solid_fill_test(x, y, addr);
...
}
And next, the pages are mapped with iommu table and the device
address is set to cmdlist so that G2D's dma can access it.
As you may know, the pages from get_user_pages() are pinned.
In other words, they CAN NOT be migrated and also swapped out.
So the dma access would be safe.
But the use of userptr feature has performance overhead so
this patch also has memory pool to the userptr feature.
Please, assume that user sends cmdlist filled with userptr
and size every time to g2d driver, and the get_user_pages
funcion will be called every time.
The memory pool has maximum 64MB size and the userptr that
user had ever sent, is holded in the memory pool.
This meaning is that if the userptr from user is same as one
in the memory pool, device address to the userptr in the memory
pool is set to cmdlist.
And last, the pages from get_user_pages() will be freed once
user calls free() and the dma access is completed. Actually,
get_user_pages() takes 2 reference counts if the user process
has never accessed user region allocated by malloc(). Then, if
the user calls free(), the page reference count becomes 1 and
becomes 0 with put_page() call. And the reverse holds as well.
This means how the pages backed are used by dma and freed.
This patch is based on "drm/exynos: add iommu support for g2d",
https://patchwork.kernel.org/patch/1629481/
Signed-off-by: Inki Dae <inki.dae@samsung.com>
Signed-off-by: Kyungmin Park <kyungmin.park@samsung.com>
2012-11-04 06:48:52 -07:00
|
|
|
struct vm_area_struct *exynos_gem_get_vma(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
struct vm_area_struct *vma_copy;
|
|
|
|
|
|
|
|
vma_copy = kmalloc(sizeof(*vma_copy), GFP_KERNEL);
|
|
|
|
if (!vma_copy)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (vma->vm_ops && vma->vm_ops->open)
|
|
|
|
vma->vm_ops->open(vma);
|
|
|
|
|
|
|
|
if (vma->vm_file)
|
|
|
|
get_file(vma->vm_file);
|
|
|
|
|
|
|
|
memcpy(vma_copy, vma, sizeof(*vma));
|
|
|
|
|
|
|
|
vma_copy->vm_mm = NULL;
|
|
|
|
vma_copy->vm_next = NULL;
|
|
|
|
vma_copy->vm_prev = NULL;
|
|
|
|
|
|
|
|
return vma_copy;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exynos_gem_put_vma(struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
if (!vma)
|
|
|
|
return;
|
|
|
|
|
|
|
|
if (vma->vm_ops && vma->vm_ops->close)
|
|
|
|
vma->vm_ops->close(vma);
|
|
|
|
|
|
|
|
if (vma->vm_file)
|
|
|
|
fput(vma->vm_file);
|
|
|
|
|
|
|
|
kfree(vma);
|
|
|
|
}
|
|
|
|
|
|
|
|
int exynos_gem_get_pages_from_userptr(unsigned long start,
|
|
|
|
unsigned int npages,
|
|
|
|
struct page **pages,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
int get_npages;
|
|
|
|
|
|
|
|
/* the memory region mmaped with VM_PFNMAP. */
|
|
|
|
if (vma_is_io(vma)) {
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < npages; ++i, start += PAGE_SIZE) {
|
|
|
|
unsigned long pfn;
|
|
|
|
int ret = follow_pfn(vma, start, &pfn);
|
|
|
|
if (ret)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
pages[i] = pfn_to_page(pfn);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (i != npages) {
|
|
|
|
DRM_ERROR("failed to get user_pages.\n");
|
|
|
|
return -EINVAL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
get_npages = get_user_pages(current, current->mm, start,
|
|
|
|
npages, 1, 1, pages, NULL);
|
|
|
|
get_npages = max(get_npages, 0);
|
|
|
|
if (get_npages != npages) {
|
|
|
|
DRM_ERROR("failed to get user_pages.\n");
|
|
|
|
while (get_npages)
|
|
|
|
put_page(pages[--get_npages]);
|
|
|
|
return -EFAULT;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exynos_gem_put_pages_to_userptr(struct page **pages,
|
|
|
|
unsigned int npages,
|
|
|
|
struct vm_area_struct *vma)
|
|
|
|
{
|
|
|
|
if (!vma_is_io(vma)) {
|
|
|
|
unsigned int i;
|
|
|
|
|
|
|
|
for (i = 0; i < npages; i++) {
|
|
|
|
set_page_dirty_lock(pages[i]);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* undo the reference we took when populating
|
|
|
|
* the table.
|
|
|
|
*/
|
|
|
|
put_page(pages[i]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int exynos_gem_map_sgt_with_dma(struct drm_device *drm_dev,
|
|
|
|
struct sg_table *sgt,
|
|
|
|
enum dma_data_direction dir)
|
|
|
|
{
|
|
|
|
int nents;
|
|
|
|
|
|
|
|
mutex_lock(&drm_dev->struct_mutex);
|
|
|
|
|
|
|
|
nents = dma_map_sg(drm_dev->dev, sgt->sgl, sgt->nents, dir);
|
|
|
|
if (!nents) {
|
|
|
|
DRM_ERROR("failed to map sgl with dma.\n");
|
|
|
|
mutex_unlock(&drm_dev->struct_mutex);
|
|
|
|
return nents;
|
|
|
|
}
|
|
|
|
|
|
|
|
mutex_unlock(&drm_dev->struct_mutex);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
void exynos_gem_unmap_sgt_from_dma(struct drm_device *drm_dev,
|
|
|
|
struct sg_table *sgt,
|
|
|
|
enum dma_data_direction dir)
|
|
|
|
{
|
|
|
|
dma_unmap_sg(drm_dev->dev, sgt->sgl, sgt->nents, dir);
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
int exynos_drm_gem_init_object(struct drm_gem_object *obj)
|
|
|
|
{
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-12-12 22:20:23 -07:00
|
|
|
void exynos_drm_gem_free_object(struct drm_gem_object *obj)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
2012-04-23 06:01:28 -06:00
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
|
|
|
struct exynos_drm_gem_buf *buf;
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
2012-04-23 06:01:28 -06:00
|
|
|
exynos_gem_obj = to_exynos_gem_obj(obj);
|
|
|
|
buf = exynos_gem_obj->buffer;
|
|
|
|
|
|
|
|
if (obj->import_attach)
|
|
|
|
drm_prime_gem_destroy(obj, buf->sgt);
|
|
|
|
|
2011-12-12 22:39:13 -07:00
|
|
|
exynos_drm_gem_destroy(to_exynos_gem_obj(obj));
|
2011-10-04 04:19:01 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
int exynos_drm_gem_dumb_create(struct drm_file *file_priv,
|
2011-12-12 22:20:23 -07:00
|
|
|
struct drm_device *dev,
|
|
|
|
struct drm_mode_create_dumb *args)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
2011-12-12 22:39:13 -07:00
|
|
|
int ret;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* alocate memory to be used for framebuffer.
|
|
|
|
* - this callback would be called by user application
|
|
|
|
* with DRM_IOCTL_MODE_CREATE_DUMB command.
|
|
|
|
*/
|
|
|
|
|
2012-06-28 20:49:45 -06:00
|
|
|
args->pitch = args->width * ((args->bpp + 7) / 8);
|
2012-08-17 00:24:03 -06:00
|
|
|
args->size = args->pitch * args->height;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-03-16 03:47:05 -06:00
|
|
|
exynos_gem_obj = exynos_drm_gem_create(dev, args->flags, args->size);
|
2011-10-04 04:19:01 -06:00
|
|
|
if (IS_ERR(exynos_gem_obj))
|
|
|
|
return PTR_ERR(exynos_gem_obj);
|
|
|
|
|
2011-12-12 22:39:13 -07:00
|
|
|
ret = exynos_drm_gem_handle_create(&exynos_gem_obj->base, file_priv,
|
|
|
|
&args->handle);
|
|
|
|
if (ret) {
|
|
|
|
exynos_drm_gem_destroy(exynos_gem_obj);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
int exynos_drm_gem_dumb_map_offset(struct drm_file *file_priv,
|
2011-12-12 22:20:23 -07:00
|
|
|
struct drm_device *dev, uint32_t handle,
|
|
|
|
uint64_t *offset)
|
2011-10-04 04:19:01 -06:00
|
|
|
{
|
|
|
|
struct drm_gem_object *obj;
|
2011-12-12 22:32:24 -07:00
|
|
|
int ret = 0;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* get offset of memory allocated for drm framebuffer.
|
|
|
|
* - this callback would be called by user application
|
|
|
|
* with DRM_IOCTL_MODE_MAP_DUMB command.
|
|
|
|
*/
|
|
|
|
|
|
|
|
obj = drm_gem_object_lookup(dev, file_priv, handle);
|
|
|
|
if (!obj) {
|
|
|
|
DRM_ERROR("failed to lookup gem object.\n");
|
2011-12-12 22:32:24 -07:00
|
|
|
ret = -EINVAL;
|
|
|
|
goto unlock;
|
2011-10-04 04:19:01 -06:00
|
|
|
}
|
|
|
|
|
2012-05-16 09:08:55 -06:00
|
|
|
if (!obj->map_list.map) {
|
|
|
|
ret = drm_gem_create_mmap_offset(obj);
|
2011-12-12 22:32:24 -07:00
|
|
|
if (ret)
|
|
|
|
goto out;
|
|
|
|
}
|
2011-10-04 04:19:01 -06:00
|
|
|
|
2012-05-16 09:08:55 -06:00
|
|
|
*offset = (u64)obj->map_list.hash.key << PAGE_SHIFT;
|
2011-10-04 04:19:01 -06:00
|
|
|
DRM_DEBUG_KMS("offset = 0x%lx\n", (unsigned long)*offset);
|
|
|
|
|
2011-12-12 22:32:24 -07:00
|
|
|
out:
|
|
|
|
drm_gem_object_unreference(obj);
|
|
|
|
unlock:
|
2011-10-04 04:19:01 -06:00
|
|
|
mutex_unlock(&dev->struct_mutex);
|
2011-12-12 22:32:24 -07:00
|
|
|
return ret;
|
2011-10-04 04:19:01 -06:00
|
|
|
}
|
|
|
|
|
2011-12-12 22:20:23 -07:00
|
|
|
int exynos_drm_gem_dumb_destroy(struct drm_file *file_priv,
|
|
|
|
struct drm_device *dev,
|
|
|
|
unsigned int handle)
|
|
|
|
{
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* obj->refcount and obj->handle_count are decreased and
|
|
|
|
* if both them are 0 then exynos_drm_gem_free_object()
|
|
|
|
* would be called by callback to release resources.
|
|
|
|
*/
|
|
|
|
ret = drm_gem_handle_delete(file_priv, handle);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to delete drm_gem_handle.\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
int exynos_drm_gem_fault(struct vm_area_struct *vma, struct vm_fault *vmf)
|
|
|
|
{
|
|
|
|
struct drm_gem_object *obj = vma->vm_private_data;
|
|
|
|
struct drm_device *dev = obj->dev;
|
2012-03-16 03:47:05 -06:00
|
|
|
unsigned long f_vaddr;
|
2011-10-04 04:19:01 -06:00
|
|
|
pgoff_t page_offset;
|
|
|
|
int ret;
|
|
|
|
|
|
|
|
page_offset = ((unsigned long)vmf->virtual_address -
|
|
|
|
vma->vm_start) >> PAGE_SHIFT;
|
2012-03-16 03:47:05 -06:00
|
|
|
f_vaddr = (unsigned long)vmf->virtual_address;
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
mutex_lock(&dev->struct_mutex);
|
|
|
|
|
2012-10-20 08:53:42 -06:00
|
|
|
ret = exynos_drm_gem_map_buf(obj, vma, f_vaddr, page_offset);
|
2012-03-16 03:47:05 -06:00
|
|
|
if (ret < 0)
|
2012-10-20 08:53:42 -06:00
|
|
|
DRM_ERROR("failed to map a buffer with user.\n");
|
2011-10-04 04:19:01 -06:00
|
|
|
|
|
|
|
mutex_unlock(&dev->struct_mutex);
|
|
|
|
|
|
|
|
return convert_to_vm_err_msg(ret);
|
|
|
|
}
|
|
|
|
|
|
|
|
int exynos_drm_gem_mmap(struct file *filp, struct vm_area_struct *vma)
|
|
|
|
{
|
2012-04-23 04:26:34 -06:00
|
|
|
struct exynos_drm_gem_obj *exynos_gem_obj;
|
|
|
|
struct drm_gem_object *obj;
|
2011-10-04 04:19:01 -06:00
|
|
|
int ret;
|
|
|
|
|
|
|
|
DRM_DEBUG_KMS("%s\n", __FILE__);
|
|
|
|
|
|
|
|
/* set vm_area_struct. */
|
|
|
|
ret = drm_gem_mmap(filp, vma);
|
|
|
|
if (ret < 0) {
|
|
|
|
DRM_ERROR("failed to mmap.\n");
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2012-04-23 04:26:34 -06:00
|
|
|
obj = vma->vm_private_data;
|
|
|
|
exynos_gem_obj = to_exynos_gem_obj(obj);
|
|
|
|
|
|
|
|
ret = check_gem_flags(exynos_gem_obj->flags);
|
|
|
|
if (ret) {
|
|
|
|
drm_gem_vm_close(vma);
|
|
|
|
drm_gem_free_mmap_offset(obj);
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
vma->vm_flags &= ~VM_PFNMAP;
|
|
|
|
vma->vm_flags |= VM_MIXEDMAP;
|
|
|
|
|
2012-04-23 04:26:34 -06:00
|
|
|
update_vm_cache_attr(exynos_gem_obj, vma);
|
|
|
|
|
2011-10-04 04:19:01 -06:00
|
|
|
return ret;
|
|
|
|
}
|