[media] media: venus: adding core part and helper functions

/*

 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.

 * Copyright (C) 2017 Linaro Ltd.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * 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.

 *

 */

#include <linux/clk.h>

#include <linux/init.h>

#include <linux/ioctl.h>

#include <linux/list.h>

#include <linux/module.h>

#include <linux/of_device.h>

#include <linux/platform_device.h>

#include <linux/slab.h>

#include <linux/types.h>

#include <linux/pm_runtime.h>

#include <media/videobuf2-v4l2.h>

#include <media/v4l2-mem2mem.h>

#include <media/v4l2-ioctl.h>

#include "core.h"

#include "vdec.h"

#include "venc.h"

#include "firmware.h"

static void venus_event_notify(struct venus_core *core, u32 event)

{

	struct venus_inst *inst;

	switch (event) {

	case EVT_SYS_WATCHDOG_TIMEOUT:

	case EVT_SYS_ERROR:

		break;

	default:

		return;

	}

	mutex_lock(&core->lock);

	core->sys_error = true;

	list_for_each_entry(inst, &core->instances, list)

		inst->ops->event_notify(inst, EVT_SESSION_ERROR, NULL);

	mutex_unlock(&core->lock);

	disable_irq_nosync(core->irq);

	/*

	 * Delay recovery to ensure venus has completed any pending cache

	 * operations. Without this sleep, we see device reset when firmware is

	 * unloaded after a system error.

	 */

	schedule_delayed_work(&core->work, msecs_to_jiffies(100));

}

static const struct hfi_core_ops venus_core_ops = {

	.event_notify = venus_event_notify,

};

static void venus_sys_error_handler(struct work_struct *work)

{

	struct venus_core *core =

			container_of(work, struct venus_core, work.work);

	int ret = 0;

	dev_warn(core->dev, "system error has occurred, starting recovery!\n");

	pm_runtime_get_sync(core->dev);

	hfi_core_deinit(core, true);

	hfi_destroy(core);

	mutex_lock(&core->lock);

	venus_shutdown(&core->dev_fw);

	pm_runtime_put_sync(core->dev);

	ret |= hfi_create(core, &venus_core_ops);

	pm_runtime_get_sync(core->dev);

	ret |= venus_boot(core->dev, &core->dev_fw);

	ret |= hfi_core_resume(core, true);

	enable_irq(core->irq);

	mutex_unlock(&core->lock);

	ret |= hfi_core_init(core);

	pm_runtime_put_sync(core->dev);

	if (ret) {

		disable_irq_nosync(core->irq);

		dev_warn(core->dev, "recovery failed (%d)\n", ret);

		schedule_delayed_work(&core->work, msecs_to_jiffies(10));

		return;

	}

	mutex_lock(&core->lock);

	core->sys_error = false;

	mutex_unlock(&core->lock);

}

static int venus_clks_get(struct venus_core *core)

{

	const struct venus_resources *res = core->res;

	struct device *dev = core->dev;

	unsigned int i;

	for (i = 0; i < res->clks_num; i++) {

		core->clks[i] = devm_clk_get(dev, res->clks[i]);

		if (IS_ERR(core->clks[i]))

			return PTR_ERR(core->clks[i]);

	}

	return 0;

}

static int venus_clks_enable(struct venus_core *core)

{

	const struct venus_resources *res = core->res;

	unsigned int i;

	int ret;

	for (i = 0; i < res->clks_num; i++) {

		ret = clk_prepare_enable(core->clks[i]);

		if (ret)

			goto err;

	}

	return 0;

err:

	while (--i)

		clk_disable_unprepare(core->clks[i]);

	return ret;

}

static void venus_clks_disable(struct venus_core *core)

{

	const struct venus_resources *res = core->res;

	unsigned int i = res->clks_num;

	while (i--)

		clk_disable_unprepare(core->clks[i]);

}

