From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.2 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, MENTIONS_GIT_HOSTING,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_SANE_1 autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1AF6EC3A59D for ; Tue, 20 Aug 2019 12:42:23 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by mail.kernel.org (Postfix) with ESMTP id C845D22CF7 for ; Tue, 20 Aug 2019 12:42:22 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729761AbfHTMmT (ORCPT ); Tue, 20 Aug 2019 08:42:19 -0400 Received: from mga03.intel.com ([134.134.136.65]:3937 "EHLO mga03.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727006AbfHTMmS (ORCPT ); Tue, 20 Aug 2019 08:42:18 -0400 X-Amp-Result: UNSCANNABLE X-Amp-File-Uploaded: False Received: from fmsmga003.fm.intel.com ([10.253.24.29]) by orsmga103.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 20 Aug 2019 05:42:16 -0700 X-IronPort-AV: E=Sophos;i="5.64,408,1559545200"; d="scan'208";a="185902800" Received: from paasikivi.fi.intel.com ([10.237.72.42]) by fmsmga003-auth.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 20 Aug 2019 05:42:12 -0700 Received: by paasikivi.fi.intel.com (Postfix, from userid 1000) id 94DD020512; Tue, 20 Aug 2019 15:42:10 +0300 (EEST) Date: Tue, 20 Aug 2019 15:42:10 +0300 From: Sakari Ailus To: Maxime Ripard Cc: Hans Verkuil , Mauro Carvalho Chehab , Thomas Petazzoni , Laurent Pinchart , linux-media@vger.kernel.org, Chen-Yu Tsai , linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org, devicetree@vger.kernel.org, Mark Rutland , Rob Herring , Frank Rowand , Maxime Ripard Subject: Re: [PATCH v7 3/5] media: sunxi: Add A10 CSI driver Message-ID: <20190820124210.GE5123@paasikivi.fi.intel.com> References: <6fdba6da624e2426937ca756d3a2c400dfd06993.1566300265.git-series.maxime.ripard@bootlin.com> MIME-Version: 1.0 Content-Type: text/plain; charset=us-ascii Content-Disposition: inline In-Reply-To: <6fdba6da624e2426937ca756d3a2c400dfd06993.1566300265.git-series.maxime.ripard@bootlin.com> User-Agent: Mutt/1.10.1 (2018-07-13) Sender: linux-media-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Hi Maxime, Thanks for the update. On Tue, Aug 20, 2019 at 01:24:34PM +0200, Maxime Ripard wrote: > From: Maxime Ripard > > 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 > --- > 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 > +L: linux-media@vger.kernel.org > +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 > M: Jerome Brunet > 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 > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > +#include > +#include > +#include > + > +#include > +#include > + > +#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 "); > +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 > + */ > + > +#ifndef _SUN4I_CSI_H_ > +#define _SUN4I_CSI_H_ > + > +#include > +#include > +#include > +#include > +#include > +#include > + > +#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 > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +#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 > + */ > + > +#include > +#include > + > +#include > +#include > +#include > + > +#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@linux.intel.com