drivers/media/platform/qcom/venus/hfi.c - linux - Git at Google

 // SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
  * Copyright (C) 2017 Linaro Ltd.
  */
 #include <linux/slab.h>
 #include <linux/mutex.h>
 #include <linux/list.h>
 #include <linux/completion.h>
 #include <linux/platform_device.h>
 #include <linux/videodev2.h>

 #include "core.h"
 #include "hfi.h"
 #include "hfi_cmds.h"
 #include "hfi_venus.h"

 #define TIMEOUT		msecs_to_jiffies(1000)

 static u32 to_codec_type(u32 pixfmt)
 {
 	switch (pixfmt) {
 	case V4L2_PIX_FMT_H264:
 	case V4L2_PIX_FMT_H264_NO_SC:
 		return HFI_VIDEO_CODEC_H264;
 	case V4L2_PIX_FMT_H263:
 		return HFI_VIDEO_CODEC_H263;
 	case V4L2_PIX_FMT_MPEG1:
 		return HFI_VIDEO_CODEC_MPEG1;
 	case V4L2_PIX_FMT_MPEG2:
 		return HFI_VIDEO_CODEC_MPEG2;
 	case V4L2_PIX_FMT_MPEG4:
 		return HFI_VIDEO_CODEC_MPEG4;
 	case V4L2_PIX_FMT_VC1_ANNEX_G:
 	case V4L2_PIX_FMT_VC1_ANNEX_L:
 		return HFI_VIDEO_CODEC_VC1;
 	case V4L2_PIX_FMT_VP8:
 		return HFI_VIDEO_CODEC_VP8;
 	case V4L2_PIX_FMT_VP9:
 		return HFI_VIDEO_CODEC_VP9;
 	case V4L2_PIX_FMT_XVID:
 		return HFI_VIDEO_CODEC_DIVX;
 	case V4L2_PIX_FMT_HEVC:
 		return HFI_VIDEO_CODEC_HEVC;
 	default:
 		return 0;
 	}
 }

 int hfi_core_init(struct venus_core *core)
 {
 	int ret = 0;

 	mutex_lock(&core->lock);

 	if (core->state >= CORE_INIT)
 		goto unlock;

 	reinit_completion(&core->done);

 	ret = core->ops->core_init(core);
 	if (ret)
 		goto unlock;

 	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
 	if (!ret) {
 		ret = -ETIMEDOUT;
 		goto unlock;
 	}

 	ret = 0;

 	if (core->error != HFI_ERR_NONE) {
 		ret = -EIO;
 		goto unlock;
 	}

 	core->state = CORE_INIT;
 unlock:
 	mutex_unlock(&core->lock);
 	return ret;
 }

 int hfi_core_deinit(struct venus_core *core, bool blocking)
 {
 	int ret = 0, empty;

 	mutex_lock(&core->lock);

 	if (core->state == CORE_UNINIT)
 		goto unlock;

 	empty = list_empty(&core->instances);

 	if (!empty && !blocking) {
 		ret = -EBUSY;
 		goto unlock;
 	}

 	if (!empty) {
 		mutex_unlock(&core->lock);
 		wait_var_event(&core->insts_count,
 			       !atomic_read(&core->insts_count));
 		mutex_lock(&core->lock);
 	}

 	if (!core->ops)
 		goto unlock;

 	ret = core->ops->core_deinit(core);

 	if (!ret)
 		core->state = CORE_UNINIT;

 unlock:
 	mutex_unlock(&core->lock);
 	return ret;
 }

 int hfi_core_suspend(struct venus_core *core)
 {
 	if (core->state != CORE_INIT)
 		return 0;

 	return core->ops->suspend(core);
 }

 int hfi_core_resume(struct venus_core *core, bool force)
 {
 	if (!force && core->state != CORE_INIT)
 		return 0;

 	return core->ops->resume(core);
 }

 int hfi_core_trigger_ssr(struct venus_core *core, u32 type)
 {
 	return core->ops->core_trigger_ssr(core, type);
 }

 int hfi_core_ping(struct venus_core *core)
 {
 	int ret;

 	mutex_lock(&core->lock);

 	ret = core->ops->core_ping(core, 0xbeef);
 	if (ret)
 		goto unlock;

 	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
 	if (!ret) {
 		ret = -ETIMEDOUT;
 		goto unlock;
 	}
 	ret = 0;
 	if (core->error != HFI_ERR_NONE)
 		ret = -ENODEV;
 unlock:
 	mutex_unlock(&core->lock);
 	return ret;
 }

 static int wait_session_msg(struct venus_inst *inst)
 {
 	int ret;

 	ret = wait_for_completion_timeout(&inst->done, TIMEOUT);
 	if (!ret)
 		return -ETIMEDOUT;

 	if (inst->error != HFI_ERR_NONE)
 		return -EIO;

 	return 0;
 }

 int hfi_session_create(struct venus_inst *inst, const struct hfi_inst_ops *ops)
 {
 	struct venus_core *core = inst->core;
 	bool max;
 	int ret;

 	if (!ops)
 		return -EINVAL;

 	inst->state = INST_UNINIT;
 	init_completion(&inst->done);
 	inst->ops = ops;

 	mutex_lock(&core->lock);

 	if (test_bit(0, &inst->core->sys_error)) {
 		ret = -EIO;
 		goto unlock;
 	}

 	max = atomic_add_unless(&core->insts_count, 1,
 				core->max_sessions_supported);
 	if (!max) {
 		ret = -EAGAIN;
 	} else {
 		list_add_tail(&inst->list, &core->instances);
 		ret = 0;
 	}

 unlock:
 	mutex_unlock(&core->lock);

 	return ret;
 }
 EXPORT_SYMBOL_GPL(hfi_session_create);

 int hfi_session_init(struct venus_inst *inst, u32 pixfmt)
 {
 	struct venus_core *core = inst->core;
 	const struct hfi_ops *ops = core->ops;
 	int ret;

 	/*
 	 * If core shutdown is in progress or if we are in system
 	 * recovery, return an error as during system error recovery
 	 * session_init() can't pass successfully
 	 */
 	mutex_lock(&core->lock);
 	if (!core->ops || test_bit(0, &inst->core->sys_error)) {
 		mutex_unlock(&core->lock);
 		return -EIO;
 	}
 	mutex_unlock(&core->lock);

 	if (inst->state != INST_UNINIT)
 		return -EALREADY;

 	inst->hfi_codec = to_codec_type(pixfmt);
 	reinit_completion(&inst->done);

 	ret = ops->session_init(inst, inst->session_type, inst->hfi_codec);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	inst->state = INST_INIT;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_init);

 void hfi_session_destroy(struct venus_inst *inst)
 {
 	struct venus_core *core = inst->core;

 	mutex_lock(&core->lock);
 	list_del_init(&inst->list);
 	if (atomic_dec_and_test(&core->insts_count))
 		wake_up_var(&core->insts_count);
 	mutex_unlock(&core->lock);
 }
 EXPORT_SYMBOL_GPL(hfi_session_destroy);

 int hfi_session_deinit(struct venus_inst *inst)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (inst->state == INST_UNINIT)
 		return 0;

 	if (inst->state < INST_INIT)
 		return -EINVAL;

 	if (test_bit(0, &inst->core->sys_error))
 		goto done;

 	reinit_completion(&inst->done);

 	ret = ops->session_end(inst);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 done:
 	inst->state = INST_UNINIT;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_deinit);

 int hfi_session_start(struct venus_inst *inst)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (inst->state != INST_LOAD_RESOURCES)
 		return -EINVAL;

 	reinit_completion(&inst->done);

 	ret = ops->session_start(inst);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	inst->state = INST_START;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_start);

 int hfi_session_stop(struct venus_inst *inst)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (inst->state != INST_START)
 		return -EINVAL;

 	reinit_completion(&inst->done);

 	ret = ops->session_stop(inst);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	inst->state = INST_STOP;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_stop);

 int hfi_session_continue(struct venus_inst *inst)
 {
 	struct venus_core *core = inst->core;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (core->res->hfi_version == HFI_VERSION_1XX)
 		return 0;

 	return core->ops->session_continue(inst);
 }
 EXPORT_SYMBOL_GPL(hfi_session_continue);

 int hfi_session_abort(struct venus_inst *inst)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	reinit_completion(&inst->done);

 	ret = ops->session_abort(inst);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_abort);

 int hfi_session_load_res(struct venus_inst *inst)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (inst->state != INST_INIT)
 		return -EINVAL;

 	reinit_completion(&inst->done);

 	ret = ops->session_load_res(inst);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	inst->state = INST_LOAD_RESOURCES;

 	return 0;
 }

 int hfi_session_unload_res(struct venus_inst *inst)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (inst->state != INST_STOP)
 		return -EINVAL;

 	reinit_completion(&inst->done);

 	ret = ops->session_release_res(inst);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	inst->state = INST_RELEASE_RESOURCES;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_unload_res);

 int hfi_session_flush(struct venus_inst *inst, u32 type, bool block)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	reinit_completion(&inst->done);

 	ret = ops->session_flush(inst, type);
 	if (ret)
 		return ret;

 	if (block) {
 		ret = wait_session_msg(inst);
 		if (ret)
 			return ret;
 	}

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_flush);

 int hfi_session_set_buffers(struct venus_inst *inst, struct hfi_buffer_desc *bd)
 {
 	const struct hfi_ops *ops = inst->core->ops;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	return ops->session_set_buffers(inst, bd);
 }

 int hfi_session_unset_buffers(struct venus_inst *inst,
 			      struct hfi_buffer_desc *bd)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	reinit_completion(&inst->done);

 	ret = ops->session_unset_buffers(inst, bd);
 	if (ret)
 		return ret;

 	if (!bd->response_required)
 		return 0;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	return 0;
 }

 int hfi_session_get_property(struct venus_inst *inst, u32 ptype,
 			     union hfi_get_property *hprop)
 {
 	const struct hfi_ops *ops = inst->core->ops;
 	int ret;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (inst->state < INST_INIT || inst->state >= INST_STOP)
 		return -EINVAL;

 	reinit_completion(&inst->done);

 	ret = ops->session_get_property(inst, ptype);
 	if (ret)
 		return ret;

 	ret = wait_session_msg(inst);
 	if (ret)
 		return ret;

 	*hprop = inst->hprop;

 	return 0;
 }
 EXPORT_SYMBOL_GPL(hfi_session_get_property);

 int hfi_session_set_property(struct venus_inst *inst, u32 ptype, void *pdata)
 {
 	const struct hfi_ops *ops = inst->core->ops;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (inst->state < INST_INIT || inst->state >= INST_STOP)
 		return -EINVAL;

 	return ops->session_set_property(inst, ptype, pdata);
 }
 EXPORT_SYMBOL_GPL(hfi_session_set_property);

 int hfi_session_process_buf(struct venus_inst *inst, struct hfi_frame_data *fd)
 {
 	const struct hfi_ops *ops = inst->core->ops;

 	if (test_bit(0, &inst->core->sys_error))
 		return -EIO;

 	if (fd->buffer_type == HFI_BUFFER_INPUT)
 		return ops->session_etb(inst, fd);
 	else if (fd->buffer_type == HFI_BUFFER_OUTPUT ||
 		 fd->buffer_type == HFI_BUFFER_OUTPUT2)
 		return ops->session_ftb(inst, fd);

 	return -EINVAL;
 }
 EXPORT_SYMBOL_GPL(hfi_session_process_buf);

 irqreturn_t hfi_isr_thread(int irq, void *dev_id)
 {
 	struct venus_core *core = dev_id;

 	return core->ops->isr_thread(core);
 }

 irqreturn_t hfi_isr(int irq, void *dev)
 {
 	struct venus_core *core = dev;

 	return core->ops->isr(core);
 }

 int hfi_create(struct venus_core *core, const struct hfi_core_ops *ops)
 {
 	if (!ops)
 		return -EINVAL;

 	atomic_set(&core->insts_count, 0);
 	core->core_ops = ops;
 	core->state = CORE_UNINIT;
 	init_completion(&core->done);
 	pkt_set_version(core->res->hfi_version);

 	return venus_hfi_create(core);
 }

 void hfi_destroy(struct venus_core *core)
 {
 	venus_hfi_destroy(core);
 }

 void hfi_reinit(struct venus_core *core)
 {
 	venus_hfi_queues_reinit(core);
 }
	// SPDX-License-Identifier: GPL-2.0-only
	/*
	* Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.
	* Copyright (C) 2017 Linaro Ltd.
	*/
	#include <linux/slab.h>
	#include <linux/mutex.h>
	#include <linux/list.h>
	#include <linux/completion.h>
	#include <linux/platform_device.h>
	#include <linux/videodev2.h>

	#include "core.h"
	#include "hfi.h"
	#include "hfi_cmds.h"
	#include "hfi_venus.h"

	#define TIMEOUT msecs_to_jiffies(1000)

	static u32 to_codec_type(u32 pixfmt)
	{
	switch (pixfmt) {
	case V4L2_PIX_FMT_H264:
	case V4L2_PIX_FMT_H264_NO_SC:
	return HFI_VIDEO_CODEC_H264;
	case V4L2_PIX_FMT_H263:
	return HFI_VIDEO_CODEC_H263;
	case V4L2_PIX_FMT_MPEG1:
	return HFI_VIDEO_CODEC_MPEG1;
	case V4L2_PIX_FMT_MPEG2:
	return HFI_VIDEO_CODEC_MPEG2;
	case V4L2_PIX_FMT_MPEG4:
	return HFI_VIDEO_CODEC_MPEG4;
	case V4L2_PIX_FMT_VC1_ANNEX_G:
	case V4L2_PIX_FMT_VC1_ANNEX_L:
	return HFI_VIDEO_CODEC_VC1;
	case V4L2_PIX_FMT_VP8:
	return HFI_VIDEO_CODEC_VP8;
	case V4L2_PIX_FMT_VP9:
	return HFI_VIDEO_CODEC_VP9;
	case V4L2_PIX_FMT_XVID:
	return HFI_VIDEO_CODEC_DIVX;
	case V4L2_PIX_FMT_HEVC:
	return HFI_VIDEO_CODEC_HEVC;
	default:
	return 0;
	}
	}

	int hfi_core_init(struct venus_core *core)
	{
	int ret = 0;

	mutex_lock(&core->lock);

	if (core->state >= CORE_INIT)
	goto unlock;

	reinit_completion(&core->done);

	ret = core->ops->core_init(core);
	if (ret)
	goto unlock;

	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
	if (!ret) {
	ret = -ETIMEDOUT;
	goto unlock;
	}

	ret = 0;

	if (core->error != HFI_ERR_NONE) {
	ret = -EIO;
	goto unlock;
	}

	core->state = CORE_INIT;
	unlock:
	mutex_unlock(&core->lock);
	return ret;
	}

	int hfi_core_deinit(struct venus_core *core, bool blocking)
	{
	int ret = 0, empty;

	mutex_lock(&core->lock);

	if (core->state == CORE_UNINIT)
	goto unlock;

	empty = list_empty(&core->instances);

	if (!empty && !blocking) {
	ret = -EBUSY;
	goto unlock;
	}

	if (!empty) {
	mutex_unlock(&core->lock);
	wait_var_event(&core->insts_count,
	!atomic_read(&core->insts_count));
	mutex_lock(&core->lock);
	}

	if (!core->ops)
	goto unlock;

	ret = core->ops->core_deinit(core);

	if (!ret)
	core->state = CORE_UNINIT;

	unlock:
	mutex_unlock(&core->lock);
	return ret;
	}

	int hfi_core_suspend(struct venus_core *core)
	{
	if (core->state != CORE_INIT)
	return 0;

	return core->ops->suspend(core);
	}

	int hfi_core_resume(struct venus_core *core, bool force)
	{
	if (!force && core->state != CORE_INIT)
	return 0;

	return core->ops->resume(core);
	}

	int hfi_core_trigger_ssr(struct venus_core *core, u32 type)
	{
	return core->ops->core_trigger_ssr(core, type);
	}

	int hfi_core_ping(struct venus_core *core)
	{
	int ret;

	mutex_lock(&core->lock);

	ret = core->ops->core_ping(core, 0xbeef);
	if (ret)
	goto unlock;

	ret = wait_for_completion_timeout(&core->done, TIMEOUT);
	if (!ret) {
	ret = -ETIMEDOUT;
	goto unlock;
	}
	ret = 0;
	if (core->error != HFI_ERR_NONE)
	ret = -ENODEV;
	unlock:
	mutex_unlock(&core->lock);
	return ret;
	}

	static int wait_session_msg(struct venus_inst *inst)
	{
	int ret;

	ret = wait_for_completion_timeout(&inst->done, TIMEOUT);
	if (!ret)
	return -ETIMEDOUT;

	if (inst->error != HFI_ERR_NONE)
	return -EIO;

	return 0;
	}

	int hfi_session_create(struct venus_inst inst, const struct hfi_inst_ops ops)
	{
	struct venus_core *core = inst->core;
	bool max;
	int ret;

	if (!ops)
	return -EINVAL;

	inst->state = INST_UNINIT;
	init_completion(&inst->done);
	inst->ops = ops;

	mutex_lock(&core->lock);

	if (test_bit(0, &inst->core->sys_error)) {
	ret = -EIO;
	goto unlock;
	}

	max = atomic_add_unless(&core->insts_count, 1,
	core->max_sessions_supported);
	if (!max) {
	ret = -EAGAIN;
	} else {
	list_add_tail(&inst->list, &core->instances);
	ret = 0;
	}

	unlock:
	mutex_unlock(&core->lock);

	return ret;
	}
	EXPORT_SYMBOL_GPL(hfi_session_create);

	int hfi_session_init(struct venus_inst *inst, u32 pixfmt)
	{
	struct venus_core *core = inst->core;
	const struct hfi_ops *ops = core->ops;
	int ret;

	/*
	* If core shutdown is in progress or if we are in system
	* recovery, return an error as during system error recovery
	* session_init() can't pass successfully
	*/
	mutex_lock(&core->lock);
	if (!core->ops \|\| test_bit(0, &inst->core->sys_error)) {
	mutex_unlock(&core->lock);
	return -EIO;
	}
	mutex_unlock(&core->lock);

	if (inst->state != INST_UNINIT)
	return -EALREADY;

	inst->hfi_codec = to_codec_type(pixfmt);
	reinit_completion(&inst->done);

	ret = ops->session_init(inst, inst->session_type, inst->hfi_codec);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	inst->state = INST_INIT;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_init);

	void hfi_session_destroy(struct venus_inst *inst)
	{
	struct venus_core *core = inst->core;

	mutex_lock(&core->lock);
	list_del_init(&inst->list);
	if (atomic_dec_and_test(&core->insts_count))
	wake_up_var(&core->insts_count);
	mutex_unlock(&core->lock);
	}
	EXPORT_SYMBOL_GPL(hfi_session_destroy);

	int hfi_session_deinit(struct venus_inst *inst)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (inst->state == INST_UNINIT)
	return 0;

	if (inst->state < INST_INIT)
	return -EINVAL;

	if (test_bit(0, &inst->core->sys_error))
	goto done;

	reinit_completion(&inst->done);

	ret = ops->session_end(inst);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	done:
	inst->state = INST_UNINIT;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_deinit);

	int hfi_session_start(struct venus_inst *inst)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (inst->state != INST_LOAD_RESOURCES)
	return -EINVAL;

	reinit_completion(&inst->done);

	ret = ops->session_start(inst);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	inst->state = INST_START;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_start);

	int hfi_session_stop(struct venus_inst *inst)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (inst->state != INST_START)
	return -EINVAL;

	reinit_completion(&inst->done);

	ret = ops->session_stop(inst);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	inst->state = INST_STOP;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_stop);

	int hfi_session_continue(struct venus_inst *inst)
	{
	struct venus_core *core = inst->core;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (core->res->hfi_version == HFI_VERSION_1XX)
	return 0;

	return core->ops->session_continue(inst);
	}
	EXPORT_SYMBOL_GPL(hfi_session_continue);

	int hfi_session_abort(struct venus_inst *inst)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	reinit_completion(&inst->done);

	ret = ops->session_abort(inst);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_abort);

	int hfi_session_load_res(struct venus_inst *inst)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (inst->state != INST_INIT)
	return -EINVAL;

	reinit_completion(&inst->done);

	ret = ops->session_load_res(inst);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	inst->state = INST_LOAD_RESOURCES;

	return 0;
	}

	int hfi_session_unload_res(struct venus_inst *inst)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (inst->state != INST_STOP)
	return -EINVAL;

	reinit_completion(&inst->done);

	ret = ops->session_release_res(inst);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	inst->state = INST_RELEASE_RESOURCES;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_unload_res);

	int hfi_session_flush(struct venus_inst *inst, u32 type, bool block)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	reinit_completion(&inst->done);

	ret = ops->session_flush(inst, type);
	if (ret)
	return ret;

	if (block) {
	ret = wait_session_msg(inst);
	if (ret)
	return ret;
	}

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_flush);

	int hfi_session_set_buffers(struct venus_inst inst, struct hfi_buffer_desc bd)
	{
	const struct hfi_ops *ops = inst->core->ops;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	return ops->session_set_buffers(inst, bd);
	}

	int hfi_session_unset_buffers(struct venus_inst *inst,
	struct hfi_buffer_desc *bd)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	reinit_completion(&inst->done);

	ret = ops->session_unset_buffers(inst, bd);
	if (ret)
	return ret;

	if (!bd->response_required)
	return 0;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	return 0;
	}

	int hfi_session_get_property(struct venus_inst *inst, u32 ptype,
	union hfi_get_property *hprop)
	{
	const struct hfi_ops *ops = inst->core->ops;
	int ret;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (inst->state < INST_INIT \|\| inst->state >= INST_STOP)
	return -EINVAL;

	reinit_completion(&inst->done);

	ret = ops->session_get_property(inst, ptype);
	if (ret)
	return ret;

	ret = wait_session_msg(inst);
	if (ret)
	return ret;

	*hprop = inst->hprop;

	return 0;
	}
	EXPORT_SYMBOL_GPL(hfi_session_get_property);

	int hfi_session_set_property(struct venus_inst inst, u32 ptype, void pdata)
	{
	const struct hfi_ops *ops = inst->core->ops;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (inst->state < INST_INIT \|\| inst->state >= INST_STOP)
	return -EINVAL;

	return ops->session_set_property(inst, ptype, pdata);
	}
	EXPORT_SYMBOL_GPL(hfi_session_set_property);

	int hfi_session_process_buf(struct venus_inst inst, struct hfi_frame_data fd)
	{
	const struct hfi_ops *ops = inst->core->ops;

	if (test_bit(0, &inst->core->sys_error))
	return -EIO;

	if (fd->buffer_type == HFI_BUFFER_INPUT)
	return ops->session_etb(inst, fd);
	else if (fd->buffer_type == HFI_BUFFER_OUTPUT \|\|
	fd->buffer_type == HFI_BUFFER_OUTPUT2)
	return ops->session_ftb(inst, fd);

	return -EINVAL;
	}
	EXPORT_SYMBOL_GPL(hfi_session_process_buf);

	irqreturn_t hfi_isr_thread(int irq, void *dev_id)
	{
	struct venus_core *core = dev_id;

	return core->ops->isr_thread(core);
	}

	irqreturn_t hfi_isr(int irq, void *dev)
	{
	struct venus_core *core = dev;

	return core->ops->isr(core);
	}

	int hfi_create(struct venus_core core, const struct hfi_core_ops ops)
	{
	if (!ops)
	return -EINVAL;

	atomic_set(&core->insts_count, 0);
	core->core_ops = ops;
	core->state = CORE_UNINIT;
	init_completion(&core->done);
	pkt_set_version(core->res->hfi_version);

	return venus_hfi_create(core);
	}

	void hfi_destroy(struct venus_core *core)
	{
	venus_hfi_destroy(core);
	}

	void hfi_reinit(struct venus_core *core)
	{
	venus_hfi_queues_reinit(core);
	}