static int venus_probe(struct platform_device *pdev)

{

	struct device *dev = &pdev->dev;

	struct venus_core *core;

	struct resource *r;

	int ret;

	core = devm_kzalloc(dev, sizeof(*core), GFP_KERNEL);

	if (!core)

		return -ENOMEM;

	core->dev = dev;

	platform_set_drvdata(pdev, core);

	r = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	core->base = devm_ioremap_resource(dev, r);

	if (IS_ERR(core->base))

		return PTR_ERR(core->base);

	core->irq = platform_get_irq(pdev, 0);

	if (core->irq < 0)

		return core->irq;

	core->res = of_device_get_match_data(dev);

	if (!core->res)

		return -ENODEV;

	ret = venus_clks_get(core);

	if (ret)

		return ret;

	ret = dma_set_mask_and_coherent(dev, core->res->dma_mask);

	if (ret)

		return ret;

	INIT_LIST_HEAD(&core->instances);

	mutex_init(&core->lock);

	INIT_DELAYED_WORK(&core->work, venus_sys_error_handler);

	ret = devm_request_threaded_irq(dev, core->irq, hfi_isr, hfi_isr_thread,

					IRQF_TRIGGER_HIGH | IRQF_ONESHOT,

					"venus", core);

	if (ret)

		return ret;

	ret = hfi_create(core, &venus_core_ops);

	if (ret)

		return ret;

	pm_runtime_enable(dev);

	ret = pm_runtime_get_sync(dev);

	if (ret < 0)

		goto err_runtime_disable;

	ret = venus_boot(dev, &core->dev_fw);

	if (ret)

		goto err_runtime_disable;

	ret = hfi_core_resume(core, true);

	if (ret)

		goto err_venus_shutdown;

	ret = hfi_core_init(core);

	if (ret)

		goto err_venus_shutdown;

	ret = v4l2_device_register(dev, &core->v4l2_dev);

	if (ret)

		goto err_core_deinit;

	ret = of_platform_populate(dev->of_node, NULL, NULL, dev);

	if (ret)

		goto err_dev_unregister;

	ret = pm_runtime_put_sync(dev);

	if (ret)

		goto err_dev_unregister;

	return 0;

err_dev_unregister:

	v4l2_device_unregister(&core->v4l2_dev);

err_core_deinit:

	hfi_core_deinit(core, false);

err_venus_shutdown:

	venus_shutdown(&core->dev_fw);

err_runtime_disable:

	pm_runtime_set_suspended(dev);

	pm_runtime_disable(dev);

	hfi_destroy(core);

	return ret;

}

static int venus_remove(struct platform_device *pdev)

{

	struct venus_core *core = platform_get_drvdata(pdev);

	struct device *dev = core->dev;

	int ret;

	ret = pm_runtime_get_sync(dev);

	WARN_ON(ret < 0);

	ret = hfi_core_deinit(core, true);

	WARN_ON(ret);

	hfi_destroy(core);

	venus_shutdown(&core->dev_fw);

	of_platform_depopulate(dev);

	pm_runtime_put_sync(dev);

	pm_runtime_disable(dev);

	v4l2_device_unregister(&core->v4l2_dev);

	return ret;

}

#ifdef CONFIG_PM

static int venus_runtime_suspend(struct device *dev)

{

	struct venus_core *core = dev_get_drvdata(dev);

	int ret;

	ret = hfi_core_suspend(core);

	venus_clks_disable(core);

	return ret;

}

static int venus_runtime_resume(struct device *dev)

{

	struct venus_core *core = dev_get_drvdata(dev);

	int ret;

	ret = venus_clks_enable(core);

	if (ret)

		return ret;

	ret = hfi_core_resume(core, false);

	if (ret)

		goto err_clks_disable;

	return 0;

err_clks_disable:

	venus_clks_disable(core);

	return ret;

}

#endif

