media: mtk-vcodec: Add to support multi hardware decode (c05bada3) · Commits · EulixOS / Software / Kernel

drivers/media/platform/mtk-vcodec/Makefile

+4 −1

Original line number	Diff line number	Diff line
		@@ -2,7 +2,8 @@

		obj-$(CONFIG_VIDEO_MEDIATEK_VCODEC) += mtk-vcodec-dec.o \
		mtk-vcodec-enc.o \
		mtk-vcodec-common.o
		mtk-vcodec-common.o \
		mtk-vcodec-dec-hw.o

		mtk-vcodec-dec-y := vdec/vdec_h264_if.o \
		vdec/vdec_vp8_if.o \
		@@ -16,6 +17,8 @@ mtk-vcodec-dec-y := vdec/vdec_h264_if.o \
		mtk_vcodec_dec_stateless.o \
		mtk_vcodec_dec_pm.o \

		mtk-vcodec-dec-hw-y := mtk_vcodec_dec_hw.o

		mtk-vcodec-enc-y := venc/venc_vp8_if.o \
		venc/venc_h264_if.o \
		mtk_vcodec_enc.o \

drivers/media/platform/mtk-vcodec/mtk_vcodec_dec_drv.c

+54 −31

Original line number	Diff line number	Diff line
		@@ -18,16 +18,12 @@

		#include "mtk_vcodec_drv.h"
		#include "mtk_vcodec_dec.h"
		#include "mtk_vcodec_dec_hw.h"
		#include "mtk_vcodec_dec_pm.h"
		#include "mtk_vcodec_intr.h"
		#include "mtk_vcodec_util.h"
		#include "mtk_vcodec_fw.h"

		#define VDEC_HW_ACTIVE 0x10
		#define VDEC_IRQ_CFG 0x11
		#define VDEC_IRQ_CLR 0x10
		#define VDEC_IRQ_CFG_REG 0xa4

		static irqreturn_t mtk_vcodec_dec_irq_handler(int irq, void *priv)
		{
		struct mtk_vcodec_dev *dev = priv;
		@@ -92,6 +88,42 @@ static int mtk_vcodec_get_reg_bases(struct mtk_vcodec_dev *dev)
		return 0;
		}

		static int mtk_vcodec_init_dec_resources(struct mtk_vcodec_dev *dev)
		{
		struct platform_device *pdev = dev->plat_dev;
		int ret;

		ret = mtk_vcodec_get_reg_bases(dev);
		if (ret)
		return ret;

		if (dev->vdec_pdata->is_subdev_supported)
		return 0;

		dev->dec_irq = platform_get_irq(pdev, 0);
		if (dev->dec_irq < 0) {
		dev_err(&pdev->dev, "failed to get irq number");
		return dev->dec_irq;
		}

		irq_set_status_flags(dev->dec_irq, IRQ_NOAUTOEN);
		ret = devm_request_irq(&pdev->dev, dev->dec_irq,
		mtk_vcodec_dec_irq_handler, 0, pdev->name, dev);
		if (ret) {
		dev_err(&pdev->dev, "failed to install dev->dec_irq %d (%d)",
		dev->dec_irq, ret);
		return ret;
		}

		ret = mtk_vcodec_init_dec_pm(pdev, &dev->pm);
		if (ret < 0) {
		dev_err(&pdev->dev, "failed to get mt vcodec clock source");
		return ret;
		}

		return 0;
		}

		static int fops_vcodec_open(struct file *file)
		{
		struct mtk_vcodec_dev *dev = video_drvdata(file);
		@@ -113,6 +145,11 @@ static int fops_vcodec_open(struct file *file)
		init_waitqueue_head(&ctx->queue);
		mutex_init(&ctx->lock);

		if (dev->vdec_pdata->is_subdev_supported && dev->subdev_prob_done) {
		ret = dev->subdev_prob_done(dev);
		if (ret)
		goto err_ctrls_setup;
		}
		ctx->type = MTK_INST_DECODER;
		ret = dev->vdec_pdata->ctrls_setup(ctx);
		if (ret) {
		@@ -217,7 +254,6 @@ static int mtk_vcodec_probe(struct platform_device *pdev)
		{
		struct mtk_vcodec_dev *dev;
		struct video_device *vfd_dec;
		struct resource *res;
		phandle rproc_phandle;
		enum mtk_vcodec_fw_type fw_type;
		int ret;
		@@ -246,32 +282,10 @@ static int mtk_vcodec_probe(struct platform_device *pdev)
		if (IS_ERR(dev->fw_handler))
		return PTR_ERR(dev->fw_handler);

		ret = mtk_vcodec_init_dec_pm(dev->plat_dev, &dev->pm);
		if (ret < 0) {
		dev_err(&pdev->dev, "Failed to get mt vcodec clock source");
		goto err_dec_pm;
		}

		ret = mtk_vcodec_get_reg_bases(dev);
		if (ret)
		goto err_res;

		res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
		if (res == NULL) {
		dev_err(&pdev->dev, "failed to get irq resource");
		ret = -ENOENT;
		goto err_res;
		}

		dev->dec_irq = platform_get_irq(pdev, 0);
		irq_set_status_flags(dev->dec_irq, IRQ_NOAUTOEN);
		ret = devm_request_irq(&pdev->dev, dev->dec_irq,
		mtk_vcodec_dec_irq_handler, 0, pdev->name, dev);
		ret = mtk_vcodec_init_dec_resources(dev);
		if (ret) {
		dev_err(&pdev->dev, "Failed to install dev->dec_irq %d (%d)",
		dev->dec_irq,
		ret);
		goto err_res;
		dev_err(&pdev->dev, "Failed to init dec resources");
		goto err_dec_pm;
		}

		mutex_init(&dev->dec_mutex);
		@@ -326,6 +340,15 @@ static int mtk_vcodec_probe(struct platform_device *pdev)
		goto err_event_workq;
		}

		if (dev->vdec_pdata->is_subdev_supported) {
		ret = of_platform_populate(pdev->dev.of_node, NULL, NULL,
		&pdev->dev);
		if (ret) {
		mtk_v4l2_err("Main device of_platform_populate failed.");
		goto err_event_workq;
		}
		}

		if (dev->vdec_pdata->uses_stateless_api) {
		dev->mdev_dec.dev = &pdev->dev;
		strscpy(dev->mdev_dec.model, MTK_VCODEC_DEC_NAME,

drivers/media/platform/mtk-vcodec/mtk_vcodec_dec_hw.c

0 → 100644

+198 −0

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		/*
		* Copyright (c) 2021 MediaTek Inc.
		* Author: Yunfei Dong <yunfei.dong@mediatek.com>
		*/

		#include <linux/interrupt.h>
		#include <linux/irq.h>
		#include <linux/module.h>
		#include <linux/of.h>
		#include <linux/of_device.h>
		#include <linux/slab.h>

		#include "mtk_vcodec_drv.h"
		#include "mtk_vcodec_dec.h"
		#include "mtk_vcodec_dec_hw.h"
		#include "mtk_vcodec_dec_pm.h"
		#include "mtk_vcodec_intr.h"
		#include "mtk_vcodec_util.h"

		static const struct of_device_id mtk_vdec_hw_match[] = {
		{
		.compatible = "mediatek,mtk-vcodec-lat",
		.data = (void *)MTK_VDEC_LAT0,
		},
		{
		.compatible = "mediatek,mtk-vcodec-core",
		.data = (void *)MTK_VDEC_CORE,
		},
		{},
		};
		MODULE_DEVICE_TABLE(of, mtk_vdec_hw_match);

		static int mtk_vdec_hw_prob_done(struct mtk_vcodec_dev *vdec_dev)
		{
		struct platform_device *pdev = vdec_dev->plat_dev;
		struct device_node *subdev_node;
		enum mtk_vdec_hw_id hw_idx;
		const struct of_device_id *of_id;
		int i;

		for (i = 0; i < ARRAY_SIZE(mtk_vdec_hw_match); i++) {
		of_id = &mtk_vdec_hw_match[i];
		subdev_node = of_find_compatible_node(NULL, NULL,
		of_id->compatible);
		if (!subdev_node)
		continue;

		hw_idx = (enum mtk_vdec_hw_id)(uintptr_t)of_id->data;
		if (!test_bit(hw_idx, vdec_dev->subdev_bitmap)) {
		dev_err(&pdev->dev, "vdec %d is not ready", hw_idx);
		return -EAGAIN;
		}
		}

		return 0;
		}

		static irqreturn_t mtk_vdec_hw_irq_handler(int irq, void *priv)
		{
		struct mtk_vdec_hw_dev *dev = priv;
		struct mtk_vcodec_ctx *ctx;
		u32 cg_status;
		unsigned int dec_done_status;
		void __iomem *vdec_misc_addr = dev->reg_base[VDEC_HW_MISC] +
		VDEC_IRQ_CFG_REG;

		ctx = mtk_vcodec_get_curr_ctx(dev->main_dev);

		/* check if HW active or not */
		cg_status = readl(dev->reg_base[VDEC_HW_SYS]);
		if (cg_status & VDEC_HW_ACTIVE) {
		mtk_v4l2_err("vdec active is not 0x0 (0x%08x)",
		cg_status);
		return IRQ_HANDLED;
		}

		dec_done_status = readl(vdec_misc_addr);
		if ((dec_done_status & MTK_VDEC_IRQ_STATUS_DEC_SUCCESS) !=
		MTK_VDEC_IRQ_STATUS_DEC_SUCCESS)
		return IRQ_HANDLED;

		/* clear interrupt */
		writel(dec_done_status \| VDEC_IRQ_CFG, vdec_misc_addr);
		writel(dec_done_status & ~VDEC_IRQ_CLR, vdec_misc_addr);

		wake_up_ctx(ctx, MTK_INST_IRQ_RECEIVED);

		mtk_v4l2_debug(3, "wake up ctx %d, dec_done_status=%x",
		ctx->id, dec_done_status);

		return IRQ_HANDLED;
		}

		static int mtk_vdec_hw_init_irq(struct mtk_vdec_hw_dev *dev)
		{
		struct platform_device *pdev = dev->plat_dev;
		int ret;

		dev->dec_irq = platform_get_irq(pdev, 0);
		if (dev->dec_irq < 0) {
		dev_err(&pdev->dev, "Failed to get irq resource");
		return dev->dec_irq;
		}

		irq_set_status_flags(dev->dec_irq, IRQ_NOAUTOEN);
		ret = devm_request_irq(&pdev->dev, dev->dec_irq,
		mtk_vdec_hw_irq_handler, 0, pdev->name, dev);
		if (ret) {
		dev_err(&pdev->dev, "Failed to install dev->dec_irq %d (%d)",
		dev->dec_irq, ret);
		return ret;
		}

		return 0;
		}

		static int mtk_vdec_hw_probe(struct platform_device *pdev)
		{
		struct device *dev = &pdev->dev;
		struct mtk_vdec_hw_dev *subdev_dev;
		struct mtk_vcodec_dev *main_dev;
		const struct of_device_id *of_id;
		int hw_idx;
		int ret;

		if (!dev->parent) {
		dev_err(dev, "no parent for hardware devices.\n");
		return -ENODEV;
		}

		main_dev = dev_get_drvdata(dev->parent);
		if (!main_dev) {
		dev_err(dev, "failed to get parent driver data");
		return -EINVAL;
		}

		subdev_dev = devm_kzalloc(dev, sizeof(*subdev_dev), GFP_KERNEL);
		if (!subdev_dev)
		return -ENOMEM;

		subdev_dev->plat_dev = pdev;
		ret = mtk_vcodec_init_dec_pm(pdev, &subdev_dev->pm);
		if (ret)
		return ret;

		of_id = of_match_device(mtk_vdec_hw_match, dev);
		if (!of_id) {
		dev_err(dev, "Can't get vdec subdev id.\n");
		ret = -EINVAL;
		goto err;
		}

		hw_idx = (enum mtk_vdec_hw_id)(uintptr_t)of_id->data;
		if (hw_idx >= MTK_VDEC_HW_MAX) {
		dev_err(dev, "Hardware index %d not correct.\n", hw_idx);
		ret = -EINVAL;
		goto err;
		}

		main_dev->subdev_dev[hw_idx] = subdev_dev;
		subdev_dev->hw_idx = hw_idx;
		subdev_dev->main_dev = main_dev;
		subdev_dev->reg_base[VDEC_HW_SYS] = main_dev->reg_base[VDEC_HW_SYS];
		set_bit(subdev_dev->hw_idx, main_dev->subdev_bitmap);

		ret = mtk_vdec_hw_init_irq(subdev_dev);
		if (ret)
		goto err;

		subdev_dev->reg_base[VDEC_HW_MISC] =
		devm_platform_ioremap_resource(pdev, 0);
		if (IS_ERR((__force void *)subdev_dev->reg_base[VDEC_HW_MISC])) {
		ret = PTR_ERR((__force void *)subdev_dev->reg_base[VDEC_HW_MISC]);
		goto err;
		}

		if (!main_dev->subdev_prob_done)
		main_dev->subdev_prob_done = mtk_vdec_hw_prob_done;

		platform_set_drvdata(pdev, subdev_dev);
		return 0;
		err:
		mtk_vcodec_release_dec_pm(&subdev_dev->pm);
		return ret;
		}

		static struct platform_driver mtk_vdec_driver = {
		.probe = mtk_vdec_hw_probe,
		.driver = {
		.name = "mtk-vdec-comp",
		.of_match_table = mtk_vdec_hw_match,
		},
		};
		module_platform_driver(mtk_vdec_driver);

		MODULE_LICENSE("GPL v2");
		MODULE_DESCRIPTION("Mediatek video decoder hardware driver");

drivers/media/platform/mtk-vcodec/mtk_vcodec_dec_hw.h

0 → 100644

+52 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Copyright (c) 2021 MediaTek Inc.
		* Author: Yunfei Dong <yunfei.dong@mediatek.com>
		*/

		#ifndef _MTK_VCODEC_DEC_HW_H_
		#define _MTK_VCODEC_DEC_HW_H_

		#include <linux/io.h>
		#include <linux/platform_device.h>

		#include "mtk_vcodec_drv.h"

		#define VDEC_HW_ACTIVE 0x10
		#define VDEC_IRQ_CFG 0x11
		#define VDEC_IRQ_CLR 0x10
		#define VDEC_IRQ_CFG_REG 0xa4

		/**
		* enum mtk_vdec_hw_reg_idx - subdev hardware register base index
		* @VDEC_HW_SYS : vdec soc register index
		* @VDEC_HW_MISC: vdec misc register index
		* @VDEC_HW_MAX : vdec supported max register index
		*/
		enum mtk_vdec_hw_reg_idx {
		VDEC_HW_SYS,
		VDEC_HW_MISC,
		VDEC_HW_MAX
		};

		/**
		* struct mtk_vdec_hw_dev - vdec hardware driver data
		* @plat_dev: platform device
		* @main_dev: main device
		* @reg_base: mapped address of MTK Vcodec registers.
		*
		* @dec_irq : decoder irq resource
		* @pm : power management control
		* @hw_idx : each hardware index
		*/
		struct mtk_vdec_hw_dev {
		struct platform_device *plat_dev;
		struct mtk_vcodec_dev *main_dev;
		void __iomem *reg_base[VDEC_HW_MAX];

		int dec_irq;
		struct mtk_vcodec_pm pm;
		int hw_idx;
		};

		#endif /* _MTK_VCODEC_DEC_HW_H_ */

drivers/media/platform/mtk-vcodec/mtk_vcodec_dec_stateful.c

+1 −0

Original line number	Diff line number	Diff line
		@@ -625,4 +625,5 @@ const struct mtk_vcodec_dec_pdata mtk_vdec_8173_pdata = {
		.num_framesizes = NUM_SUPPORTED_FRAMESIZE,
		.worker = mtk_vdec_worker,
		.flush_decoder = mtk_vdec_flush_decoder,
		.is_subdev_supported = false,
		};