mirror of
https://github.com/linux-msm/laptops-kernel.git
synced 2026-08-13 14:19:53 -07:00
[media] media: venus: adding core part and helper functions
* core.c has implemented the platform driver methods, file operations and v4l2 registration. * helpers.c has implemented common helper functions for: - buffer management - vb2_ops and functions for format propagation, - functions for allocating and freeing buffers for internal usage. The buffer parameters describing internal buffers depends on current format, resolution and codec. - functions for calculation of current load of the hardware. Depending on the count of instances and resolutions it selects the best clock rate for the video core. * firmware loader Signed-off-by: Stanimir Varbanov <stanimir.varbanov@linaro.org> Signed-off-by: Hans Verkuil <hans.verkuil@cisco.com> Signed-off-by: Mauro Carvalho Chehab <mchehab@s-opensource.com>
This commit is contained in:
Stanimir Varbanov
committed by
Mauro Carvalho Chehab
Mauro Carvalho Chehab
parent
097748eb64
commit
af2c3834c8
@@ -0,0 +1,388 @@
|
||||
/*
|
||||
* 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");
|
||||
@@ -0,0 +1,323 @@
|
||||
/*
|
||||
* 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
|
||||
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
* 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");
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
ret = device_register(fw_dev);
|
||||
if (ret < 0)
|
||||
return ret;
|
||||
|
||||
ret = of_reserved_mem_device_init_by_idx(fw_dev, parent->of_node, 0);
|
||||
if (ret)
|
||||
goto err_unreg_device;
|
||||
|
||||
mem_size = VENUS_FW_MEM_SIZE;
|
||||
|
||||
mem_va = dmam_alloc_coherent(fw_dev, mem_size, &mem_phys, GFP_KERNEL);
|
||||
if (!mem_va) {
|
||||
ret = -ENOMEM;
|
||||
goto err_unreg_device;
|
||||
}
|
||||
|
||||
ret = request_firmware(&mdt, VENUS_FIRMWARE_NAME, fw_dev);
|
||||
if (ret < 0)
|
||||
goto err_unreg_device;
|
||||
|
||||
fw_size = qcom_mdt_get_size(mdt);
|
||||
if (fw_size < 0) {
|
||||
ret = fw_size;
|
||||
release_firmware(mdt);
|
||||
goto err_unreg_device;
|
||||
}
|
||||
|
||||
ret = qcom_mdt_load(fw_dev, mdt, VENUS_FIRMWARE_NAME, VENUS_PAS_ID,
|
||||
mem_va, mem_phys, mem_size);
|
||||
|
||||
release_firmware(mdt);
|
||||
|
||||
if (ret)
|
||||
goto err_unreg_device;
|
||||
|
||||
ret = qcom_scm_pas_auth_and_reset(VENUS_PAS_ID);
|
||||
if (ret)
|
||||
goto err_unreg_device;
|
||||
|
||||
return 0;
|
||||
|
||||
err_unreg_device:
|
||||
device_unregister(fw_dev);
|
||||
return ret;
|
||||
}
|
||||
|
||||
int venus_shutdown(struct device *fw_dev)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = qcom_scm_pas_shutdown(VENUS_PAS_ID);
|
||||
device_unregister(fw_dev);
|
||||
memset(fw_dev, 0, sizeof(*fw_dev));
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
/*
|
||||
* 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_FIRMWARE_H__
|
||||
#define __VENUS_FIRMWARE_H__
|
||||
|
||||
struct device;
|
||||
|
||||
int venus_boot(struct device *parent, struct device *fw_dev);
|
||||
int venus_shutdown(struct device *fw_dev);
|
||||
|
||||
#endif
|
||||
File diff suppressed because it is too large
Load Diff
@@ -0,0 +1,45 @@
|
||||
/*
|
||||
* 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_HELPERS_H__
|
||||
#define __VENUS_HELPERS_H__
|
||||
|
||||
#include <media/videobuf2-v4l2.h>
|
||||
|
||||
struct venus_inst;
|
||||
|
||||
struct vb2_v4l2_buffer *venus_helper_find_buf(struct venus_inst *inst,
|
||||
unsigned int type, u32 idx);
|
||||
void venus_helper_buffers_done(struct venus_inst *inst,
|
||||
enum vb2_buffer_state state);
|
||||
int venus_helper_vb2_buf_init(struct vb2_buffer *vb);
|
||||
int venus_helper_vb2_buf_prepare(struct vb2_buffer *vb);
|
||||
void venus_helper_vb2_buf_queue(struct vb2_buffer *vb);
|
||||
void venus_helper_vb2_stop_streaming(struct vb2_queue *q);
|
||||
int venus_helper_vb2_start_streaming(struct venus_inst *inst);
|
||||
void venus_helper_m2m_device_run(void *priv);
|
||||
void venus_helper_m2m_job_abort(void *priv);
|
||||
int venus_helper_get_bufreq(struct venus_inst *inst, u32 type,
|
||||
struct hfi_buffer_requirements *req);
|
||||
int venus_helper_set_input_resolution(struct venus_inst *inst,
|
||||
unsigned int width, unsigned int height);
|
||||
int venus_helper_set_output_resolution(struct venus_inst *inst,
|
||||
unsigned int width, unsigned int height);
|
||||
int venus_helper_set_num_bufs(struct venus_inst *inst, unsigned int input_bufs,
|
||||
unsigned int output_bufs);
|
||||
int venus_helper_set_color_format(struct venus_inst *inst, u32 fmt);
|
||||
void venus_helper_acquire_buf_ref(struct vb2_v4l2_buffer *vbuf);
|
||||
void venus_helper_release_buf_ref(struct venus_inst *inst, unsigned int idx);
|
||||
void venus_helper_init_instance(struct venus_inst *inst);
|
||||
#endif
|
||||
Reference in New Issue
Block a user