static const struct dev_pm_ops venus_pm_ops = {

	SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,

				pm_runtime_force_resume)

	SET_RUNTIME_PM_OPS(venus_runtime_suspend, venus_runtime_resume, NULL)

};

static const struct freq_tbl msm8916_freq_table[] = {

	{ 352800, 228570000 },	/* 1920x1088 @ 30 + 1280x720 @ 30 */

	{ 244800, 160000000 },	/* 1920x1088 @ 30 */

	{ 108000, 100000000 },	/* 1280x720 @ 30 */

};

static const struct reg_val msm8916_reg_preset[] = {

	{ 0xe0020, 0x05555556 },

	{ 0xe0024, 0x05555556 },

	{ 0x80124, 0x00000003 },

};

static const struct venus_resources msm8916_res = {

	.freq_tbl = msm8916_freq_table,

	.freq_tbl_size = ARRAY_SIZE(msm8916_freq_table),

	.reg_tbl = msm8916_reg_preset,

	.reg_tbl_size = ARRAY_SIZE(msm8916_reg_preset),

	.clks = { "core", "iface", "bus", },

	.clks_num = 3,

	.max_load = 352800, /* 720p@30 + 1080p@30 */

	.hfi_version = HFI_VERSION_1XX,

	.vmem_id = VIDC_RESOURCE_NONE,

	.vmem_size = 0,

	.vmem_addr = 0,

	.dma_mask = 0xddc00000 - 1,

};

static const struct freq_tbl msm8996_freq_table[] = {

	{ 1944000, 490000000 },	/* 4k UHD @ 60 */

	{  972000, 320000000 },	/* 4k UHD @ 30 */

	{  489600, 150000000 },	/* 1080p @ 60 */

	{  244800,  75000000 },	/* 1080p @ 30 */

};

static const struct reg_val msm8996_reg_preset[] = {

	{ 0x80010, 0xffffffff },

	{ 0x80018, 0x00001556 },

	{ 0x8001C, 0x00001556 },

};

static const struct venus_resources msm8996_res = {

	.freq_tbl = msm8996_freq_table,

	.freq_tbl_size = ARRAY_SIZE(msm8996_freq_table),

	.reg_tbl = msm8996_reg_preset,

	.reg_tbl_size = ARRAY_SIZE(msm8996_reg_preset),

	.clks = {"core", "iface", "bus", "mbus" },

	.clks_num = 4,

	.max_load = 2563200,

	.hfi_version = HFI_VERSION_3XX,

	.vmem_id = VIDC_RESOURCE_NONE,

	.vmem_size = 0,

	.vmem_addr = 0,

	.dma_mask = 0xddc00000 - 1,

};

static const struct of_device_id venus_dt_match[] = {

	{ .compatible = "qcom,msm8916-venus", .data = &msm8916_res, },

	{ .compatible = "qcom,msm8996-venus", .data = &msm8996_res, },

	{ }

};

MODULE_DEVICE_TABLE(of, venus_dt_match);

static struct platform_driver qcom_venus_driver = {

	.probe = venus_probe,

	.remove = venus_remove,

	.driver = {

		.name = "qcom-venus",

		.of_match_table = venus_dt_match,

		.pm = &venus_pm_ops,

	},

};

module_platform_driver(qcom_venus_driver);

MODULE_ALIAS("platform:qcom-venus");

MODULE_DESCRIPTION("Qualcomm Venus video encoder and decoder driver");

MODULE_LICENSE("GPL v2");

/*

 * Copyright (c) 2012-2016, The Linux Foundation. All rights reserved.

 * Copyright (C) 2017 Linaro Ltd.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * 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.

 *

 */

#ifndef __VENUS_CORE_H_

#define __VENUS_CORE_H_

#include <linux/list.h>

#include <media/videobuf2-v4l2.h>

#include <media/v4l2-ctrls.h>

#include <media/v4l2-device.h>

#include "hfi.h"

