Hi Todor,
On Mon, Jul 17, 2017 at 01:33:36PM +0300, Todor Tomov wrote:
> These files control the VFE module. The VFE has different input interfaces.
> The PIX input interface feeds the input data to an image processing pipeline.
> Three RDI input interfaces bypass the image processing pipeline. The VFE also
> contains the AXI bus interface which writes the output data to memory.
>
> RDI interfaces are supported in this version. PIX interface is not supported.
>
> Signed-off-by: Todor Tomov <todor.tomov@xxxxxxxxxx>
> ---
> drivers/media/platform/qcom/camss-8x16/camss-vfe.c | 1913 ++++++++++++++++++++
> drivers/media/platform/qcom/camss-8x16/camss-vfe.h | 114 ++
> 2 files changed, 2027 insertions(+)
> create mode 100644 drivers/media/platform/qcom/camss-8x16/camss-vfe.c
> create mode 100644 drivers/media/platform/qcom/camss-8x16/camss-vfe.h
>
> diff --git a/drivers/media/platform/qcom/camss-8x16/camss-vfe.c b/drivers/media/platform/qcom/camss-8x16/camss-vfe.c
> new file mode 100644
> index 0000000..b6dd29b
> --- /dev/null
> +++ b/drivers/media/platform/qcom/camss-8x16/camss-vfe.c
> @@ -0,0 +1,1913 @@
> +/*
> + * camss-vfe.c
> + *
> + * Qualcomm MSM Camera Subsystem - VFE Module
> + *
> + * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
> + * Copyright (C) 2015-2017 Linaro Ltd.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +#include <linux/clk.h>
> +#include <linux/completion.h>
> +#include <linux/interrupt.h>
> +#include <linux/iommu.h>
> +#include <linux/mutex.h>
> +#include <linux/of.h>
> +#include <linux/platform_device.h>
> +#include <linux/spinlock_types.h>
> +#include <linux/spinlock.h>
> +#include <media/media-entity.h>
> +#include <media/v4l2-device.h>
> +#include <media/v4l2-subdev.h>
> +
> +#include "camss-vfe.h"
> +#include "camss.h"
> +
> +#define MSM_VFE_NAME "msm_vfe"
> +
> +#define vfe_line_array(ptr_line) \
> + ((const struct vfe_line (*)[]) &(ptr_line[-(ptr_line->id)]))
If you have something like that used by multiple parts of the driver, it'd
be good to define it in a common header. (I ignore if the types are exactly
the same though. Ignore the comment if they're different.)
> +
> +#define to_vfe(ptr_line) \
> + container_of(vfe_line_array(ptr_line), struct vfe_device, ptr_line)
> +
> +#define VFE_0_HW_VERSION 0x000
> +
> +#define VFE_0_GLOBAL_RESET_CMD 0x00c
> +#define VFE_0_GLOBAL_RESET_CMD_CORE (1 << 0)
> +#define VFE_0_GLOBAL_RESET_CMD_CAMIF (1 << 1)
> +#define VFE_0_GLOBAL_RESET_CMD_BUS (1 << 2)
> +#define VFE_0_GLOBAL_RESET_CMD_BUS_BDG (1 << 3)
> +#define VFE_0_GLOBAL_RESET_CMD_REGISTER (1 << 4)
> +#define VFE_0_GLOBAL_RESET_CMD_TIMER (1 << 5)
> +#define VFE_0_GLOBAL_RESET_CMD_PM (1 << 6)
> +#define VFE_0_GLOBAL_RESET_CMD_BUS_MISR (1 << 7)
> +#define VFE_0_GLOBAL_RESET_CMD_TESTGEN (1 << 8)
> +
> +#define VFE_0_IRQ_CMD 0x024
> +#define VFE_0_IRQ_CMD_GLOBAL_CLEAR (1 << 0)
> +
> +#define VFE_0_IRQ_MASK_0 0x028
> +#define VFE_0_IRQ_MASK_0_RDIn_REG_UPDATE(n) (1 << ((n) + 5))
> +#define VFE_0_IRQ_MASK_0_IMAGE_MASTER_n_PING_PONG(n) (1 << ((n) + 8))
> +#define VFE_0_IRQ_MASK_0_RESET_ACK (1 << 31)
> +#define VFE_0_IRQ_MASK_1 0x02c
> +#define VFE_0_IRQ_MASK_1_VIOLATION (1 << 7)
> +#define VFE_0_IRQ_MASK_1_BUS_BDG_HALT_ACK (1 << 8)
> +#define VFE_0_IRQ_MASK_1_IMAGE_MASTER_n_BUS_OVERFLOW(n) (1 << ((n) + 9))
> +
> +#define VFE_0_IRQ_CLEAR_0 0x030
> +#define VFE_0_IRQ_CLEAR_1 0x034
> +
> +#define VFE_0_IRQ_STATUS_0 0x038
> +#define VFE_0_IRQ_STATUS_0_RDIn_REG_UPDATE(n) (1 << ((n) + 5))
> +#define VFE_0_IRQ_STATUS_0_IMAGE_MASTER_n_PING_PONG(n) (1 << ((n) + 8))
> +#define VFE_0_IRQ_STATUS_0_RESET_ACK (1 << 31)
> +#define VFE_0_IRQ_STATUS_1 0x03c
> +#define VFE_0_IRQ_STATUS_1_VIOLATION (1 << 7)
> +#define VFE_0_IRQ_STATUS_1_BUS_BDG_HALT_ACK (1 << 8)
> +
> +#define VFE_0_VIOLATION_STATUS 0x48
> +
> +#define VFE_0_BUS_CMD 0x4c
> +#define VFE_0_BUS_CMD_Mx_RLD_CMD(x) (1 << (x))
> +
> +#define VFE_0_BUS_CFG 0x050
> +
> +#define VFE_0_BUS_XBAR_CFG_x(x) (0x58 + 0x4 * ((x) / 2))
> +#define VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT 8
> +#define VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI0 5
> +#define VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI1 6
> +#define VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI2 7
> +
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_CFG(n) (0x06c + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_CFG_WR_PATH_SHIFT 0
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_CFG_FRM_BASED_SHIFT 1
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_PING_ADDR(n) (0x070 + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_PONG_ADDR(n) (0x074 + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG(n) (0x078 + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG_FRM_DROP_PER_SHIFT 2
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG_FRM_DROP_PER_MASK (0x1F << 2)
> +
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_UB_CFG(n) (0x07c + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_UB_CFG_OFFSET_SHIFT 16
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_FRAMEDROP_PATTERN(n) \
> + (0x088 + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_IRQ_SUBSAMPLE_PATTERN(n) \
> + (0x08c + 0x24 * (n))
> +#define VFE_0_BUS_IMAGE_MASTER_n_WR_IRQ_SUBSAMPLE_PATTERN_DEF 0xffffffff
> +
> +#define VFE_0_BUS_PING_PONG_STATUS 0x268
> +
> +#define VFE_0_BUS_BDG_CMD 0x2c0
> +#define VFE_0_BUS_BDG_CMD_HALT_REQ 1
> +
> +#define VFE_0_BUS_BDG_QOS_CFG_0 0x2c4
> +#define VFE_0_BUS_BDG_QOS_CFG_1 0x2c8
> +#define VFE_0_BUS_BDG_QOS_CFG_2 0x2cc
> +#define VFE_0_BUS_BDG_QOS_CFG_3 0x2d0
> +#define VFE_0_BUS_BDG_QOS_CFG_4 0x2d4
> +#define VFE_0_BUS_BDG_QOS_CFG_5 0x2d8
> +#define VFE_0_BUS_BDG_QOS_CFG_6 0x2dc
> +#define VFE_0_BUS_BDG_QOS_CFG_7 0x2e0
> +
> +#define VFE_0_RDI_CFG_x(x) (0x2e8 + (0x4 * (x)))
> +#define VFE_0_RDI_CFG_x_RDI_STREAM_SEL_SHIFT 28
> +#define VFE_0_RDI_CFG_x_RDI_STREAM_SEL_MASK (0xf << 28)
> +#define VFE_0_RDI_CFG_x_RDI_M0_SEL_SHIFT 4
> +#define VFE_0_RDI_CFG_x_RDI_M0_SEL_MASK (0xf << 4)
> +#define VFE_0_RDI_CFG_x_RDI_EN_BIT (1 << 2)
> +#define VFE_0_RDI_CFG_x_MIPI_EN_BITS 0x3
> +#define VFE_0_RDI_CFG_x_RDI_Mr_FRAME_BASED_EN(r) (1 << (16 + (r)))
> +
> +#define VFE_0_REG_UPDATE 0x378
> +#define VFE_0_REG_UPDATE_RDIn(n) (1 << (1 + (n)))
> +
> +#define VFE_0_CGC_OVERRIDE_1 0x974
> +#define VFE_0_CGC_OVERRIDE_1_IMAGE_Mx_CGC_OVERRIDE(x) (1 << (x))
> +
> +/* VFE reset timeout */
> +#define VFE_RESET_TIMEOUT_MS 50
> +/* VFE halt timeout */
> +#define VFE_HALT_TIMEOUT_MS 100
> +/* Max number of frame drop updates per frame */
> +#define VFE_FRAME_DROP_UPDATES 5
> +/* Frame drop value. NOTE: VAL + UPDATES should not exceed 31 */
> +#define VFE_FRAME_DROP_VAL 20
> +
> +static const u32 vfe_formats[] = {
> + MEDIA_BUS_FMT_UYVY8_2X8,
> + MEDIA_BUS_FMT_VYUY8_2X8,
> + MEDIA_BUS_FMT_YUYV8_2X8,
> + MEDIA_BUS_FMT_YVYU8_2X8,
> + MEDIA_BUS_FMT_SBGGR8_1X8,
> + MEDIA_BUS_FMT_SGBRG8_1X8,
> + MEDIA_BUS_FMT_SGRBG8_1X8,
> + MEDIA_BUS_FMT_SRGGB8_1X8,
> + MEDIA_BUS_FMT_SBGGR10_1X10,
> + MEDIA_BUS_FMT_SGBRG10_1X10,
> + MEDIA_BUS_FMT_SGRBG10_1X10,
> + MEDIA_BUS_FMT_SRGGB10_1X10,
> + MEDIA_BUS_FMT_SBGGR12_1X12,
> + MEDIA_BUS_FMT_SGBRG12_1X12,
> + MEDIA_BUS_FMT_SGRBG12_1X12,
> + MEDIA_BUS_FMT_SRGGB12_1X12,
> +};
> +
> +static inline void vfe_reg_clr(struct vfe_device *vfe, u32 reg, u32 clr_bits)
> +{
> + u32 bits = readl_relaxed(vfe->base + reg);
> +
> + writel_relaxed(bits & ~clr_bits, vfe->base + reg);
> +}
> +
> +static inline void vfe_reg_set(struct vfe_device *vfe, u32 reg, u32 set_bits)
> +{
> + u32 bits = readl_relaxed(vfe->base + reg);
> +
> + writel_relaxed(bits | set_bits, vfe->base + reg);
> +}
> +
> +static void vfe_global_reset(struct vfe_device *vfe)
> +{
> + u32 reset_bits = VFE_0_GLOBAL_RESET_CMD_TESTGEN |
> + VFE_0_GLOBAL_RESET_CMD_BUS_MISR |
> + VFE_0_GLOBAL_RESET_CMD_PM |
> + VFE_0_GLOBAL_RESET_CMD_TIMER |
> + VFE_0_GLOBAL_RESET_CMD_REGISTER |
> + VFE_0_GLOBAL_RESET_CMD_BUS_BDG |
> + VFE_0_GLOBAL_RESET_CMD_BUS |
> + VFE_0_GLOBAL_RESET_CMD_CAMIF |
> + VFE_0_GLOBAL_RESET_CMD_CORE;
> +
> + writel_relaxed(reset_bits, vfe->base + VFE_0_GLOBAL_RESET_CMD);
> +}
> +
> +static void vfe_wm_enable(struct vfe_device *vfe, u8 wm, u8 enable)
> +{
> + if (enable)
> + vfe_reg_set(vfe, VFE_0_BUS_IMAGE_MASTER_n_WR_CFG(wm),
> + 1 << VFE_0_BUS_IMAGE_MASTER_n_WR_CFG_WR_PATH_SHIFT);
> + else
> + vfe_reg_clr(vfe, VFE_0_BUS_IMAGE_MASTER_n_WR_CFG(wm),
> + 1 << VFE_0_BUS_IMAGE_MASTER_n_WR_CFG_WR_PATH_SHIFT);
> +}
> +
> +static void vfe_wm_frame_based(struct vfe_device *vfe, u8 wm, u8 enable)
> +{
> + if (enable)
> + vfe_reg_set(vfe, VFE_0_BUS_IMAGE_MASTER_n_WR_CFG(wm),
> + 1 << VFE_0_BUS_IMAGE_MASTER_n_WR_CFG_FRM_BASED_SHIFT);
> + else
> + vfe_reg_clr(vfe, VFE_0_BUS_IMAGE_MASTER_n_WR_CFG(wm),
> + 1 << VFE_0_BUS_IMAGE_MASTER_n_WR_CFG_FRM_BASED_SHIFT);
> +}
> +
> +static void vfe_wm_set_framedrop_period(struct vfe_device *vfe, u8 wm, u8 per)
> +{
> + u32 reg;
> +
> + reg = readl_relaxed(vfe->base +
> + VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG(wm));
> +
> + reg &= ~(VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG_FRM_DROP_PER_MASK);
> +
> + reg |= (per << VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG_FRM_DROP_PER_SHIFT)
> + & VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG_FRM_DROP_PER_MASK;
> +
> + writel_relaxed(reg,
> + vfe->base + VFE_0_BUS_IMAGE_MASTER_n_WR_ADDR_CFG(wm));
> +}
> +
> +static void vfe_wm_set_framedrop_pattern(struct vfe_device *vfe, u8 wm,
> + u32 pattern)
> +{
> + writel_relaxed(pattern,
> + vfe->base + VFE_0_BUS_IMAGE_MASTER_n_WR_FRAMEDROP_PATTERN(wm));
> +}
> +
> +static void vfe_wm_set_ub_cfg(struct vfe_device *vfe, u8 wm, u16 offset,
> + u16 depth)
> +{
> + u32 reg;
> +
> + reg = (offset << VFE_0_BUS_IMAGE_MASTER_n_WR_UB_CFG_OFFSET_SHIFT) |
> + depth;
> + writel_relaxed(reg, vfe->base + VFE_0_BUS_IMAGE_MASTER_n_WR_UB_CFG(wm));
> +}
> +
> +static void vfe_bus_reload_wm(struct vfe_device *vfe, u8 wm)
> +{
> + wmb();
> + writel_relaxed(VFE_0_BUS_CMD_Mx_RLD_CMD(wm), vfe->base + VFE_0_BUS_CMD);
> + wmb();
> +}
> +
> +static void vfe_wm_set_ping_addr(struct vfe_device *vfe, u8 wm, u32 addr)
> +{
> + writel_relaxed(addr,
> + vfe->base + VFE_0_BUS_IMAGE_MASTER_n_WR_PING_ADDR(wm));
> +}
> +
> +static void vfe_wm_set_pong_addr(struct vfe_device *vfe, u8 wm, u32 addr)
> +{
> + writel_relaxed(addr,
> + vfe->base + VFE_0_BUS_IMAGE_MASTER_n_WR_PONG_ADDR(wm));
> +}
> +
> +static int vfe_wm_get_ping_pong_status(struct vfe_device *vfe, u8 wm)
> +{
> + u32 reg;
> +
> + reg = readl_relaxed(vfe->base + VFE_0_BUS_PING_PONG_STATUS);
> +
> + return (reg >> wm) & 0x1;
> +}
> +
> +static void vfe_bus_enable_wr_if(struct vfe_device *vfe, u8 enable)
> +{
> + if (enable)
> + writel_relaxed(0x10000009, vfe->base + VFE_0_BUS_CFG);
> + else
> + writel_relaxed(0, vfe->base + VFE_0_BUS_CFG);
> +}
> +
> +static void vfe_bus_connect_wm_to_rdi(struct vfe_device *vfe, u8 wm,
> + enum vfe_line_id id)
> +{
> + u32 reg;
> +
> + reg = VFE_0_RDI_CFG_x_MIPI_EN_BITS;
> + reg |= VFE_0_RDI_CFG_x_RDI_Mr_FRAME_BASED_EN(id);
> + vfe_reg_set(vfe, VFE_0_RDI_CFG_x(0), reg);
> +
> + reg = VFE_0_RDI_CFG_x_RDI_EN_BIT;
> + reg |= ((3 * id) << VFE_0_RDI_CFG_x_RDI_STREAM_SEL_SHIFT) &
> + VFE_0_RDI_CFG_x_RDI_STREAM_SEL_MASK;
> + vfe_reg_set(vfe, VFE_0_RDI_CFG_x(id), reg);
> +
> + switch (id) {
> + case VFE_LINE_RDI0:
> + default:
> + reg = VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI0 <<
> + VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT;
> + break;
> + case VFE_LINE_RDI1:
> + reg = VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI1 <<
> + VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT;
> + break;
> + case VFE_LINE_RDI2:
> + reg = VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI2 <<
> + VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT;
> + break;
> + }
> +
> + if (wm % 2 == 1)
> + reg <<= 16;
> +
> + vfe_reg_set(vfe, VFE_0_BUS_XBAR_CFG_x(wm), reg);
> +
> + writel_relaxed(VFE_0_BUS_IMAGE_MASTER_n_WR_IRQ_SUBSAMPLE_PATTERN_DEF,
> + vfe->base +
> + VFE_0_BUS_IMAGE_MASTER_n_WR_IRQ_SUBSAMPLE_PATTERN(wm));
> +}
> +
> +static void vfe_bus_disconnect_wm_from_rdi(struct vfe_device *vfe, u8 wm,
> + enum vfe_line_id id)
> +{
> + u32 reg;
> +
> + reg = VFE_0_RDI_CFG_x_RDI_Mr_FRAME_BASED_EN(id);
> + vfe_reg_clr(vfe, VFE_0_RDI_CFG_x(0), reg);
> +
> + reg = VFE_0_RDI_CFG_x_RDI_EN_BIT;
> + vfe_reg_clr(vfe, VFE_0_RDI_CFG_x(id), reg);
> +
> + switch (id) {
> + case VFE_LINE_RDI0:
> + default:
> + reg = VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI0 <<
> + VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT;
> + break;
> + case VFE_LINE_RDI1:
> + reg = VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI1 <<
> + VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT;
> + break;
> + case VFE_LINE_RDI2:
> + reg = VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_VAL_RDI2 <<
> + VFE_0_BUS_XBAR_CFG_x_M_SINGLE_STREAM_SEL_SHIFT;
> + break;
> + }
> +
> + if (wm % 2 == 1)
> + reg <<= 16;
> +
> + vfe_reg_clr(vfe, VFE_0_BUS_XBAR_CFG_x(wm), reg);
> +}
> +
> +static void vfe_set_rdi_cid(struct vfe_device *vfe, enum vfe_line_id id, u8 cid)
> +{
> + vfe_reg_clr(vfe, VFE_0_RDI_CFG_x(id),
> + VFE_0_RDI_CFG_x_RDI_M0_SEL_MASK);
> +
> + vfe_reg_set(vfe, VFE_0_RDI_CFG_x(id),
> + cid << VFE_0_RDI_CFG_x_RDI_M0_SEL_SHIFT);
> +}
> +
> +static void vfe_reg_update(struct vfe_device *vfe, enum vfe_line_id line_id)
> +{
> + vfe->reg_update |= VFE_0_REG_UPDATE_RDIn(line_id);
> + wmb();
> + writel_relaxed(vfe->reg_update, vfe->base + VFE_0_REG_UPDATE);
> + wmb();
> +}
> +
> +static void vfe_enable_irq_wm_line(struct vfe_device *vfe, u8 wm,
> + enum vfe_line_id line_id, u8 enable)
> +{
> + u32 irq_en0 = VFE_0_IRQ_MASK_0_IMAGE_MASTER_n_PING_PONG(wm) |
> + VFE_0_IRQ_MASK_0_RDIn_REG_UPDATE(line_id);
> + u32 irq_en1 = VFE_0_IRQ_MASK_1_IMAGE_MASTER_n_BUS_OVERFLOW(wm);
> +
> + if (enable) {
> + vfe_reg_set(vfe, VFE_0_IRQ_MASK_0, irq_en0);
> + vfe_reg_set(vfe, VFE_0_IRQ_MASK_1, irq_en1);
> + } else {
> + vfe_reg_clr(vfe, VFE_0_IRQ_MASK_0, irq_en0);
> + vfe_reg_clr(vfe, VFE_0_IRQ_MASK_1, irq_en1);
> + }
> +}
> +
> +static void vfe_enable_irq_common(struct vfe_device *vfe)
> +{
> + u32 irq_en0 = VFE_0_IRQ_MASK_0_RESET_ACK;
> + u32 irq_en1 = VFE_0_IRQ_MASK_1_VIOLATION |
> + VFE_0_IRQ_MASK_1_BUS_BDG_HALT_ACK;
> +
> + vfe_reg_set(vfe, VFE_0_IRQ_MASK_0, irq_en0);
> + vfe_reg_set(vfe, VFE_0_IRQ_MASK_1, irq_en1);
> +}
> +
> +/*
> + * vfe_reset - Trigger reset on VFE module and wait to complete
> + * @vfe: VFE device
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_reset(struct vfe_device *vfe)
> +{
> + unsigned long time;
> +
> + reinit_completion(&vfe->reset_complete);
> +
> + vfe_global_reset(vfe);
> +
> + time = wait_for_completion_timeout(&vfe->reset_complete,
> + msecs_to_jiffies(VFE_RESET_TIMEOUT_MS));
> + if (!time) {
> + dev_err(to_device(vfe), "VFE reset timeout\n");
> + return -EIO;
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_halt - Trigger halt on VFE module and wait to complete
> + * @vfe: VFE device
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_halt(struct vfe_device *vfe)
> +{
> + unsigned long time;
> +
> + reinit_completion(&vfe->halt_complete);
> +
> + writel_relaxed(VFE_0_BUS_BDG_CMD_HALT_REQ,
> + vfe->base + VFE_0_BUS_BDG_CMD);
> +
> + time = wait_for_completion_timeout(&vfe->halt_complete,
> + msecs_to_jiffies(VFE_HALT_TIMEOUT_MS));
> + if (!time) {
> + dev_err(to_device(vfe), "VFE halt timeout\n");
> + return -EIO;
> + }
> +
> + return 0;
> +}
> +
> +static void vfe_init_outputs(struct vfe_device *vfe)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(vfe->line); i++) {
> + struct vfe_output *output = &vfe->line[i].output;
> +
> + output->state = VFE_OUTPUT_OFF;
> + output->buf[0] = NULL;
> + output->buf[1] = NULL;
> + INIT_LIST_HEAD(&output->pending_bufs);
> + }
> +}
> +
> +static void vfe_reset_output_maps(struct vfe_device *vfe)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++)
> + vfe->wm_output_map[i] = VFE_LINE_NONE;
> +}
> +
> +static void vfe_set_qos(struct vfe_device *vfe)
> +{
> + u32 val = 0xaaa5aaa5;
> + u32 val7 = 0x0001aaa5;
Huh. What do these mean? :-)
> +
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_0);
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_1);
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_2);
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_3);
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_4);
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_5);
> + writel_relaxed(val, vfe->base + VFE_0_BUS_BDG_QOS_CFG_6);
> + writel_relaxed(val7, vfe->base + VFE_0_BUS_BDG_QOS_CFG_7);
> +}
> +
> +static void vfe_set_cgc_override(struct vfe_device *vfe, u8 wm, u8 enable)
> +{
> + u32 val = VFE_0_CGC_OVERRIDE_1_IMAGE_Mx_CGC_OVERRIDE(wm);
> +
> + if (enable)
> + vfe_reg_set(vfe, VFE_0_CGC_OVERRIDE_1, val);
> + else
> + vfe_reg_clr(vfe, VFE_0_CGC_OVERRIDE_1, val);
> +
> + wmb();
> +}
> +
> +static void vfe_output_init_addrs(struct vfe_device *vfe,
> + struct vfe_output *output, u8 sync)
> +{
> + u32 ping_addr = 0;
> + u32 pong_addr = 0;
> +
> + output->active_buf = 0;
> +
> + if (output->buf[0])
> + ping_addr = output->buf[0]->addr;
> +
> + if (output->buf[1])
> + pong_addr = output->buf[1]->addr;
> + else
> + pong_addr = ping_addr;
> +
> + vfe_wm_set_ping_addr(vfe, output->wm_idx, ping_addr);
> + vfe_wm_set_pong_addr(vfe, output->wm_idx, pong_addr);
> + if (sync)
> + vfe_bus_reload_wm(vfe, output->wm_idx);
> +}
> +
> +static void vfe_output_update_ping_addr(struct vfe_device *vfe,
> + struct vfe_output *output, u8 sync)
> +{
> + u32 addr = 0;
> +
> + if (output->buf[0])
> + addr = output->buf[0]->addr;
> +
> + vfe_wm_set_ping_addr(vfe, output->wm_idx, addr);
> + if (sync)
> + vfe_bus_reload_wm(vfe, output->wm_idx);
> +}
> +
> +static void vfe_output_update_pong_addr(struct vfe_device *vfe,
> + struct vfe_output *output, u8 sync)
> +{
> + u32 addr = 0;
> +
> + if (output->buf[1])
> + addr = output->buf[1]->addr;
> +
> + vfe_wm_set_pong_addr(vfe, output->wm_idx, addr);
> + if (sync)
> + vfe_bus_reload_wm(vfe, output->wm_idx);
> +
> +}
> +
> +static int vfe_reserve_wm(struct vfe_device *vfe, enum vfe_line_id line_id)
> +{
> + int ret = -EBUSY;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(vfe->wm_output_map); i++) {
> + if (vfe->wm_output_map[i] == VFE_LINE_NONE) {
> + vfe->wm_output_map[i] = line_id;
> + ret = i;
> + break;
> + }
> + }
> +
> + return ret;
> +}
> +
> +static int vfe_release_wm(struct vfe_device *vfe, u8 wm)
> +{
> + if (wm > ARRAY_SIZE(vfe->wm_output_map))
> + return -EINVAL;
> +
> + vfe->wm_output_map[wm] = VFE_LINE_NONE;
> +
> + return 0;
> +}
> +
> +static void vfe_output_frame_drop(struct vfe_device *vfe,
> + struct vfe_output *output,
> + u32 drop_pattern)
> +{
> + u8 drop_period;
> +
> + /* We need to toggle update period to be valid on next frame */
> + output->drop_update_idx++;
> + output->drop_update_idx %= VFE_FRAME_DROP_UPDATES;
> + drop_period = VFE_FRAME_DROP_VAL + output->drop_update_idx;
> +
> + vfe_wm_set_framedrop_period(vfe, output->wm_idx, drop_period);
> + vfe_wm_set_framedrop_pattern(vfe, output->wm_idx, drop_pattern);
> + vfe_reg_update(vfe, container_of(output, struct vfe_line, output)->id);
> +
> +}
> +
> +static struct camss_buffer *vfe_buf_get_pending(struct vfe_output *output)
> +{
> + struct camss_buffer *buffer = NULL;
> +
> + if (!list_empty(&output->pending_bufs)) {
> + buffer = list_first_entry(&output->pending_bufs,
> + struct camss_buffer,
> + queue);
> + list_del(&buffer->queue);
> + }
> +
> + return buffer;
> +}
> +
> +/*
> + * vfe_buf_add_pending - Add output buffer to list of pending
> + * @output: VFE output
> + * @buffer: Video buffer
> + */
> +static void vfe_buf_add_pending(struct vfe_output *output,
> + struct camss_buffer *buffer)
> +{
> + INIT_LIST_HEAD(&buffer->queue);
> + list_add_tail(&buffer->queue, &output->pending_bufs);
> +}
> +
> +/*
> + * vfe_buf_flush_pending - Flush all pending buffers.
> + * @output: VFE output
> + * @state: vb2 buffer state
> + */
> +static void vfe_buf_flush_pending(struct vfe_output *output,
> + enum vb2_buffer_state state)
> +{
> + struct camss_buffer *buf;
> + struct camss_buffer *t;
> +
> + list_for_each_entry_safe(buf, t, &output->pending_bufs, queue) {
> + vb2_buffer_done(&buf->vb.vb2_buf, state);
> + list_del(&buf->queue);
> + }
> +}
> +
> +static void vfe_buf_update_wm_on_next(struct vfe_device *vfe,
> + struct vfe_output *output)
> +{
> + switch (output->state) {
> + case VFE_OUTPUT_CONTINUOUS:
> + vfe_output_frame_drop(vfe, output, 3);
> + break;
> + case VFE_OUTPUT_SINGLE:
> + default:
> + dev_err_ratelimited(to_device(vfe),
> + "Next buf in wrong state! %d\n",
> + output->state);
> + break;
> + }
> +}
> +
> +static void vfe_buf_update_wm_on_last(struct vfe_device *vfe,
> + struct vfe_output *output)
> +{
> + switch (output->state) {
> + case VFE_OUTPUT_CONTINUOUS:
> + output->state = VFE_OUTPUT_SINGLE;
> + vfe_output_frame_drop(vfe, output, 1);
> + break;
> + case VFE_OUTPUT_SINGLE:
> + output->state = VFE_OUTPUT_STOPPING;
> + vfe_output_frame_drop(vfe, output, 0);
> + break;
> + default:
> + dev_err_ratelimited(to_device(vfe),
> + "Last buff in wrong state! %d\n",
> + output->state);
> + break;
> + }
> +}
> +
> +static void vfe_buf_update_wm_on_new(struct vfe_device *vfe,
> + struct vfe_output *output,
> + struct camss_buffer *new_buf)
> +{
> + int inactive_idx;
> +
> + switch (output->state) {
> + case VFE_OUTPUT_SINGLE:
> + inactive_idx = !output->active_buf;
> +
> + if (!output->buf[inactive_idx]) {
> + output->buf[inactive_idx] = new_buf;
> +
> + if (inactive_idx)
> + vfe_output_update_pong_addr(vfe, output, 0);
> + else
> + vfe_output_update_ping_addr(vfe, output, 0);
> +
> + vfe_output_frame_drop(vfe, output, 3);
> + output->state = VFE_OUTPUT_CONTINUOUS;
> + } else {
> + vfe_buf_add_pending(output, new_buf);
> + dev_err_ratelimited(to_device(vfe),
> + "Inactive buffer is busy\n");
> + }
> + break;
> +
> + case VFE_OUTPUT_IDLE:
> + if (!output->buf[0]) {
> + output->buf[0] = new_buf;
> +
> + vfe_output_init_addrs(vfe, output, 1);
> +
> + vfe_output_frame_drop(vfe, output, 1);
> + output->state = VFE_OUTPUT_SINGLE;
> + } else {
> + vfe_buf_add_pending(output, new_buf);
> + dev_err_ratelimited(to_device(vfe),
> + "Output idle with buffer set!\n");
> + }
> + break;
> +
> + case VFE_OUTPUT_CONTINUOUS:
> + default:
> + vfe_buf_add_pending(output, new_buf);
> + break;
> + }
> +}
> +
> +static int vfe_get_output(struct vfe_line *line)
> +{
> + struct vfe_device *vfe = to_vfe(line);
> + struct vfe_output *output;
> + unsigned long flags;
> + int wm_idx;
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + output = &line->output;
> + if (output->state != VFE_OUTPUT_OFF) {
> + dev_err(to_device(vfe), "Output is running\n");
> + goto error;
> + }
> + output->state = VFE_OUTPUT_RESERVED;
> +
> + output->active_buf = 0;
> +
> + /* We will use only one wm per output for now */
> + wm_idx = vfe_reserve_wm(vfe, line->id);
> + if (wm_idx < 0) {
> + dev_err(to_device(vfe), "Can not reserve wm\n");
> + goto error_get_wm;
> + }
> + output->drop_update_idx = 0;
> + output->wm_idx = wm_idx;
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + return 0;
> +
> +error_get_wm:
> + output->state = VFE_OUTPUT_OFF;
> +error:
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + return -EINVAL;
> +}
> +
> +static int vfe_put_output(struct vfe_line *line)
> +{
> + struct vfe_device *vfe = to_vfe(line);
> + struct vfe_output *output = &line->output;
> + unsigned long flags;
> + int ret;
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + ret = vfe_release_wm(vfe, output->wm_idx);
> + if (ret < 0)
> + goto out;
> +
> + output->state = VFE_OUTPUT_OFF;
> +
> +out:
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> + return ret;
> +}
> +
> +static int vfe_enable_output(struct vfe_line *line)
> +{
> + struct vfe_device *vfe = to_vfe(line);
> + struct vfe_output *output = &line->output;
> + unsigned long flags;
> + u16 ub_size;
> +
> + switch (vfe->id) {
> + case 0:
> + ub_size = MSM_VFE_VFE0_UB_SIZE_RDI;
> + break;
> + case 1:
> + ub_size = MSM_VFE_VFE1_UB_SIZE_RDI;
> + break;
> + default:
> + return -EINVAL;
> + }
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + vfe->reg_update &= ~VFE_0_REG_UPDATE_RDIn(line->id);
> +
> + if (output->state != VFE_OUTPUT_RESERVED) {
> + dev_err(to_device(vfe), "Output is not in reserved state %d\n",
> + output->state);
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> + return -EINVAL;
> + }
> + output->state = VFE_OUTPUT_IDLE;
> +
> + output->buf[0] = vfe_buf_get_pending(output);
> + output->buf[1] = vfe_buf_get_pending(output);
> +
> + if (!output->buf[0] && output->buf[1]) {
> + output->buf[0] = output->buf[1];
> + output->buf[1] = NULL;
> + }
> +
> + if (output->buf[0])
> + output->state = VFE_OUTPUT_SINGLE;
> +
> + if (output->buf[1])
> + output->state = VFE_OUTPUT_CONTINUOUS;
> +
> + switch (output->state) {
> + case VFE_OUTPUT_SINGLE:
> + vfe_output_frame_drop(vfe, output, 1);
> + break;
> + case VFE_OUTPUT_CONTINUOUS:
> + vfe_output_frame_drop(vfe, output, 3);
> + break;
> + default:
> + vfe_output_frame_drop(vfe, output, 0);
> + break;
> + }
> +
> + output->sequence = 0;
> +
> + vfe_output_init_addrs(vfe, output, 0);
> +
> + vfe_set_cgc_override(vfe, output->wm_idx, 1);
> +
> + vfe_enable_irq_wm_line(vfe, output->wm_idx, line->id, 1);
> +
> + vfe_bus_connect_wm_to_rdi(vfe, output->wm_idx, line->id);
> +
> + vfe_set_rdi_cid(vfe, line->id, 0);
> +
> + vfe_wm_set_ub_cfg(vfe, output->wm_idx,
> + (ub_size + 1) * output->wm_idx, ub_size);
> +
> + vfe_wm_frame_based(vfe, output->wm_idx, 1);
> + vfe_wm_enable(vfe, output->wm_idx, 1);
> +
> + vfe_bus_reload_wm(vfe, output->wm_idx);
> +
> + vfe_reg_update(vfe, line->id);
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + return 0;
> +}
> +
> +static int vfe_disable_output(struct vfe_line *line)
> +{
> + struct vfe_device *vfe = to_vfe(line);
> + struct vfe_output *output = &line->output;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + vfe_wm_enable(vfe, output->wm_idx, 0);
> + vfe_bus_disconnect_wm_from_rdi(vfe, output->wm_idx, line->id);
> + vfe_reg_update(vfe, line->id);
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_enable - Enable streaming on VFE line
> + * @line: VFE line
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_enable(struct vfe_line *line)
> +{
> + struct vfe_device *vfe = to_vfe(line);
> + int ret;
> +
> + mutex_lock(&vfe->stream_lock);
> +
> + if (!vfe->stream_count) {
> + vfe_enable_irq_common(vfe);
> +
> + vfe_bus_enable_wr_if(vfe, 1);
> +
> + vfe_set_qos(vfe);
> + }
> +
> + vfe->stream_count++;
> +
> + mutex_unlock(&vfe->stream_lock);
> +
> + ret = vfe_get_output(line);
> + if (ret < 0)
> + goto error_get_output;
> +
> + ret = vfe_enable_output(line);
> + if (ret < 0)
> + goto error_enable_output;
> +
> + vfe->was_streaming = 1;
> +
> + return 0;
> +
> +
> +error_enable_output:
> + vfe_put_output(line);
> +
> +error_get_output:
> + mutex_lock(&vfe->stream_lock);
> +
> + if (vfe->stream_count == 1)
> + vfe_bus_enable_wr_if(vfe, 0);
> +
> + vfe->stream_count--;
> +
> + mutex_unlock(&vfe->stream_lock);
> +
> + return ret;
> +}
> +
> +/*
> + * vfe_disable - Disable streaming on VFE line
> + * @line: VFE line
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_disable(struct vfe_line *line)
> +{
> + struct vfe_device *vfe = to_vfe(line);
> +
> + mutex_lock(&vfe->stream_lock);
> +
> + if (vfe->stream_count == 1)
> + vfe_bus_enable_wr_if(vfe, 0);
> +
> + vfe->stream_count--;
> +
> + mutex_unlock(&vfe->stream_lock);
> +
> + vfe_disable_output(line);
> +
> + vfe_put_output(line);
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_isr_reg_update - Process reg update interrupt
> + * @vfe: VFE Device
> + * @line_id: VFE line
> + */
> +static void vfe_isr_reg_update(struct vfe_device *vfe, enum vfe_line_id line_id)
> +{
> + struct vfe_output *output;
> + unsigned long flags;
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> + vfe->reg_update &= ~VFE_0_REG_UPDATE_RDIn(line_id);
> +
> + output = &vfe->line[line_id].output;
> + if (output->state == VFE_OUTPUT_STOPPING) {
> + /* Release last buffer when hw is idle */
> + if (output->last_buffer) {
> + vb2_buffer_done(&output->last_buffer->vb.vb2_buf,
> + VB2_BUF_STATE_DONE);
> + output->last_buffer = NULL;
> + }
> + output->state = VFE_OUTPUT_IDLE;
> +
> + /* Buffers received in stopping state are queued in */
> + /* dma pending queue, start next capture here */
> +
> + output->buf[0] = vfe_buf_get_pending(output);
> + output->buf[1] = vfe_buf_get_pending(output);
> +
> + if (!output->buf[0] && output->buf[1]) {
> + output->buf[0] = output->buf[1];
> + output->buf[1] = NULL;
> + }
> +
> + if (output->buf[0])
> + output->state = VFE_OUTPUT_SINGLE;
> +
> + if (output->buf[1])
> + output->state = VFE_OUTPUT_CONTINUOUS;
> +
> + switch (output->state) {
> + case VFE_OUTPUT_SINGLE:
> + vfe_output_frame_drop(vfe, output, 2);
> + break;
> + case VFE_OUTPUT_CONTINUOUS:
> + vfe_output_frame_drop(vfe, output, 3);
> + break;
> + default:
> + vfe_output_frame_drop(vfe, output, 0);
> + break;
> + }
> +
> + vfe_output_init_addrs(vfe, output, 1);
> + }
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +}
> +
> +/*
> + * vfe_isr_wm_done - Process write master done interrupt
> + * @vfe: VFE Device
> + * @wm: Write master id
> + */
> +static void vfe_isr_wm_done(struct vfe_device *vfe, u8 wm)
> +{
> + struct camss_buffer *ready_buf;
> + struct vfe_output *output;
> + dma_addr_t new_addr;
> + unsigned long flags;
> + u32 active_index;
> + u64 ts = ktime_get_ns();
> +
> + active_index = vfe_wm_get_ping_pong_status(vfe, wm);
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + if (vfe->wm_output_map[wm] == VFE_LINE_NONE) {
> + dev_err_ratelimited(to_device(vfe),
> + "Received wm done for unmapped index\n");
> + goto out_unlock;
> + }
> + output = &vfe->line[vfe->wm_output_map[wm]].output;
> +
> + if (output->active_buf == active_index) {
> + dev_err_ratelimited(to_device(vfe),
> + "Active buffer mismatch!\n");
> + goto out_unlock;
> + }
> + output->active_buf = active_index;
> +
> + ready_buf = output->buf[!active_index];
> + if (!ready_buf) {
> + dev_err_ratelimited(to_device(vfe),
> + "Missing ready buf %d %d!\n",
> + !active_index, output->state);
> + goto out_unlock;
> + }
> +
> + ready_buf->vb.vb2_buf.timestamp = ts;
> + ready_buf->vb.sequence = output->sequence++;
> +
> + /* Get next buffer */
> + output->buf[!active_index] = vfe_buf_get_pending(output);
> + if (!output->buf[!active_index]) {
> + /* No next buffer - set same address */
> + new_addr = ready_buf->addr;
> + vfe_buf_update_wm_on_last(vfe, output);
> + } else {
> + new_addr = output->buf[!active_index]->addr;
> + vfe_buf_update_wm_on_next(vfe, output);
> + }
> +
> + if (active_index)
> + vfe_wm_set_ping_addr(vfe, wm, new_addr);
> + else
> + vfe_wm_set_pong_addr(vfe, wm, new_addr);
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + if (output->state == VFE_OUTPUT_STOPPING)
> + output->last_buffer = ready_buf;
> + else
> + vb2_buffer_done(&ready_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
> +
> + return;
> +
> +out_unlock:
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +}
> +
> +/*
> + * vfe_isr - ISPIF module interrupt handler
> + * @irq: Interrupt line
> + * @dev: VFE device
> + *
> + * Return IRQ_HANDLED on success
> + */
> +static irqreturn_t vfe_isr(int irq, void *dev)
> +{
> + struct vfe_device *vfe = dev;
> + u32 value0, value1;
> + u32 violation;
> + int i;
> +
> + value0 = readl_relaxed(vfe->base + VFE_0_IRQ_STATUS_0);
> + value1 = readl_relaxed(vfe->base + VFE_0_IRQ_STATUS_1);
> +
> + writel_relaxed(value0, vfe->base + VFE_0_IRQ_CLEAR_0);
> + writel_relaxed(value1, vfe->base + VFE_0_IRQ_CLEAR_1);
> +
> + wmb();
> + writel_relaxed(VFE_0_IRQ_CMD_GLOBAL_CLEAR, vfe->base + VFE_0_IRQ_CMD);
> +
> + if (value0 & VFE_0_IRQ_STATUS_0_RESET_ACK)
> + complete(&vfe->reset_complete);
> +
> + if (value1 & VFE_0_IRQ_STATUS_1_VIOLATION) {
> + violation = readl_relaxed(vfe->base + VFE_0_VIOLATION_STATUS);
> + dev_err_ratelimited(to_device(vfe),
> + "VFE: violation = 0x%08x\n", violation);
> + }
> +
> + if (value1 & VFE_0_IRQ_STATUS_1_BUS_BDG_HALT_ACK) {
> + complete(&vfe->halt_complete);
> + writel_relaxed(0x0, vfe->base + VFE_0_BUS_BDG_CMD);
> + }
> +
> + for (i = VFE_LINE_RDI0; i <= VFE_LINE_RDI2; i++)
> + if (value0 & VFE_0_IRQ_STATUS_0_RDIn_REG_UPDATE(i))
> + vfe_isr_reg_update(vfe, i);
> +
> + for (i = 0; i < MSM_VFE_IMAGE_MASTERS_NUM; i++)
> + if (value0 & VFE_0_IRQ_STATUS_0_IMAGE_MASTER_n_PING_PONG(i))
> + vfe_isr_wm_done(vfe, i);
> +
> + return IRQ_HANDLED;
> +}
> +
> +/*
> + * vfe_get - Power up and reset VFE module
> + * @vfe: VFE Device
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_get(struct vfe_device *vfe)
> +{
> + int ret;
> +
> + mutex_lock(&vfe->power_lock);
> +
> + if (vfe->power_count == 0) {
> + ret = camss_enable_clocks(vfe->nclocks, vfe->clock,
> + to_device(vfe));
> + if (ret < 0)
> + goto error_clocks;
> +
> + ret = vfe_reset(vfe);
> + if (ret < 0)
> + goto error_reset;
> +
> + vfe_reset_output_maps(vfe);
> +
> + vfe_init_outputs(vfe);
> + }
> + vfe->power_count++;
> +
> + mutex_unlock(&vfe->power_lock);
> +
> + return 0;
> +
> +error_reset:
> + camss_disable_clocks(vfe->nclocks, vfe->clock);
> +
> +error_clocks:
> + mutex_unlock(&vfe->power_lock);
> +
> + return ret;
> +}
> +
> +/*
> + * vfe_put - Power down VFE module
> + * @vfe: VFE Device
> + */
> +static void vfe_put(struct vfe_device *vfe)
> +{
> + mutex_lock(&vfe->power_lock);
> +
> + if (vfe->power_count == 0) {
> + dev_err(to_device(vfe), "vfe power off on power_count == 0\n");
> + goto exit;
> + } else if (vfe->power_count == 1) {
> + if (vfe->was_streaming) {
> + vfe->was_streaming = 0;
> + vfe_halt(vfe);
> + }
> + camss_disable_clocks(vfe->nclocks, vfe->clock);
> + }
> +
> + vfe->power_count--;
> +
> +exit:
> + mutex_unlock(&vfe->power_lock);
> +}
> +
> +/*
> + * vfe_video_pad_to_line - Get pointer to VFE line by media pad
> + * @pad: Media pad
> + *
> + * Return pointer to vfe line structure
> + */
> +static struct vfe_line *vfe_video_pad_to_line(struct media_pad *pad)
> +{
> + struct media_pad *vfe_pad;
> + struct v4l2_subdev *subdev;
> +
> + vfe_pad = media_entity_remote_pad(pad);
> + if (vfe_pad == NULL)
> + return NULL;
> +
> + subdev = media_entity_to_v4l2_subdev(vfe_pad->entity);
> +
> + return container_of(subdev, struct vfe_line, subdev);
> +}
> +
> +/*
> + * vfe_queue_buffer - Add empty buffer
> + * @vid: Video device structure
> + * @buf: Buffer to be enqueued
> + *
> + * Add an empty buffer - depending on the current number of buffers it will be
> + * put in pending buffer queue or directly given to the hardware to be filled.
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_queue_buffer(struct camss_video *vid,
> + struct camss_buffer *buf)
> +{
> + struct vfe_device *vfe = &vid->camss->vfe;
> + struct vfe_line *line;
> + struct vfe_output *output;
> + unsigned long flags;
> +
> + line = vfe_video_pad_to_line(&vid->pad);
> + if (!line) {
> + dev_err(to_device(vfe), "Can not queue buffer\n");
> + return -1;
> + }
> + output = &line->output;
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + vfe_buf_update_wm_on_new(vfe, output, buf);
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_flush_buffers - Return all vb2 buffers
> + * @vid: Video device structure
> + * @state: vb2 buffer state of the returned buffers
> + *
> + * Return all buffers to vb2. This includes queued pending buffers (still
> + * unused) and any buffers given to the hardware but again still not used.
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_flush_buffers(struct camss_video *vid,
> + enum vb2_buffer_state state)
> +{
> + struct vfe_device *vfe = &vid->camss->vfe;
> + struct vfe_line *line;
> + struct vfe_output *output;
> + unsigned long flags;
> +
> + line = vfe_video_pad_to_line(&vid->pad);
> + if (!line) {
> + dev_err(to_device(vfe), "Can not flush buffers\n");
> + return -1;
> + }
> + output = &line->output;
> +
> + spin_lock_irqsave(&vfe->output_lock, flags);
> +
> + vfe_buf_flush_pending(output, state);
> +
> + if (output->buf[0])
> + vb2_buffer_done(&output->buf[0]->vb.vb2_buf, state);
> +
> + if (output->buf[1])
> + vb2_buffer_done(&output->buf[1]->vb.vb2_buf, state);
> +
> + if (output->last_buffer) {
> + vb2_buffer_done(&output->last_buffer->vb.vb2_buf, state);
> + output->last_buffer = NULL;
> + }
> +
> + spin_unlock_irqrestore(&vfe->output_lock, flags);
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_set_power - Power on/off VFE module
> + * @sd: VFE V4L2 subdevice
> + * @on: Requested power state
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_set_power(struct v4l2_subdev *sd, int on)
> +{
> + struct vfe_line *line = v4l2_get_subdevdata(sd);
> + struct vfe_device *vfe = to_vfe(line);
> + int ret;
> +
> + if (on) {
> + u32 hw_version;
> +
> + ret = vfe_get(vfe);
> + if (ret < 0)
> + return ret;
> +
> + hw_version = readl_relaxed(vfe->base + VFE_0_HW_VERSION);
> + dev_dbg(to_device(vfe),
> + "VFE HW Version = 0x%08x\n", hw_version);
> + } else {
> + vfe_put(vfe);
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_set_stream - Enable/disable streaming on VFE module
> + * @sd: VFE V4L2 subdevice
> + * @enable: Requested streaming state
> + *
> + * Main configuration of VFE module is triggered here.
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_set_stream(struct v4l2_subdev *sd, int enable)
> +{
> + struct vfe_line *line = v4l2_get_subdevdata(sd);
> + struct vfe_device *vfe = to_vfe(line);
> + int ret;
> +
> + if (enable) {
> + ret = vfe_enable(line);
> + if (ret < 0)
> + dev_err(to_device(vfe),
> + "Failed to enable vfe outputs\n");
> + } else {
> + ret = vfe_disable(line);
> + if (ret < 0)
> + dev_err(to_device(vfe),
> + "Failed to disable vfe outputs\n");
> + }
> +
> + return ret;
> +}
> +
> +/*
> + * __vfe_get_format - Get pointer to format structure
> + * @line: VFE line
> + * @cfg: V4L2 subdev pad configuration
> + * @pad: pad from which format is requested
> + * @which: TRY or ACTIVE format
> + *
> + * Return pointer to TRY or ACTIVE format structure
> + */
> +static struct v4l2_mbus_framefmt *
> +__vfe_get_format(struct vfe_line *line,
> + struct v4l2_subdev_pad_config *cfg,
> + unsigned int pad,
> + enum v4l2_subdev_format_whence which)
> +{
> + if (which == V4L2_SUBDEV_FORMAT_TRY)
> + return v4l2_subdev_get_try_format(&line->subdev, cfg, pad);
> +
> + return &line->fmt[pad];
> +}
> +
> +
> +/*
> + * vfe_try_format - Handle try format by pad subdev method
> + * @line: VFE line
> + * @cfg: V4L2 subdev pad configuration
> + * @pad: pad on which format is requested
> + * @fmt: pointer to v4l2 format structure
> + * @which: wanted subdev format
> + */
> +static void vfe_try_format(struct vfe_line *line,
> + struct v4l2_subdev_pad_config *cfg,
> + unsigned int pad,
> + struct v4l2_mbus_framefmt *fmt,
> + enum v4l2_subdev_format_whence which)
> +{
> + unsigned int i;
> +
> + switch (pad) {
> + case MSM_VFE_PAD_SINK:
> + /* Set format on sink pad */
> +
> + for (i = 0; i < ARRAY_SIZE(vfe_formats); i++)
> + if (fmt->code == vfe_formats[i])
> + break;
> +
> + /* If not found, use UYVY as default */
> + if (i >= ARRAY_SIZE(vfe_formats))
> + fmt->code = MEDIA_BUS_FMT_UYVY8_2X8;
> +
> + fmt->width = clamp_t(u32, fmt->width, 1, 8191);
> + fmt->height = clamp_t(u32, fmt->height, 1, 8191);
> +
> + if (fmt->field == V4L2_FIELD_ANY)
> + fmt->field = V4L2_FIELD_NONE;
> +
> + break;
> +
> + case MSM_VFE_PAD_SRC:
> + /* Set and return a format same as sink pad */
> +
> + *fmt = *__vfe_get_format(line, cfg, MSM_VFE_PAD_SINK,
> + which);
> +
> + break;
> + }
> +
> + fmt->colorspace = V4L2_COLORSPACE_SRGB;
> +}
> +
> +/*
> + * vfe_enum_mbus_code - Handle pixel format enumeration
> + * @sd: VFE V4L2 subdevice
> + * @cfg: V4L2 subdev pad configuration
> + * @code: pointer to v4l2_subdev_mbus_code_enum structure
> + *
> + * return -EINVAL or zero on success
> + */
> +static int vfe_enum_mbus_code(struct v4l2_subdev *sd,
> + struct v4l2_subdev_pad_config *cfg,
> + struct v4l2_subdev_mbus_code_enum *code)
> +{
> + struct vfe_line *line = v4l2_get_subdevdata(sd);
> + struct v4l2_mbus_framefmt *format;
> +
> + if (code->pad == MSM_VFE_PAD_SINK) {
> + if (code->index >= ARRAY_SIZE(vfe_formats))
> + return -EINVAL;
> +
> + code->code = vfe_formats[code->index];
> + } else {
> + if (code->index > 0)
> + return -EINVAL;
> +
> + format = __vfe_get_format(line, cfg, MSM_VFE_PAD_SINK,
> + code->which);
> +
> + code->code = format->code;
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_enum_frame_size - Handle frame size enumeration
> + * @sd: VFE V4L2 subdevice
> + * @cfg: V4L2 subdev pad configuration
> + * @fse: pointer to v4l2_subdev_frame_size_enum structure
> + *
> + * Return -EINVAL or zero on success
> + */
> +static int vfe_enum_frame_size(struct v4l2_subdev *sd,
> + struct v4l2_subdev_pad_config *cfg,
> + struct v4l2_subdev_frame_size_enum *fse)
> +{
> + struct vfe_line *line = v4l2_get_subdevdata(sd);
> + struct v4l2_mbus_framefmt format;
> +
> + if (fse->index != 0)
> + return -EINVAL;
> +
> + format.code = fse->code;
> + format.width = 1;
> + format.height = 1;
> + vfe_try_format(line, cfg, fse->pad, &format, fse->which);
> + fse->min_width = format.width;
> + fse->min_height = format.height;
> +
> + if (format.code != fse->code)
> + return -EINVAL;
> +
> + format.code = fse->code;
> + format.width = -1;
> + format.height = -1;
> + vfe_try_format(line, cfg, fse->pad, &format, fse->which);
> + fse->max_width = format.width;
> + fse->max_height = format.height;
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_get_format - Handle get format by pads subdev method
> + * @sd: VFE V4L2 subdevice
> + * @cfg: V4L2 subdev pad configuration
> + * @fmt: pointer to v4l2 subdev format structure
> + *
> + * Return -EINVAL or zero on success
> + */
> +static int vfe_get_format(struct v4l2_subdev *sd,
> + struct v4l2_subdev_pad_config *cfg,
> + struct v4l2_subdev_format *fmt)
> +{
> + struct vfe_line *line = v4l2_get_subdevdata(sd);
> + struct v4l2_mbus_framefmt *format;
> +
> + format = __vfe_get_format(line, cfg, fmt->pad, fmt->which);
> + if (format == NULL)
> + return -EINVAL;
> +
> + fmt->format = *format;
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_set_format - Handle set format by pads subdev method
> + * @sd: VFE V4L2 subdevice
> + * @cfg: V4L2 subdev pad configuration
> + * @fmt: pointer to v4l2 subdev format structure
> + *
> + * Return -EINVAL or zero on success
> + */
> +static int vfe_set_format(struct v4l2_subdev *sd,
> + struct v4l2_subdev_pad_config *cfg,
> + struct v4l2_subdev_format *fmt)
> +{
> + struct vfe_line *line = v4l2_get_subdevdata(sd);
> + struct v4l2_mbus_framefmt *format;
> +
> + format = __vfe_get_format(line, cfg, fmt->pad, fmt->which);
> + if (format == NULL)
> + return -EINVAL;
> +
> + vfe_try_format(line, cfg, fmt->pad, &fmt->format, fmt->which);
> + *format = fmt->format;
> +
> + /* Propagate the format from sink to source */
> + if (fmt->pad == MSM_VFE_PAD_SINK) {
> + format = __vfe_get_format(line, cfg, MSM_VFE_PAD_SRC,
> + fmt->which);
> +
> + *format = fmt->format;
> + vfe_try_format(line, cfg, MSM_VFE_PAD_SRC, format,
> + fmt->which);
> + }
> +
> + return 0;
> +}
> +
> +/*
> + * vfe_init_formats - Initialize formats on all pads
> + * @sd: VFE V4L2 subdevice
> + * @fh: V4L2 subdev file handle
> + *
> + * Initialize all pad formats with default values.
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +static int vfe_init_formats(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
> +{
> + struct v4l2_subdev_format format = {
> + .pad = MSM_VFE_PAD_SINK,
> + .which = fh ? V4L2_SUBDEV_FORMAT_TRY :
> + V4L2_SUBDEV_FORMAT_ACTIVE,
> + .format = {
> + .code = MEDIA_BUS_FMT_UYVY8_2X8,
> + .width = 1920,
> + .height = 1080
> + }
> + };
> +
> + return vfe_set_format(sd, fh ? fh->pad : NULL, &format);
> +}
> +
> +/*
> + * msm_vfe_subdev_init - Initialize VFE device structure and resources
> + * @vfe: VFE device
> + * @res: VFE module resources table
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +int msm_vfe_subdev_init(struct vfe_device *vfe, const struct resources *res)
> +{
> + struct device *dev = to_device(vfe);
> + struct platform_device *pdev = to_platform_device(dev);
> + struct resource *r;
> + struct camss *camss = to_camss(vfe);
> +
> + int i;
> + int ret;
> +
> + mutex_init(&vfe->power_lock);
> + vfe->power_count = 0;
> +
> + mutex_init(&vfe->stream_lock);
> + vfe->stream_count = 0;
> +
> + spin_lock_init(&vfe->output_lock);
> +
> + vfe->id = 0;
> + vfe->reg_update = 0;
> +
> + for (i = VFE_LINE_RDI0; i <= VFE_LINE_RDI2; i++) {
> + vfe->line[i].video_out.type =
> + V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
> + vfe->line[i].video_out.camss = camss;
> + vfe->line[i].id = i;
> + }
> +
> + /* Memory */
> +
> + r = platform_get_resource_byname(pdev, IORESOURCE_MEM, res->reg[0]);
> + vfe->base = devm_ioremap_resource(dev, r);
> + if (IS_ERR(vfe->base)) {
> + dev_err(dev, "could not map memory\n");
mutex_destroy() for bothof the mutexes. The same below.
Do you have a corresponding cleanup function?
> + return PTR_ERR(vfe->base);
> + }
> +
> + /* Interrupt */
> +
> + r = platform_get_resource_byname(pdev, IORESOURCE_IRQ,
> + res->interrupt[0]);
> + if (!r) {
> + dev_err(dev, "missing IRQ\n");
> + return -EINVAL;
> + }
> +
> + vfe->irq = r->start;
> + snprintf(vfe->irq_name, sizeof(vfe->irq_name), "%s_%s%d",
> + dev_name(dev), MSM_VFE_NAME, vfe->id);
> + ret = devm_request_irq(dev, vfe->irq, vfe_isr,
> + IRQF_TRIGGER_RISING, vfe->irq_name, vfe);
> + if (ret < 0) {
> + dev_err(dev, "request_irq failed: %d\n", ret);
> + return ret;
> + }
> +
> + /* Clocks */
> +
> + vfe->nclocks = 0;
> + while (res->clock[vfe->nclocks])
> + vfe->nclocks++;
> +
> + vfe->clock = devm_kzalloc(dev, vfe->nclocks * sizeof(*vfe->clock),
> + GFP_KERNEL);
> + if (!vfe->clock)
> + return -ENOMEM;
> +
> + for (i = 0; i < vfe->nclocks; i++) {
> + vfe->clock[i] = devm_clk_get(dev, res->clock[i]);
> + if (IS_ERR(vfe->clock[i]))
> + return PTR_ERR(vfe->clock[i]);
> +
> + if (res->clock_rate[i]) {
> + long clk_rate = clk_round_rate(vfe->clock[i],
> + res->clock_rate[i]);
> + if (clk_rate < 0) {
> + dev_err(dev, "clk round rate failed\n");
> + return -EINVAL;
> + }
> + ret = clk_set_rate(vfe->clock[i], clk_rate);
> + if (ret < 0) {
> + dev_err(dev, "clk set rate failed\n");
> + return ret;
> + }
> + }
> + }
> +
> + init_completion(&vfe->reset_complete);
> + init_completion(&vfe->halt_complete);
> +
> + return 0;
> +}
> +
> +/*
> + * msm_vfe_get_vfe_id - Get VFE HW module id
> + * @entity: Pointer to VFE media entity structure
> + * @id: Return CSID HW module id here
> + */
> +void msm_vfe_get_vfe_id(struct media_entity *entity, u8 *id)
> +{
> + struct v4l2_subdev *sd;
> + struct vfe_line *line;
> + struct vfe_device *vfe;
> +
> + sd = media_entity_to_v4l2_subdev(entity);
> + line = v4l2_get_subdevdata(sd);
> + vfe = to_vfe(line);
> +
> + *id = vfe->id;
> +}
> +
> +/*
> + * msm_vfe_get_vfe_line_id - Get VFE line id by media entity
> + * @entity: Pointer to VFE media entity structure
> + * @id: Return VFE line id here
> + */
> +void msm_vfe_get_vfe_line_id(struct media_entity *entity, enum vfe_line_id *id)
> +{
> + struct v4l2_subdev *sd;
> + struct vfe_line *line;
> +
> + sd = media_entity_to_v4l2_subdev(entity);
> + line = v4l2_get_subdevdata(sd);
> +
> + *id = line->id;
> +}
> +
> +/*
> + * vfe_link_setup - Setup VFE connections
> + * @entity: Pointer to media entity structure
> + * @local: Pointer to local pad
> + * @remote: Pointer to remote pad
> + * @flags: Link flags
> + *
> + * Return 0 on success
> + */
> +static int vfe_link_setup(struct media_entity *entity,
> + const struct media_pad *local,
> + const struct media_pad *remote, u32 flags)
> +{
> + if (flags & MEDIA_LNK_FL_ENABLED)
> + if (media_entity_remote_pad(local))
> + return -EBUSY;
> +
> + return 0;
> +}
> +
> +static const struct v4l2_subdev_core_ops vfe_core_ops = {
> + .s_power = vfe_set_power,
> +};
> +
> +static const struct v4l2_subdev_video_ops vfe_video_ops = {
> + .s_stream = vfe_set_stream,
> +};
> +
> +static const struct v4l2_subdev_pad_ops vfe_pad_ops = {
> + .enum_mbus_code = vfe_enum_mbus_code,
> + .enum_frame_size = vfe_enum_frame_size,
> + .get_fmt = vfe_get_format,
> + .set_fmt = vfe_set_format,
> +};
> +
> +static const struct v4l2_subdev_ops vfe_v4l2_ops = {
> + .core = &vfe_core_ops,
> + .video = &vfe_video_ops,
> + .pad = &vfe_pad_ops,
> +};
> +
> +static const struct v4l2_subdev_internal_ops vfe_v4l2_internal_ops = {
> + .open = vfe_init_formats,
> +};
> +
> +static const struct media_entity_operations vfe_media_ops = {
> + .link_setup = vfe_link_setup,
> + .link_validate = v4l2_subdev_link_validate,
> +};
> +
> +static const struct camss_video_ops camss_vfe_video_ops = {
> + .queue_buffer = vfe_queue_buffer,
> + .flush_buffers = vfe_flush_buffers,
> +};
> +
> +void msm_vfe_stop_streaming(struct vfe_device *vfe)
> +{
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(vfe->line); i++)
> + msm_video_stop_streaming(&vfe->line[i].video_out);
> +}
> +
> +/*
> + * msm_vfe_register_entities - Register subdev node for VFE module
> + * @vfe: VFE device
> + * @v4l2_dev: V4L2 device
> + *
> + * Initialize and register a subdev node for the VFE module. Then
> + * call msm_video_register() to register the video device node which
> + * will be connected to this subdev node. Then actually create the
> + * media link between them.
> + *
> + * Return 0 on success or a negative error code otherwise
> + */
> +int msm_vfe_register_entities(struct vfe_device *vfe,
> + struct v4l2_device *v4l2_dev)
> +{
> + struct device *dev = to_device(vfe);
> + struct v4l2_subdev *sd;
> + struct media_pad *pads;
> + struct camss_video *video_out;
> + int ret;
> + int i;
> +
> + for (i = 0; i < ARRAY_SIZE(vfe->line); i++) {
> + char name[32];
> +
> + sd = &vfe->line[i].subdev;
> + pads = vfe->line[i].pads;
> + video_out = &vfe->line[i].video_out;
> +
> + v4l2_subdev_init(sd, &vfe_v4l2_ops);
> + sd->internal_ops = &vfe_v4l2_internal_ops;
> + sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
> + snprintf(sd->name, ARRAY_SIZE(sd->name), "%s%d_%s%d",
> + MSM_VFE_NAME, vfe->id, "rdi", i);
> + v4l2_set_subdevdata(sd, &vfe->line[i]);
> +
> + ret = vfe_init_formats(sd, NULL);
> + if (ret < 0) {
> + dev_err(dev, "Failed to init format: %d\n", ret);
> + goto error_init;
> + }
> +
> + pads[MSM_VFE_PAD_SINK].flags = MEDIA_PAD_FL_SINK;
> + pads[MSM_VFE_PAD_SRC].flags = MEDIA_PAD_FL_SOURCE;
> +
> + sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER;
> + sd->entity.ops = &vfe_media_ops;
> + ret = media_entity_pads_init(&sd->entity, MSM_VFE_PADS_NUM,
> + pads);
> + if (ret < 0) {
> + dev_err(dev, "Failed to init media entity: %d\n", ret);
> + goto error_init;
> + }
> +
> + ret = v4l2_device_register_subdev(v4l2_dev, sd);
> + if (ret < 0) {
> + dev_err(dev, "Failed to register subdev: %d\n", ret);
> + goto error_reg_subdev;
> + }
> +
> + video_out->ops = &camss_vfe_video_ops;
> + snprintf(name, ARRAY_SIZE(name), "%s%d_%s%d",
> + MSM_VFE_NAME, vfe->id, "video", i);
> + ret = msm_video_register(video_out, v4l2_dev, name);
> + if (ret < 0) {
> + dev_err(dev, "Failed to register video node: %d\n",
> + ret);
> + goto error_reg_video;
> + }
> +
> + ret = media_create_pad_link(
> + &sd->entity, MSM_VFE_PAD_SRC,
> + &video_out->vdev.entity, 0,
> + MEDIA_LNK_FL_IMMUTABLE | MEDIA_LNK_FL_ENABLED);
> + if (ret < 0) {
> + dev_err(dev, "Failed to link %s->%s entities: %d\n",
> + sd->entity.name, video_out->vdev.entity.name,
> + ret);
> + goto error_link;
> + }
> +
> + ret = msm_video_init_format(video_out);
> + if (ret < 0) {
> + dev_err(dev, "Failed to init format: %d\n", ret);
> + goto error_link;
> + }
> +
> + }
> +
> + return 0;
> +
> +error_link:
> + msm_video_unregister(video_out);
> +
> +error_reg_video:
> + v4l2_device_unregister_subdev(sd);
> +
> +error_reg_subdev:
> + media_entity_cleanup(&sd->entity);
> +
> +error_init:
> + for (i--; i >= 0; i--) {
> + sd = &vfe->line[i].subdev;
> + video_out = &vfe->line[i].video_out;
> +
> + msm_video_unregister(video_out);
> + v4l2_device_unregister_subdev(sd);
> + media_entity_cleanup(&sd->entity);
> + }
> +
> + return ret;
> +}
> +
> +/*
> + * msm_vfe_unregister_entities - Unregister VFE module subdev node
> + * @vfe: VFE device
> + */
> +void msm_vfe_unregister_entities(struct vfe_device *vfe)
> +{
> + int i;
> +
> + mutex_destroy(&vfe->power_lock);
> + mutex_destroy(&vfe->stream_lock);
> +
> + for (i = 0; i < ARRAY_SIZE(vfe->line); i++) {
> + struct v4l2_subdev *sd = &vfe->line[i].subdev;
> + struct camss_video *video_out = &vfe->line[i].video_out;
> +
> + msm_video_unregister(video_out);
> + v4l2_device_unregister_subdev(sd);
> + media_entity_cleanup(&sd->entity);
> + }
> +}
> diff --git a/drivers/media/platform/qcom/camss-8x16/camss-vfe.h b/drivers/media/platform/qcom/camss-8x16/camss-vfe.h
> new file mode 100644
> index 0000000..6d2fc57
> --- /dev/null
> +++ b/drivers/media/platform/qcom/camss-8x16/camss-vfe.h
> @@ -0,0 +1,114 @@
> +/*
> + * camss-vfe.h
> + *
> + * Qualcomm MSM Camera Subsystem - VFE Module
> + *
> + * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved.
> + * Copyright (C) 2015-2017 Linaro Ltd.
> + *
> + * This program is free software; you can redistribute it and/or modify
> + * it under the terms of the GNU General Public License version 2 and
> + * only version 2 as published by the Free Software Foundation.
> + *
> + * This program is distributed in the hope that it will be useful,
> + * but WITHOUT ANY WARRANTY; without even the implied warranty of
> + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
> + * GNU General Public License for more details.
> + */
> +#ifndef QC_MSM_CAMSS_VFE_H
> +#define QC_MSM_CAMSS_VFE_H
> +
> +#include <linux/clk.h>
> +#include <linux/spinlock_types.h>
> +#include <media/media-entity.h>
> +#include <media/v4l2-device.h>
> +#include <media/v4l2-subdev.h>
> +
> +#include "camss-video.h"
> +
> +#define MSM_VFE_PAD_SINK 0
> +#define MSM_VFE_PAD_SRC 1
> +#define MSM_VFE_PADS_NUM 2
> +
> +#define MSM_VFE_LINE_NUM 3
> +#define MSM_VFE_IMAGE_MASTERS_NUM 7
> +
> +#define MSM_VFE_VFE0_UB_SIZE 1023
> +#define MSM_VFE_VFE0_UB_SIZE_RDI (MSM_VFE_VFE0_UB_SIZE / 3)
> +#define MSM_VFE_VFE1_UB_SIZE 1535
> +#define MSM_VFE_VFE1_UB_SIZE_RDI (MSM_VFE_VFE1_UB_SIZE / 3)
> +
> +enum vfe_output_state {
> + VFE_OUTPUT_OFF,
> + VFE_OUTPUT_RESERVED,
> + VFE_OUTPUT_SINGLE,
> + VFE_OUTPUT_CONTINUOUS,
> + VFE_OUTPUT_IDLE,
> + VFE_OUTPUT_STOPPING
> +};
> +
> +enum vfe_line_id {
> + VFE_LINE_NONE = -1,
> + VFE_LINE_RDI0 = 0,
> + VFE_LINE_RDI1 = 1,
> + VFE_LINE_RDI2 = 2
> +};
> +
> +struct vfe_output {
> + u8 wm_idx;
> +
> + int active_buf;
> + struct camss_buffer *buf[2];
> + struct camss_buffer *last_buffer;
> + struct list_head pending_bufs;
> +
> + unsigned int drop_update_idx;
> +
> + enum vfe_output_state state;
> + unsigned int sequence;
> +};
> +
> +struct vfe_line {
> + enum vfe_line_id id;
> + struct v4l2_subdev subdev;
> + struct media_pad pads[MSM_VFE_PADS_NUM];
> + struct v4l2_mbus_framefmt fmt[MSM_VFE_PADS_NUM];
> + struct camss_video video_out;
> + struct vfe_output output;
> +};
> +
> +struct vfe_device {
> + u8 id;
> + void __iomem *base;
> + u32 irq;
> + char irq_name[30];
> + struct clk **clock;
> + int nclocks;
> + struct completion reset_complete;
> + struct completion halt_complete;
> + struct mutex power_lock;
> + int power_count;
> + struct mutex stream_lock;
> + int stream_count;
> + spinlock_t output_lock;
> + enum vfe_line_id wm_output_map[MSM_VFE_IMAGE_MASTERS_NUM];
> + struct vfe_line line[MSM_VFE_LINE_NUM];
> + u32 reg_update;
> + u8 was_streaming;
> +};
> +
> +struct resources;
> +
> +int msm_vfe_subdev_init(struct vfe_device *vfe, const struct resources *res);
> +
> +int msm_vfe_register_entities(struct vfe_device *vfe,
> + struct v4l2_device *v4l2_dev);
> +
> +void msm_vfe_unregister_entities(struct vfe_device *vfe);
> +
> +void msm_vfe_get_vfe_id(struct media_entity *entity, u8 *id);
> +void msm_vfe_get_vfe_line_id(struct media_entity *entity, enum vfe_line_id *id);
> +
> +void msm_vfe_stop_streaming(struct vfe_device *vfe);
> +
> +#endif /* QC_MSM_CAMSS_VFE_H */
--
Regards,
Sakari Ailus
e-mail: sakari.ailus@xxxxxx XMPP: sailus@xxxxxxxxxxxxxx
--
To unsubscribe from this list: send the line "unsubscribe linux-arm-msm" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
