drivers/amvdec_ports/aml_task_chain.c - manifest_repos/media_modules - Git at Google

 /*
 * Copyright (C) 2017 Amlogic, Inc. All rights reserved.
 *
 * 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.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 * Description:
 */

 #include <linux/list.h>
 #include <linux/spinlock.h>

 #include "aml_vcodec_drv.h"
 #include "aml_task_chain.h"

 #define KERNEL_ATRACE_TAG KERNEL_ATRACE_TAG_V4L2
 #include <trace/events/meson_atrace.h>

 struct task_item_name_s {
 	enum task_type_e	type;
 	const u8		*name;
 };

 static const struct task_item_name_s iname[] = {
 	{TASK_TYPE_DEC,		"dec"},
 	{TASK_TYPE_VPP,		"vpp"},
 	{TASK_TYPE_V4L_SINK,	"v4l-sink"},
 	{TASK_TYPE_GE2D,	"ge2d"},
 	{TASK_TYPE_MAX,		"unknown"},
 };

 static const u8 *type_to_name(enum task_type_e type)
 {
 	const u8 *name = "unknown";
 	int i, size = ARRAY_SIZE(iname);

 	for (i = 0; i < size; i++) {
 		if (type == iname[i].type)
 			name = iname[i].name;
 	}

 	return name;
 }

 static struct task_item_s *find_task_item(struct task_chain_s *task,
 					  enum task_type_e type)
 {
 	struct task_item_s *item = NULL;
 	ulong flags;

 	spin_lock_irqsave(&task->slock, flags);

 	if (!list_empty(&task->list_item)) {
 		struct task_item_s *p;

 		list_for_each_entry(p, &task->list_item, node) {
 			if (p->ops->type == type) {
 				item = p;
 				break;
 			}
 		}
 	}

 	if (item)
 		kref_get(&item->ref);

 	spin_unlock_irqrestore(&task->slock, flags);

 	return item;
 }

 static void task_item_release(struct kref *kref);

 static void task_item_vframe_push(struct task_item_s *item, struct vframe_s *vframe)
 {
 	int i = 0;

 	for (i = 0 ; i < 3; i++) {
 		if (item->vframe[i] == NULL) {
 			item->vframe[i] = vframe;
 			break;
 		}
 	}
 }

 static struct vframe_s *task_item_vframe_pop(struct task_item_s *item)
 {
 	struct vframe_s *vframe = NULL;
 	int i = 0;

 	for (i = 0 ; i < 3; i++) {
 		if (item->vframe[i] != NULL) {
 			vframe = item->vframe[i];
 			item->vframe[i] = NULL;
 			break;
 		}
 	}

 	return vframe;
 }

 static struct task_item_s *task_item_get(struct task_chain_s *task,
 				  enum task_type_e type)
 {
 	struct task_item_s *item = NULL;

 	item = find_task_item(task, type);
 	if (!item) {
 		v4l_dbg(task->ctx, V4L_DEBUG_CODEC_ERROR,
 			"TSK(%px):%d get item:%d fail.\n", task, task->id, type);
 	}

 	return item;
 }

 static int task_item_put(struct task_item_s *item)
 {
 	return kref_put(&item->ref, task_item_release);
 }

 static void task_buffer_submit(struct task_chain_s *task,
 			       enum task_type_e type)
 {
 	struct vdec_v4l2_buffer *fb =
 		(struct vdec_v4l2_buffer *)task->obj;
 	struct task_item_s *item = NULL;
 	struct task_item_s *item2 = NULL;
 	struct vframe_s *vf = NULL;

 	item = task_item_get(task, type);
 	if (item) {
 		item->ops->get_vframe(item->caller, &vf);
 		fb->vframe = (void *)vf;
 		task_item_vframe_push(item, vf);
 		item->is_active = false;

 		item2 = task_item_get(task, task->map[0][type]);
 		if (item2) {
 			item2->is_active = true;
 			item2->ops->fill_buffer(task->ctx, fb);

 			v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 				"TSK(%px):%d, vf:%px, phy:%lx, submit %d => %d.\n",
 				task, task->id, vf, fb->m.mem[0].addr,
 				type, task->map[0][type]);

 			task->direction = TASK_DIR_SUBMIT;
 			task_item_put(item2);
 		}
 		task_item_put(item);
 	}
 }

 static void task_buffer_recycle(struct task_chain_s *task,
 			       enum task_type_e type)
 {
 	struct vdec_v4l2_buffer *fb =
 		(struct vdec_v4l2_buffer *)task->obj;
 	struct task_item_s *item = NULL;
 	struct task_item_s *item2 = NULL;

 	item = task_item_get(task, type);
 	if (item) {
 		item->is_active = false;

 		item2 = task_item_get(task, task->map[1][type]);
 		if (item2) {
 			struct vframe_s *vf = NULL;

 			item2->is_active = true;

 			vf = task_item_vframe_pop(item2);
 			item2->ops->put_vframe(item2->caller, vf);

 			v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 				"TSK(%px):%d, vf:%px, phy:%lx, recycle %d => %d.\n",
 				task, task->id, vf, fb->m.mem[0].addr,
 				type, task->map[1][type]);

 			task->direction = TASK_DIR_RECYCLE;
 			task_item_put(item2);
 		}
 		task_item_put(item);
 	}
 }

 void task_chain_show(struct task_chain_s *task)
 {
 	struct task_item_s *item = NULL;
 	char buf[128] = {0};
 	char *pbuf = buf;
 	ulong flags;

 	if (!task || !task->ctx)
 		return;

 	spin_lock_irqsave(&task->slock, flags);

 	if (!list_empty(&task->list_item)) {
 		struct vdec_v4l2_buffer *fb =
 			(struct vdec_v4l2_buffer *)task->obj;

 		list_for_each_entry(item, &task->list_item, node) {
 			pbuf += sprintf(pbuf, "%s(%d)",
 				item->name, item->is_active);
 			if (item->node.next != &task->list_item) {
 				if (task->direction == TASK_DIR_SUBMIT)
 					pbuf += sprintf(pbuf, " ==> ");
 				else
 					pbuf += sprintf(pbuf, " <== ");
 			}
 		}
 		v4l_dbg(task->ctx, V4L_DEBUG_CODEC_PRINFO,
 			"vb:%2d, phy:%lx  %s\n",
 			task->id, fb->m.mem[0].addr, buf);
 	}

 	spin_unlock_irqrestore(&task->slock, flags);
 }
 EXPORT_SYMBOL(task_chain_show);

 static void task_chain_destroy(struct kref *kref)
 {
 	struct task_chain_s *task;

 	task = container_of(kref, struct task_chain_s, ref);

 	task->cur_type = TASK_TYPE_MAX;
 	memset(task->map, 0, sizeof(task->map));

 	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d task chain destroyed.\n", task, task->id);

 	kfree(task);
 }

 static void task_item_release(struct kref *kref)
 {
 	struct task_item_s *item;

 	item = container_of(kref, struct task_item_s, ref);
 	list_del(&item->node);

 	v4l_dbg(item->task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d task item:(%px,%d) released.\n",
 		item->task, item->task->id, item, item->ops->type);

 	kref_put(&item->task->ref, task_chain_destroy);

 	kfree(item);
 }

 void task_chain_clean(struct task_chain_s *task)
 {
 	struct task_item_s *item, *tmp;

 	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d task chain clean.\n", task, task->id);

 	if (!list_empty(&task->list_item)) {
 		list_for_each_entry_safe(item, tmp, &task->list_item, node)
 			kref_put(&item->ref, task_item_release);
 	}
 }
 EXPORT_SYMBOL(task_chain_clean);

 void task_chain_release(struct task_chain_s *task)
 {
 	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d task chain release.\n", task, task->id);

 	kref_put(&task->ref, task_chain_destroy);
 }
 EXPORT_SYMBOL(task_chain_release);

 void task_order_attach(struct task_chain_s *task,
 			 struct task_ops_s *ops,
 			 void *caller)
 {
 	struct task_item_s *item;

 	item = kzalloc(sizeof(struct task_item_s), GFP_ATOMIC);
 	if (!item) {
 		v4l_dbg(task->ctx, V4L_DEBUG_CODEC_ERROR,
 			"TSK(%px):%d alloc item fail.\n", task, task->id);
 		return;
 	}

 	item->task	= task;
 	item->ops	= ops;
 	item->caller	= caller;
 	item->name	= type_to_name(ops->type);
 	kref_init(&item->ref);

 	task->map[0][ops->type] = task->cur_type;
 	task->map[1][task->cur_type] = ops->type;
 	task->cur_type = ops->type;
 	kref_get(&task->ref);

 	list_add(&item->node, &task->list_item);

 	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d attach item:(%px,%d).\n",
 		task, task->id, item, ops->type);
 }
 EXPORT_SYMBOL(task_order_attach);

 void task_chain_update_object(struct task_chain_s *task, void *obj)
 {
 	/*
 	 * Note: have to invoke this funtion
 	 * if the task object has been changed.
 	 */
 	task->obj = obj;

 	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d update task obj:%px.\n",
 		task, task->id, obj);
 }
 EXPORT_SYMBOL(task_chain_update_object);

 int task_chain_init(struct task_chain_s **task_out,
 			    void *v4l_ctx,
 			    void *obj,
 			    int vb_idx)
 {
 	struct task_chain_s *task;

 	task = kzalloc(sizeof(struct task_chain_s), GFP_ATOMIC);
 	if (!task) {
 		v4l_dbg(task->ctx, V4L_DEBUG_CODEC_ERROR,
 			"TSK(%px):%d alloc task fail.\n", task, task->id);
 		return -ENOMEM;
 	}

 	task->id	= vb_idx;
 	task->obj	= obj;
 	task->ctx	= v4l_ctx;
 	kref_init(&task->ref);
 	spin_lock_init(&task->slock);
 	INIT_LIST_HEAD(&task->list_item);

 	task->attach	= task_order_attach;
 	task->submit	= task_buffer_submit;
 	task->recycle	= task_buffer_recycle;

 	*task_out = task;

 	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
 		"TSK(%px):%d task chain creat success.\n", task, task->id);
 	return 0;
 }
 EXPORT_SYMBOL(task_chain_init);
	/*
	* Copyright (C) 2017 Amlogic, Inc. All rights reserved.
	*
	* 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.
	*
	* You should have received a copy of the GNU General Public License along
	* with this program; if not, write to the Free Software Foundation, Inc.,
	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	*
	* Description:
	*/

	#include <linux/list.h>
	#include <linux/spinlock.h>

	#include "aml_vcodec_drv.h"
	#include "aml_task_chain.h"

	#define KERNEL_ATRACE_TAG KERNEL_ATRACE_TAG_V4L2
	#include <trace/events/meson_atrace.h>

	struct task_item_name_s {
	enum task_type_e type;
	const u8 *name;
	};

	static const struct task_item_name_s iname[] = {
	{TASK_TYPE_DEC, "dec"},
	{TASK_TYPE_VPP, "vpp"},
	{TASK_TYPE_V4L_SINK, "v4l-sink"},
	{TASK_TYPE_GE2D, "ge2d"},
	{TASK_TYPE_MAX, "unknown"},
	};

	static const u8 *type_to_name(enum task_type_e type)
	{
	const u8 *name = "unknown";
	int i, size = ARRAY_SIZE(iname);

	for (i = 0; i < size; i++) {
	if (type == iname[i].type)
	name = iname[i].name;
	}

	return name;
	}

	static struct task_item_s find_task_item(struct task_chain_s task,
	enum task_type_e type)
	{
	struct task_item_s *item = NULL;
	ulong flags;

	spin_lock_irqsave(&task->slock, flags);

	if (!list_empty(&task->list_item)) {
	struct task_item_s *p;

	list_for_each_entry(p, &task->list_item, node) {
	if (p->ops->type == type) {
	item = p;
	break;
	}
	}
	}

	if (item)
	kref_get(&item->ref);

	spin_unlock_irqrestore(&task->slock, flags);

	return item;
	}

	static void task_item_release(struct kref *kref);

	static void task_item_vframe_push(struct task_item_s item, struct vframe_s vframe)
	{
	int i = 0;

	for (i = 0 ; i < 3; i++) {
	if (item->vframe[i] == NULL) {
	item->vframe[i] = vframe;
	break;
	}
	}
	}

	static struct vframe_s task_item_vframe_pop(struct task_item_s item)
	{
	struct vframe_s *vframe = NULL;
	int i = 0;

	for (i = 0 ; i < 3; i++) {
	if (item->vframe[i] != NULL) {
	vframe = item->vframe[i];
	item->vframe[i] = NULL;
	break;
	}
	}

	return vframe;
	}

	static struct task_item_s task_item_get(struct task_chain_s task,
	enum task_type_e type)
	{
	struct task_item_s *item = NULL;

	item = find_task_item(task, type);
	if (!item) {
	v4l_dbg(task->ctx, V4L_DEBUG_CODEC_ERROR,
	"TSK(%px):%d get item:%d fail.\n", task, task->id, type);
	}

	return item;
	}

	static int task_item_put(struct task_item_s *item)
	{
	return kref_put(&item->ref, task_item_release);
	}

	static void task_buffer_submit(struct task_chain_s *task,
	enum task_type_e type)
	{
	struct vdec_v4l2_buffer *fb =
	(struct vdec_v4l2_buffer *)task->obj;
	struct task_item_s *item = NULL;
	struct task_item_s *item2 = NULL;
	struct vframe_s *vf = NULL;

	item = task_item_get(task, type);
	if (item) {
	item->ops->get_vframe(item->caller, &vf);
	fb->vframe = (void *)vf;
	task_item_vframe_push(item, vf);
	item->is_active = false;

	item2 = task_item_get(task, task->map[0][type]);
	if (item2) {
	item2->is_active = true;
	item2->ops->fill_buffer(task->ctx, fb);

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d, vf:%px, phy:%lx, submit %d => %d.\n",
	task, task->id, vf, fb->m.mem[0].addr,
	type, task->map[0][type]);

	task->direction = TASK_DIR_SUBMIT;
	task_item_put(item2);
	}
	task_item_put(item);
	}
	}

	static void task_buffer_recycle(struct task_chain_s *task,
	enum task_type_e type)
	{
	struct vdec_v4l2_buffer *fb =
	(struct vdec_v4l2_buffer *)task->obj;
	struct task_item_s *item = NULL;
	struct task_item_s *item2 = NULL;

	item = task_item_get(task, type);
	if (item) {
	item->is_active = false;

	item2 = task_item_get(task, task->map[1][type]);
	if (item2) {
	struct vframe_s *vf = NULL;

	item2->is_active = true;

	vf = task_item_vframe_pop(item2);
	item2->ops->put_vframe(item2->caller, vf);

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d, vf:%px, phy:%lx, recycle %d => %d.\n",
	task, task->id, vf, fb->m.mem[0].addr,
	type, task->map[1][type]);

	task->direction = TASK_DIR_RECYCLE;
	task_item_put(item2);
	}
	task_item_put(item);
	}
	}

	void task_chain_show(struct task_chain_s *task)
	{
	struct task_item_s *item = NULL;
	char buf[128] = {0};
	char *pbuf = buf;
	ulong flags;

	if (!task \|\| !task->ctx)
	return;

	spin_lock_irqsave(&task->slock, flags);

	if (!list_empty(&task->list_item)) {
	struct vdec_v4l2_buffer *fb =
	(struct vdec_v4l2_buffer *)task->obj;

	list_for_each_entry(item, &task->list_item, node) {
	pbuf += sprintf(pbuf, "%s(%d)",
	item->name, item->is_active);
	if (item->node.next != &task->list_item) {
	if (task->direction == TASK_DIR_SUBMIT)
	pbuf += sprintf(pbuf, " ==> ");
	else
	pbuf += sprintf(pbuf, " <== ");
	}
	}
	v4l_dbg(task->ctx, V4L_DEBUG_CODEC_PRINFO,
	"vb:%2d, phy:%lx %s\n",
	task->id, fb->m.mem[0].addr, buf);
	}

	spin_unlock_irqrestore(&task->slock, flags);
	}
	EXPORT_SYMBOL(task_chain_show);

	static void task_chain_destroy(struct kref *kref)
	{
	struct task_chain_s *task;

	task = container_of(kref, struct task_chain_s, ref);

	task->cur_type = TASK_TYPE_MAX;
	memset(task->map, 0, sizeof(task->map));

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d task chain destroyed.\n", task, task->id);

	kfree(task);
	}

	static void task_item_release(struct kref *kref)
	{
	struct task_item_s *item;

	item = container_of(kref, struct task_item_s, ref);
	list_del(&item->node);

	v4l_dbg(item->task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d task item:(%px,%d) released.\n",
	item->task, item->task->id, item, item->ops->type);

	kref_put(&item->task->ref, task_chain_destroy);

	kfree(item);
	}

	void task_chain_clean(struct task_chain_s *task)
	{
	struct task_item_s item, tmp;

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d task chain clean.\n", task, task->id);

	if (!list_empty(&task->list_item)) {
	list_for_each_entry_safe(item, tmp, &task->list_item, node)
	kref_put(&item->ref, task_item_release);
	}
	}
	EXPORT_SYMBOL(task_chain_clean);

	void task_chain_release(struct task_chain_s *task)
	{
	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d task chain release.\n", task, task->id);

	kref_put(&task->ref, task_chain_destroy);
	}
	EXPORT_SYMBOL(task_chain_release);

	void task_order_attach(struct task_chain_s *task,
	struct task_ops_s *ops,
	void *caller)
	{
	struct task_item_s *item;

	item = kzalloc(sizeof(struct task_item_s), GFP_ATOMIC);
	if (!item) {
	v4l_dbg(task->ctx, V4L_DEBUG_CODEC_ERROR,
	"TSK(%px):%d alloc item fail.\n", task, task->id);
	return;
	}

	item->task = task;
	item->ops = ops;
	item->caller = caller;
	item->name = type_to_name(ops->type);
	kref_init(&item->ref);

	task->map[0][ops->type] = task->cur_type;
	task->map[1][task->cur_type] = ops->type;
	task->cur_type = ops->type;
	kref_get(&task->ref);

	list_add(&item->node, &task->list_item);

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d attach item:(%px,%d).\n",
	task, task->id, item, ops->type);
	}
	EXPORT_SYMBOL(task_order_attach);

	void task_chain_update_object(struct task_chain_s task, void obj)
	{
	/*
	* Note: have to invoke this funtion
	* if the task object has been changed.
	*/
	task->obj = obj;

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d update task obj:%px.\n",
	task, task->id, obj);
	}
	EXPORT_SYMBOL(task_chain_update_object);

	int task_chain_init(struct task_chain_s **task_out,
	void *v4l_ctx,
	void *obj,
	int vb_idx)
	{
	struct task_chain_s *task;

	task = kzalloc(sizeof(struct task_chain_s), GFP_ATOMIC);
	if (!task) {
	v4l_dbg(task->ctx, V4L_DEBUG_CODEC_ERROR,
	"TSK(%px):%d alloc task fail.\n", task, task->id);
	return -ENOMEM;
	}

	task->id = vb_idx;
	task->obj = obj;
	task->ctx = v4l_ctx;
	kref_init(&task->ref);
	spin_lock_init(&task->slock);
	INIT_LIST_HEAD(&task->list_item);

	task->attach = task_order_attach;
	task->submit = task_buffer_submit;
	task->recycle = task_buffer_recycle;

	*task_out = task;

	v4l_dbg(task->ctx, V4L_DEBUG_TASK_CHAIN,
	"TSK(%px):%d task chain creat success.\n", task, task->id);
	return 0;
	}
	EXPORT_SYMBOL(task_chain_init);