| Message ID | 1500287629-23703-11-git-send-email-todor.tomov@linaro.org (mailing list archive) |
|---|---|
| State | Not Applicable, archived |
| Delegated to: | Andy Gross |
| Headers | show |
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@linaro.org> > --- > 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 */
Hi Sakari, Thank you for the review. On 20.07.2017 17:59, Sakari Ailus wrote: > 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@linaro.org> >> --- >> 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 @@ <snip> >> + >> +static void vfe_set_qos(struct vfe_device *vfe) >> +{ >> + u32 val = 0xaaa5aaa5; >> + u32 val7 = 0x0001aaa5; > > Huh. What do these mean? :-) For these here I don't have understanding of the values. I'll remove the magic values here and on all the other places but these here I'll just move to a #define. > >> + >> + 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); >> +} >> + <snip> >> + >> +/* >> + * 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? msm_vfe_subdev_init() and msm_vfe_register_entities() are called on probe(). msm_vfe_unregister_entities() is called on remove() - this is the cleanup function. The mutexes are destroyed there. Is there something else that you are concerned about? > >> + 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 */ >
Hi Todor, Todor Tomov wrote: > Hi Sakari, > > Thank you for the review. > > On 20.07.2017 17:59, Sakari Ailus wrote: >> 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@linaro.org> >>> --- >>> 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 @@ > > <snip> > >>> + >>> +static void vfe_set_qos(struct vfe_device *vfe) >>> +{ >>> + u32 val = 0xaaa5aaa5; >>> + u32 val7 = 0x0001aaa5; >> >> Huh. What do these mean? :-) > > For these here I don't have understanding of the values. I'll remove the magic > values here and on all the other places but these here I'll just move to a #define. If there is no documentation then I guess that's all that can be done. Works for me. > >> >>> + >>> + 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); >>> +} >>> + > > <snip> > >>> + >>> +/* >>> + * 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? > > msm_vfe_subdev_init() and msm_vfe_register_entities() are called on probe(). > msm_vfe_unregister_entities() is called on remove() - this is the cleanup > function. The mutexes are destroyed there. Is there something else that you > are concerned about? What about the error case above then? Where are the mutexes destroyed?
Hi Sakari, On 4.08.2017 21:02, Sakari Ailus wrote: > Hi Todor, > > Todor Tomov wrote: >> Hi Sakari, >> >> Thank you for the review. >> >> On 20.07.2017 17:59, Sakari Ailus wrote: >>> 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@linaro.org> >>>> --- >>>> 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 @@ >> >> <snip> >> >>>> + >>>> +static void vfe_set_qos(struct vfe_device *vfe) >>>> +{ >>>> + u32 val = 0xaaa5aaa5; >>>> + u32 val7 = 0x0001aaa5; >>> >>> Huh. What do these mean? :-) >> >> For these here I don't have understanding of the values. I'll remove the magic >> values here and on all the other places but these here I'll just move to a #define. > > If there is no documentation then I guess that's all that can be done. > Works for me. > >> >>> >>>> + >>>> + 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); >>>> +} >>>> + >> >> <snip> >> >>>> + >>>> +/* >>>> + * 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? >> >> msm_vfe_subdev_init() and msm_vfe_register_entities() are called on probe(). >> msm_vfe_unregister_entities() is called on remove() - this is the cleanup >> function. The mutexes are destroyed there. Is there something else that you >> are concerned about? > > What about the error case above then? Where are the mutexes destroyed? > Right, I'll add mutex_destroy() for the error cases too.
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)])) + +#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; + + 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"); + 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 */
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@linaro.org> --- 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