#define VIDC_CLKS_NUM_MAX	4

struct freq_tbl {

	unsigned int load;

	unsigned long freq;

};

struct reg_val {

	u32 reg;

	u32 value;

};

struct venus_resources {

	u64 dma_mask;

	const struct freq_tbl *freq_tbl;

	unsigned int freq_tbl_size;

	const struct reg_val *reg_tbl;

	unsigned int reg_tbl_size;

	const char * const clks[VIDC_CLKS_NUM_MAX];

	unsigned int clks_num;

	enum hfi_version hfi_version;

	u32 max_load;

	unsigned int vmem_id;

	u32 vmem_size;

	u32 vmem_addr;

};

struct venus_format {

	u32 pixfmt;

	unsigned int num_planes;

	u32 type;

};

/**

 * struct venus_core - holds core parameters valid for all instances

 *

 * @base:	IO memory base address

 * @irq:		Venus irq

 * @clks:	an array of struct clk pointers

 * @core0_clk:	a struct clk pointer for core0

 * @core1_clk:	a struct clk pointer for core1

 * @vdev_dec:	a reference to video device structure for decoder instances

 * @vdev_enc:	a reference to video device structure for encoder instances

 * @v4l2_dev:	a holder for v4l2 device structure

 * @res:		a reference to venus resources structure

 * @dev:		convenience struct device pointer

 * @dev_dec:	convenience struct device pointer for decoder device

 * @dev_enc:	convenience struct device pointer for encoder device

 * @lock:	a lock for this strucure

 * @instances:	a list_head of all instances

 * @insts_count:	num of instances

 * @state:	the state of the venus core

 * @done:	a completion for sync HFI operations

 * @error:	an error returned during last HFI sync operations

 * @sys_error:	an error flag that signal system error event

 * @core_ops:	the core operations

 * @enc_codecs:	encoders supported by this core

 * @dec_codecs:	decoders supported by this core

 * @max_sessions_supported:	holds the maximum number of sessions

 * @core_caps:	core capabilities

 * @priv:	a private filed for HFI operations

 * @ops:		the core HFI operations

 * @work:	a delayed work for handling system fatal error

 */

struct venus_core {

	void __iomem *base;

	int irq;

	struct clk *clks[VIDC_CLKS_NUM_MAX];

	struct clk *core0_clk;

	struct clk *core1_clk;

	struct video_device *vdev_dec;

	struct video_device *vdev_enc;

	struct v4l2_device v4l2_dev;

	const struct venus_resources *res;

	struct device *dev;

	struct device *dev_dec;

	struct device *dev_enc;

	struct device dev_fw;

	struct mutex lock;

	struct list_head instances;

	atomic_t insts_count;

	unsigned int state;

	struct completion done;

	unsigned int error;

	bool sys_error;

	const struct hfi_core_ops *core_ops;

	u32 enc_codecs;

	u32 dec_codecs;

	unsigned int max_sessions_supported;

#define ENC_ROTATION_CAPABILITY		0x1

#define ENC_SCALING_CAPABILITY		0x2

#define ENC_DEINTERLACE_CAPABILITY	0x4

#define DEC_MULTI_STREAM_CAPABILITY	0x8

	unsigned int core_caps;

	void *priv;

	const struct hfi_ops *ops;

	struct delayed_work work;

};

struct vdec_controls {

	u32 post_loop_deb_mode;

	u32 profile;

	u32 level;

};

struct venc_controls {

	u16 gop_size;

	u32 num_p_frames;

	u32 num_b_frames;

	u32 bitrate_mode;

	u32 bitrate;

	u32 bitrate_peak;

	u32 h264_i_period;

	u32 h264_entropy_mode;

	u32 h264_i_qp;

	u32 h264_p_qp;

	u32 h264_b_qp;

	u32 h264_min_qp;

	u32 h264_max_qp;

	u32 h264_loop_filter_mode;

