struct drm_gem_object *exynos_dmabuf_prime_import(struct drm_device *drm_dev,
struct dma_buf *dma_buf)
{
struct dma_buf_attachment *attach;
struct sg_table *sgt;
struct scatterlist *sgl;
struct exynos_drm_gem_obj *exynos_gem_obj;
struct exynos_drm_gem_buf *buffer;
struct page *page;
int ret;
DRM_DEBUG_PRIME("%s\n", __FILE__);
/* is this one of own objects? */
if (dma_buf->ops == &exynos_dmabuf_ops) {
struct drm_gem_object *obj;
exynos_gem_obj = dma_buf->priv;
obj = &exynos_gem_obj->base;
/* is it from our device? */
if (obj->dev == drm_dev) {
drm_gem_object_reference(obj);
return obj;
}
}
attach = dma_buf_attach(dma_buf, drm_dev->dev);
if (IS_ERR(attach))
return ERR_PTR(-EINVAL);
sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
if (IS_ERR(sgt)) {
ret = PTR_ERR(sgt);
goto err_buf_detach;
}
buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
if (!buffer) {
DRM_ERROR("failed to allocate exynos_drm_gem_buf.\n");
ret = -ENOMEM;
goto err_unmap_attach;
}
buffer->pages = kzalloc(sizeof(*page) * sgt->nents, GFP_KERNEL);
if (!buffer->pages) {
DRM_ERROR("failed to allocate pages.\n");
ret = -ENOMEM;
goto err_free_buffer;
}
exynos_gem_obj = exynos_drm_gem_init(drm_dev, dma_buf->size);
if (!exynos_gem_obj) {
ret = -ENOMEM;
goto err_free_pages;
}
sgl = sgt->sgl;
if (sgt->nents == 1) {
buffer->dma_addr = sg_dma_address(sgt->sgl);
buffer->size = sg_dma_len(sgt->sgl);
} else {
unsigned int i = 0;
buffer->dma_addr = sg_dma_address(sgl);
while (i < sgt->nents) {
buffer->pages[i] = sg_page(sgl);
buffer->size += sg_dma_len(sgl);
sgl = sg_next(sgl);
i++;
}
}
exynos_gem_obj->buffer = buffer;
buffer->sgt = sgt;
exynos_gem_obj->base.import_attach = attach;
/* register buffer information to private buffer manager. */
ret = register_buf_to_priv_mgr(exynos_gem_obj,
&exynos_gem_obj->priv_handle,
&exynos_gem_obj->priv_id);
if (ret < 0)
goto err_release_gem;
DRM_DEBUG_PRIME("ump id = %d, dma_addr = 0x%x, size = 0x%lx\n",
exynos_gem_obj->priv_id,
buffer->dma_addr,
buffer->size);
return &exynos_gem_obj->base;
err_release_gem:
drm_gem_object_release(&exynos_gem_obj->base);
kfree(exynos_gem_obj);
exynos_gem_obj = NULL;
err_free_pages:
kfree(buffer->pages);
buffer->pages = NULL;
err_free_buffer:
kfree(buffer);
buffer = NULL;
err_unmap_attach:
dma_buf_unmap_attachment(attach, sgt, DMA_BIDIRECTIONAL);
err_buf_detach:
dma_buf_detach(dma_buf, attach);
return ERR_PTR(ret);
}
int exynos_dmabuf_prime_fd_to_handle(struct drm_device *drm_dev,
struct drm_file *file,
int prime_fd, unsigned int *handle)
{
struct drm_exynos_file_private *file_priv = file->driver_priv;
struct dma_buf_attachment *attach;
struct dma_buf *dmabuf;
struct sg_table *sgt;
struct exynos_drm_gem_obj *exynos_gem_obj;
struct exynos_drm_gem_buf *buffer;
int ret;
DRM_DEBUG_KMS("%s\n", __FILE__);
ret = mutex_lock_interruptible(&drm_dev->struct_mutex);
if (ret < 0)
return ret;
dmabuf = dma_buf_get(prime_fd);
if (IS_ERR(dmabuf)) {
ret = PTR_ERR(dmabuf);
goto out;
}
/*
* if there is same dmabuf as the one to prime_fd
* in file_priv->prime list then return the handle.
*
* Note:
* but if the prime_fd from user belongs to another process
* then there couldn't be the dmabuf in file_priv->prime list
* because file_priv is unique to process.
*/
ret = drm_prime_lookup_fd_handle_mapping(&file_priv->prime,
dmabuf, handle);
if (!ret) {
/* drop reference we got above. */
dma_buf_put(dmabuf);
goto out;
}
attach = dma_buf_attach(dmabuf, drm_dev->dev);
if (IS_ERR(attach)) {
ret = PTR_ERR(attach);
goto fail_put;
}
sgt = dma_buf_map_attachment(attach, DMA_BIDIRECTIONAL);
if (IS_ERR(sgt)) {
ret = PTR_ERR(sgt);
goto fail_detach;
}
buffer = kzalloc(sizeof(*buffer), GFP_KERNEL);
if (!buffer) {
DRM_ERROR("failed to allocate exynos_drm_gem_buf.\n");
ret = -ENOMEM;
goto fail_unmap;
}
exynos_gem_obj = exynos_drm_gem_init(drm_dev, dmabuf->size);
if (!exynos_gem_obj) {
ret = -ENOMEM;
goto fail_unmap;
}
ret = drm_gem_handle_create(file, &exynos_gem_obj->base, handle);
if (ret < 0)
goto fail_handle;
/* consider physically non-continuous memory with IOMMU. */
buffer->dma_addr = sg_dma_address(sgt->sgl);
buffer->size = sg_dma_len(sgt->sgl);
buffer->sgt = sgt;
/*
* import(fd to handle) means that the physical memory region
* from the sgt is being shared with others so shared_refcount
* should be 1.
*/
atomic_set(&buffer->shared_refcount, 1);
exynos_gem_obj->base.import_attach = attach;
ret = drm_prime_insert_fd_handle_mapping(&file_priv->prime,
dmabuf, *handle);
if (ret < 0)
goto fail_handle;
/* register buffer information to private buffer manager. */
ret = register_buf_to_priv_mgr(exynos_gem_obj,
&exynos_gem_obj->priv_handle,
&exynos_gem_obj->priv_id);
if (ret < 0) {
drm_prime_remove_fd_handle_mapping(&file_priv->prime, dmabuf);
goto fail_handle;
}
DRM_DEBUG_KMS("fd = %d, handle = %d, dma_addr = 0x%x, size = 0x%lx\n",
prime_fd, *handle, buffer->dma_addr, buffer->size);
drm_gem_object_unreference(&exynos_gem_obj->base);
mutex_unlock(&drm_dev->struct_mutex);
return 0;
fail_handle:
drm_gem_object_unreference(&exynos_gem_obj->base);
kfree(buffer);
drm_gem_object_release(&exynos_gem_obj->base);
kfree(exynos_gem_obj);
fail_unmap:
dma_buf_unmap_attachment(attach, sgt);
fail_detach:
dma_buf_detach(dmabuf, attach);
fail_put:
dma_buf_put(dmabuf);
out:
mutex_unlock(&drm_dev->struct_mutex);
return ret;
}
