blob: 1c5b94989aec071063e9a1a7721c15ce6100bde2 [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0+
/*
* NVIDIA Tegra Video decoder driver
*
* Copyright (C) 2016-2019 GRATE-DRIVER project
*/
#include <linux/dma-buf.h>
#include <linux/iova.h>
#include <linux/kernel.h>
#include <linux/list.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/workqueue.h>
#include <linux/module.h>
#include "vde.h"
MODULE_IMPORT_NS(DMA_BUF);
struct tegra_vde_cache_entry {
enum dma_data_direction dma_dir;
struct dma_buf_attachment *a;
struct delayed_work dwork;
struct tegra_vde *vde;
struct list_head list;
struct sg_table *sgt;
struct iova *iova;
unsigned int refcnt;
};
static void tegra_vde_release_entry(struct tegra_vde_cache_entry *entry)
{
struct dma_buf *dmabuf = entry->a->dmabuf;
WARN_ON_ONCE(entry->refcnt);
if (entry->vde->domain)
tegra_vde_iommu_unmap(entry->vde, entry->iova);
dma_buf_unmap_attachment_unlocked(entry->a, entry->sgt, entry->dma_dir);
dma_buf_detach(dmabuf, entry->a);
dma_buf_put(dmabuf);
list_del(&entry->list);
kfree(entry);
}
static void tegra_vde_delayed_unmap(struct work_struct *work)
{
struct tegra_vde_cache_entry *entry;
struct tegra_vde *vde;
entry = container_of(work, struct tegra_vde_cache_entry,
dwork.work);
vde = entry->vde;
mutex_lock(&vde->map_lock);
tegra_vde_release_entry(entry);
mutex_unlock(&vde->map_lock);
}
int tegra_vde_dmabuf_cache_map(struct tegra_vde *vde,
struct dma_buf *dmabuf,
enum dma_data_direction dma_dir,
struct dma_buf_attachment **ap,
dma_addr_t *addrp)
{
struct dma_buf_attachment *attachment;
struct tegra_vde_cache_entry *entry;
struct device *dev = vde->dev;
struct sg_table *sgt;
struct iova *iova;
int err;
mutex_lock(&vde->map_lock);
list_for_each_entry(entry, &vde->map_list, list) {
if (entry->a->dmabuf != dmabuf)
continue;
if (!cancel_delayed_work(&entry->dwork))
continue;
if (entry->dma_dir != dma_dir)
entry->dma_dir = DMA_BIDIRECTIONAL;
dma_buf_put(dmabuf);
if (vde->domain)
*addrp = iova_dma_addr(&vde->iova, entry->iova);
else
*addrp = sg_dma_address(entry->sgt->sgl);
goto ref;
}
attachment = dma_buf_attach(dmabuf, dev);
if (IS_ERR(attachment)) {
dev_err(dev, "Failed to attach dmabuf\n");
err = PTR_ERR(attachment);
goto err_unlock;
}
sgt = dma_buf_map_attachment_unlocked(attachment, dma_dir);
if (IS_ERR(sgt)) {
dev_err(dev, "Failed to get dmabufs sg_table\n");
err = PTR_ERR(sgt);
goto err_detach;
}
if (!vde->domain && sgt->nents > 1) {
dev_err(dev, "Sparse DMA region is unsupported, please enable IOMMU\n");
err = -EINVAL;
goto err_unmap;
}
entry = kzalloc(sizeof(*entry), GFP_KERNEL);
if (!entry) {
err = -ENOMEM;
goto err_unmap;
}
if (vde->domain) {
err = tegra_vde_iommu_map(vde, sgt, &iova, dmabuf->size);
if (err)
goto err_free;
*addrp = iova_dma_addr(&vde->iova, iova);
} else {
*addrp = sg_dma_address(sgt->sgl);
iova = NULL;
}
INIT_DELAYED_WORK(&entry->dwork, tegra_vde_delayed_unmap);
list_add(&entry->list, &vde->map_list);
entry->dma_dir = dma_dir;
entry->iova = iova;
entry->vde = vde;
entry->sgt = sgt;
entry->a = attachment;
ref:
entry->refcnt++;
*ap = entry->a;
mutex_unlock(&vde->map_lock);
return 0;
err_free:
kfree(entry);
err_unmap:
dma_buf_unmap_attachment_unlocked(attachment, sgt, dma_dir);
err_detach:
dma_buf_detach(dmabuf, attachment);
err_unlock:
mutex_unlock(&vde->map_lock);
return err;
}
void tegra_vde_dmabuf_cache_unmap(struct tegra_vde *vde,
struct dma_buf_attachment *a,
bool release)
{
struct tegra_vde_cache_entry *entry;
mutex_lock(&vde->map_lock);
list_for_each_entry(entry, &vde->map_list, list) {
if (entry->a != a)
continue;
WARN_ON_ONCE(!entry->refcnt);
if (--entry->refcnt == 0) {
if (release)
tegra_vde_release_entry(entry);
else
schedule_delayed_work(&entry->dwork, 5 * HZ);
}
break;
}
mutex_unlock(&vde->map_lock);
}
void tegra_vde_dmabuf_cache_unmap_sync(struct tegra_vde *vde)
{
struct tegra_vde_cache_entry *entry, *tmp;
mutex_lock(&vde->map_lock);
list_for_each_entry_safe(entry, tmp, &vde->map_list, list) {
if (entry->refcnt)
continue;
if (!cancel_delayed_work(&entry->dwork))
continue;
tegra_vde_release_entry(entry);
}
mutex_unlock(&vde->map_lock);
}
void tegra_vde_dmabuf_cache_unmap_all(struct tegra_vde *vde)
{
struct tegra_vde_cache_entry *entry, *tmp;
mutex_lock(&vde->map_lock);
while (!list_empty(&vde->map_list)) {
list_for_each_entry_safe(entry, tmp, &vde->map_list, list) {
if (!cancel_delayed_work(&entry->dwork))
continue;
tegra_vde_release_entry(entry);
}
mutex_unlock(&vde->map_lock);
schedule();
mutex_lock(&vde->map_lock);
}
mutex_unlock(&vde->map_lock);
}