// SPDX-License-Identifier: GPL-2.0
/*
 * Copyright (c) 2021 Rockchip Electronics Co. Ltd.
 */

#include <linux/slab.h>
#include <linux/dma-buf.h>
#undef CONFIG_DMABUF_CACHE
#include <linux/dma-buf-cache.h>

struct dma_buf_cache_list {
	struct list_head head;
	struct mutex lock;
};

struct dma_buf_cache {
	struct list_head list;
	struct dma_buf_attachment *attach;
	enum dma_data_direction direction;
	struct sg_table *sg_table;
};

static int dma_buf_cache_destructor(struct dma_buf *dmabuf, void *dtor_data)
{
	struct dma_buf_cache_list *data;
	struct dma_buf_cache *cache, *tmp;

	data = dmabuf->dtor_data;

	mutex_lock(&data->lock);
	list_for_each_entry_safe(cache, tmp, &data->head, list) {
		if (!IS_ERR_OR_NULL(cache->sg_table))
			dma_buf_unmap_attachment(cache->attach,
						 cache->sg_table,
						 cache->direction);

		dma_buf_detach(dmabuf, cache->attach);
		list_del(&cache->list);
		kfree(cache);

	}
	mutex_unlock(&data->lock);

	kfree(data);
	return 0;
}

static struct dma_buf_cache *
dma_buf_cache_get_cache(struct dma_buf_attachment *attach)
{
	struct dma_buf_cache_list *data;
	struct dma_buf_cache *cache;
	struct dma_buf *dmabuf = attach->dmabuf;

	if (dmabuf->dtor != dma_buf_cache_destructor)
		return NULL;

	data = dmabuf->dtor_data;

	mutex_lock(&data->lock);
	list_for_each_entry(cache, &data->head, list) {
		if (cache->attach == attach) {
			mutex_unlock(&data->lock);
			return cache;
		}
	}
	mutex_unlock(&data->lock);

	return NULL;
}

void dma_buf_cache_detach(struct dma_buf *dmabuf,
			  struct dma_buf_attachment *attach)
{
	struct dma_buf_cache *cache;

	cache = dma_buf_cache_get_cache(attach);
	if (!cache)
		dma_buf_detach(dmabuf, attach);
}
EXPORT_SYMBOL(dma_buf_cache_detach);

struct dma_buf_attachment *dma_buf_cache_attach(struct dma_buf *dmabuf,
						struct device *dev)
{
	struct dma_buf_attachment *attach;
	struct dma_buf_cache_list *data;
	struct dma_buf_cache *cache;

	if (!dmabuf->dtor) {
		data = kzalloc(sizeof(*data), GFP_KERNEL);
		if (!data)
			return ERR_PTR(-ENOMEM);

		mutex_init(&data->lock);
		INIT_LIST_HEAD(&data->head);

		dma_buf_set_destructor(dmabuf, dma_buf_cache_destructor, data);
	}

	if (dmabuf->dtor && dmabuf->dtor != dma_buf_cache_destructor)
		return dma_buf_attach(dmabuf, dev);

	data = dmabuf->dtor_data;

	mutex_lock(&data->lock);
	list_for_each_entry(cache, &data->head, list) {
		if (cache->attach->dev == dev) {
			/* Already attached */
			mutex_unlock(&data->lock);
			return cache->attach;
		}
	}
	mutex_unlock(&data->lock);

	cache = kzalloc(sizeof(*cache), GFP_KERNEL);
	if (!cache)
		return ERR_PTR(-ENOMEM);

	/* Cache attachment */
	attach = dma_buf_attach(dmabuf, dev);
	if (IS_ERR_OR_NULL(attach)) {
		kfree(cache);
		return attach;
	}

	cache->attach = attach;
	mutex_lock(&data->lock);
	list_add(&cache->list, &data->head);
	mutex_unlock(&data->lock);

	return cache->attach;
}
EXPORT_SYMBOL(dma_buf_cache_attach);

void dma_buf_cache_unmap_attachment(struct dma_buf_attachment *attach,
				    struct sg_table *sg_table,
				    enum dma_data_direction direction)
{
	struct dma_buf_cache *cache;

	cache = dma_buf_cache_get_cache(attach);
	if (!cache)
		dma_buf_unmap_attachment(attach, sg_table, direction);
}
EXPORT_SYMBOL(dma_buf_cache_unmap_attachment);

struct sg_table *dma_buf_cache_map_attachment(struct dma_buf_attachment *attach,
					      enum dma_data_direction direction)
{
	struct dma_buf_cache *cache;

	cache = dma_buf_cache_get_cache(attach);
	if (!cache)
		return dma_buf_map_attachment(attach, direction);

	if (cache->sg_table) {
		/* Already mapped */
		if (cache->direction == direction)
			return cache->sg_table;

		/* Different directions */
		dma_buf_unmap_attachment(attach, cache->sg_table,
					 cache->direction);

	}

	/* Cache map */
	cache->sg_table = dma_buf_map_attachment(attach, direction);
	cache->direction = direction;

	return cache->sg_table;
}
EXPORT_SYMBOL(dma_buf_cache_map_attachment);