	u32 h264_loop_filter_alpha;

	u32 h264_loop_filter_beta;

	u32 vp8_min_qp;

	u32 vp8_max_qp;

	u32 multi_slice_mode;

	u32 multi_slice_max_bytes;

	u32 multi_slice_max_mb;

	u32 header_mode;

	struct {

		u32 mpeg4;

		u32 h264;

		u32 vpx;

	} profile;

	struct {

		u32 mpeg4;

		u32 h264;

	} level;

};

struct venus_buffer {

	struct vb2_v4l2_buffer vb;

	struct list_head list;

	dma_addr_t dma_addr;

	u32 size;

	struct list_head reg_list;

	u32 flags;

	struct list_head ref_list;

};

#define to_venus_buffer(ptr)	container_of(ptr, struct venus_buffer, vb)

/**

 * struct venus_inst - holds per instance paramerters

 *

 * @list:	used for attach an instance to the core

 * @lock:	instance lock

 * @core:	a reference to the core struct

 * @internalbufs:	a list of internal bufferes

 * @registeredbufs:	a list of registered capture bufferes

 * @delayed_process	a list of delayed buffers

 * @delayed_process_work:	a work_struct for process delayed buffers

 * @ctrl_handler:	v4l control handler

 * @controls:	a union of decoder and encoder control parameters

 * @fh:	 a holder of v4l file handle structure

 * @streamon_cap: stream on flag for capture queue

 * @streamon_out: stream on flag for output queue

 * @cmd_stop:	a flag to signal encoder/decoder commands

 * @width:	current capture width

 * @height:	current capture height

 * @out_width:	current output width

 * @out_height:	current output height

 * @colorspace:	current color space

 * @quantization:	current quantization

 * @xfer_func:	current xfer function

 * @fps:		holds current FPS

 * @timeperframe:	holds current time per frame structure

 * @fmt_out:	a reference to output format structure

 * @fmt_cap:	a reference to capture format structure

 * @num_input_bufs:	holds number of input buffers

 * @num_output_bufs:	holds number of output buffers

 * @input_buf_size	holds input buffer size

 * @output_buf_size:	holds output buffer size

 * @reconfig:	a flag raised by decoder when the stream resolution changed

 * @reconfig_width:	holds the new width

 * @reconfig_height:	holds the new height

 * @sequence_cap:	a sequence counter for capture queue

 * @sequence_out:	a sequence counter for output queue

 * @m2m_dev:	a reference to m2m device structure

 * @m2m_ctx:	a reference to m2m context structure

 * @state:	current state of the instance

 * @done:	a completion for sync HFI operation

 * @error:	an error returned during last HFI sync operation

 * @session_error:	a flag rised by HFI interface in case of session error

 * @ops:		HFI operations

 * @priv:	a private for HFI operations callbacks

 * @session_type:	the type of the session (decoder or encoder)

 * @hprop:	a union used as a holder by get property

 * @cap_width:	width capability

 * @cap_height:	height capability

 * @cap_mbs_per_frame:	macroblocks per frame capability

 * @cap_mbs_per_sec:	macroblocks per second capability

 * @cap_framerate:	framerate capability

 * @cap_scale_x:		horizontal scaling capability

 * @cap_scale_y:		vertical scaling capability

 * @cap_bitrate:		bitrate capability

 * @cap_hier_p:		hier capability

 * @cap_ltr_count:	LTR count capability

 * @cap_secure_output2_threshold: secure OUTPUT2 threshold capability

 * @cap_bufs_mode_static:	buffers allocation mode capability

 * @cap_bufs_mode_dynamic:	buffers allocation mode capability

 * @pl_count:	count of supported profiles/levels

 * @pl:		supported profiles/levels

 * @bufreq:	holds buffer requirements

 */

struct venus_inst {

	struct list_head list;

	struct mutex lock;

	struct venus_core *core;

