Re: [PATCH v7 3/5] media: sunxi: Add A10 CSI driver

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



Hi Maxime,

Thanks for the update.

On Tue, Aug 20, 2019 at 01:24:34PM +0200, Maxime Ripard wrote:
> From: Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> 
> The older CSI drivers have camera capture interface different from the one
> in the newer ones.
> 
> This IP is pretty simple. Some variants (one controller out of two
> instances on some SoCs) have an ISP embedded, but there's no code that make
> use of it, so we ignored that part for now.
> 
> Signed-off-by: Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> ---
>  MAINTAINERS                                         |   8 +-
>  drivers/media/platform/sunxi/Kconfig                |   1 +-
>  drivers/media/platform/sunxi/Makefile               |   1 +-
>  drivers/media/platform/sunxi/sun4i-csi/Kconfig      |  11 +-
>  drivers/media/platform/sunxi/sun4i-csi/Makefile     |   5 +-
>  drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.c  | 305 +++++++++-
>  drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.h  | 159 +++++-
>  drivers/media/platform/sunxi/sun4i-csi/sun4i_dma.c  | 444 +++++++++++++-
>  drivers/media/platform/sunxi/sun4i-csi/sun4i_v4l2.c | 383 +++++++++++-
>  9 files changed, 1317 insertions(+)
>  create mode 100644 drivers/media/platform/sunxi/sun4i-csi/Kconfig
>  create mode 100644 drivers/media/platform/sunxi/sun4i-csi/Makefile
>  create mode 100644 drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.c
>  create mode 100644 drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.h
>  create mode 100644 drivers/media/platform/sunxi/sun4i-csi/sun4i_dma.c
>  create mode 100644 drivers/media/platform/sunxi/sun4i-csi/sun4i_v4l2.c
> 
> diff --git a/MAINTAINERS b/MAINTAINERS
> index 30bf852e6d6b..b15543b06a16 100644
> --- a/MAINTAINERS
> +++ b/MAINTAINERS
> @@ -1420,6 +1420,14 @@ F:	drivers/pinctrl/sunxi/
>  F:	drivers/soc/sunxi/
>  T:	git git://git.kernel.org/pub/scm/linux/kernel/git/sunxi/linux.git
>  
> +Allwinner A10 CSI driver
> +M:	Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> +L:	linux-media@xxxxxxxxxxxxxxx
> +T:	git git://linuxtv.org/media_tree.git
> +S:	Maintained
> +F:	drivers/media/platform/sunxi/sun4i-csi/
> +F:	Documentation/devicetree/bindings/media/allwinner,sun4i-a10-csi.yaml

The MAINTAINERS entry should be added in the first patch adding new files,
i.e. the DT binding patch.

> +
>  ARM/Amlogic Meson SoC CLOCK FRAMEWORK
>  M:	Neil Armstrong <narmstrong@xxxxxxxxxxxx>
>  M:	Jerome Brunet <jbrunet@xxxxxxxxxxxx>
> diff --git a/drivers/media/platform/sunxi/Kconfig b/drivers/media/platform/sunxi/Kconfig
> index 1b6e89cb78b2..71808e93ac2e 100644
> --- a/drivers/media/platform/sunxi/Kconfig
> +++ b/drivers/media/platform/sunxi/Kconfig
> @@ -1 +1,2 @@
> +source "drivers/media/platform/sunxi/sun4i-csi/Kconfig"
>  source "drivers/media/platform/sunxi/sun6i-csi/Kconfig"
> diff --git a/drivers/media/platform/sunxi/Makefile b/drivers/media/platform/sunxi/Makefile
> index 8d06f98500ee..a05127529006 100644
> --- a/drivers/media/platform/sunxi/Makefile
> +++ b/drivers/media/platform/sunxi/Makefile
> @@ -1 +1,2 @@
> +obj-y		+= sun4i-csi/
>  obj-y		+= sun6i-csi/
> diff --git a/drivers/media/platform/sunxi/sun4i-csi/Kconfig b/drivers/media/platform/sunxi/sun4i-csi/Kconfig
> new file mode 100644
> index 000000000000..e86e29b6a603
> --- /dev/null
> +++ b/drivers/media/platform/sunxi/sun4i-csi/Kconfig
> @@ -0,0 +1,11 @@
> +config VIDEO_SUN4I_CSI
> +	tristate "Allwinner A10 CMOS Sensor Interface Support"
> +	depends on VIDEO_V4L2 && COMMON_CLK && VIDEO_V4L2_SUBDEV_API && HAS_DMA
> +	depends on ARCH_SUNXI || COMPILE_TEST
> +	select VIDEOBUF2_DMA_CONTIG
> +	select V4L2_FWNODE
> +	help
> +	  This is a V4L2 driver for the Allwinner A10 CSI
> +
> +	  To compile this driver as a module, choose M here: the module
> +	  will be called sun4i_csi.
> diff --git a/drivers/media/platform/sunxi/sun4i-csi/Makefile b/drivers/media/platform/sunxi/sun4i-csi/Makefile
> new file mode 100644
> index 000000000000..7c790a57f5ee
> --- /dev/null
> +++ b/drivers/media/platform/sunxi/sun4i-csi/Makefile
> @@ -0,0 +1,5 @@
> +sun4i-csi-y += sun4i_csi.o
> +sun4i-csi-y += sun4i_dma.o
> +sun4i-csi-y += sun4i_v4l2.o
> +
> +obj-$(CONFIG_VIDEO_SUN4I_CSI)	+= sun4i-csi.o
> diff --git a/drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.c b/drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.c
> new file mode 100644
> index 000000000000..6f7980e28a98
> --- /dev/null
> +++ b/drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.c
> @@ -0,0 +1,305 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright (C) 2016 NextThing Co
> + * Copyright (C) 2016-2019 Bootlin
> + *
> + * Author: Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> + */
> +
> +#include <linux/clk.h>
> +#include <linux/interrupt.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/of.h>
> +#include <linux/of_graph.h>
> +#include <linux/platform_device.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/reset.h>
> +#include <linux/videodev2.h>
> +
> +#include <media/v4l2-dev.h>
> +#include <media/v4l2-device.h>
> +#include <media/v4l2-fwnode.h>
> +#include <media/v4l2-ioctl.h>
> +#include <media/v4l2-mediabus.h>
> +
> +#include <media/videobuf2-core.h>
> +#include <media/videobuf2-dma-contig.h>
> +
> +#include "sun4i_csi.h"
> +
> +static const struct media_entity_operations sun4i_csi_video_entity_ops = {
> +	.link_validate = v4l2_subdev_link_validate,
> +};
> +
> +static int sun4i_csi_notify_bound(struct v4l2_async_notifier *notifier,
> +				  struct v4l2_subdev *subdev,
> +				  struct v4l2_async_subdev *asd)
> +{
> +	struct sun4i_csi *csi = container_of(notifier, struct sun4i_csi,
> +					     notifier);
> +
> +	csi->src_subdev = subdev;
> +	csi->src_pad = media_entity_get_fwnode_pad(&subdev->entity,
> +						   subdev->fwnode,
> +						   MEDIA_PAD_FL_SOURCE);
> +	if (csi->src_pad < 0) {
> +		dev_err(csi->dev, "Couldn't find output pad for subdev %s\n",
> +			subdev->name);
> +		return csi->src_pad;
> +	}
> +
> +	dev_dbg(csi->dev, "Bound %s pad: %d\n", subdev->name, csi->src_pad);
> +	return 0;
> +}
> +
> +static int sun4i_csi_notify_complete(struct v4l2_async_notifier *notifier)
> +{
> +	struct sun4i_csi *csi = container_of(notifier, struct sun4i_csi,
> +					     notifier);
> +	struct v4l2_subdev *subdev = &csi->subdev;
> +	struct video_device *vdev = &csi->vdev;
> +	int ret;
> +
> +	ret = v4l2_device_register_subdev(&csi->v4l, subdev);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = sun4i_csi_v4l2_register(csi);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = media_device_register(&csi->mdev);
> +	if (ret)
> +		return ret;
> +
> +	/* Create link from subdev to main device */
> +	ret = media_create_pad_link(&subdev->entity, CSI_SUBDEV_SOURCE,
> +				    &vdev->entity, 0,
> +				    MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
> +	if (ret)
> +		goto err_clean_media;
> +
> +	ret = media_create_pad_link(&csi->src_subdev->entity, csi->src_pad,
> +				    &subdev->entity, CSI_SUBDEV_SINK,
> +				    MEDIA_LNK_FL_ENABLED | MEDIA_LNK_FL_IMMUTABLE);
> +	if (ret)
> +		goto err_clean_media;
> +
> +	ret = v4l2_device_register_subdev_nodes(&csi->v4l);
> +	if (ret < 0)
> +		goto err_clean_media;
> +
> +	return 0;
> +
> +err_clean_media:
> +	media_device_unregister(&csi->mdev);
> +
> +	return ret;
> +}
> +
> +static const struct v4l2_async_notifier_operations sun4i_csi_notify_ops = {
> +	.bound		= sun4i_csi_notify_bound,
> +	.complete	= sun4i_csi_notify_complete,
> +};
> +
> +static int sun4i_csi_async_parse(struct device *dev,
> +				 struct v4l2_fwnode_endpoint *vep,
> +				 struct v4l2_async_subdev *asd)
> +{
> +	struct sun4i_csi *csi = dev_get_drvdata(dev);
> +
> +	if (vep->base.port || vep->base.id)
> +		return -EINVAL;
> +
> +	if (vep->bus_type != V4L2_MBUS_PARALLEL)
> +		return -EINVAL;
> +
> +	csi->bus = vep->bus.parallel;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_probe(struct platform_device *pdev)
> +{
> +	struct v4l2_subdev *subdev;
> +	struct video_device *vdev;
> +	struct sun4i_csi *csi;
> +	struct resource *res;
> +	int ret;
> +	int irq;
> +
> +	csi = devm_kzalloc(&pdev->dev, sizeof(*csi), GFP_KERNEL);
> +	if (!csi)
> +		return -ENOMEM;
> +	platform_set_drvdata(pdev, csi);
> +	csi->dev = &pdev->dev;
> +	subdev = &csi->subdev;
> +	vdev = &csi->vdev;
> +
> +	csi->mdev.dev = csi->dev;
> +	strscpy(csi->mdev.model, "Allwinner Video Capture Device",
> +		sizeof(csi->mdev.model));
> +	csi->mdev.hw_revision = 0;
> +	media_device_init(&csi->mdev);
> +	v4l2_async_notifier_init(&csi->notifier);
> +
> +	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
> +	csi->regs = devm_ioremap_resource(&pdev->dev, res);
> +	if (IS_ERR(csi->regs))
> +		return PTR_ERR(csi->regs);
> +
> +	irq = platform_get_irq(pdev, 0);
> +	if (irq < 0)
> +		return irq;
> +
> +	csi->bus_clk = devm_clk_get(&pdev->dev, "bus");
> +	if (IS_ERR(csi->bus_clk)) {
> +		dev_err(&pdev->dev, "Couldn't get our bus clock\n");
> +		return PTR_ERR(csi->bus_clk);
> +	}
> +
> +	csi->isp_clk = devm_clk_get(&pdev->dev, "isp");
> +	if (IS_ERR(csi->isp_clk)) {
> +		dev_err(&pdev->dev, "Couldn't get our ISP clock\n");
> +		return PTR_ERR(csi->isp_clk);
> +	}
> +
> +	csi->ram_clk = devm_clk_get(&pdev->dev, "ram");
> +	if (IS_ERR(csi->ram_clk)) {
> +		dev_err(&pdev->dev, "Couldn't get our ram clock\n");
> +		return PTR_ERR(csi->ram_clk);
> +	}
> +
> +	csi->rst = devm_reset_control_get(&pdev->dev, NULL);
> +	if (IS_ERR(csi->rst)) {
> +		dev_err(&pdev->dev, "Couldn't get our reset line\n");
> +		return PTR_ERR(csi->rst);
> +	}
> +
> +	/* Initialize subdev */
> +	v4l2_subdev_init(subdev, &sun4i_csi_subdev_ops);
> +	subdev->flags = V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS;
> +	subdev->entity.function = MEDIA_ENT_F_VID_IF_BRIDGE;
> +	subdev->owner = THIS_MODULE;
> +	snprintf(subdev->name, sizeof(subdev->name), "sun4i-csi-0");
> +	v4l2_set_subdevdata(subdev, csi);
> +
> +	csi->subdev_pads[CSI_SUBDEV_SINK].flags =
> +		MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
> +	csi->subdev_pads[CSI_SUBDEV_SOURCE].flags = MEDIA_PAD_FL_SOURCE;
> +	ret = media_entity_pads_init(&subdev->entity, CSI_SUBDEV_PADS,
> +				     csi->subdev_pads);
> +	if (ret < 0)
> +		return ret;
> +
> +	csi->vdev_pad.flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
> +	vdev->entity.ops = &sun4i_csi_video_entity_ops;
> +	ret = media_entity_pads_init(&vdev->entity, 1, &csi->vdev_pad);
> +	if (ret < 0)
> +		return ret;
> +
> +	ret = sun4i_csi_dma_register(csi, irq);
> +	if (ret)
> +		goto err_clean_pad;
> +
> +	csi->v4l.mdev = &csi->mdev;
> +	ret = v4l2_async_notifier_parse_fwnode_endpoints(csi->dev,
> +							 &csi->notifier,
> +							 sizeof(struct v4l2_async_subdev),
> +							 sun4i_csi_async_parse);

Could you instead use fwnode_graph_get_endpoint_by_id() and then parse it
using v4l2_fwnode_endpoint_parse()? There's an example in
drivers/media/pci/intel/ipu3/ipu3-cio2.c .

> +	if (ret)
> +		goto err_unregister_media;
> +	csi->notifier.ops = &sun4i_csi_notify_ops;
> +
> +	ret = v4l2_async_notifier_register(&csi->v4l, &csi->notifier);
> +	if (ret) {
> +		dev_err(csi->dev,
> +			"Couldn't register our v4l2-async notifier\n");
> +		goto err_free_notifier;
> +	}
> +
> +	pm_runtime_enable(&pdev->dev);
> +
> +	return 0;
> +
> +err_free_notifier:
> +	v4l2_async_notifier_cleanup(&csi->notifier);
> +
> +err_unregister_media:
> +	media_device_unregister(&csi->mdev);
> +	sun4i_csi_dma_unregister(csi);
> +
> +err_clean_pad:
> +	media_device_cleanup(&csi->mdev);
> +
> +	return ret;
> +}
> +
> +static int sun4i_csi_remove(struct platform_device *pdev)
> +{
> +	struct sun4i_csi *csi = platform_get_drvdata(pdev);
> +
> +	v4l2_async_notifier_unregister(&csi->notifier);
> +	v4l2_async_notifier_cleanup(&csi->notifier);
> +	media_device_unregister(&csi->mdev);
> +	sun4i_csi_dma_unregister(csi);
> +	media_device_cleanup(&csi->mdev);
> +
> +	return 0;
> +}
> +
> +static const struct of_device_id sun4i_csi_of_match[] = {
> +	{ .compatible = "allwinner,sun7i-a20-csi0" },
> +	{ /* Sentinel */ }
> +};
> +MODULE_DEVICE_TABLE(of, sun4i_csi_of_match);
> +
> +static int __maybe_unused sun4i_csi_runtime_resume(struct device *dev)
> +{
> +	struct sun4i_csi *csi = dev_get_drvdata(dev);
> +
> +	reset_control_deassert(csi->rst);
> +	clk_prepare_enable(csi->bus_clk);
> +	clk_prepare_enable(csi->ram_clk);
> +	clk_set_rate(csi->isp_clk, 80000000);
> +	clk_prepare_enable(csi->isp_clk);
> +
> +	writel(1, csi->regs + CSI_EN_REG);
> +
> +	return 0;
> +}
> +
> +static int __maybe_unused sun4i_csi_runtime_suspend(struct device *dev)
> +{
> +	struct sun4i_csi *csi = dev_get_drvdata(dev);
> +
> +	clk_disable_unprepare(csi->isp_clk);
> +	clk_disable_unprepare(csi->ram_clk);
> +	clk_disable_unprepare(csi->bus_clk);
> +
> +	reset_control_assert(csi->rst);
> +
> +	return 0;
> +}
> +
> +static const struct dev_pm_ops sun4i_csi_pm_ops = {
> +	SET_RUNTIME_PM_OPS(sun4i_csi_runtime_suspend,
> +			   sun4i_csi_runtime_resume,
> +			   NULL)
> +};
> +
> +static struct platform_driver sun4i_csi_driver = {
> +	.probe	= sun4i_csi_probe,
> +	.remove	= sun4i_csi_remove,
> +	.driver	= {
> +		.name		= "sun4i-csi",
> +		.of_match_table	= sun4i_csi_of_match,
> +		.pm		= &sun4i_csi_pm_ops,
> +	},
> +};
> +module_platform_driver(sun4i_csi_driver);
> +
> +MODULE_DESCRIPTION("Allwinner A10 Camera Sensor Interface driver");
> +MODULE_AUTHOR("Maxime Ripard <mripard@xxxxxxxxxx>");
> +MODULE_LICENSE("GPL");
> diff --git a/drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.h b/drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.h
> new file mode 100644
> index 000000000000..df23fda46c0e
> --- /dev/null
> +++ b/drivers/media/platform/sunxi/sun4i-csi/sun4i_csi.h
> @@ -0,0 +1,159 @@
> +/* SPDX-License-Identifier: GPL-2.0+ */
> +/*
> + * Copyright (C) 2016 NextThing Co
> + * Copyright (C) 2016-2019 Bootlin
> + *
> + * Author: Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> + */
> +
> +#ifndef _SUN4I_CSI_H_
> +#define _SUN4I_CSI_H_
> +
> +#include <media/media-device.h>
> +#include <media/v4l2-async.h>
> +#include <media/v4l2-dev.h>
> +#include <media/v4l2-device.h>
> +#include <media/v4l2-fwnode.h>
> +#include <media/videobuf2-core.h>
> +
> +#define CSI_EN_REG			0x00
> +
> +#define CSI_CFG_REG			0x04
> +#define CSI_CFG_INPUT_FMT(fmt)			((fmt) << 20)
> +#define CSI_CFG_OUTPUT_FMT(fmt)			((fmt) << 16)
> +#define CSI_CFG_YUV_DATA_SEQ(seq)		((seq) << 8)
> +#define CSI_CFG_VSYNC_POL(pol)			((pol) << 2)
> +#define CSI_CFG_HSYNC_POL(pol)			((pol) << 1)
> +#define CSI_CFG_PCLK_POL(pol)			((pol) << 0)
> +
> +#define CSI_CPT_CTRL_REG		0x08
> +#define CSI_CPT_CTRL_VIDEO_START		BIT(1)
> +#define CSI_CPT_CTRL_IMAGE_START		BIT(0)
> +
> +#define CSI_BUF_ADDR_REG(fifo, buf)	(0x10 + (0x8 * (fifo)) + (0x4 * (buf)))
> +
> +#define CSI_BUF_CTRL_REG		0x28
> +#define CSI_BUF_CTRL_DBN			BIT(2)
> +#define CSI_BUF_CTRL_DBS			BIT(1)
> +#define CSI_BUF_CTRL_DBE			BIT(0)
> +
> +#define CSI_INT_EN_REG			0x30
> +#define CSI_INT_FRM_DONE			BIT(1)
> +#define CSI_INT_CPT_DONE			BIT(0)
> +
> +#define CSI_INT_STA_REG			0x34
> +
> +#define CSI_WIN_CTRL_W_REG		0x40
> +#define CSI_WIN_CTRL_W_ACTIVE(w)		((w) << 16)
> +
> +#define CSI_WIN_CTRL_H_REG		0x44
> +#define CSI_WIN_CTRL_H_ACTIVE(h)		((h) << 16)
> +
> +#define CSI_BUF_LEN_REG			0x48
> +
> +#define CSI_MAX_BUFFER		2
> +#define CSI_MAX_HEIGHT		8192U
> +#define CSI_MAX_WIDTH		8192U
> +
> +enum csi_input {
> +	CSI_INPUT_RAW	= 0,
> +	CSI_INPUT_BT656	= 2,
> +	CSI_INPUT_YUV	= 3,
> +};
> +
> +enum csi_output_raw {
> +	CSI_OUTPUT_RAW_PASSTHROUGH = 0,
> +};
> +
> +enum csi_output_yuv {
> +	CSI_OUTPUT_YUV_422_PLANAR	= 0,
> +	CSI_OUTPUT_YUV_420_PLANAR	= 1,
> +	CSI_OUTPUT_YUV_422_UV		= 4,
> +	CSI_OUTPUT_YUV_420_UV		= 5,
> +	CSI_OUTPUT_YUV_422_MACRO	= 8,
> +	CSI_OUTPUT_YUV_420_MACRO	= 9,
> +};
> +
> +enum csi_yuv_data_seq {
> +	CSI_YUV_DATA_SEQ_YUYV	= 0,
> +	CSI_YUV_DATA_SEQ_YVYU	= 1,
> +	CSI_YUV_DATA_SEQ_UYVY	= 2,
> +	CSI_YUV_DATA_SEQ_VYUY	= 3,
> +};
> +
> +enum csi_subdev_pads {
> +	CSI_SUBDEV_SINK,
> +	CSI_SUBDEV_SOURCE,
> +
> +	CSI_SUBDEV_PADS,
> +};
> +
> +extern const struct v4l2_subdev_ops sun4i_csi_subdev_ops;
> +
> +struct sun4i_csi_format {
> +	u32			mbus;
> +	u32			fourcc;
> +	enum csi_input		input;
> +	u32			output;
> +	unsigned int		num_planes;
> +	u8			bpp[3];
> +	unsigned int		hsub;
> +	unsigned int		vsub;
> +};
> +
> +const struct sun4i_csi_format *sun4i_csi_find_format(const u32 *fourcc,
> +						     const u32 *mbus);
> +
> +struct sun4i_csi {
> +	/* Device resources */
> +	struct device			*dev;
> +
> +	void __iomem			*regs;
> +	struct clk			*bus_clk;
> +	struct clk			*isp_clk;
> +	struct clk			*ram_clk;
> +	struct reset_control		*rst;
> +
> +	struct vb2_v4l2_buffer		*current_buf[CSI_MAX_BUFFER];
> +
> +	struct {
> +		size_t			size;
> +		void			*vaddr;
> +		dma_addr_t		paddr;
> +	} scratch;
> +
> +	struct v4l2_fwnode_bus_parallel	bus;
> +
> +	/* Main Device */
> +	struct v4l2_device		v4l;
> +	struct media_device		mdev;
> +	struct video_device		vdev;
> +	struct media_pad		vdev_pad;
> +	struct v4l2_pix_format_mplane	fmt;
> +
> +	/* Local subdev */
> +	struct v4l2_subdev		subdev;
> +	struct media_pad		subdev_pads[CSI_SUBDEV_PADS];
> +	struct v4l2_mbus_framefmt	subdev_fmt;
> +
> +	/* V4L2 Async variables */
> +	struct v4l2_async_notifier	notifier;
> +	struct v4l2_subdev		*src_subdev;
> +	int				src_pad;
> +
> +	/* V4L2 variables */
> +	struct mutex			lock;
> +
> +	/* Videobuf2 */
> +	struct vb2_queue		queue;
> +	struct list_head		buf_list;
> +	spinlock_t			qlock;
> +	unsigned int			sequence;
> +};
> +
> +int sun4i_csi_dma_register(struct sun4i_csi *csi, int irq);
> +void sun4i_csi_dma_unregister(struct sun4i_csi *csi);
> +
> +int sun4i_csi_v4l2_register(struct sun4i_csi *csi);
> +
> +#endif /* _SUN4I_CSI_H_ */
> diff --git a/drivers/media/platform/sunxi/sun4i-csi/sun4i_dma.c b/drivers/media/platform/sunxi/sun4i-csi/sun4i_dma.c
> new file mode 100644
> index 000000000000..06cea6d2ea87
> --- /dev/null
> +++ b/drivers/media/platform/sunxi/sun4i-csi/sun4i_dma.c
> @@ -0,0 +1,444 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright (C) 2016 NextThing Co
> + * Copyright (C) 2016-2019 Bootlin
> + *
> + * Author: Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> + */
> +
> +#include <linux/device.h>
> +#include <linux/interrupt.h>
> +#include <linux/list.h>
> +#include <linux/mutex.h>
> +#include <linux/spinlock.h>
> +#include <media/videobuf2-dma-contig.h>
> +#include <media/videobuf2-v4l2.h>
> +
> +#include "sun4i_csi.h"
> +
> +struct sun4i_csi_buffer {
> +	struct vb2_v4l2_buffer	vb;
> +	struct list_head	list;
> +};
> +
> +static inline struct sun4i_csi_buffer *
> +vb2_v4l2_to_csi_buffer(const struct vb2_v4l2_buffer *p)
> +{
> +	return container_of(p, struct sun4i_csi_buffer, vb);
> +}
> +
> +static inline struct sun4i_csi_buffer *
> +vb2_to_csi_buffer(const struct vb2_buffer *p)
> +{
> +	return vb2_v4l2_to_csi_buffer(to_vb2_v4l2_buffer(p));
> +}
> +
> +static void sun4i_csi_capture_start(struct sun4i_csi *csi)
> +{
> +	writel(CSI_CPT_CTRL_VIDEO_START, csi->regs + CSI_CPT_CTRL_REG);
> +}
> +
> +static void sun4i_csi_capture_stop(struct sun4i_csi *csi)
> +{
> +	writel(0, csi->regs + CSI_CPT_CTRL_REG);
> +}
> +
> +static int sun4i_csi_queue_setup(struct vb2_queue *vq,
> +				 unsigned int *nbuffers,
> +				 unsigned int *nplanes,
> +				 unsigned int sizes[],
> +				 struct device *alloc_devs[])
> +{
> +	struct sun4i_csi *csi = vb2_get_drv_priv(vq);
> +	unsigned int num_planes = csi->fmt.num_planes;
> +	unsigned int i;
> +
> +	if (*nplanes) {
> +                if (*nplanes != num_planes)
> +                        return -EINVAL;
> +
> +                for (i = 0; i < num_planes; i++)
> +                        if (sizes[i] < csi->fmt.plane_fmt[i].sizeimage)
> +                                return -EINVAL;
> +                return 0;
> +        }

Tabs, please.

> +
> +	*nplanes = num_planes;
> +	for (i = 0; i < num_planes; i++)
> +		sizes[i] = csi->fmt.plane_fmt[i].sizeimage;
> +
> +	return 0;
> +};
> +
> +static int sun4i_csi_buffer_prepare(struct vb2_buffer *vb)
> +{
> +	struct sun4i_csi *csi = vb2_get_drv_priv(vb->vb2_queue);
> +	unsigned int i;
> +
> +	for (i = 0; i < csi->fmt.num_planes; i++) {
> +		unsigned long size = csi->fmt.plane_fmt[i].sizeimage;
> +
> +		if (vb2_plane_size(vb, i) < size) {
> +			dev_err(csi->dev, "buffer too small (%lu < %lu)\n",
> +				vb2_plane_size(vb, i), size);
> +			return -EINVAL;
> +		}
> +
> +		vb2_set_plane_payload(vb, i, size);
> +	}
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_setup_scratch_buffer(struct sun4i_csi *csi, unsigned int slot)
> +{
> +	dma_addr_t addr = csi->scratch.paddr;
> +	unsigned int plane;
> +
> +	dev_dbg(csi->dev,
> +		"No more available buffer, using the scratch buffer\n");
> +
> +	for (plane = 0; plane < csi->fmt.num_planes; plane++) {
> +		writel(addr, csi->regs + CSI_BUF_ADDR_REG(plane, slot));
> +		addr += csi->fmt.plane_fmt[plane].sizeimage;
> +	}
> +
> +	csi->current_buf[slot] = NULL;
> +	return 0;
> +}
> +
> +static int sun4i_csi_buffer_fill_slot(struct sun4i_csi *csi, unsigned int slot)
> +{
> +	struct sun4i_csi_buffer *c_buf;
> +	struct vb2_v4l2_buffer *v_buf;
> +	unsigned int plane;
> +
> +	/*
> +	 * We should never end up in a situation where we overwrite an
> +	 * already filled slot.
> +	 */
> +	if (WARN_ON(csi->current_buf[slot]))
> +		return -EINVAL;
> +
> +	if (list_empty(&csi->buf_list))
> +		return sun4i_csi_setup_scratch_buffer(csi, slot);
> +
> +	c_buf = list_first_entry(&csi->buf_list, struct sun4i_csi_buffer, list);
> +	list_del_init(&c_buf->list);
> +
> +	v_buf = &c_buf->vb;
> +	csi->current_buf[slot] = v_buf;
> +
> +	for (plane = 0; plane < csi->fmt.num_planes; plane++) {
> +		dma_addr_t buf_addr;
> +
> +		buf_addr = vb2_dma_contig_plane_dma_addr(&v_buf->vb2_buf,
> +							 plane);
> +		writel(buf_addr, csi->regs + CSI_BUF_ADDR_REG(plane, slot));
> +	}
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_buffer_fill_all(struct sun4i_csi *csi)
> +{
> +	unsigned int slot;
> +	int ret;
> +
> +	for (slot = 0; slot < CSI_MAX_BUFFER; slot++) {
> +		ret = sun4i_csi_buffer_fill_slot(csi, slot);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +static void sun4i_csi_buffer_mark_done(struct sun4i_csi *csi,
> +				       unsigned int slot,
> +				       unsigned int sequence)
> +{
> +	struct vb2_v4l2_buffer *v_buf;
> +
> +	if (!csi->current_buf[slot]) {
> +		dev_dbg(csi->dev, "Scratch buffer was used, ignoring..\n");
> +		return;
> +	}
> +
> +	v_buf = csi->current_buf[slot];
> +	v_buf->field = csi->fmt.field;
> +	v_buf->sequence = sequence;
> +	v_buf->vb2_buf.timestamp = ktime_get_ns();
> +	vb2_buffer_done(&v_buf->vb2_buf, VB2_BUF_STATE_DONE);
> +
> +	csi->current_buf[slot] = NULL;
> +}
> +
> +static int sun4i_csi_buffer_flip(struct sun4i_csi *csi, unsigned int sequence)
> +{
> +	u32 reg = readl(csi->regs + CSI_BUF_CTRL_REG);
> +	unsigned int curr, next;
> +
> +	/* Our next buffer is not the current buffer */
> +	curr = !!(reg & CSI_BUF_CTRL_DBS);
> +	next = !curr;

Hmm. Isn't this the same as:

	next = !(reg & CSI_BUF_CTRL_DBS);

> +
> +	/* Report the previous buffer as done */
> +	sun4i_csi_buffer_mark_done(csi, next, sequence);
> +
> +	/* Put a new buffer in there */
> +	return sun4i_csi_buffer_fill_slot(csi, next);
> +}
> +
> +static void sun4i_csi_buffer_queue(struct vb2_buffer *vb)
> +{
> +	struct sun4i_csi *csi = vb2_get_drv_priv(vb->vb2_queue);
> +	struct sun4i_csi_buffer *buf = vb2_to_csi_buffer(vb);
> +	unsigned long flags;
> +
> +	spin_lock_irqsave(&csi->qlock, flags);
> +	list_add_tail(&buf->list, &csi->buf_list);
> +	spin_unlock_irqrestore(&csi->qlock, flags);
> +}
> +
> +static void return_all_buffers(struct sun4i_csi *csi,
> +			       enum vb2_buffer_state state)
> +{
> +	struct sun4i_csi_buffer *buf, *node;
> +	unsigned int slot;
> +
> +	list_for_each_entry_safe(buf, node, &csi->buf_list, list) {
> +		vb2_buffer_done(&buf->vb.vb2_buf, state);
> +		list_del(&buf->list);
> +	}
> +
> +	for (slot = 0; slot < CSI_MAX_BUFFER; slot++) {
> +		struct vb2_v4l2_buffer *v_buf = csi->current_buf[slot];
> +
> +		if (!v_buf)
> +			continue;
> +
> +		vb2_buffer_done(&v_buf->vb2_buf, state);
> +		csi->current_buf[slot] = NULL;
> +	}
> +}
> +
> +static int sun4i_csi_start_streaming(struct vb2_queue *vq, unsigned int count)
> +{
> +	struct sun4i_csi *csi = vb2_get_drv_priv(vq);
> +	struct v4l2_fwnode_bus_parallel *bus = &csi->bus;
> +	const struct sun4i_csi_format *csi_fmt;
> +	unsigned long hsync_pol, pclk_pol, vsync_pol;
> +	unsigned long flags;
> +	unsigned int i;
> +	int ret;
> +
> +	csi_fmt = sun4i_csi_find_format(&csi->fmt.pixelformat, NULL);
> +	if (!csi_fmt)
> +		return -EINVAL;
> +
> +	dev_dbg(csi->dev, "Starting capture\n");
> +
> +	csi->sequence = 0;
> +
> +	/*
> +	 * We need a scratch buffer in case where we'll not have any
> +	 * more buffer queued so that we don't error out. One of those
> +	 * cases is when you end up at the last frame to capture, you
> +	 * don't havea any buffer queued any more, and yet it doesn't
> +	 * really matter since you'll never reach the next buffer.
> +	 *
> +	 * Since we support the multi-planar API, we need to have a
> +	 * buffer for each plane. Allocating a single one large enough
> +	 * to hold all the buffers is simpler, so let's go for that.
> +	 */
> +	csi->scratch.size = 0;
> +	for (i = 0; i < csi->fmt.num_planes; i++)
> +		csi->scratch.size += csi->fmt.plane_fmt[i].sizeimage;
> +
> +	csi->scratch.vaddr = dma_alloc_coherent(csi->dev,
> +						csi->scratch.size,
> +						&csi->scratch.paddr,
> +						GFP_KERNEL);
> +	if (!csi->scratch.vaddr) {
> +		dev_err(csi->dev, "Failed to allocate scratch buffer\n");
> +		ret = -ENOMEM;
> +		goto err_clear_dma_queue;
> +	}
> +
> +	ret = media_pipeline_start(&csi->vdev.entity, &csi->vdev.pipe);
> +	if (ret < 0)
> +		goto err_free_scratch_buffer;
> +
> +	spin_lock_irqsave(&csi->qlock, flags);
> +
> +	/* Setup timings */
> +	writel(CSI_WIN_CTRL_W_ACTIVE(csi->fmt.width * 2),
> +	       csi->regs + CSI_WIN_CTRL_W_REG);
> +	writel(CSI_WIN_CTRL_H_ACTIVE(csi->fmt.height),
> +	       csi->regs + CSI_WIN_CTRL_H_REG);
> +
> +	hsync_pol = !!(bus->flags & V4L2_MBUS_HSYNC_ACTIVE_HIGH);
> +	pclk_pol = !!(bus->flags & V4L2_MBUS_DATA_ACTIVE_HIGH);
> +	vsync_pol = !!(bus->flags & V4L2_MBUS_VSYNC_ACTIVE_HIGH);
> +	writel(CSI_CFG_INPUT_FMT(csi_fmt->input) |
> +	       CSI_CFG_OUTPUT_FMT(csi_fmt->output) |
> +	       CSI_CFG_VSYNC_POL(vsync_pol) |
> +	       CSI_CFG_HSYNC_POL(hsync_pol) |
> +	       CSI_CFG_PCLK_POL(pclk_pol),
> +	       csi->regs + CSI_CFG_REG);
> +
> +	/* Setup buffer length */
> +	writel(csi->fmt.plane_fmt[0].bytesperline,
> +	       csi->regs + CSI_BUF_LEN_REG);
> +
> +	/* Prepare our buffers in hardware */
> +	ret = sun4i_csi_buffer_fill_all(csi);
> +	if (ret) {
> +		spin_unlock_irqrestore(&csi->qlock, flags);
> +		goto err_disable_pipeline;
> +	}
> +
> +	/* Enable double buffering */
> +	writel(CSI_BUF_CTRL_DBE, csi->regs + CSI_BUF_CTRL_REG);
> +
> +	/* Clear the pending interrupts */
> +	writel(CSI_INT_FRM_DONE, csi->regs + 0x34);
> +
> +	/* Enable frame done interrupt */
> +	writel(CSI_INT_FRM_DONE, csi->regs + CSI_INT_EN_REG);
> +
> +	sun4i_csi_capture_start(csi);
> +
> +	spin_unlock_irqrestore(&csi->qlock, flags);
> +
> +	ret = v4l2_subdev_call(csi->src_subdev, video, s_stream, 1);
> +	if (ret < 0 && ret != -ENOIOCTLCMD)
> +		goto err_disable_device;
> +
> +	return 0;
> +
> +err_disable_device:
> +	sun4i_csi_capture_stop(csi);
> +
> +err_disable_pipeline:
> +	media_pipeline_stop(&csi->vdev.entity);
> +
> +err_free_scratch_buffer:
> +	dma_free_coherent(csi->dev, csi->scratch.size, csi->scratch.vaddr,
> +			  csi->scratch.paddr);
> +
> +err_clear_dma_queue:
> +	spin_lock_irqsave(&csi->qlock, flags);
> +	return_all_buffers(csi, VB2_BUF_STATE_QUEUED);
> +	spin_unlock_irqrestore(&csi->qlock, flags);
> +
> +	return ret;
> +}
> +
> +static void sun4i_csi_stop_streaming(struct vb2_queue *vq)
> +{
> +	struct sun4i_csi *csi = vb2_get_drv_priv(vq);
> +	unsigned long flags;
> +
> +	dev_dbg(csi->dev, "Stopping capture\n");
> +
> +	v4l2_subdev_call(csi->src_subdev, video, s_stream, 0);
> +	sun4i_csi_capture_stop(csi);
> +
> +	/* Release all active buffers */
> +	spin_lock_irqsave(&csi->qlock, flags);
> +	return_all_buffers(csi, VB2_BUF_STATE_ERROR);
> +	spin_unlock_irqrestore(&csi->qlock, flags);
> +
> +	media_pipeline_stop(&csi->vdev.entity);
> +
> +	dma_free_coherent(csi->dev, csi->scratch.size, csi->scratch.vaddr,
> +			  csi->scratch.paddr);
> +}
> +
> +static const struct vb2_ops sun4i_csi_qops = {
> +	.queue_setup		= sun4i_csi_queue_setup,
> +	.buf_prepare		= sun4i_csi_buffer_prepare,
> +	.buf_queue		= sun4i_csi_buffer_queue,
> +	.start_streaming	= sun4i_csi_start_streaming,
> +	.stop_streaming		= sun4i_csi_stop_streaming,
> +	.wait_prepare		= vb2_ops_wait_prepare,
> +	.wait_finish		= vb2_ops_wait_finish,
> +};
> +
> +static irqreturn_t sun4i_csi_irq(int irq, void *data)
> +{
> +	struct sun4i_csi *csi = data;
> +	u32 reg;
> +
> +	reg = readl(csi->regs + CSI_INT_STA_REG);
> +
> +	/* Acknowledge the interrupts */
> +	writel(reg, csi->regs + CSI_INT_STA_REG);
> +
> +	if (!(reg & CSI_INT_FRM_DONE))
> +		goto out;

I'd just return IRQ_HANDLED, no need for goto.

> +
> +	spin_lock(&csi->qlock);
> +	if (sun4i_csi_buffer_flip(csi, csi->sequence++)) {
> +		dev_warn(csi->dev, "%s: Flip failed\n", __func__);
> +		sun4i_csi_capture_stop(csi);
> +	}
> +	spin_unlock(&csi->qlock);
> +
> +out:
> +	return IRQ_HANDLED;
> +}
> +
> +int sun4i_csi_dma_register(struct sun4i_csi *csi, int irq)
> +{
> +	struct vb2_queue *q = &csi->queue;
> +	int ret;
> +	int i;
> +
> +	ret = v4l2_device_register(csi->dev, &csi->v4l);
> +	if (ret) {
> +		dev_err(csi->dev, "Couldn't register the v4l2 device\n");
> +		return ret;
> +	}
> +
> +	spin_lock_init(&csi->qlock);
> +	mutex_init(&csi->lock);
> +
> +	INIT_LIST_HEAD(&csi->buf_list);
> +	for (i = 0; i < CSI_MAX_BUFFER; i++)
> +		csi->current_buf[i] = NULL;
> +
> +	q->min_buffers_needed = 3;
> +	q->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> +	q->io_modes = VB2_MMAP;
> +	q->lock = &csi->lock;
> +	q->drv_priv = csi;
> +	q->buf_struct_size = sizeof(struct sun4i_csi_buffer);
> +	q->ops = &sun4i_csi_qops;
> +	q->mem_ops = &vb2_dma_contig_memops;
> +	q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
> +	q->dev = csi->dev;
> +
> +	ret = vb2_queue_init(q);
> +	if (ret < 0) {
> +		dev_err(csi->dev, "failed to initialize VB2 queue\n");
> +		return ret;
> +	}
> +
> +	ret = devm_request_irq(csi->dev, irq, sun4i_csi_irq, 0,
> +			       dev_name(csi->dev), csi);
> +	if (ret) {
> +		dev_err(csi->dev, "Couldn't register our interrupt\n");
> +		vb2_queue_release(q);

mutex_destroy(); same above and in cun4i_csi_dma_unregister(). A few labels
for error handling would seem appropriate.

v4l2_device_unregister(), too. I'd actually register the V4L2 device as
last.

> +		return ret;
> +	}
> +
> +	return 0;
> +}
> +
> +void sun4i_csi_dma_unregister(struct sun4i_csi *csi)
> +{
> +	v4l2_device_unregister(&csi->v4l);
> +}
> diff --git a/drivers/media/platform/sunxi/sun4i-csi/sun4i_v4l2.c b/drivers/media/platform/sunxi/sun4i-csi/sun4i_v4l2.c
> new file mode 100644
> index 000000000000..7e5369fab8a2
> --- /dev/null
> +++ b/drivers/media/platform/sunxi/sun4i-csi/sun4i_v4l2.c
> @@ -0,0 +1,383 @@
> +// SPDX-License-Identifier: GPL-2.0+
> +/*
> + * Copyright (C) 2016 NextThing Co
> + * Copyright (C) 2016-2019 Bootlin
> + *
> + * Author: Maxime Ripard <maxime.ripard@xxxxxxxxxxx>
> + */
> +
> +#include <linux/device.h>
> +#include <linux/pm_runtime.h>
> +
> +#include <media/v4l2-ioctl.h>
> +#include <media/v4l2-mc.h>
> +#include <media/videobuf2-v4l2.h>
> +
> +#include "sun4i_csi.h"
> +
> +#define CSI_DEFAULT_WIDTH	640
> +#define CSI_DEFAULT_HEIGHT	480
> +
> +const struct sun4i_csi_format sun4i_csi_formats[] = {
> +	/* YUV422 inputs */
> +	{
> +		.mbus		= MEDIA_BUS_FMT_YUYV8_2X8,
> +		.fourcc		= V4L2_PIX_FMT_YUV420M,
> +		.input		= CSI_INPUT_YUV,
> +		.output		= CSI_OUTPUT_YUV_420_PLANAR,
> +		.num_planes	= 3,
> +		.bpp		= { 8, 8, 8 },
> +		.hsub		= 2,
> +		.vsub		= 2,
> +	},
> +};
> +
> +const struct sun4i_csi_format *sun4i_csi_find_format(const u32 *fourcc,
> +						     const u32 *mbus)
> +{
> +	unsigned int i;
> +
> +	for (i = 0; i < ARRAY_SIZE(sun4i_csi_formats); i++) {
> +		if (fourcc && *fourcc != sun4i_csi_formats[i].fourcc)
> +			continue;
> +
> +		if (mbus && *mbus != sun4i_csi_formats[i].mbus)
> +			continue;
> +
> +		return &sun4i_csi_formats[i];
> +	}
> +
> +	return NULL;
> +}
> +
> +static int sun4i_csi_querycap(struct file *file, void *priv,
> +			      struct v4l2_capability *cap)
> +{
> +	struct sun4i_csi *csi = video_drvdata(file);
> +
> +	strscpy(cap->driver, KBUILD_MODNAME, sizeof(cap->driver));
> +	strscpy(cap->card, "sun4i-csi", sizeof(cap->card));
> +	snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
> +		 dev_name(csi->dev));
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_enum_input(struct file *file, void *priv,
> +				struct v4l2_input *inp)
> +{
> +	if (inp->index != 0)
> +		return -EINVAL;
> +
> +	inp->type = V4L2_INPUT_TYPE_CAMERA;
> +	strscpy(inp->name, "Camera", sizeof(inp->name));
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_g_input(struct file *file, void *fh,
> +			     unsigned int *i)
> +{
> +	*i = 0;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_s_input(struct file *file, void *fh,
> +			     unsigned int i)
> +{
> +	if (i != 0)
> +		return -EINVAL;
> +
> +	return 0;
> +}
> +
> +static void _sun4i_csi_try_fmt(struct sun4i_csi *csi,
> +			       struct v4l2_pix_format_mplane *pix)
> +{
> +	const struct sun4i_csi_format *_fmt;
> +	unsigned int height, width;
> +	unsigned int i;
> +
> +	_fmt = sun4i_csi_find_format(&pix->pixelformat, NULL);
> +	if (!_fmt)
> +		_fmt = &sun4i_csi_formats[0];
> +
> +	pix->field = V4L2_FIELD_NONE;
> +	pix->colorspace = V4L2_COLORSPACE_SRGB;
> +	pix->xfer_func = V4L2_MAP_XFER_FUNC_DEFAULT(pix->colorspace);
> +	pix->ycbcr_enc = V4L2_MAP_YCBCR_ENC_DEFAULT(pix->colorspace);
> +	pix->quantization = V4L2_MAP_QUANTIZATION_DEFAULT(true, pix->colorspace,
> +							  pix->ycbcr_enc);
> +
> +	pix->num_planes = _fmt->num_planes;
> +	pix->pixelformat = _fmt->fourcc;
> +
> +	memset(pix->reserved, 0, sizeof(pix->reserved));
> +
> +	/* Align the width and height on the subsampling */
> +	width = ALIGN(pix->width, _fmt->hsub);
> +	height = ALIGN(pix->height, _fmt->vsub);
> +
> +	/* Clamp the width and height to our capabilities */
> +	pix->width = clamp(width, _fmt->hsub, CSI_MAX_WIDTH);
> +	pix->height = clamp(height, _fmt->vsub, CSI_MAX_HEIGHT);
> +
> +	for (i = 0; i < _fmt->num_planes; i++) {
> +		unsigned int hsub = i > 0 ? _fmt->hsub : 1;
> +		unsigned int vsub = i > 0 ? _fmt->vsub : 1;
> +		unsigned int bpl;
> +
> +		bpl = pix->width / hsub * _fmt->bpp[i] / 8;
> +		pix->plane_fmt[i].bytesperline = bpl;
> +		pix->plane_fmt[i].sizeimage = bpl * pix->height / vsub;
> +		memset(pix->plane_fmt[i].reserved, 0,
> +		       sizeof(pix->plane_fmt[i].reserved));
> +	}
> +}
> +
> +static int sun4i_csi_try_fmt_vid_cap(struct file *file, void *priv,
> +				     struct v4l2_format *f)
> +{
> +	struct sun4i_csi *csi = video_drvdata(file);
> +
> +	_sun4i_csi_try_fmt(csi, &f->fmt.pix_mp);

Newline?

> +	return 0;
> +}
> +
> +static int sun4i_csi_s_fmt_vid_cap(struct file *file, void *priv,
> +				   struct v4l2_format *f)
> +{
> +	struct sun4i_csi *csi = video_drvdata(file);
> +
> +	_sun4i_csi_try_fmt(csi, &f->fmt.pix_mp);
> +	csi->fmt = f->fmt.pix_mp;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_g_fmt_vid_cap(struct file *file, void *priv,
> +				   struct v4l2_format *f)
> +{
> +	struct sun4i_csi *csi = video_drvdata(file);
> +
> +	f->fmt.pix_mp = csi->fmt;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_enum_fmt_vid_cap(struct file *file, void *priv,
> +				      struct v4l2_fmtdesc *f)
> +{
> +	if (f->index >= ARRAY_SIZE(sun4i_csi_formats))
> +		return -EINVAL;
> +
> +	f->pixelformat = sun4i_csi_formats[f->index].fourcc;
> +
> +	return 0;
> +}
> +
> +static const struct v4l2_ioctl_ops sun4i_csi_ioctl_ops = {
> +	.vidioc_querycap		= sun4i_csi_querycap,
> +
> +	.vidioc_enum_fmt_vid_cap	= sun4i_csi_enum_fmt_vid_cap,
> +	.vidioc_g_fmt_vid_cap_mplane	= sun4i_csi_g_fmt_vid_cap,
> +	.vidioc_s_fmt_vid_cap_mplane	= sun4i_csi_s_fmt_vid_cap,
> +	.vidioc_try_fmt_vid_cap_mplane	= sun4i_csi_try_fmt_vid_cap,
> +
> +	.vidioc_enum_input		= sun4i_csi_enum_input,
> +	.vidioc_g_input			= sun4i_csi_g_input,
> +	.vidioc_s_input			= sun4i_csi_s_input,
> +
> +	.vidioc_reqbufs			= vb2_ioctl_reqbufs,
> +	.vidioc_create_bufs		= vb2_ioctl_create_bufs,
> +	.vidioc_querybuf		= vb2_ioctl_querybuf,
> +	.vidioc_qbuf			= vb2_ioctl_qbuf,
> +	.vidioc_dqbuf			= vb2_ioctl_dqbuf,
> +	.vidioc_expbuf			= vb2_ioctl_expbuf,
> +	.vidioc_prepare_buf		= vb2_ioctl_prepare_buf,
> +	.vidioc_streamon		= vb2_ioctl_streamon,
> +	.vidioc_streamoff		= vb2_ioctl_streamoff,
> +};
> +
> +static int sun4i_csi_open(struct file *file)
> +{
> +	struct sun4i_csi *csi = video_drvdata(file);
> +	int ret;
> +
> +	ret = mutex_lock_interruptible(&csi->lock);
> +	if (ret)
> +		return ret;
> +
> +	ret = pm_runtime_get_sync(csi->dev);
> +	if (ret < 0)
> +		goto err_pm_put;
> +
> +	ret = v4l2_pipeline_pm_use(&csi->vdev.entity, 1);
> +	if (ret)
> +		goto err_pm_put;
> +
> +	ret = v4l2_fh_open(file);
> +	if (ret)
> +		goto err_pipeline_pm_put;
> +
> +	mutex_unlock(&csi->lock);
> +
> +	return 0;
> +
> +err_pipeline_pm_put:
> +	v4l2_pipeline_pm_use(&csi->vdev.entity, 0);
> +
> +err_pm_put:
> +	pm_runtime_put(csi->dev);
> +	mutex_unlock(&csi->lock);
> +
> +	return ret;
> +}
> +
> +static int sun4i_csi_release(struct file *file)
> +{
> +	struct sun4i_csi *csi = video_drvdata(file);
> +
> +	mutex_lock(&csi->lock);
> +
> +	v4l2_fh_release(file);
> +	v4l2_pipeline_pm_use(&csi->vdev.entity, 0);
> +	pm_runtime_put(csi->dev);
> +
> +	mutex_unlock(&csi->lock);
> +
> +	return 0;
> +}
> +
> +static const struct v4l2_file_operations sun4i_csi_fops = {
> +	.owner		= THIS_MODULE,
> +	.open		= sun4i_csi_open,
> +	.release	= sun4i_csi_release,
> +	.unlocked_ioctl	= video_ioctl2,
> +	.read		= vb2_fop_read,
> +	.write		= vb2_fop_write,
> +	.poll		= vb2_fop_poll,
> +	.mmap		= vb2_fop_mmap,
> +};
> +
> +static const struct v4l2_mbus_framefmt sun4i_csi_pad_fmt_default = {
> +	.width = CSI_DEFAULT_WIDTH,
> +	.height = CSI_DEFAULT_HEIGHT,
> +	.code = sun4i_csi_formats[0].mbus,
> +	.field = V4L2_FIELD_NONE,
> +	.colorspace = V4L2_COLORSPACE_RAW,
> +	.ycbcr_enc = V4L2_YCBCR_ENC_DEFAULT,
> +	.quantization = V4L2_QUANTIZATION_DEFAULT,
> +	.xfer_func = V4L2_XFER_FUNC_DEFAULT,
> +};
> +
> +static int sun4i_csi_subdev_init_cfg(struct v4l2_subdev *subdev,
> +				     struct v4l2_subdev_pad_config *cfg)
> +{
> +	struct v4l2_mbus_framefmt *fmt;
> +
> +	fmt = v4l2_subdev_get_try_format(subdev, cfg, CSI_SUBDEV_SINK);
> +	*fmt = sun4i_csi_pad_fmt_default;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_subdev_get_fmt(struct v4l2_subdev *subdev,
> +				    struct v4l2_subdev_pad_config *cfg,
> +				    struct v4l2_subdev_format *fmt)
> +{
> +	struct sun4i_csi *csi = container_of(subdev, struct sun4i_csi, subdev);
> +	struct v4l2_mbus_framefmt *subdev_fmt;
> +
> +	if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
> +		subdev_fmt = v4l2_subdev_get_try_format(subdev, cfg, fmt->pad);
> +	else
> +		subdev_fmt = &csi->subdev_fmt;
> +
> +	fmt->format = *subdev_fmt;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_subdev_set_fmt(struct v4l2_subdev *subdev,
> +				    struct v4l2_subdev_pad_config *cfg,
> +				    struct v4l2_subdev_format *fmt)
> +{
> +	struct sun4i_csi *csi = container_of(subdev, struct sun4i_csi, subdev);
> +	struct v4l2_mbus_framefmt *subdev_fmt;
> +
> +	if (fmt->which == V4L2_SUBDEV_FORMAT_TRY)
> +		subdev_fmt = v4l2_subdev_get_try_format(subdev, cfg, fmt->pad);
> +	else
> +		subdev_fmt = &csi->subdev_fmt;
> +
> +	/* We can only set the format on the sink pad */
> +	if (fmt->pad == CSI_SUBDEV_SINK) {
> +		/* It's the sink, only allow changing the frame size */
> +		subdev_fmt->width = fmt->format.width;
> +		subdev_fmt->height = fmt->format.height;
> +		subdev_fmt->code = fmt->format.code;
> +	}
> +
> +	fmt->format = *subdev_fmt;
> +
> +	return 0;
> +}
> +
> +static int sun4i_csi_subdev_enum_mbus_code(struct v4l2_subdev *subdev,
> +					   struct v4l2_subdev_pad_config *cfg,
> +					   struct v4l2_subdev_mbus_code_enum *mbus)

Over 80 characters per line.

> +{
> +	if (mbus->index >= ARRAY_SIZE(sun4i_csi_formats))
> +		return -EINVAL;
> +
> +	mbus->code = sun4i_csi_formats[mbus->index].mbus;
> +
> +	return 0;
> +}
> +
> +static const struct v4l2_subdev_pad_ops sun4i_csi_subdev_pad_ops = {
> +	.link_validate	= v4l2_subdev_link_validate_default,
> +	.init_cfg	= sun4i_csi_subdev_init_cfg,
> +	.get_fmt	= sun4i_csi_subdev_get_fmt,
> +	.set_fmt	= sun4i_csi_subdev_set_fmt,
> +	.enum_mbus_code	= sun4i_csi_subdev_enum_mbus_code,
> +};
> +
> +const struct v4l2_subdev_ops sun4i_csi_subdev_ops = {
> +	.pad = &sun4i_csi_subdev_pad_ops,
> +};
> +
> +int sun4i_csi_v4l2_register(struct sun4i_csi *csi)
> +{
> +	struct video_device *vdev = &csi->vdev;
> +	int ret;
> +
> +	vdev->device_caps = V4L2_CAP_VIDEO_CAPTURE_MPLANE | V4L2_CAP_STREAMING;
> +	vdev->v4l2_dev = &csi->v4l;
> +	vdev->queue = &csi->queue;
> +	strscpy(vdev->name, KBUILD_MODNAME, sizeof(vdev->name));
> +	vdev->release = video_device_release_empty;
> +	vdev->lock = &csi->lock;
> +
> +	/* Set a default format */
> +	csi->fmt.pixelformat = sun4i_csi_formats[0].fourcc,
> +	csi->fmt.width = CSI_DEFAULT_WIDTH;
> +	csi->fmt.height = CSI_DEFAULT_HEIGHT;
> +	_sun4i_csi_try_fmt(csi, &csi->fmt);
> +	csi->subdev_fmt = sun4i_csi_pad_fmt_default;
> +
> +	vdev->fops = &sun4i_csi_fops;
> +	vdev->ioctl_ops = &sun4i_csi_ioctl_ops;
> +	video_set_drvdata(vdev, csi);
> +
> +	ret = video_register_device(&csi->vdev, VFL_TYPE_GRABBER, -1);
> +	if (ret)
> +		return ret;
> +
> +	dev_info(csi->dev, "Device registered as %s\n",
> +		 video_device_node_name(vdev));
> +
> +	return 0;
> +}

-- 
Kind regards,

Sakari Ailus
sakari.ailus@xxxxxxxxxxxxxxx



[Index of Archives]     [Linux Input]     [Video for Linux]     [Gstreamer Embedded]     [Mplayer Users]     [Linux USB Devel]     [Linux Audio Users]     [Linux Kernel]     [Linux SCSI]     [Yosemite Backpacking]

  Powered by Linux