	struct list_head internalbufs;

	struct list_head registeredbufs;

	struct list_head delayed_process;

	struct work_struct delayed_process_work;

	struct v4l2_ctrl_handler ctrl_handler;

	union {

		struct vdec_controls dec;

		struct venc_controls enc;

	} controls;

	struct v4l2_fh fh;

	unsigned int streamon_cap, streamon_out;

	bool cmd_stop;

	u32 width;

	u32 height;

	u32 out_width;

	u32 out_height;

	u32 colorspace;

	u8 ycbcr_enc;

	u8 quantization;

	u8 xfer_func;

	u64 fps;

	struct v4l2_fract timeperframe;

	const struct venus_format *fmt_out;

	const struct venus_format *fmt_cap;

	unsigned int num_input_bufs;

	unsigned int num_output_bufs;

	unsigned int input_buf_size;

	unsigned int output_buf_size;

	bool reconfig;

	u32 reconfig_width;

	u32 reconfig_height;

	u32 sequence_cap;

	u32 sequence_out;

	struct v4l2_m2m_dev *m2m_dev;

	struct v4l2_m2m_ctx *m2m_ctx;

	unsigned int state;

	struct completion done;

	unsigned int error;

	bool session_error;

	const struct hfi_inst_ops *ops;

	u32 session_type;

	union hfi_get_property hprop;

	struct hfi_capability cap_width;

	struct hfi_capability cap_height;

	struct hfi_capability cap_mbs_per_frame;

	struct hfi_capability cap_mbs_per_sec;

	struct hfi_capability cap_framerate;

	struct hfi_capability cap_scale_x;

	struct hfi_capability cap_scale_y;

	struct hfi_capability cap_bitrate;

	struct hfi_capability cap_hier_p;

	struct hfi_capability cap_ltr_count;

	struct hfi_capability cap_secure_output2_threshold;

	bool cap_bufs_mode_static;

	bool cap_bufs_mode_dynamic;

	unsigned int pl_count;

	struct hfi_profile_level pl[HFI_MAX_PROFILE_COUNT];

	struct hfi_buffer_requirements bufreq[HFI_BUFFER_TYPE_MAX];

};

#define ctrl_to_inst(ctrl)	\

	container_of((ctrl)->handler, struct venus_inst, ctrl_handler)

static inline struct venus_inst *to_inst(struct file *filp)

{

	return container_of(filp->private_data, struct venus_inst, fh);

}

static inline void *to_hfi_priv(struct venus_core *core)

{

	return core->priv;

}

#endif

/*

 * Copyright (C) 2017 Linaro Ltd.

 *

 * This program is free software; you can redistribute it and/or modify

 * it under the terms of the GNU General Public License version 2 and

 * only version 2 as published by the Free Software Foundation.

 *

 * 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.

 *

 */

#include <linux/dma-mapping.h>

#include <linux/firmware.h>

#include <linux/kernel.h>

#include <linux/of.h>

#include <linux/of_reserved_mem.h>

#include <linux/slab.h>

#include <linux/qcom_scm.h>

#include <linux/soc/qcom/mdt_loader.h>

#include "firmware.h"

#define VENUS_FIRMWARE_NAME		"venus.mdt"

#define VENUS_PAS_ID			9

#define VENUS_FW_MEM_SIZE		SZ_8M

static void device_release_dummy(struct device *dev)

{

	of_reserved_mem_device_release(dev);

}

int venus_boot(struct device *parent, struct device *fw_dev)

{

	const struct firmware *mdt;

	phys_addr_t mem_phys;

	ssize_t fw_size;

	size_t mem_size;

	void *mem_va;

	int ret;

	if (!qcom_scm_is_available())

		return -EPROBE_DEFER;

	fw_dev->parent = parent;

	fw_dev->release = device_release_dummy;

	ret = dev_set_name(fw_dev, "%s:%s", dev_name(parent), "firmware");