mirror of
https://github.com/openwrt/openwrt.git
synced 2024-12-22 23:12:32 +00:00
4528 lines
124 KiB
Diff
4528 lines
124 KiB
Diff
|
From ebc5df290ebb09d9388577f83b4529bfd97d92e9 Mon Sep 17 00:00:00 2001
|
||
|
From: Naushir Patuck <naush@raspberrypi.com>
|
||
|
Date: Tue, 14 Feb 2023 17:30:12 +0000
|
||
|
Subject: [PATCH 0543/1085] media: rp1: Add CFE (Camera Front End) support
|
||
|
|
||
|
Signed-off-by: Naushir Patuck <naush@raspberrypi.com>
|
||
|
---
|
||
|
drivers/media/platform/raspberrypi/Kconfig | 1 +
|
||
|
drivers/media/platform/raspberrypi/Makefile | 1 +
|
||
|
.../platform/raspberrypi/rp1_cfe/Kconfig | 14 +
|
||
|
.../platform/raspberrypi/rp1_cfe/Makefile | 6 +
|
||
|
.../media/platform/raspberrypi/rp1_cfe/cfe.c | 2186 +++++++++++++++++
|
||
|
.../media/platform/raspberrypi/rp1_cfe/cfe.h | 40 +
|
||
|
.../platform/raspberrypi/rp1_cfe/cfe_fmts.h | 294 +++
|
||
|
.../media/platform/raspberrypi/rp1_cfe/csi2.c | 446 ++++
|
||
|
.../media/platform/raspberrypi/rp1_cfe/csi2.h | 75 +
|
||
|
.../media/platform/raspberrypi/rp1_cfe/dphy.c | 177 ++
|
||
|
.../media/platform/raspberrypi/rp1_cfe/dphy.h | 26 +
|
||
|
.../raspberrypi/rp1_cfe/pisp_common.h | 69 +
|
||
|
.../platform/raspberrypi/rp1_cfe/pisp_fe.c | 563 +++++
|
||
|
.../platform/raspberrypi/rp1_cfe/pisp_fe.h | 53 +
|
||
|
.../raspberrypi/rp1_cfe/pisp_fe_config.h | 272 ++
|
||
|
.../raspberrypi/rp1_cfe/pisp_statistics.h | 62 +
|
||
|
.../platform/raspberrypi/rp1_cfe/pisp_types.h | 144 ++
|
||
|
17 files changed, 4429 insertions(+)
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/Kconfig
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/Makefile
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/cfe.c
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/cfe.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/cfe_fmts.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/csi2.c
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/csi2.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/dphy.c
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/dphy.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/pisp_common.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/pisp_fe.c
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/pisp_fe.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/pisp_fe_config.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/pisp_statistics.h
|
||
|
create mode 100644 drivers/media/platform/raspberrypi/rp1_cfe/pisp_types.h
|
||
|
|
||
|
--- a/drivers/media/platform/raspberrypi/Kconfig
|
||
|
+++ b/drivers/media/platform/raspberrypi/Kconfig
|
||
|
@@ -3,3 +3,4 @@
|
||
|
comment "Raspberry Pi media platform drivers"
|
||
|
|
||
|
source "drivers/media/platform/raspberrypi/pisp_be/Kconfig"
|
||
|
+source "drivers/media/platform/raspberrypi/rp1_cfe/Kconfig"
|
||
|
--- a/drivers/media/platform/raspberrypi/Makefile
|
||
|
+++ b/drivers/media/platform/raspberrypi/Makefile
|
||
|
@@ -1,3 +1,4 @@
|
||
|
# SPDX-License-Identifier: GPL-2.0
|
||
|
|
||
|
obj-y += pisp_be/
|
||
|
+obj-y += rp1_cfe/
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/Kconfig
|
||
|
@@ -0,0 +1,14 @@
|
||
|
+# RP1 V4L2 camera support
|
||
|
+
|
||
|
+config VIDEO_RP1_CFE
|
||
|
+ tristate "RP1 Camera Frond End (CFE) video capture driver"
|
||
|
+ depends on VIDEO_DEV
|
||
|
+ select VIDEO_V4L2_SUBDEV_API
|
||
|
+ select MEDIA_CONTROLLER
|
||
|
+ select VIDEOBUF2_DMA_CONTIG
|
||
|
+ select V4L2_FWNODE
|
||
|
+ help
|
||
|
+ Say Y here to enable support for the RP1 Camera Front End.
|
||
|
+
|
||
|
+ To compile this driver as a module, choose M here. The module will be
|
||
|
+ called rp1-cfe.
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/Makefile
|
||
|
@@ -0,0 +1,6 @@
|
||
|
+# SPDX-License-Identifier: GPL-2.0
|
||
|
+#
|
||
|
+# Makefile for RP1 Camera Front End driver
|
||
|
+#
|
||
|
+rp1-cfe-objs := cfe.o csi2.o pisp_fe.o dphy.o
|
||
|
+obj-$(CONFIG_VIDEO_RP1_CFE) += rp1-cfe.o
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/cfe.c
|
||
|
@@ -0,0 +1,2186 @@
|
||
|
+// SPDX-License-Identifier: GPL-2.0-only
|
||
|
+/*
|
||
|
+ * RP1 Camera Front End Driver
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021-2022 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+
|
||
|
+#include <linux/atomic.h>
|
||
|
+#include <linux/clk.h>
|
||
|
+#include <linux/debugfs.h>
|
||
|
+#include <linux/delay.h>
|
||
|
+#include <linux/device.h>
|
||
|
+#include <linux/dma-mapping.h>
|
||
|
+#include <linux/err.h>
|
||
|
+#include <linux/init.h>
|
||
|
+#include <linux/interrupt.h>
|
||
|
+#include <linux/io.h>
|
||
|
+#include <linux/module.h>
|
||
|
+#include <linux/of_device.h>
|
||
|
+#include <linux/of_graph.h>
|
||
|
+#include <linux/phy/phy.h>
|
||
|
+#include <linux/pinctrl/consumer.h>
|
||
|
+#include <linux/platform_device.h>
|
||
|
+#include <linux/pm_runtime.h>
|
||
|
+#include <linux/seq_file.h>
|
||
|
+#include <linux/slab.h>
|
||
|
+#include <linux/uaccess.h>
|
||
|
+#include <linux/videodev2.h>
|
||
|
+
|
||
|
+#include <media/v4l2-async.h>
|
||
|
+#include <media/v4l2-common.h>
|
||
|
+#include <media/v4l2-ctrls.h>
|
||
|
+#include <media/v4l2-dev.h>
|
||
|
+#include <media/v4l2-device.h>
|
||
|
+#include <media/v4l2-dv-timings.h>
|
||
|
+#include <media/v4l2-event.h>
|
||
|
+#include <media/v4l2-fwnode.h>
|
||
|
+#include <media/v4l2-ioctl.h>
|
||
|
+#include <media/videobuf2-dma-contig.h>
|
||
|
+
|
||
|
+#include "cfe.h"
|
||
|
+#include "cfe_fmts.h"
|
||
|
+#include "csi2.h"
|
||
|
+#include "pisp_fe.h"
|
||
|
+#include "pisp_fe_config.h"
|
||
|
+#include "pisp_statistics.h"
|
||
|
+
|
||
|
+#define CFE_MODULE_NAME "rp1-cfe"
|
||
|
+#define CFE_VERSION "1.0"
|
||
|
+
|
||
|
+bool cfe_debug_irq;
|
||
|
+
|
||
|
+#define cfe_dbg_irq(fmt, arg...) \
|
||
|
+ do { \
|
||
|
+ if (cfe_debug_irq) \
|
||
|
+ dev_dbg(&cfe->pdev->dev, fmt, ##arg); \
|
||
|
+ } while (0)
|
||
|
+#define cfe_dbg(fmt, arg...) dev_dbg(&cfe->pdev->dev, fmt, ##arg)
|
||
|
+#define cfe_info(fmt, arg...) dev_info(&cfe->pdev->dev, fmt, ##arg)
|
||
|
+#define cfe_err(fmt, arg...) dev_err(&cfe->pdev->dev, fmt, ##arg)
|
||
|
+
|
||
|
+/* MIPICFG registers */
|
||
|
+#define MIPICFG_CFG 0x004
|
||
|
+#define MIPICFG_INTR 0x028
|
||
|
+#define MIPICFG_INTE 0x02c
|
||
|
+#define MIPICFG_INTF 0x030
|
||
|
+#define MIPICFG_INTS 0x034
|
||
|
+
|
||
|
+#define MIPICFG_CFG_SEL_CSI BIT(0)
|
||
|
+
|
||
|
+#define MIPICFG_INT_CSI_DMA BIT(0)
|
||
|
+#define MIPICFG_INT_CSI_HOST BIT(2)
|
||
|
+#define MIPICFG_INT_PISP_FE BIT(4)
|
||
|
+
|
||
|
+#define BPL_ALIGNMENT 16
|
||
|
+#define MAX_BYTESPERLINE 0xffffff00
|
||
|
+#define MAX_BUFFER_SIZE 0xffffff00
|
||
|
+/*
|
||
|
+ * Max width is therefore determined by the max stride divided by the number of
|
||
|
+ * bits per pixel.
|
||
|
+ *
|
||
|
+ * However, to avoid overflow issues let's use a 16k maximum. This lets us
|
||
|
+ * calculate 16k * 16k * 4 with 32bits. If we need higher maximums, a careful
|
||
|
+ * review and adjustment of the code is needed so that it will deal with
|
||
|
+ * overflows correctly.
|
||
|
+ */
|
||
|
+#define MAX_WIDTH 16384
|
||
|
+#define MAX_HEIGHT MAX_WIDTH
|
||
|
+/* Define a nominal minimum image size */
|
||
|
+#define MIN_WIDTH 16
|
||
|
+#define MIN_HEIGHT 16
|
||
|
+/* Default size of the embedded buffer */
|
||
|
+#define DEFAULT_EMBEDDED_SIZE 8192
|
||
|
+
|
||
|
+const struct v4l2_mbus_framefmt cfe_default_format = {
|
||
|
+ .width = 640,
|
||
|
+ .height = 480,
|
||
|
+ .code = MEDIA_BUS_FMT_SRGGB10_1X10,
|
||
|
+ .field = V4L2_FIELD_NONE,
|
||
|
+ .colorspace = V4L2_COLORSPACE_RAW,
|
||
|
+ .ycbcr_enc = V4L2_YCBCR_ENC_601,
|
||
|
+ .quantization = V4L2_QUANTIZATION_FULL_RANGE,
|
||
|
+ .xfer_func = V4L2_XFER_FUNC_NONE,
|
||
|
+};
|
||
|
+
|
||
|
+const struct v4l2_mbus_framefmt cfe_default_meta_format = {
|
||
|
+ .width = 8192,
|
||
|
+ .height = 1,
|
||
|
+ .code = MEDIA_BUS_FMT_SENSOR_DATA,
|
||
|
+};
|
||
|
+
|
||
|
+enum node_ids {
|
||
|
+ /* CSI2 HW output nodes first. */
|
||
|
+ CSI2_CH0,
|
||
|
+ CSI2_CH1_EMBEDDED,
|
||
|
+ CSI2_CH2,
|
||
|
+ CSI2_CH3,
|
||
|
+ /* FE only nodes from here on. */
|
||
|
+ FE_OUT0,
|
||
|
+ FE_OUT1,
|
||
|
+ FE_STATS,
|
||
|
+ FE_CONFIG,
|
||
|
+ NUM_NODES
|
||
|
+};
|
||
|
+
|
||
|
+struct node_description {
|
||
|
+ unsigned int id;
|
||
|
+ const char *name;
|
||
|
+ enum v4l2_buf_type buf_type;
|
||
|
+ unsigned int cap;
|
||
|
+ unsigned int pad_flags;
|
||
|
+ unsigned int link_pad;
|
||
|
+};
|
||
|
+
|
||
|
+/* Must match the ordering of enum ids */
|
||
|
+static const struct node_description node_desc[NUM_NODES] = {
|
||
|
+ [CSI2_CH0] = {
|
||
|
+ .name = "csi2_ch0",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_VIDEO_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = CSI2_NUM_CHANNELS + 0
|
||
|
+ },
|
||
|
+ /* This node is assigned for the embedded data channel! */
|
||
|
+ [CSI2_CH1_EMBEDDED] = {
|
||
|
+ .name = "embedded",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_META_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_META_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = CSI2_NUM_CHANNELS + 1
|
||
|
+ },
|
||
|
+ [CSI2_CH2] = {
|
||
|
+ .name = "csi2_ch2",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_META_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = CSI2_NUM_CHANNELS + 2
|
||
|
+ },
|
||
|
+ [CSI2_CH3] = {
|
||
|
+ .name = "csi2_ch3",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_META_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = CSI2_NUM_CHANNELS + 3
|
||
|
+ },
|
||
|
+ [FE_OUT0] = {
|
||
|
+ .name = "fe_image0",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_VIDEO_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = FE_OUTPUT0_PAD
|
||
|
+ },
|
||
|
+ [FE_OUT1] = {
|
||
|
+ .name = "fe_image1",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_VIDEO_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_VIDEO_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = FE_OUTPUT1_PAD
|
||
|
+ },
|
||
|
+ [FE_STATS] = {
|
||
|
+ .name = "fe_stats",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_META_CAPTURE,
|
||
|
+ .cap = V4L2_CAP_META_CAPTURE,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = FE_STATS_PAD
|
||
|
+ },
|
||
|
+ [FE_CONFIG] = {
|
||
|
+ .name = "fe_config",
|
||
|
+ .buf_type = V4L2_BUF_TYPE_META_OUTPUT,
|
||
|
+ .cap = V4L2_CAP_META_OUTPUT,
|
||
|
+ .pad_flags = MEDIA_PAD_FL_SOURCE | MEDIA_PAD_FL_MUST_CONNECT,
|
||
|
+ .link_pad = FE_CONFIG_PAD
|
||
|
+ },
|
||
|
+};
|
||
|
+
|
||
|
+#define is_fe_node(node) (((node)->id) >= FE_OUT0)
|
||
|
+#define is_csi2_node(node) (!is_fe_node(node))
|
||
|
+#define is_image_output_node(node) \
|
||
|
+ (node_desc[(node)->id].buf_type == V4L2_BUF_TYPE_VIDEO_CAPTURE)
|
||
|
+#define is_meta_output_node(node) \
|
||
|
+ (node_desc[(node)->id].buf_type == V4L2_BUF_TYPE_META_CAPTURE)
|
||
|
+#define is_meta_input_node(node) \
|
||
|
+ (node_desc[(node)->id].buf_type == V4L2_BUF_TYPE_META_OUTPUT)
|
||
|
+#define is_meta_node(node) (is_meta_output_node(node) || is_meta_input_node(node))
|
||
|
+
|
||
|
+/* To track state across all nodes. */
|
||
|
+#define NUM_STATES 5
|
||
|
+#define NODE_REGISTERED BIT(0)
|
||
|
+#define NODE_ENABLED BIT(1)
|
||
|
+#define NODE_STREAMING BIT(2)
|
||
|
+#define FS_INT BIT(3)
|
||
|
+#define FE_INT BIT(4)
|
||
|
+
|
||
|
+struct cfe_buffer {
|
||
|
+ struct vb2_v4l2_buffer vb;
|
||
|
+ struct list_head list;
|
||
|
+};
|
||
|
+
|
||
|
+struct cfe_config_buffer {
|
||
|
+ struct cfe_buffer buf;
|
||
|
+ struct pisp_fe_config config;
|
||
|
+};
|
||
|
+
|
||
|
+static inline struct cfe_buffer *to_cfe_buffer(struct vb2_buffer *vb)
|
||
|
+{
|
||
|
+ return container_of(vb, struct cfe_buffer, vb.vb2_buf);
|
||
|
+}
|
||
|
+
|
||
|
+static inline
|
||
|
+struct cfe_config_buffer *to_cfe_config_buffer(struct cfe_buffer *buf)
|
||
|
+{
|
||
|
+ return container_of(buf, struct cfe_config_buffer, buf);
|
||
|
+}
|
||
|
+
|
||
|
+struct cfe_node {
|
||
|
+ unsigned int id;
|
||
|
+ /* Pointer pointing to current v4l2_buffer */
|
||
|
+ struct cfe_buffer *cur_frm;
|
||
|
+ /* Pointer pointing to next v4l2_buffer */
|
||
|
+ struct cfe_buffer *next_frm;
|
||
|
+ /* Used to store current pixel format */
|
||
|
+ struct v4l2_format fmt;
|
||
|
+ /* Buffer queue used in video-buf */
|
||
|
+ struct vb2_queue buffer_queue;
|
||
|
+ /* Queue of filled frames */
|
||
|
+ struct list_head dma_queue;
|
||
|
+ /* lock used to access this structure */
|
||
|
+ struct mutex lock;
|
||
|
+ /* Identifies video device for this channel */
|
||
|
+ struct video_device video_dev;
|
||
|
+ /* Pointer to the parent handle */
|
||
|
+ struct cfe_device *cfe;
|
||
|
+ struct media_pad pad;
|
||
|
+};
|
||
|
+
|
||
|
+struct cfe_device {
|
||
|
+ struct dentry *debugfs;
|
||
|
+ struct kref kref;
|
||
|
+
|
||
|
+ /* V4l2 specific parameters */
|
||
|
+ struct v4l2_async_connection *asd;
|
||
|
+
|
||
|
+ /* peripheral base address */
|
||
|
+ void __iomem *mipi_cfg_base;
|
||
|
+
|
||
|
+ struct clk *clk;
|
||
|
+
|
||
|
+ /* V4l2 device */
|
||
|
+ struct v4l2_device v4l2_dev;
|
||
|
+ struct media_device mdev;
|
||
|
+ struct media_pipeline pipe;
|
||
|
+
|
||
|
+ /* IRQ lock for node state and DMA queues */
|
||
|
+ spinlock_t state_lock;
|
||
|
+ bool job_ready;
|
||
|
+ bool job_queued;
|
||
|
+
|
||
|
+ /* parent device */
|
||
|
+ struct platform_device *pdev;
|
||
|
+ /* subdevice async Notifier */
|
||
|
+ struct v4l2_async_notifier notifier;
|
||
|
+
|
||
|
+ /* ptr to sub device */
|
||
|
+ struct v4l2_subdev *sensor;
|
||
|
+
|
||
|
+ struct cfe_node node[NUM_NODES];
|
||
|
+ DECLARE_BITMAP(node_flags, NUM_STATES * NUM_NODES);
|
||
|
+
|
||
|
+ struct csi2_device csi2;
|
||
|
+ struct pisp_fe_device fe;
|
||
|
+
|
||
|
+ bool sensor_embedded_data;
|
||
|
+ int fe_csi2_channel;
|
||
|
+
|
||
|
+ unsigned int sequence;
|
||
|
+ u64 ts;
|
||
|
+};
|
||
|
+
|
||
|
+static inline bool is_fe_enabled(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ return cfe->fe_csi2_channel != -1;
|
||
|
+}
|
||
|
+
|
||
|
+static inline struct cfe_device *to_cfe_device(struct v4l2_device *v4l2_dev)
|
||
|
+{
|
||
|
+ return container_of(v4l2_dev, struct cfe_device, v4l2_dev);
|
||
|
+}
|
||
|
+
|
||
|
+static inline u32 cfg_reg_read(struct cfe_device *cfe, u32 offset)
|
||
|
+{
|
||
|
+ return readl(cfe->mipi_cfg_base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static inline void cfg_reg_write(struct cfe_device *cfe, u32 offset, u32 val)
|
||
|
+{
|
||
|
+ writel(val, cfe->mipi_cfg_base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static bool check_state(struct cfe_device *cfe, unsigned long state,
|
||
|
+ unsigned int node_id)
|
||
|
+{
|
||
|
+ unsigned long bit;
|
||
|
+
|
||
|
+ for_each_set_bit(bit, &state, sizeof(state)) {
|
||
|
+ if (!test_bit(bit + (node_id * NUM_STATES), cfe->node_flags))
|
||
|
+ return false;
|
||
|
+ }
|
||
|
+ return true;
|
||
|
+}
|
||
|
+
|
||
|
+static void set_state(struct cfe_device *cfe, unsigned long state,
|
||
|
+ unsigned int node_id)
|
||
|
+{
|
||
|
+ unsigned long bit;
|
||
|
+
|
||
|
+ for_each_set_bit(bit, &state, sizeof(state))
|
||
|
+ set_bit(bit + (node_id * NUM_STATES), cfe->node_flags);
|
||
|
+}
|
||
|
+
|
||
|
+static void clear_state(struct cfe_device *cfe, unsigned long state,
|
||
|
+ unsigned int node_id)
|
||
|
+{
|
||
|
+ unsigned long bit;
|
||
|
+
|
||
|
+ for_each_set_bit(bit, &state, sizeof(state))
|
||
|
+ clear_bit(bit + (node_id * NUM_STATES), cfe->node_flags);
|
||
|
+}
|
||
|
+
|
||
|
+static bool test_any_node(struct cfe_device *cfe, unsigned long cond)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ if (check_state(cfe, cond, i))
|
||
|
+ return true;
|
||
|
+ }
|
||
|
+
|
||
|
+ return false;
|
||
|
+}
|
||
|
+
|
||
|
+static bool test_all_nodes(struct cfe_device *cfe, unsigned long precond,
|
||
|
+ unsigned long cond)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ if (check_state(cfe, precond, i)) {
|
||
|
+ if (!check_state(cfe, cond, i))
|
||
|
+ return false;
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+ return true;
|
||
|
+}
|
||
|
+
|
||
|
+static void clear_all_nodes(struct cfe_device *cfe, unsigned long precond,
|
||
|
+ unsigned long state)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ if (check_state(cfe, precond, i))
|
||
|
+ clear_state(cfe, state, i);
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+static int mipi_cfg_regs_show(struct seq_file *s, void *data)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = s->private;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ ret = pm_runtime_resume_and_get(&cfe->pdev->dev);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+#define DUMP(reg) seq_printf(s, #reg " \t0x%08x\n", cfg_reg_read(cfe, reg))
|
||
|
+ DUMP(MIPICFG_CFG);
|
||
|
+ DUMP(MIPICFG_INTR);
|
||
|
+ DUMP(MIPICFG_INTE);
|
||
|
+ DUMP(MIPICFG_INTF);
|
||
|
+ DUMP(MIPICFG_INTS);
|
||
|
+#undef DUMP
|
||
|
+
|
||
|
+ pm_runtime_put(&cfe->pdev->dev);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int format_show(struct seq_file *s, void *data)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = s->private;
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+ unsigned long sb, state = 0;
|
||
|
+
|
||
|
+ for (sb = 0; sb < NUM_STATES; sb++) {
|
||
|
+ if (check_state(cfe, BIT(sb), i))
|
||
|
+ state |= BIT(sb);
|
||
|
+ }
|
||
|
+
|
||
|
+ seq_printf(s, "\nNode %u (%s) state: 0x%lx\n", i,
|
||
|
+ node_desc[i].name, state);
|
||
|
+
|
||
|
+ if (is_image_output_node(node))
|
||
|
+ seq_printf(s, "format: " V4L2_FOURCC_CONV " 0x%x\n"
|
||
|
+ "resolution: %ux%u\nbpl: %u\nsize: %u\n",
|
||
|
+ V4L2_FOURCC_CONV_ARGS(node->fmt.fmt.pix.pixelformat),
|
||
|
+ node->fmt.fmt.pix.pixelformat,
|
||
|
+ node->fmt.fmt.pix.width,
|
||
|
+ node->fmt.fmt.pix.height,
|
||
|
+ node->fmt.fmt.pix.bytesperline,
|
||
|
+ node->fmt.fmt.pix.sizeimage);
|
||
|
+ else
|
||
|
+ seq_printf(s, "format: " V4L2_FOURCC_CONV " 0x%x\nsize: %u\n",
|
||
|
+ V4L2_FOURCC_CONV_ARGS(node->fmt.fmt.meta.dataformat),
|
||
|
+ node->fmt.fmt.meta.dataformat,
|
||
|
+ node->fmt.fmt.meta.buffersize);
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+DEFINE_SHOW_ATTRIBUTE(mipi_cfg_regs);
|
||
|
+DEFINE_SHOW_ATTRIBUTE(format);
|
||
|
+
|
||
|
+/* Format setup functions */
|
||
|
+const struct cfe_fmt *find_format_by_code(u32 code)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < ARRAY_SIZE(formats); i++) {
|
||
|
+ if (formats[i].code == code)
|
||
|
+ return &formats[i];
|
||
|
+ }
|
||
|
+
|
||
|
+ return NULL;
|
||
|
+}
|
||
|
+
|
||
|
+static const struct cfe_fmt *find_format_by_pix(u32 pixelformat)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < ARRAY_SIZE(formats); i++) {
|
||
|
+ if (formats[i].fourcc == pixelformat)
|
||
|
+ return &formats[i];
|
||
|
+ }
|
||
|
+
|
||
|
+ return NULL;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_calc_format_size_bpl(struct cfe_device *cfe,
|
||
|
+ const struct cfe_fmt *fmt,
|
||
|
+ struct v4l2_format *f)
|
||
|
+{
|
||
|
+ unsigned int min_bytesperline;
|
||
|
+
|
||
|
+ v4l_bound_align_image(&f->fmt.pix.width, MIN_WIDTH, MAX_WIDTH, 2,
|
||
|
+ &f->fmt.pix.height, MIN_HEIGHT, MAX_HEIGHT, 0, 0);
|
||
|
+
|
||
|
+ min_bytesperline =
|
||
|
+ ALIGN((f->fmt.pix.width * fmt->depth) >> 3, BPL_ALIGNMENT);
|
||
|
+
|
||
|
+ if (f->fmt.pix.bytesperline > min_bytesperline &&
|
||
|
+ f->fmt.pix.bytesperline <= MAX_BYTESPERLINE)
|
||
|
+ f->fmt.pix.bytesperline =
|
||
|
+ ALIGN(f->fmt.pix.bytesperline, BPL_ALIGNMENT);
|
||
|
+ else
|
||
|
+ f->fmt.pix.bytesperline = min_bytesperline;
|
||
|
+
|
||
|
+ f->fmt.pix.sizeimage = f->fmt.pix.height * f->fmt.pix.bytesperline;
|
||
|
+
|
||
|
+ cfe_dbg("%s: " V4L2_FOURCC_CONV " size: %ux%u bpl:%u img_size:%u\n",
|
||
|
+ __func__, V4L2_FOURCC_CONV_ARGS(f->fmt.pix.pixelformat),
|
||
|
+ f->fmt.pix.width, f->fmt.pix.height,
|
||
|
+ f->fmt.pix.bytesperline, f->fmt.pix.sizeimage);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_schedule_next_csi2_job(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ struct cfe_buffer *buf;
|
||
|
+ unsigned int i;
|
||
|
+ dma_addr_t addr;
|
||
|
+
|
||
|
+ for (i = 0; i < CSI2_NUM_CHANNELS; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+ unsigned int stride, size;
|
||
|
+
|
||
|
+ if (!check_state(cfe, NODE_STREAMING, i))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ buf = list_first_entry(&node->dma_queue, struct cfe_buffer,
|
||
|
+ list);
|
||
|
+ node->next_frm = buf;
|
||
|
+ list_del(&buf->list);
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] buffer:%p\n",
|
||
|
+ __func__, node_desc[node->id].name, &buf->vb.vb2_buf);
|
||
|
+
|
||
|
+ if (is_meta_node(node)) {
|
||
|
+ size = node->fmt.fmt.meta.buffersize;
|
||
|
+ stride = 0;
|
||
|
+ } else {
|
||
|
+ size = node->fmt.fmt.pix.sizeimage;
|
||
|
+ stride = node->fmt.fmt.pix.bytesperline;
|
||
|
+ }
|
||
|
+
|
||
|
+ addr = vb2_dma_contig_plane_dma_addr(&buf->vb.vb2_buf, 0);
|
||
|
+ csi2_set_buffer(&cfe->csi2, node->id, addr, stride, size);
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_schedule_next_pisp_job(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ struct vb2_buffer *vb2_bufs[FE_NUM_PADS] = { 0 };
|
||
|
+ struct cfe_config_buffer *config_buf;
|
||
|
+ struct cfe_buffer *buf;
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = CSI2_NUM_CHANNELS; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+
|
||
|
+ if (!check_state(cfe, NODE_STREAMING, i))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ buf = list_first_entry(&node->dma_queue, struct cfe_buffer,
|
||
|
+ list);
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: [%s] buffer:%p\n", __func__,
|
||
|
+ node_desc[node->id].name, &buf->vb.vb2_buf);
|
||
|
+
|
||
|
+ node->next_frm = buf;
|
||
|
+ vb2_bufs[node_desc[i].link_pad] = &buf->vb.vb2_buf;
|
||
|
+ list_del(&buf->list);
|
||
|
+ }
|
||
|
+
|
||
|
+ config_buf = to_cfe_config_buffer(cfe->node[FE_CONFIG].next_frm);
|
||
|
+ pisp_fe_submit_job(&cfe->fe, vb2_bufs, &config_buf->config);
|
||
|
+}
|
||
|
+
|
||
|
+static bool cfe_check_job_ready(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+
|
||
|
+ if (!check_state(cfe, NODE_ENABLED, i))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ if (list_empty(&node->dma_queue)) {
|
||
|
+ cfe_dbg_irq("%s: [%s] has no buffer, unable to schedule job\n",
|
||
|
+ __func__, node_desc[i].name);
|
||
|
+ return false;
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+ return true;
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_prepare_next_job(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ cfe->job_queued = true;
|
||
|
+ cfe_schedule_next_csi2_job(cfe);
|
||
|
+ if (is_fe_enabled(cfe))
|
||
|
+ cfe_schedule_next_pisp_job(cfe);
|
||
|
+
|
||
|
+ /* Flag if another job is ready after this. */
|
||
|
+ cfe->job_ready = cfe_check_job_ready(cfe);
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: end with scheduled job\n", __func__);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_process_buffer_complete(struct cfe_node *node,
|
||
|
+ unsigned int sequence)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: [%s] buffer:%p\n", __func__, node_desc[node->id].name,
|
||
|
+ &node->cur_frm->vb.vb2_buf);
|
||
|
+
|
||
|
+ node->cur_frm->vb.sequence = sequence;
|
||
|
+ vb2_buffer_done(&node->cur_frm->vb.vb2_buf, VB2_BUF_STATE_DONE);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_queue_event_sof(struct cfe_node *node)
|
||
|
+{
|
||
|
+ struct v4l2_event event = {
|
||
|
+ .type = V4L2_EVENT_FRAME_SYNC,
|
||
|
+ .u.frame_sync.frame_sequence = node->cfe->sequence,
|
||
|
+ };
|
||
|
+
|
||
|
+ v4l2_event_queue(&node->video_dev, &event);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_sof_isr_handler(struct cfe_node *node)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: [%s] seq %u\n", __func__, node_desc[node->id].name,
|
||
|
+ cfe->sequence);
|
||
|
+
|
||
|
+ node->cur_frm = node->next_frm;
|
||
|
+ node->next_frm = NULL;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * If this is the first node to see a frame start, sample the
|
||
|
+ * timestamp to use for all frames across all channels.
|
||
|
+ */
|
||
|
+ if (!test_any_node(cfe, NODE_STREAMING | FS_INT))
|
||
|
+ cfe->ts = ktime_get_ns();
|
||
|
+
|
||
|
+ set_state(cfe, FS_INT, node->id);
|
||
|
+
|
||
|
+ /* If all nodes have seen a frame start, we can queue another job. */
|
||
|
+ if (test_all_nodes(cfe, NODE_STREAMING, FS_INT))
|
||
|
+ cfe->job_queued = false;
|
||
|
+
|
||
|
+ if (node->cur_frm)
|
||
|
+ node->cur_frm->vb.vb2_buf.timestamp = cfe->ts;
|
||
|
+
|
||
|
+ if (is_image_output_node(node))
|
||
|
+ cfe_queue_event_sof(node);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_eof_isr_handler(struct cfe_node *node)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: [%s] seq %u\n", __func__, node_desc[node->id].name,
|
||
|
+ cfe->sequence);
|
||
|
+
|
||
|
+ if (node->cur_frm)
|
||
|
+ cfe_process_buffer_complete(node, cfe->sequence);
|
||
|
+
|
||
|
+ node->cur_frm = NULL;
|
||
|
+ set_state(cfe, FE_INT, node->id);
|
||
|
+
|
||
|
+ /*
|
||
|
+ * If all nodes have seen a frame end, we can increment
|
||
|
+ * the sequence counter now.
|
||
|
+ */
|
||
|
+ if (test_all_nodes(cfe, NODE_STREAMING, FE_INT)) {
|
||
|
+ cfe->sequence++;
|
||
|
+ clear_all_nodes(cfe, NODE_STREAMING, FE_INT | FS_INT);
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+static irqreturn_t cfe_isr(int irq, void *dev)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = dev;
|
||
|
+ unsigned int i;
|
||
|
+ bool sof[NUM_NODES] = {0}, eof[NUM_NODES] = {0}, lci[NUM_NODES] = {0};
|
||
|
+ u32 sts;
|
||
|
+
|
||
|
+ sts = cfg_reg_read(cfe, MIPICFG_INTS);
|
||
|
+
|
||
|
+ if (sts & MIPICFG_INT_CSI_DMA)
|
||
|
+ csi2_isr(&cfe->csi2, sof, eof, lci);
|
||
|
+
|
||
|
+ if (sts & MIPICFG_INT_PISP_FE)
|
||
|
+ pisp_fe_isr(&cfe->fe, sof + CSI2_NUM_CHANNELS,
|
||
|
+ eof + CSI2_NUM_CHANNELS);
|
||
|
+
|
||
|
+ spin_lock(&cfe->state_lock);
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+
|
||
|
+ /*
|
||
|
+ * The check_state(NODE_STREAMING) is to ensure we do not loop
|
||
|
+ * over the CSI2_CHx nodes when the FE is active since they
|
||
|
+ * generate interrupts even though the node is not streaming.
|
||
|
+ */
|
||
|
+ if (!check_state(cfe, NODE_STREAMING, i) ||
|
||
|
+ !(sof[i] || eof[i] || lci[i]))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * There are 3 cases where we could get FS + FE_ACK at
|
||
|
+ * the same time:
|
||
|
+ * 1) FE of the current frame, and FS of the next frame.
|
||
|
+ * 2) FS + FE of the same frame.
|
||
|
+ * 3) FE of the current frame, and FS + FE of the next
|
||
|
+ * frame. To handle this, see the sof handler below.
|
||
|
+ *
|
||
|
+ * (1) is handled implicitly by the ordering of the FE and FS
|
||
|
+ * handlers below.
|
||
|
+ */
|
||
|
+ if (eof[i]) {
|
||
|
+ /*
|
||
|
+ * The condition below tests for (2). Run the FS handler
|
||
|
+ * first before the FE handler, both for the current
|
||
|
+ * frame.
|
||
|
+ */
|
||
|
+ if (sof[i] && !check_state(cfe, FS_INT, i)) {
|
||
|
+ cfe_sof_isr_handler(node);
|
||
|
+ sof[i] = false;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_eof_isr_handler(node);
|
||
|
+ }
|
||
|
+
|
||
|
+ if (sof[i]) {
|
||
|
+ /*
|
||
|
+ * The condition below tests for (3). In such cases, we
|
||
|
+ * come in here with FS flag set in the node state from
|
||
|
+ * the previous frame since it only gets cleared in
|
||
|
+ * eof_isr_handler(). Handle the FE for the previous
|
||
|
+ * frame first before the FS handler for the current
|
||
|
+ * frame.
|
||
|
+ */
|
||
|
+ if (check_state(cfe, FS_INT, node->id)) {
|
||
|
+ cfe_dbg("%s: [%s] Handling missing previous FE interrupt\n",
|
||
|
+ __func__, node_desc[node->id].name);
|
||
|
+ cfe_eof_isr_handler(node);
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_sof_isr_handler(node);
|
||
|
+ }
|
||
|
+
|
||
|
+ if (!cfe->job_queued && cfe->job_ready)
|
||
|
+ cfe_prepare_next_job(cfe);
|
||
|
+ }
|
||
|
+
|
||
|
+ spin_unlock(&cfe->state_lock);
|
||
|
+
|
||
|
+ return IRQ_HANDLED;
|
||
|
+}
|
||
|
+
|
||
|
+/*
|
||
|
+ * Stream helpers
|
||
|
+ */
|
||
|
+
|
||
|
+static void cfe_start_channel(struct cfe_node *node)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct v4l2_subdev_state *state;
|
||
|
+ struct v4l2_mbus_framefmt *source_fmt;
|
||
|
+ const struct cfe_fmt *fmt;
|
||
|
+ unsigned long flags;
|
||
|
+ unsigned int width = 0, height = 0;
|
||
|
+ bool start_fe = is_fe_enabled(cfe) &&
|
||
|
+ test_all_nodes(cfe, NODE_ENABLED, NODE_STREAMING);
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (start_fe || is_image_output_node(node)) {
|
||
|
+ width = node->fmt.fmt.pix.width;
|
||
|
+ height = node->fmt.fmt.pix.height;
|
||
|
+ }
|
||
|
+
|
||
|
+ state = v4l2_subdev_lock_and_get_active_state(&cfe->csi2.sd);
|
||
|
+
|
||
|
+ if (start_fe) {
|
||
|
+ WARN_ON(!is_fe_enabled(cfe));
|
||
|
+ cfe_dbg("%s: %s using csi2 channel %d\n",
|
||
|
+ __func__, node_desc[FE_OUT0].name,
|
||
|
+ cfe->fe_csi2_channel);
|
||
|
+
|
||
|
+ source_fmt = v4l2_subdev_get_pad_format(&cfe->csi2.sd, state, cfe->fe_csi2_channel);
|
||
|
+ fmt = find_format_by_code(source_fmt->code);
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Start the associated CSI2 Channel as well.
|
||
|
+ *
|
||
|
+ * Must write to the ADDR register to latch the ctrl values
|
||
|
+ * even if we are connected to the front end. Once running,
|
||
|
+ * this is handled by the CSI2 AUTO_ARM mode.
|
||
|
+ */
|
||
|
+ csi2_start_channel(&cfe->csi2, cfe->fe_csi2_channel,
|
||
|
+ fmt->csi_dt, CSI2_MODE_FE_STREAMING,
|
||
|
+ true, false, width, height);
|
||
|
+ csi2_set_buffer(&cfe->csi2, cfe->fe_csi2_channel, 0, 0, -1);
|
||
|
+ pisp_fe_start(&cfe->fe);
|
||
|
+ }
|
||
|
+
|
||
|
+ if (is_csi2_node(node)) {
|
||
|
+ u32 mode = CSI2_MODE_NORMAL;
|
||
|
+
|
||
|
+ source_fmt = v4l2_subdev_get_pad_format(&cfe->csi2.sd, state,
|
||
|
+ node_desc[node->id].link_pad - CSI2_NUM_CHANNELS);
|
||
|
+ fmt = find_format_by_code(source_fmt->code);
|
||
|
+
|
||
|
+ if (is_image_output_node(node)) {
|
||
|
+ if (node->fmt.fmt.pix.pixelformat ==
|
||
|
+ fmt->remap[CFE_REMAP_16BIT])
|
||
|
+ mode = CSI2_MODE_REMAP;
|
||
|
+ else if (node->fmt.fmt.pix.pixelformat ==
|
||
|
+ fmt->remap[CFE_REMAP_COMPRESSED]) {
|
||
|
+ mode = CSI2_MODE_COMPRESSED;
|
||
|
+ csi2_set_compression(&cfe->csi2, node->id,
|
||
|
+ CSI2_COMPRESSION_DELTA, 0,
|
||
|
+ 0);
|
||
|
+ }
|
||
|
+ }
|
||
|
+ /* Unconditionally start this CSI2 channel. */
|
||
|
+ csi2_start_channel(&cfe->csi2, node->id, fmt->csi_dt,
|
||
|
+ mode,
|
||
|
+ /* Auto arm */
|
||
|
+ false,
|
||
|
+ /* Pack bytes */
|
||
|
+ node->id == CSI2_CH1_EMBEDDED ? true : false,
|
||
|
+ width, height);
|
||
|
+ }
|
||
|
+
|
||
|
+ v4l2_subdev_unlock_state(state);
|
||
|
+
|
||
|
+ spin_lock_irqsave(&cfe->state_lock, flags);
|
||
|
+ if (cfe->job_ready && test_all_nodes(cfe, NODE_ENABLED, NODE_STREAMING))
|
||
|
+ cfe_prepare_next_job(cfe);
|
||
|
+ spin_unlock_irqrestore(&cfe->state_lock, flags);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_stop_channel(struct cfe_node *node, bool fe_stop)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] fe_stop %u\n", __func__,
|
||
|
+ node_desc[node->id].name, fe_stop);
|
||
|
+
|
||
|
+ if (fe_stop) {
|
||
|
+ csi2_stop_channel(&cfe->csi2, cfe->fe_csi2_channel);
|
||
|
+ pisp_fe_stop(&cfe->fe);
|
||
|
+ }
|
||
|
+
|
||
|
+ if (is_csi2_node(node))
|
||
|
+ csi2_stop_channel(&cfe->csi2, node->id);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_return_buffers(struct cfe_node *node,
|
||
|
+ enum vb2_buffer_state state)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct cfe_buffer *buf, *tmp;
|
||
|
+ unsigned long flags;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ spin_lock_irqsave(&cfe->state_lock, flags);
|
||
|
+ list_for_each_entry_safe(buf, tmp, &node->dma_queue, list) {
|
||
|
+ list_del(&buf->list);
|
||
|
+ vb2_buffer_done(&buf->vb.vb2_buf, state);
|
||
|
+ }
|
||
|
+
|
||
|
+ if (node->cur_frm)
|
||
|
+ vb2_buffer_done(&node->cur_frm->vb.vb2_buf, state);
|
||
|
+ if (node->next_frm && node->cur_frm != node->next_frm)
|
||
|
+ vb2_buffer_done(&node->next_frm->vb.vb2_buf, state);
|
||
|
+
|
||
|
+ node->cur_frm = NULL;
|
||
|
+ node->next_frm = NULL;
|
||
|
+ spin_unlock_irqrestore(&cfe->state_lock, flags);
|
||
|
+}
|
||
|
+
|
||
|
+/*
|
||
|
+ * vb2 ops
|
||
|
+ */
|
||
|
+
|
||
|
+static int cfe_queue_setup(struct vb2_queue *vq, unsigned int *nbuffers,
|
||
|
+ unsigned int *nplanes, unsigned int sizes[],
|
||
|
+ struct device *alloc_devs[])
|
||
|
+{
|
||
|
+ struct cfe_node *node = vb2_get_drv_priv(vq);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ unsigned int size = is_image_output_node(node) ?
|
||
|
+ node->fmt.fmt.pix.sizeimage :
|
||
|
+ node->fmt.fmt.meta.buffersize;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (vq->num_buffers + *nbuffers < 3)
|
||
|
+ *nbuffers = 3 - vq->num_buffers;
|
||
|
+
|
||
|
+ if (*nplanes) {
|
||
|
+ if (sizes[0] < size) {
|
||
|
+ cfe_err("sizes[0] %i < size %u\n", sizes[0], size);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+ size = sizes[0];
|
||
|
+ }
|
||
|
+
|
||
|
+ *nplanes = 1;
|
||
|
+ sizes[0] = size;
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_buffer_prepare(struct vb2_buffer *vb)
|
||
|
+{
|
||
|
+ struct cfe_node *node = vb2_get_drv_priv(vb->vb2_queue);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct cfe_buffer *buf = to_cfe_buffer(vb);
|
||
|
+ unsigned long size;
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: [%s] buffer:%p\n", __func__, node_desc[node->id].name,
|
||
|
+ vb);
|
||
|
+
|
||
|
+ size = is_image_output_node(node) ? node->fmt.fmt.pix.sizeimage :
|
||
|
+ node->fmt.fmt.meta.buffersize;
|
||
|
+ if (vb2_plane_size(vb, 0) < size) {
|
||
|
+ cfe_err("data will not fit into plane (%lu < %lu)\n",
|
||
|
+ vb2_plane_size(vb, 0), size);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ vb2_set_plane_payload(&buf->vb.vb2_buf, 0, size);
|
||
|
+
|
||
|
+ if (node->id == FE_CONFIG) {
|
||
|
+ struct cfe_config_buffer *b = to_cfe_config_buffer(buf);
|
||
|
+ void *addr = vb2_plane_vaddr(vb, 0);
|
||
|
+
|
||
|
+ memcpy(&b->config, addr, sizeof(struct pisp_fe_config));
|
||
|
+ return pisp_fe_validate_config(&cfe->fe, &b->config,
|
||
|
+ &cfe->node[FE_OUT0].fmt,
|
||
|
+ &cfe->node[FE_OUT1].fmt);
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_buffer_queue(struct vb2_buffer *vb)
|
||
|
+{
|
||
|
+ struct cfe_node *node = vb2_get_drv_priv(vb->vb2_queue);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct cfe_buffer *buf = to_cfe_buffer(vb);
|
||
|
+ unsigned long flags;
|
||
|
+
|
||
|
+ cfe_dbg_irq("%s: [%s] buffer:%p\n", __func__, node_desc[node->id].name,
|
||
|
+ vb);
|
||
|
+
|
||
|
+ spin_lock_irqsave(&cfe->state_lock, flags);
|
||
|
+
|
||
|
+ list_add_tail(&buf->list, &node->dma_queue);
|
||
|
+
|
||
|
+ if (!cfe->job_ready)
|
||
|
+ cfe->job_ready = cfe_check_job_ready(cfe);
|
||
|
+
|
||
|
+ if (!cfe->job_queued && cfe->job_ready &&
|
||
|
+ test_all_nodes(cfe, NODE_ENABLED, NODE_STREAMING)) {
|
||
|
+ cfe_dbg("Preparing job immediately for channel %u\n",
|
||
|
+ node->id);
|
||
|
+ cfe_prepare_next_job(cfe);
|
||
|
+ }
|
||
|
+
|
||
|
+ spin_unlock_irqrestore(&cfe->state_lock, flags);
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_start_streaming(struct vb2_queue *vq, unsigned int count)
|
||
|
+{
|
||
|
+ struct v4l2_mbus_config mbus_config = { 0 };
|
||
|
+ struct cfe_node *node = vb2_get_drv_priv(vq);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] begin.\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (!check_state(cfe, NODE_ENABLED, node->id)) {
|
||
|
+ cfe_err("%s node link is not enabled.\n",
|
||
|
+ node_desc[node->id].name);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = pm_runtime_resume_and_get(&cfe->pdev->dev);
|
||
|
+ if (ret < 0) {
|
||
|
+ cfe_err("pm_runtime_resume_and_get failed\n");
|
||
|
+ goto err_streaming;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = media_pipeline_start(&node->pad, &cfe->pipe);
|
||
|
+ if (ret < 0) {
|
||
|
+ cfe_err("Failed to start media pipeline: %d\n", ret);
|
||
|
+ goto err_pm_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ clear_state(cfe, FS_INT | FE_INT, node->id);
|
||
|
+ set_state(cfe, NODE_STREAMING, node->id);
|
||
|
+ cfe_start_channel(node);
|
||
|
+
|
||
|
+ if (!test_all_nodes(cfe, NODE_ENABLED, NODE_STREAMING)) {
|
||
|
+ cfe_dbg("Not all nodes are set to streaming yet!\n");
|
||
|
+ return 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfg_reg_write(cfe, MIPICFG_CFG, MIPICFG_CFG_SEL_CSI);
|
||
|
+ cfg_reg_write(cfe, MIPICFG_INTE, MIPICFG_INT_CSI_DMA | MIPICFG_INT_PISP_FE);
|
||
|
+
|
||
|
+ cfe->csi2.active_data_lanes = cfe->csi2.dphy.num_lanes;
|
||
|
+ cfe_dbg("Running with %u data lanes\n", cfe->csi2.active_data_lanes);
|
||
|
+
|
||
|
+ ret = v4l2_subdev_call(cfe->sensor, pad, get_mbus_config, 0,
|
||
|
+ &mbus_config);
|
||
|
+ if (ret < 0 && ret != -ENOIOCTLCMD) {
|
||
|
+ cfe_err("g_mbus_config failed\n");
|
||
|
+ goto err_pm_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->csi2.active_data_lanes = mbus_config.bus.mipi_csi2.num_data_lanes;
|
||
|
+ if (!cfe->csi2.active_data_lanes)
|
||
|
+ cfe->csi2.active_data_lanes = cfe->csi2.dphy.num_lanes;
|
||
|
+ if (cfe->csi2.active_data_lanes > cfe->csi2.dphy.num_lanes) {
|
||
|
+ cfe_err("Device has requested %u data lanes, which is >%u configured in DT\n",
|
||
|
+ cfe->csi2.active_data_lanes, cfe->csi2.dphy.num_lanes);
|
||
|
+ ret = -EINVAL;
|
||
|
+ goto err_disable_cfe;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_dbg("Starting sensor streaming\n");
|
||
|
+
|
||
|
+ csi2_open_rx(&cfe->csi2);
|
||
|
+
|
||
|
+ cfe->sequence = 0;
|
||
|
+ ret = v4l2_subdev_call(cfe->sensor, video, s_stream, 1);
|
||
|
+ if (ret < 0) {
|
||
|
+ cfe_err("stream on failed in subdev\n");
|
||
|
+ goto err_disable_cfe;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] end.\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+
|
||
|
+err_disable_cfe:
|
||
|
+ csi2_close_rx(&cfe->csi2);
|
||
|
+ cfe_stop_channel(node, true);
|
||
|
+ media_pipeline_stop(&node->pad);
|
||
|
+err_pm_put:
|
||
|
+ pm_runtime_put(&cfe->pdev->dev);
|
||
|
+err_streaming:
|
||
|
+ cfe_return_buffers(node, VB2_BUF_STATE_QUEUED);
|
||
|
+ clear_state(cfe, NODE_STREAMING, node->id);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_stop_streaming(struct vb2_queue *vq)
|
||
|
+{
|
||
|
+ struct cfe_node *node = vb2_get_drv_priv(vq);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ unsigned long flags;
|
||
|
+ bool fe_stop;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] begin.\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ spin_lock_irqsave(&cfe->state_lock, flags);
|
||
|
+ fe_stop = is_fe_enabled(cfe) &&
|
||
|
+ test_all_nodes(cfe, NODE_ENABLED, NODE_STREAMING);
|
||
|
+
|
||
|
+ cfe->job_ready = false;
|
||
|
+ clear_state(cfe, NODE_STREAMING, node->id);
|
||
|
+ spin_unlock_irqrestore(&cfe->state_lock, flags);
|
||
|
+
|
||
|
+ cfe_stop_channel(node, fe_stop);
|
||
|
+
|
||
|
+ if (!test_any_node(cfe, NODE_STREAMING)) {
|
||
|
+ /* Stop streaming the sensor and disable the peripheral. */
|
||
|
+ if (v4l2_subdev_call(cfe->sensor, video, s_stream, 0) < 0)
|
||
|
+ cfe_err("stream off failed in subdev\n");
|
||
|
+
|
||
|
+ csi2_close_rx(&cfe->csi2);
|
||
|
+
|
||
|
+ cfg_reg_write(cfe, MIPICFG_INTE, 0);
|
||
|
+ }
|
||
|
+
|
||
|
+ media_pipeline_stop(&node->pad);
|
||
|
+
|
||
|
+ /* Clear all queued buffers for the node */
|
||
|
+ cfe_return_buffers(node, VB2_BUF_STATE_ERROR);
|
||
|
+
|
||
|
+ pm_runtime_put(&cfe->pdev->dev);
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] end.\n", __func__, node_desc[node->id].name);
|
||
|
+}
|
||
|
+
|
||
|
+static const struct vb2_ops cfe_video_qops = {
|
||
|
+ .wait_prepare = vb2_ops_wait_prepare,
|
||
|
+ .wait_finish = vb2_ops_wait_finish,
|
||
|
+ .queue_setup = cfe_queue_setup,
|
||
|
+ .buf_prepare = cfe_buffer_prepare,
|
||
|
+ .buf_queue = cfe_buffer_queue,
|
||
|
+ .start_streaming = cfe_start_streaming,
|
||
|
+ .stop_streaming = cfe_stop_streaming,
|
||
|
+};
|
||
|
+
|
||
|
+/*
|
||
|
+ * v4l2 ioctl ops
|
||
|
+ */
|
||
|
+
|
||
|
+static int cfe_querycap(struct file *file, void *priv,
|
||
|
+ struct v4l2_capability *cap)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ strscpy(cap->driver, CFE_MODULE_NAME, sizeof(cap->driver));
|
||
|
+ strscpy(cap->card, CFE_MODULE_NAME, sizeof(cap->card));
|
||
|
+
|
||
|
+ snprintf(cap->bus_info, sizeof(cap->bus_info), "platform:%s",
|
||
|
+ dev_name(&cfe->pdev->dev));
|
||
|
+
|
||
|
+ cap->capabilities |= V4L2_CAP_VIDEO_CAPTURE | V4L2_CAP_META_CAPTURE |
|
||
|
+ V4L2_CAP_META_OUTPUT;
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_enum_fmt_vid_cap(struct file *file, void *priv,
|
||
|
+ struct v4l2_fmtdesc *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ unsigned int i, j;
|
||
|
+
|
||
|
+ if (!is_image_output_node(node))
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ for (i = 0, j = 0; i < ARRAY_SIZE(formats); i++) {
|
||
|
+ if (f->mbus_code && formats[i].code != f->mbus_code)
|
||
|
+ continue;
|
||
|
+
|
||
|
+ if (formats[i].flags & CFE_FORMAT_FLAG_META_OUT ||
|
||
|
+ formats[i].flags & CFE_FORMAT_FLAG_META_CAP)
|
||
|
+ continue;
|
||
|
+
|
||
|
+ if (is_fe_node(node) &&
|
||
|
+ !(formats[i].flags & CFE_FORMAT_FLAG_FE_OUT))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ if (j == f->index) {
|
||
|
+ f->pixelformat = formats[i].fourcc;
|
||
|
+ f->type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
|
||
|
+ return 0;
|
||
|
+ }
|
||
|
+ j++;
|
||
|
+ }
|
||
|
+
|
||
|
+ return -EINVAL;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_g_fmt(struct file *file, void *priv,
|
||
|
+ struct v4l2_format *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (f->type != node->buffer_queue.type)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ *f = node->fmt;
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int try_fmt_vid_cap(struct cfe_node *node, struct v4l2_format *f)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ const struct cfe_fmt *fmt;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] %ux%u, V4L2 pix " V4L2_FOURCC_CONV "\n",
|
||
|
+ __func__, node_desc[node->id].name,
|
||
|
+ f->fmt.pix.width, f->fmt.pix.height,
|
||
|
+ V4L2_FOURCC_CONV_ARGS(f->fmt.pix.pixelformat));
|
||
|
+
|
||
|
+ if (!is_image_output_node(node))
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Default to a format that works for both CSI2 and FE.
|
||
|
+ */
|
||
|
+ fmt = find_format_by_pix(f->fmt.pix.pixelformat);
|
||
|
+ if (!fmt)
|
||
|
+ fmt = find_format_by_code(MEDIA_BUS_FMT_SBGGR10_1X10);
|
||
|
+
|
||
|
+ f->fmt.pix.pixelformat = fmt->fourcc;
|
||
|
+
|
||
|
+ if (is_fe_node(node) && fmt->remap[CFE_REMAP_16BIT]) {
|
||
|
+ f->fmt.pix.pixelformat = fmt->remap[CFE_REMAP_16BIT];
|
||
|
+ fmt = find_format_by_pix(f->fmt.pix.pixelformat);
|
||
|
+ }
|
||
|
+
|
||
|
+ f->fmt.pix.field = V4L2_FIELD_NONE;
|
||
|
+
|
||
|
+ cfe_calc_format_size_bpl(cfe, fmt, f);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_s_fmt_vid_cap(struct file *file, void *priv,
|
||
|
+ struct v4l2_format *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct vb2_queue *q = &node->buffer_queue;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (vb2_is_busy(q))
|
||
|
+ return -EBUSY;
|
||
|
+
|
||
|
+ ret = try_fmt_vid_cap(node, f);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ node->fmt = *f;
|
||
|
+
|
||
|
+ cfe_dbg("%s: Set %ux%u, V4L2 pix " V4L2_FOURCC_CONV "\n", __func__,
|
||
|
+ node->fmt.fmt.pix.width, node->fmt.fmt.pix.height,
|
||
|
+ V4L2_FOURCC_CONV_ARGS(node->fmt.fmt.pix.pixelformat));
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_try_fmt_vid_cap(struct file *file, void *priv,
|
||
|
+ struct v4l2_format *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ return try_fmt_vid_cap(node, f);
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_enum_fmt_meta(struct file *file, void *priv,
|
||
|
+ struct v4l2_fmtdesc *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (!is_meta_node(node) || f->index != 0)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ switch (node->id) {
|
||
|
+ case CSI2_CH1_EMBEDDED:
|
||
|
+ f->pixelformat = V4L2_META_FMT_SENSOR_DATA;
|
||
|
+ return 0;
|
||
|
+ case FE_STATS:
|
||
|
+ f->pixelformat = V4L2_META_FMT_RPI_FE_STATS;
|
||
|
+ return 0;
|
||
|
+ case FE_CONFIG:
|
||
|
+ f->pixelformat = V4L2_META_FMT_RPI_FE_CFG;
|
||
|
+ return 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ return -EINVAL;
|
||
|
+}
|
||
|
+
|
||
|
+static int try_fmt_meta(struct cfe_node *node, struct v4l2_format *f)
|
||
|
+{
|
||
|
+ switch (node->id) {
|
||
|
+ case CSI2_CH1_EMBEDDED:
|
||
|
+ f->fmt.meta.dataformat = V4L2_META_FMT_SENSOR_DATA;
|
||
|
+ if (!f->fmt.meta.buffersize)
|
||
|
+ f->fmt.meta.buffersize = DEFAULT_EMBEDDED_SIZE;
|
||
|
+ f->fmt.meta.buffersize =
|
||
|
+ min_t(u32, f->fmt.meta.buffersize, MAX_BUFFER_SIZE);
|
||
|
+ f->fmt.meta.buffersize =
|
||
|
+ ALIGN(f->fmt.meta.buffersize, BPL_ALIGNMENT);
|
||
|
+ return 0;
|
||
|
+ case FE_STATS:
|
||
|
+ f->fmt.meta.dataformat = V4L2_META_FMT_RPI_FE_STATS;
|
||
|
+ f->fmt.meta.buffersize = sizeof(struct pisp_statistics);
|
||
|
+ return 0;
|
||
|
+ case FE_CONFIG:
|
||
|
+ f->fmt.meta.dataformat = V4L2_META_FMT_RPI_FE_CFG;
|
||
|
+ f->fmt.meta.buffersize = sizeof(struct pisp_fe_config);
|
||
|
+ return 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ return -EINVAL;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_s_fmt_meta(struct file *file, void *priv, struct v4l2_format *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct vb2_queue *q = &node->buffer_queue;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (vb2_is_busy(q))
|
||
|
+ return -EBUSY;
|
||
|
+
|
||
|
+ if (f->type != node->buffer_queue.type)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ ret = try_fmt_meta(node, f);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ node->fmt = *f;
|
||
|
+
|
||
|
+ cfe_dbg("%s: Set " V4L2_FOURCC_CONV "\n", __func__,
|
||
|
+ V4L2_FOURCC_CONV_ARGS(node->fmt.fmt.meta.dataformat));
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_try_fmt_meta(struct file *file, void *priv,
|
||
|
+ struct v4l2_format *f)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+ return try_fmt_meta(node, f);
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_enum_framesizes(struct file *file, void *priv,
|
||
|
+ struct v4l2_frmsizeenum *fsize)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_drvdata(file);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ const struct cfe_fmt *fmt;
|
||
|
+
|
||
|
+ cfe_dbg("%s [%s]\n", __func__, node_desc[node->id].name);
|
||
|
+
|
||
|
+ if (fsize->index > 0)
|
||
|
+ return -EINVAL;
|
||
|
+
|
||
|
+ /* check for valid format */
|
||
|
+ fmt = find_format_by_pix(fsize->pixel_format);
|
||
|
+ if (!fmt) {
|
||
|
+ cfe_dbg("Invalid pixel code: %x\n", fsize->pixel_format);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* TODO: Do we have limits on the step_width? */
|
||
|
+
|
||
|
+ fsize->type = V4L2_FRMSIZE_TYPE_STEPWISE;
|
||
|
+ fsize->stepwise.min_width = MIN_WIDTH;
|
||
|
+ fsize->stepwise.max_width = MAX_WIDTH;
|
||
|
+ fsize->stepwise.step_width = 2;
|
||
|
+ fsize->stepwise.min_height = MIN_HEIGHT;
|
||
|
+ fsize->stepwise.max_height = MAX_HEIGHT;
|
||
|
+ fsize->stepwise.step_height = 1;
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_subscribe_event(struct v4l2_fh *fh,
|
||
|
+ const struct v4l2_event_subscription *sub)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_get_drvdata(fh->vdev);
|
||
|
+
|
||
|
+ switch (sub->type) {
|
||
|
+ case V4L2_EVENT_FRAME_SYNC:
|
||
|
+ if (!is_image_output_node(node))
|
||
|
+ break;
|
||
|
+
|
||
|
+ return v4l2_event_subscribe(fh, sub, 2, NULL);
|
||
|
+ case V4L2_EVENT_SOURCE_CHANGE:
|
||
|
+ if (is_meta_input_node(node))
|
||
|
+ break;
|
||
|
+
|
||
|
+ return v4l2_event_subscribe(fh, sub, 4, NULL);
|
||
|
+ }
|
||
|
+
|
||
|
+ return v4l2_ctrl_subscribe_event(fh, sub);
|
||
|
+}
|
||
|
+
|
||
|
+static const struct v4l2_ioctl_ops cfe_ioctl_ops = {
|
||
|
+ .vidioc_querycap = cfe_querycap,
|
||
|
+ .vidioc_enum_fmt_vid_cap = cfe_enum_fmt_vid_cap,
|
||
|
+ .vidioc_g_fmt_vid_cap = cfe_g_fmt,
|
||
|
+ .vidioc_s_fmt_vid_cap = cfe_s_fmt_vid_cap,
|
||
|
+ .vidioc_try_fmt_vid_cap = cfe_try_fmt_vid_cap,
|
||
|
+
|
||
|
+ .vidioc_enum_fmt_meta_cap = cfe_enum_fmt_meta,
|
||
|
+ .vidioc_g_fmt_meta_cap = cfe_g_fmt,
|
||
|
+ .vidioc_s_fmt_meta_cap = cfe_s_fmt_meta,
|
||
|
+ .vidioc_try_fmt_meta_cap = cfe_try_fmt_meta,
|
||
|
+
|
||
|
+ .vidioc_enum_fmt_meta_out = cfe_enum_fmt_meta,
|
||
|
+ .vidioc_g_fmt_meta_out = cfe_g_fmt,
|
||
|
+ .vidioc_s_fmt_meta_out = cfe_s_fmt_meta,
|
||
|
+ .vidioc_try_fmt_meta_out = cfe_try_fmt_meta,
|
||
|
+
|
||
|
+ .vidioc_enum_framesizes = cfe_enum_framesizes,
|
||
|
+
|
||
|
+ .vidioc_reqbufs = vb2_ioctl_reqbufs,
|
||
|
+ .vidioc_create_bufs = vb2_ioctl_create_bufs,
|
||
|
+ .vidioc_prepare_buf = vb2_ioctl_prepare_buf,
|
||
|
+ .vidioc_querybuf = vb2_ioctl_querybuf,
|
||
|
+ .vidioc_qbuf = vb2_ioctl_qbuf,
|
||
|
+ .vidioc_dqbuf = vb2_ioctl_dqbuf,
|
||
|
+ .vidioc_expbuf = vb2_ioctl_expbuf,
|
||
|
+ .vidioc_streamon = vb2_ioctl_streamon,
|
||
|
+ .vidioc_streamoff = vb2_ioctl_streamoff,
|
||
|
+
|
||
|
+ .vidioc_subscribe_event = cfe_subscribe_event,
|
||
|
+ .vidioc_unsubscribe_event = v4l2_event_unsubscribe,
|
||
|
+};
|
||
|
+
|
||
|
+static void cfe_notify(struct v4l2_subdev *sd, unsigned int notification,
|
||
|
+ void *arg)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = to_cfe_device(sd->v4l2_dev);
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ switch (notification) {
|
||
|
+ case V4L2_DEVICE_NOTIFY_EVENT:
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+
|
||
|
+ if (check_state(cfe, NODE_REGISTERED, i))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ v4l2_event_queue(&node->video_dev, arg);
|
||
|
+ }
|
||
|
+ break;
|
||
|
+ default:
|
||
|
+ break;
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+/* cfe capture driver file operations */
|
||
|
+static const struct v4l2_file_operations cfe_fops = {
|
||
|
+ .owner = THIS_MODULE,
|
||
|
+ .open = v4l2_fh_open,
|
||
|
+ .release = vb2_fop_release,
|
||
|
+ .poll = vb2_fop_poll,
|
||
|
+ .unlocked_ioctl = video_ioctl2,
|
||
|
+ .mmap = vb2_fop_mmap,
|
||
|
+};
|
||
|
+
|
||
|
+static int cfe_video_link_validate(struct media_link *link)
|
||
|
+{
|
||
|
+ struct video_device *vd = container_of(link->sink->entity,
|
||
|
+ struct video_device, entity);
|
||
|
+ struct cfe_node *node = container_of(vd, struct cfe_node, video_dev);
|
||
|
+ struct cfe_device *cfe = node->cfe;
|
||
|
+ struct v4l2_mbus_framefmt *source_fmt;
|
||
|
+ struct v4l2_subdev_state *state;
|
||
|
+ struct v4l2_subdev *source_sd;
|
||
|
+ int ret = 0;
|
||
|
+
|
||
|
+ cfe_dbg("%s: [%s] link \"%s\":%u -> \"%s\":%u\n", __func__,
|
||
|
+ node_desc[node->id].name,
|
||
|
+ link->source->entity->name, link->source->index,
|
||
|
+ link->sink->entity->name, link->sink->index);
|
||
|
+
|
||
|
+ if (!media_entity_remote_source_pad_unique(link->sink->entity)) {
|
||
|
+ cfe_err("video node %s pad not connected\n", vd->name);
|
||
|
+ return -ENOTCONN;
|
||
|
+ }
|
||
|
+
|
||
|
+ source_sd = media_entity_to_v4l2_subdev(link->source->entity);
|
||
|
+
|
||
|
+ state = v4l2_subdev_lock_and_get_active_state(source_sd);
|
||
|
+
|
||
|
+ source_fmt = v4l2_subdev_get_pad_format(source_sd, state,
|
||
|
+ link->source->index);
|
||
|
+ if (!source_fmt) {
|
||
|
+ ret = -EINVAL;
|
||
|
+ goto out;
|
||
|
+ }
|
||
|
+
|
||
|
+ if (is_image_output_node(node)) {
|
||
|
+ struct v4l2_pix_format *pix_fmt = &node->fmt.fmt.pix;
|
||
|
+ const struct cfe_fmt *fmt;
|
||
|
+
|
||
|
+ if (source_fmt->width != pix_fmt->width ||
|
||
|
+ source_fmt->height != pix_fmt->height) {
|
||
|
+ cfe_err("Wrong width or height %ux%u (remote pad set to %ux%u)\n",
|
||
|
+ pix_fmt->width, pix_fmt->height,
|
||
|
+ source_fmt->width,
|
||
|
+ source_fmt->height);
|
||
|
+ ret = -EINVAL;
|
||
|
+ goto out;
|
||
|
+ }
|
||
|
+
|
||
|
+ fmt = find_format_by_code(source_fmt->code);
|
||
|
+ if (!fmt || fmt->fourcc != pix_fmt->pixelformat) {
|
||
|
+ cfe_err("Format mismatch!\n");
|
||
|
+ ret = -EINVAL;
|
||
|
+ goto out;
|
||
|
+ }
|
||
|
+ } else if (node->id == CSI2_CH1_EMBEDDED) {
|
||
|
+ struct v4l2_meta_format *meta_fmt = &node->fmt.fmt.meta;
|
||
|
+
|
||
|
+ if (source_fmt->width * source_fmt->height !=
|
||
|
+ meta_fmt->buffersize ||
|
||
|
+ source_fmt->code != MEDIA_BUS_FMT_SENSOR_DATA) {
|
||
|
+ cfe_err("WARNING: Wrong metadata width/height/code %ux%u %08x (remote pad set to %ux%u %08x)\n",
|
||
|
+ meta_fmt->buffersize, 1,
|
||
|
+ MEDIA_BUS_FMT_SENSOR_DATA,
|
||
|
+ source_fmt->width,
|
||
|
+ source_fmt->height,
|
||
|
+ source_fmt->code);
|
||
|
+ /* TODO: this should throw an error eventually */
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+out:
|
||
|
+ v4l2_subdev_unlock_state(state);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static const struct media_entity_operations cfe_media_entity_ops = {
|
||
|
+ .link_validate = cfe_video_link_validate,
|
||
|
+};
|
||
|
+
|
||
|
+static int cfe_video_link_notify(struct media_link *link, u32 flags,
|
||
|
+ unsigned int notification)
|
||
|
+{
|
||
|
+ struct media_device *mdev = link->graph_obj.mdev;
|
||
|
+ struct cfe_device *cfe = container_of(mdev, struct cfe_device, mdev);
|
||
|
+ struct media_entity *fe = &cfe->fe.sd.entity;
|
||
|
+ struct media_entity *csi2 = &cfe->csi2.sd.entity;
|
||
|
+ unsigned long lock_flags;
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ if (notification != MEDIA_DEV_NOTIFY_POST_LINK_CH)
|
||
|
+ return 0;
|
||
|
+
|
||
|
+ cfe_dbg("%s: %s[%u] -> %s[%u] 0x%x", __func__,
|
||
|
+ link->source->entity->name, link->source->index,
|
||
|
+ link->sink->entity->name, link->sink->index, flags);
|
||
|
+
|
||
|
+ spin_lock_irqsave(&cfe->state_lock, lock_flags);
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ if (link->sink->entity != &cfe->node[i].video_dev.entity &&
|
||
|
+ link->source->entity != &cfe->node[i].video_dev.entity)
|
||
|
+ continue;
|
||
|
+
|
||
|
+ if (link->flags & MEDIA_LNK_FL_ENABLED)
|
||
|
+ set_state(cfe, NODE_ENABLED, i);
|
||
|
+ else
|
||
|
+ clear_state(cfe, NODE_ENABLED, i);
|
||
|
+
|
||
|
+ break;
|
||
|
+ }
|
||
|
+
|
||
|
+ spin_unlock_irqrestore(&cfe->state_lock, lock_flags);
|
||
|
+
|
||
|
+ if (link->source->entity != csi2)
|
||
|
+ return 0;
|
||
|
+ if (link->sink->index != 0)
|
||
|
+ return 0;
|
||
|
+ if (link->source->index == node_desc[CSI2_CH1_EMBEDDED].link_pad)
|
||
|
+ return 0;
|
||
|
+
|
||
|
+ cfe->fe_csi2_channel = -1;
|
||
|
+ if (link->sink->entity == fe && (link->flags & MEDIA_LNK_FL_ENABLED)) {
|
||
|
+ if (link->source->index == node_desc[CSI2_CH0].link_pad)
|
||
|
+ cfe->fe_csi2_channel = CSI2_CH0;
|
||
|
+ else if (link->source->index == node_desc[CSI2_CH2].link_pad)
|
||
|
+ cfe->fe_csi2_channel = CSI2_CH2;
|
||
|
+ else if (link->source->index == node_desc[CSI2_CH3].link_pad)
|
||
|
+ cfe->fe_csi2_channel = CSI2_CH3;
|
||
|
+ }
|
||
|
+
|
||
|
+ if (is_fe_enabled(cfe))
|
||
|
+ cfe_dbg("%s: Found CSI2:%d -> FE:0 link\n", __func__,
|
||
|
+ cfe->fe_csi2_channel);
|
||
|
+ else
|
||
|
+ cfe_dbg("%s: Unable to find CSI2:x -> FE:0 link\n", __func__);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static const struct media_device_ops cfe_media_device_ops = {
|
||
|
+ .link_notify = cfe_video_link_notify,
|
||
|
+};
|
||
|
+
|
||
|
+static void cfe_release(struct kref *kref)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = container_of(kref, struct cfe_device, kref);
|
||
|
+
|
||
|
+ media_device_cleanup(&cfe->mdev);
|
||
|
+
|
||
|
+ kfree(cfe);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_put(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ kref_put(&cfe->kref, cfe_release);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_get(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ kref_get(&cfe->kref);
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_node_release(struct video_device *vdev)
|
||
|
+{
|
||
|
+ struct cfe_node *node = video_get_drvdata(vdev);
|
||
|
+
|
||
|
+ cfe_put(node->cfe);
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_register_node(struct cfe_device *cfe, int id)
|
||
|
+{
|
||
|
+ struct video_device *vdev;
|
||
|
+ const struct cfe_fmt *fmt;
|
||
|
+ struct vb2_queue *q;
|
||
|
+ struct cfe_node *node = &cfe->node[id];
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ node->cfe = cfe;
|
||
|
+ node->id = id;
|
||
|
+
|
||
|
+ if (is_image_output_node(node)) {
|
||
|
+ fmt = find_format_by_code(cfe_default_format.code);
|
||
|
+ if (!fmt) {
|
||
|
+ cfe_err("Failed to find format code\n");
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ node->fmt.fmt.pix.pixelformat = fmt->fourcc;
|
||
|
+ v4l2_fill_pix_format(&node->fmt.fmt.pix, &cfe_default_format);
|
||
|
+
|
||
|
+ ret = try_fmt_vid_cap(node, &node->fmt);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+ } else {
|
||
|
+ ret = try_fmt_meta(node, &node->fmt);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+ node->fmt.type = node_desc[id].buf_type;
|
||
|
+
|
||
|
+ mutex_init(&node->lock);
|
||
|
+
|
||
|
+ q = &node->buffer_queue;
|
||
|
+ q->type = node_desc[id].buf_type;
|
||
|
+ q->io_modes = VB2_MMAP | VB2_DMABUF;
|
||
|
+ q->drv_priv = node;
|
||
|
+ q->ops = &cfe_video_qops;
|
||
|
+ q->mem_ops = &vb2_dma_contig_memops;
|
||
|
+ q->buf_struct_size = id == FE_CONFIG ? sizeof(struct cfe_config_buffer)
|
||
|
+ : sizeof(struct cfe_buffer);
|
||
|
+ q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
|
||
|
+ q->lock = &node->lock;
|
||
|
+ q->min_buffers_needed = 1;
|
||
|
+ q->dev = &cfe->pdev->dev;
|
||
|
+
|
||
|
+ ret = vb2_queue_init(q);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("vb2_queue_init() failed\n");
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+
|
||
|
+ INIT_LIST_HEAD(&node->dma_queue);
|
||
|
+
|
||
|
+ vdev = &node->video_dev;
|
||
|
+ vdev->release = cfe_node_release;
|
||
|
+ vdev->fops = &cfe_fops;
|
||
|
+ vdev->ioctl_ops = &cfe_ioctl_ops;
|
||
|
+ vdev->entity.ops = &cfe_media_entity_ops;
|
||
|
+ vdev->v4l2_dev = &cfe->v4l2_dev;
|
||
|
+ vdev->vfl_dir = (is_image_output_node(node) || is_meta_output_node(node))
|
||
|
+ ? VFL_DIR_RX : VFL_DIR_TX;
|
||
|
+ vdev->queue = q;
|
||
|
+ vdev->lock = &node->lock;
|
||
|
+ vdev->device_caps = node_desc[id].cap;
|
||
|
+ vdev->device_caps |= V4L2_CAP_STREAMING | V4L2_CAP_IO_MC;
|
||
|
+
|
||
|
+ /* Define the device names */
|
||
|
+ snprintf(vdev->name, sizeof(vdev->name), "%s-%s", CFE_MODULE_NAME,
|
||
|
+ node_desc[id].name);
|
||
|
+
|
||
|
+ video_set_drvdata(vdev, node);
|
||
|
+ if (node->id == FE_OUT0)
|
||
|
+ vdev->entity.flags |= MEDIA_ENT_FL_DEFAULT;
|
||
|
+ node->pad.flags = node_desc[id].pad_flags;
|
||
|
+ media_entity_pads_init(&vdev->entity, 1, &node->pad);
|
||
|
+
|
||
|
+ if (is_meta_node(node)) {
|
||
|
+ v4l2_disable_ioctl(&node->video_dev,
|
||
|
+ VIDIOC_ENUM_FRAMEINTERVALS);
|
||
|
+ v4l2_disable_ioctl(&node->video_dev,
|
||
|
+ VIDIOC_ENUM_FRAMESIZES);
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = video_register_device(vdev, VFL_TYPE_VIDEO, -1);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Unable to register video device %s\n", vdev->name);
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_info("Registered [%s] node id %d successfully as /dev/video%u\n",
|
||
|
+ vdev->name, id, vdev->num);
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Acquire a reference to cfe, which will be released when the video
|
||
|
+ * device will be unregistered and userspace will have closed all open
|
||
|
+ * file handles.
|
||
|
+ */
|
||
|
+ cfe_get(cfe);
|
||
|
+ set_state(cfe, NODE_REGISTERED, id);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static void cfe_unregister_nodes(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+
|
||
|
+ if (check_state(cfe, NODE_REGISTERED, i)) {
|
||
|
+ clear_state(cfe, NODE_REGISTERED, i);
|
||
|
+ video_unregister_device(&node->video_dev);
|
||
|
+ }
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_link_node_pads(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ for (i = 0; i < CSI2_NUM_CHANNELS; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+
|
||
|
+ if (!check_state(cfe, NODE_REGISTERED, i))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ if (i < cfe->sensor->entity.num_pads) {
|
||
|
+ /* Sensor -> CSI2 */
|
||
|
+ ret = media_create_pad_link(&cfe->sensor->entity, i,
|
||
|
+ &cfe->csi2.sd.entity, i,
|
||
|
+ MEDIA_LNK_FL_IMMUTABLE |
|
||
|
+ MEDIA_LNK_FL_ENABLED);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* CSI2 channel # -> /dev/video# */
|
||
|
+ ret = media_create_pad_link(&cfe->csi2.sd.entity,
|
||
|
+ node_desc[i].link_pad,
|
||
|
+ &node->video_dev.entity, 0, 0);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ if (node->id != CSI2_CH1_EMBEDDED) {
|
||
|
+ /* CSI2 channel # -> FE Input */
|
||
|
+ ret = media_create_pad_link(&cfe->csi2.sd.entity,
|
||
|
+ node_desc[i].link_pad,
|
||
|
+ &cfe->fe.sd.entity,
|
||
|
+ FE_STREAM_PAD, 0);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+ for (; i < NUM_NODES; i++) {
|
||
|
+ struct cfe_node *node = &cfe->node[i];
|
||
|
+ struct media_entity *src, *dst;
|
||
|
+ unsigned int src_pad, dst_pad;
|
||
|
+
|
||
|
+ if (node_desc[i].pad_flags & MEDIA_PAD_FL_SINK) {
|
||
|
+ /* FE -> /dev/video# */
|
||
|
+ src = &cfe->fe.sd.entity;
|
||
|
+ src_pad = node_desc[i].link_pad;
|
||
|
+ dst = &node->video_dev.entity;
|
||
|
+ dst_pad = 0;
|
||
|
+ } else {
|
||
|
+ /* /dev/video# -> FE */
|
||
|
+ dst = &cfe->fe.sd.entity;
|
||
|
+ dst_pad = node_desc[i].link_pad;
|
||
|
+ src = &node->video_dev.entity;
|
||
|
+ src_pad = 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = media_create_pad_link(src, src_pad, dst, dst_pad, 0);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_probe_complete(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ cfe->v4l2_dev.notify = cfe_notify;
|
||
|
+
|
||
|
+ cfe->sensor_embedded_data = (cfe->sensor->entity.num_pads >= 2);
|
||
|
+
|
||
|
+ for (i = 0; i < NUM_NODES; i++) {
|
||
|
+ ret = cfe_register_node(cfe, i);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Unable to register video node %u.\n", i);
|
||
|
+ goto unregister;
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = cfe_link_node_pads(cfe);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Unable to link node pads.\n");
|
||
|
+ goto unregister;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = v4l2_device_register_subdev_nodes(&cfe->v4l2_dev);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Unable to register subdev nodes.\n");
|
||
|
+ goto unregister;
|
||
|
+ }
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Release the initial reference, all references are now owned by the
|
||
|
+ * video devices.
|
||
|
+ */
|
||
|
+ cfe_put(cfe);
|
||
|
+ return 0;
|
||
|
+
|
||
|
+unregister:
|
||
|
+ cfe_unregister_nodes(cfe);
|
||
|
+ cfe_put(cfe);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_async_bound(struct v4l2_async_notifier *notifier,
|
||
|
+ struct v4l2_subdev *subdev,
|
||
|
+ struct v4l2_async_connection *asd)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = to_cfe_device(notifier->v4l2_dev);
|
||
|
+
|
||
|
+ if (cfe->sensor) {
|
||
|
+ cfe_info("Rejecting subdev %s (Already set!!)", subdev->name);
|
||
|
+ return 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->sensor = subdev;
|
||
|
+ cfe_info("Using sensor %s for capture\n", subdev->name);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_async_complete(struct v4l2_async_notifier *notifier)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = to_cfe_device(notifier->v4l2_dev);
|
||
|
+
|
||
|
+ return cfe_probe_complete(cfe);
|
||
|
+}
|
||
|
+
|
||
|
+static const struct v4l2_async_notifier_operations cfe_async_ops = {
|
||
|
+ .bound = cfe_async_bound,
|
||
|
+ .complete = cfe_async_complete,
|
||
|
+};
|
||
|
+
|
||
|
+static int of_cfe_connect_subdevs(struct cfe_device *cfe)
|
||
|
+{
|
||
|
+ struct platform_device *pdev = cfe->pdev;
|
||
|
+ struct v4l2_fwnode_endpoint ep = { .bus_type = V4L2_MBUS_CSI2_DPHY };
|
||
|
+ struct device_node *node = pdev->dev.of_node;
|
||
|
+ struct device_node *ep_node;
|
||
|
+ struct device_node *sensor_node;
|
||
|
+ unsigned int lane;
|
||
|
+ int ret = -EINVAL;
|
||
|
+
|
||
|
+ /* Get the local endpoint and remote device. */
|
||
|
+ ep_node = of_graph_get_next_endpoint(node, NULL);
|
||
|
+ if (!ep_node) {
|
||
|
+ cfe_err("can't get next endpoint\n");
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_dbg("ep_node is %pOF\n", ep_node);
|
||
|
+
|
||
|
+ sensor_node = of_graph_get_remote_port_parent(ep_node);
|
||
|
+ if (!sensor_node) {
|
||
|
+ cfe_err("can't get remote parent\n");
|
||
|
+ goto cleanup_exit;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe_info("found subdevice %pOF\n", sensor_node);
|
||
|
+
|
||
|
+ /* Parse the local endpoint and validate its configuration. */
|
||
|
+ v4l2_fwnode_endpoint_parse(of_fwnode_handle(ep_node), &ep);
|
||
|
+
|
||
|
+ cfe->csi2.multipacket_line =
|
||
|
+ fwnode_property_present(of_fwnode_handle(ep_node),
|
||
|
+ "multipacket-line");
|
||
|
+
|
||
|
+ if (ep.bus_type != V4L2_MBUS_CSI2_DPHY) {
|
||
|
+ cfe_err("endpoint node type != CSI2\n");
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ for (lane = 0; lane < ep.bus.mipi_csi2.num_data_lanes; lane++) {
|
||
|
+ if (ep.bus.mipi_csi2.data_lanes[lane] != lane + 1) {
|
||
|
+ cfe_err("subdevice %pOF: data lanes reordering not supported\n",
|
||
|
+ sensor_node);
|
||
|
+ goto cleanup_exit;
|
||
|
+ }
|
||
|
+ }
|
||
|
+
|
||
|
+ /* TODO: Get the frequency from devicetree */
|
||
|
+ cfe->csi2.dphy.dphy_freq = 999;
|
||
|
+ cfe->csi2.dphy.num_lanes = ep.bus.mipi_csi2.num_data_lanes;
|
||
|
+ cfe->csi2.bus_flags = ep.bus.mipi_csi2.flags;
|
||
|
+
|
||
|
+ cfe_dbg("subdevice %pOF: %u data lanes, flags=0x%08x, multipacket_line=%u\n",
|
||
|
+ sensor_node, cfe->csi2.dphy.num_lanes, cfe->csi2.bus_flags,
|
||
|
+ cfe->csi2.multipacket_line);
|
||
|
+
|
||
|
+ /* Initialize and register the async notifier. */
|
||
|
+ v4l2_async_nf_init(&cfe->notifier, &cfe->v4l2_dev);
|
||
|
+ cfe->notifier.ops = &cfe_async_ops;
|
||
|
+
|
||
|
+ cfe->asd = v4l2_async_nf_add_fwnode(&cfe->notifier,
|
||
|
+ of_fwnode_handle(sensor_node),
|
||
|
+ struct v4l2_async_connection);
|
||
|
+ if (IS_ERR(cfe->asd)) {
|
||
|
+ cfe_err("Error adding subdevice: %d\n", ret);
|
||
|
+ goto cleanup_exit;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = v4l2_async_nf_register(&cfe->notifier);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Error registering async notifier: %d\n", ret);
|
||
|
+ ret = -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+cleanup_exit:
|
||
|
+ of_node_put(sensor_node);
|
||
|
+ of_node_put(ep_node);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_probe(struct platform_device *pdev)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe;
|
||
|
+ char debugfs_name[32];
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ cfe = kzalloc(sizeof(*cfe), GFP_KERNEL);
|
||
|
+ if (!cfe)
|
||
|
+ return -ENOMEM;
|
||
|
+
|
||
|
+ platform_set_drvdata(pdev, cfe);
|
||
|
+
|
||
|
+ kref_init(&cfe->kref);
|
||
|
+ cfe->pdev = pdev;
|
||
|
+ cfe->fe_csi2_channel = -1;
|
||
|
+ spin_lock_init(&cfe->state_lock);
|
||
|
+
|
||
|
+ cfe->csi2.base = devm_platform_ioremap_resource(pdev, 0);
|
||
|
+ if (IS_ERR(cfe->csi2.base)) {
|
||
|
+ dev_err(&pdev->dev, "Failed to get dma io block\n");
|
||
|
+ ret = PTR_ERR(cfe->csi2.base);
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->csi2.dphy.base = devm_platform_ioremap_resource(pdev, 1);
|
||
|
+ if (IS_ERR(cfe->csi2.dphy.base)) {
|
||
|
+ dev_err(&pdev->dev, "Failed to get host io block\n");
|
||
|
+ ret = PTR_ERR(cfe->csi2.dphy.base);
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->mipi_cfg_base = devm_platform_ioremap_resource(pdev, 2);
|
||
|
+ if (IS_ERR(cfe->mipi_cfg_base)) {
|
||
|
+ dev_err(&pdev->dev, "Failed to get mipi cfg io block\n");
|
||
|
+ ret = PTR_ERR(cfe->mipi_cfg_base);
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->fe.base = devm_platform_ioremap_resource(pdev, 3);
|
||
|
+ if (IS_ERR(cfe->fe.base)) {
|
||
|
+ dev_err(&pdev->dev, "Failed to get pisp fe io block\n");
|
||
|
+ ret = PTR_ERR(cfe->fe.base);
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = platform_get_irq(pdev, 0);
|
||
|
+ if (ret <= 0) {
|
||
|
+ dev_err(&pdev->dev, "No IRQ resource\n");
|
||
|
+ ret = -EINVAL;
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = devm_request_irq(&pdev->dev, ret, cfe_isr, 0, "rp1-cfe", cfe);
|
||
|
+ if (ret) {
|
||
|
+ dev_err(&pdev->dev, "Unable to request interrupt\n");
|
||
|
+ ret = -EINVAL;
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
|
||
|
+ if (ret) {
|
||
|
+ dev_err(&pdev->dev, "DMA enable failed\n");
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* TODO: Enable clock only when running. */
|
||
|
+ cfe->clk = devm_clk_get(&pdev->dev, NULL);
|
||
|
+ if (IS_ERR(cfe->clk))
|
||
|
+ return dev_err_probe(&pdev->dev, PTR_ERR(cfe->clk),
|
||
|
+ "clock not found\n");
|
||
|
+
|
||
|
+ cfe->mdev.dev = &pdev->dev;
|
||
|
+ cfe->mdev.ops = &cfe_media_device_ops;
|
||
|
+ strscpy(cfe->mdev.model, CFE_MODULE_NAME, sizeof(cfe->mdev.model));
|
||
|
+ strscpy(cfe->mdev.serial, "", sizeof(cfe->mdev.serial));
|
||
|
+ snprintf(cfe->mdev.bus_info, sizeof(cfe->mdev.bus_info), "platform:%s",
|
||
|
+ dev_name(&pdev->dev));
|
||
|
+
|
||
|
+ media_device_init(&cfe->mdev);
|
||
|
+
|
||
|
+ cfe->v4l2_dev.mdev = &cfe->mdev;
|
||
|
+
|
||
|
+ ret = v4l2_device_register(&pdev->dev, &cfe->v4l2_dev);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Unable to register v4l2 device.\n");
|
||
|
+ goto err_cfe_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ snprintf(debugfs_name, sizeof(debugfs_name), "rp1-cfe:%s",
|
||
|
+ dev_name(&pdev->dev));
|
||
|
+ cfe->debugfs = debugfs_create_dir(debugfs_name, NULL);
|
||
|
+ debugfs_create_file("format", 0444, cfe->debugfs, cfe, &format_fops);
|
||
|
+ debugfs_create_file("regs", 0444, cfe->debugfs, cfe,
|
||
|
+ &mipi_cfg_regs_fops);
|
||
|
+
|
||
|
+ /* Enable the block power domain */
|
||
|
+ pm_runtime_enable(&pdev->dev);
|
||
|
+
|
||
|
+ ret = pm_runtime_resume_and_get(&cfe->pdev->dev);
|
||
|
+ if (ret)
|
||
|
+ goto err_runtime_disable;
|
||
|
+
|
||
|
+ cfe->csi2.v4l2_dev = &cfe->v4l2_dev;
|
||
|
+ ret = csi2_init(&cfe->csi2, cfe->debugfs);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Failed to init csi2 (%d)\n", ret);
|
||
|
+ goto err_runtime_put;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->fe.v4l2_dev = &cfe->v4l2_dev;
|
||
|
+ ret = pisp_fe_init(&cfe->fe, cfe->debugfs);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Failed to init pisp fe (%d)\n", ret);
|
||
|
+ goto err_csi2_uninit;
|
||
|
+ }
|
||
|
+
|
||
|
+ cfe->mdev.hw_revision = cfe->fe.hw_revision;
|
||
|
+ ret = media_device_register(&cfe->mdev);
|
||
|
+ if (ret < 0) {
|
||
|
+ cfe_err("Unable to register media-controller device.\n");
|
||
|
+ goto err_pisp_fe_uninit;
|
||
|
+ }
|
||
|
+
|
||
|
+ ret = of_cfe_connect_subdevs(cfe);
|
||
|
+ if (ret) {
|
||
|
+ cfe_err("Failed to connect subdevs\n");
|
||
|
+ goto err_media_unregister;
|
||
|
+ }
|
||
|
+
|
||
|
+ pm_runtime_put(&cfe->pdev->dev);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+
|
||
|
+err_media_unregister:
|
||
|
+ media_device_unregister(&cfe->mdev);
|
||
|
+err_pisp_fe_uninit:
|
||
|
+ pisp_fe_uninit(&cfe->fe);
|
||
|
+err_csi2_uninit:
|
||
|
+ csi2_uninit(&cfe->csi2);
|
||
|
+err_runtime_put:
|
||
|
+ pm_runtime_put(&cfe->pdev->dev);
|
||
|
+err_runtime_disable:
|
||
|
+ pm_runtime_disable(&pdev->dev);
|
||
|
+ debugfs_remove(cfe->debugfs);
|
||
|
+ v4l2_device_unregister(&cfe->v4l2_dev);
|
||
|
+err_cfe_put:
|
||
|
+ cfe_put(cfe);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_remove(struct platform_device *pdev)
|
||
|
+{
|
||
|
+ struct cfe_device *cfe = platform_get_drvdata(pdev);
|
||
|
+
|
||
|
+ debugfs_remove(cfe->debugfs);
|
||
|
+
|
||
|
+ v4l2_async_nf_unregister(&cfe->notifier);
|
||
|
+ media_device_unregister(&cfe->mdev);
|
||
|
+ cfe_unregister_nodes(cfe);
|
||
|
+
|
||
|
+ pisp_fe_uninit(&cfe->fe);
|
||
|
+ csi2_uninit(&cfe->csi2);
|
||
|
+
|
||
|
+ pm_runtime_disable(&pdev->dev);
|
||
|
+
|
||
|
+ v4l2_device_unregister(&cfe->v4l2_dev);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_runtime_suspend(struct device *dev)
|
||
|
+{
|
||
|
+ struct platform_device *pdev = to_platform_device(dev);
|
||
|
+ struct cfe_device *cfe = platform_get_drvdata(pdev);
|
||
|
+
|
||
|
+ clk_disable_unprepare(cfe->clk);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int cfe_runtime_resume(struct device *dev)
|
||
|
+{
|
||
|
+ struct platform_device *pdev = to_platform_device(dev);
|
||
|
+ struct cfe_device *cfe = platform_get_drvdata(pdev);
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ ret = clk_prepare_enable(cfe->clk);
|
||
|
+ if (ret) {
|
||
|
+ dev_err(dev, "Unable to enable clock\n");
|
||
|
+ return ret;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static const struct dev_pm_ops cfe_pm_ops = {
|
||
|
+ SET_RUNTIME_PM_OPS(cfe_runtime_suspend, cfe_runtime_resume, NULL)
|
||
|
+ SET_LATE_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend, pm_runtime_force_resume)
|
||
|
+};
|
||
|
+
|
||
|
+static const struct of_device_id cfe_of_match[] = {
|
||
|
+ { .compatible = "raspberrypi,rp1-cfe" },
|
||
|
+ { /* sentinel */ },
|
||
|
+};
|
||
|
+MODULE_DEVICE_TABLE(of, cfe_of_match);
|
||
|
+
|
||
|
+static struct platform_driver cfe_driver = {
|
||
|
+ .probe = cfe_probe,
|
||
|
+ .remove = cfe_remove,
|
||
|
+ .driver = {
|
||
|
+ .name = CFE_MODULE_NAME,
|
||
|
+ .of_match_table = cfe_of_match,
|
||
|
+ .pm = &cfe_pm_ops,
|
||
|
+ },
|
||
|
+};
|
||
|
+
|
||
|
+module_platform_driver(cfe_driver);
|
||
|
+
|
||
|
+MODULE_AUTHOR("Naushir Patuck <naush@raspberrypi.com>");
|
||
|
+MODULE_DESCRIPTION("RP1 Camera Front End driver");
|
||
|
+MODULE_LICENSE("GPL");
|
||
|
+MODULE_VERSION(CFE_VERSION);
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/cfe.h
|
||
|
@@ -0,0 +1,40 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 CFE driver.
|
||
|
+ * Copyright (c) 2021 Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _RP1_CFE_
|
||
|
+#define _RP1_CFE_
|
||
|
+
|
||
|
+#include <linux/types.h>
|
||
|
+#include <linux/media-bus-format.h>
|
||
|
+#include <linux/videodev2.h>
|
||
|
+
|
||
|
+extern bool cfe_debug_irq;
|
||
|
+
|
||
|
+enum cfe_remap_types {
|
||
|
+ CFE_REMAP_16BIT,
|
||
|
+ CFE_REMAP_COMPRESSED,
|
||
|
+ CFE_NUM_REMAP,
|
||
|
+};
|
||
|
+
|
||
|
+#define CFE_FORMAT_FLAG_META_OUT BIT(0)
|
||
|
+#define CFE_FORMAT_FLAG_META_CAP BIT(1)
|
||
|
+#define CFE_FORMAT_FLAG_FE_OUT BIT(2)
|
||
|
+
|
||
|
+struct cfe_fmt {
|
||
|
+ u32 fourcc;
|
||
|
+ u32 code;
|
||
|
+ u8 depth;
|
||
|
+ u8 csi_dt;
|
||
|
+ u32 remap[CFE_NUM_REMAP];
|
||
|
+ u32 flags;
|
||
|
+};
|
||
|
+
|
||
|
+extern const struct v4l2_mbus_framefmt cfe_default_format;
|
||
|
+extern const struct v4l2_mbus_framefmt cfe_default_meta_format;
|
||
|
+
|
||
|
+const struct cfe_fmt *find_format_by_code(u32 code);
|
||
|
+
|
||
|
+#endif
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/cfe_fmts.h
|
||
|
@@ -0,0 +1,294 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 Camera Front End formats definition
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _CFE_FMTS_H_
|
||
|
+#define _CFE_FMTS_H_
|
||
|
+
|
||
|
+#include "cfe.h"
|
||
|
+
|
||
|
+static const struct cfe_fmt formats[] = {
|
||
|
+ /* YUV Formats */
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_YUYV,
|
||
|
+ .code = MEDIA_BUS_FMT_YUYV8_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x1e,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_UYVY,
|
||
|
+ .code = MEDIA_BUS_FMT_UYVY8_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x1e,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_YVYU,
|
||
|
+ .code = MEDIA_BUS_FMT_YVYU8_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x1e,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_VYUY,
|
||
|
+ .code = MEDIA_BUS_FMT_VYUY8_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x1e,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ /* RGB Formats */
|
||
|
+ .fourcc = V4L2_PIX_FMT_RGB565, /* gggbbbbb rrrrrggg */
|
||
|
+ .code = MEDIA_BUS_FMT_RGB565_2X8_LE,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x22,
|
||
|
+ },
|
||
|
+ { .fourcc = V4L2_PIX_FMT_RGB565X, /* rrrrrggg gggbbbbb */
|
||
|
+ .code = MEDIA_BUS_FMT_RGB565_2X8_BE,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x22
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_RGB555, /* gggbbbbb arrrrrgg */
|
||
|
+ .code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_LE,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x21,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_RGB555X, /* arrrrrgg gggbbbbb */
|
||
|
+ .code = MEDIA_BUS_FMT_RGB555_2X8_PADHI_BE,
|
||
|
+ .depth = 16,
|
||
|
+ .csi_dt = 0x21,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_RGB24, /* rgb */
|
||
|
+ .code = MEDIA_BUS_FMT_RGB888_1X24,
|
||
|
+ .depth = 24,
|
||
|
+ .csi_dt = 0x24,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_BGR24, /* bgr */
|
||
|
+ .code = MEDIA_BUS_FMT_BGR888_1X24,
|
||
|
+ .depth = 24,
|
||
|
+ .csi_dt = 0x24,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_RGB32, /* argb */
|
||
|
+ .code = MEDIA_BUS_FMT_ARGB8888_1X32,
|
||
|
+ .depth = 32,
|
||
|
+ .csi_dt = 0x0,
|
||
|
+ },
|
||
|
+
|
||
|
+ /* Bayer Formats */
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SBGGR8,
|
||
|
+ .code = MEDIA_BUS_FMT_SBGGR8_1X8,
|
||
|
+ .depth = 8,
|
||
|
+ .csi_dt = 0x2a,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGBRG8,
|
||
|
+ .code = MEDIA_BUS_FMT_SGBRG8_1X8,
|
||
|
+ .depth = 8,
|
||
|
+ .csi_dt = 0x2a,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGRBG8,
|
||
|
+ .code = MEDIA_BUS_FMT_SGRBG8_1X8,
|
||
|
+ .depth = 8,
|
||
|
+ .csi_dt = 0x2a,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SRGGB8,
|
||
|
+ .code = MEDIA_BUS_FMT_SRGGB8_1X8,
|
||
|
+ .depth = 8,
|
||
|
+ .csi_dt = 0x2a,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SBGGR10P,
|
||
|
+ .code = MEDIA_BUS_FMT_SBGGR10_1X10,
|
||
|
+ .depth = 10,
|
||
|
+ .csi_dt = 0x2b,
|
||
|
+ .remap = { V4L2_PIX_FMT_SBGGR16, V4L2_PIX_FMT_PISP_COMP1_BGGR },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGBRG10P,
|
||
|
+ .code = MEDIA_BUS_FMT_SGBRG10_1X10,
|
||
|
+ .depth = 10,
|
||
|
+ .csi_dt = 0x2b,
|
||
|
+ .remap = { V4L2_PIX_FMT_SGBRG16, V4L2_PIX_FMT_PISP_COMP1_GBRG },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGRBG10P,
|
||
|
+ .code = MEDIA_BUS_FMT_SGRBG10_1X10,
|
||
|
+ .depth = 10,
|
||
|
+ .csi_dt = 0x2b,
|
||
|
+ .remap = { V4L2_PIX_FMT_SGRBG16, V4L2_PIX_FMT_PISP_COMP1_GRBG },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SRGGB10P,
|
||
|
+ .code = MEDIA_BUS_FMT_SRGGB10_1X10,
|
||
|
+ .depth = 10,
|
||
|
+ .csi_dt = 0x2b,
|
||
|
+ .remap = { V4L2_PIX_FMT_SRGGB16, V4L2_PIX_FMT_PISP_COMP1_RGGB },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SBGGR12P,
|
||
|
+ .code = MEDIA_BUS_FMT_SBGGR12_1X12,
|
||
|
+ .depth = 12,
|
||
|
+ .csi_dt = 0x2c,
|
||
|
+ .remap = { V4L2_PIX_FMT_SBGGR16, V4L2_PIX_FMT_PISP_COMP1_BGGR },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGBRG12P,
|
||
|
+ .code = MEDIA_BUS_FMT_SGBRG12_1X12,
|
||
|
+ .depth = 12,
|
||
|
+ .csi_dt = 0x2c,
|
||
|
+ .remap = { V4L2_PIX_FMT_SGBRG16, V4L2_PIX_FMT_PISP_COMP1_GBRG },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGRBG12P,
|
||
|
+ .code = MEDIA_BUS_FMT_SGRBG12_1X12,
|
||
|
+ .depth = 12,
|
||
|
+ .csi_dt = 0x2c,
|
||
|
+ .remap = { V4L2_PIX_FMT_SGRBG16, V4L2_PIX_FMT_PISP_COMP1_GRBG },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SRGGB12P,
|
||
|
+ .code = MEDIA_BUS_FMT_SRGGB12_1X12,
|
||
|
+ .depth = 12,
|
||
|
+ .csi_dt = 0x2c,
|
||
|
+ .remap = { V4L2_PIX_FMT_SRGGB16, V4L2_PIX_FMT_PISP_COMP1_RGGB },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SBGGR14P,
|
||
|
+ .code = MEDIA_BUS_FMT_SBGGR14_1X14,
|
||
|
+ .depth = 14,
|
||
|
+ .csi_dt = 0x2d,
|
||
|
+ .remap = { V4L2_PIX_FMT_SBGGR16, V4L2_PIX_FMT_PISP_COMP1_BGGR },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGBRG14P,
|
||
|
+ .code = MEDIA_BUS_FMT_SGBRG14_1X14,
|
||
|
+ .depth = 14,
|
||
|
+ .csi_dt = 0x2d,
|
||
|
+ .remap = { V4L2_PIX_FMT_SGBRG16, V4L2_PIX_FMT_PISP_COMP1_GBRG },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGRBG14P,
|
||
|
+ .code = MEDIA_BUS_FMT_SGRBG14_1X14,
|
||
|
+ .depth = 14,
|
||
|
+ .csi_dt = 0x2d,
|
||
|
+ .remap = { V4L2_PIX_FMT_SGRBG16, V4L2_PIX_FMT_PISP_COMP1_GRBG },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SRGGB14P,
|
||
|
+ .code = MEDIA_BUS_FMT_SRGGB14_1X14,
|
||
|
+ .depth = 14,
|
||
|
+ .csi_dt = 0x2d,
|
||
|
+ .remap = { V4L2_PIX_FMT_SRGGB16, V4L2_PIX_FMT_PISP_COMP1_RGGB },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SBGGR16,
|
||
|
+ .code = MEDIA_BUS_FMT_SBGGR16_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGBRG16,
|
||
|
+ .code = MEDIA_BUS_FMT_SGBRG16_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SGRBG16,
|
||
|
+ .code = MEDIA_BUS_FMT_SGRBG16_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_SRGGB16,
|
||
|
+ .code = MEDIA_BUS_FMT_SRGGB16_1X16,
|
||
|
+ .depth = 16,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ /* PiSP Compressed Mode 1 */
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_PISP_COMP1_RGGB,
|
||
|
+ .code = MEDIA_BUS_FMT_PISP_COMP1_RGGB,
|
||
|
+ .depth = 8,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_PISP_COMP1_BGGR,
|
||
|
+ .code = MEDIA_BUS_FMT_PISP_COMP1_BGGR,
|
||
|
+ .depth = 8,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_PISP_COMP1_GBRG,
|
||
|
+ .code = MEDIA_BUS_FMT_PISP_COMP1_GBRG,
|
||
|
+ .depth = 8,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_PISP_COMP1_GRBG,
|
||
|
+ .code = MEDIA_BUS_FMT_PISP_COMP1_GRBG,
|
||
|
+ .depth = 8,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+ /* Greyscale format */
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_GREY,
|
||
|
+ .code = MEDIA_BUS_FMT_Y8_1X8,
|
||
|
+ .depth = 8,
|
||
|
+ .csi_dt = 0x2a,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_Y10P,
|
||
|
+ .code = MEDIA_BUS_FMT_Y10_1X10,
|
||
|
+ .depth = 10,
|
||
|
+ .csi_dt = 0x2b,
|
||
|
+ .remap = { V4L2_PIX_FMT_Y16 },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_Y12P,
|
||
|
+ .code = MEDIA_BUS_FMT_Y12_1X12,
|
||
|
+ .depth = 12,
|
||
|
+ .csi_dt = 0x2c,
|
||
|
+ .remap = { V4L2_PIX_FMT_Y16 },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_Y14P,
|
||
|
+ .code = MEDIA_BUS_FMT_Y14_1X14,
|
||
|
+ .depth = 14,
|
||
|
+ .csi_dt = 0x2d,
|
||
|
+ .remap = { V4L2_PIX_FMT_Y16 },
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_PIX_FMT_Y16,
|
||
|
+ .depth = 16,
|
||
|
+ .flags = CFE_FORMAT_FLAG_FE_OUT,
|
||
|
+ },
|
||
|
+
|
||
|
+ /* Embedded data format */
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_META_FMT_SENSOR_DATA,
|
||
|
+ .code = MEDIA_BUS_FMT_SENSOR_DATA,
|
||
|
+ .depth = 8,
|
||
|
+ .csi_dt = 0x12,
|
||
|
+ .flags = CFE_FORMAT_FLAG_META_CAP,
|
||
|
+ },
|
||
|
+
|
||
|
+ /* Frontend formats */
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_META_FMT_RPI_FE_CFG,
|
||
|
+ .flags = CFE_FORMAT_FLAG_META_OUT,
|
||
|
+ },
|
||
|
+ {
|
||
|
+ .fourcc = V4L2_META_FMT_RPI_FE_STATS,
|
||
|
+ .flags = CFE_FORMAT_FLAG_META_CAP,
|
||
|
+ },
|
||
|
+};
|
||
|
+
|
||
|
+#endif /* _CFE_FMTS_H_ */
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/csi2.c
|
||
|
@@ -0,0 +1,446 @@
|
||
|
+// SPDX-License-Identifier: GPL-2.0-only
|
||
|
+/*
|
||
|
+ * RP1 CSI-2 Driver
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+
|
||
|
+#include <linux/delay.h>
|
||
|
+#include <linux/moduleparam.h>
|
||
|
+#include <linux/pm_runtime.h>
|
||
|
+#include <linux/seq_file.h>
|
||
|
+
|
||
|
+#include <media/videobuf2-dma-contig.h>
|
||
|
+
|
||
|
+#include "csi2.h"
|
||
|
+#include "cfe.h"
|
||
|
+
|
||
|
+#define csi2_dbg_irq(fmt, arg...) \
|
||
|
+ do { \
|
||
|
+ if (cfe_debug_irq) \
|
||
|
+ dev_dbg(csi2->v4l2_dev->dev, fmt, ##arg); \
|
||
|
+ } while (0)
|
||
|
+#define csi2_dbg(fmt, arg...) dev_dbg(csi2->v4l2_dev->dev, fmt, ##arg)
|
||
|
+#define csi2_info(fmt, arg...) dev_info(csi2->v4l2_dev->dev, fmt, ##arg)
|
||
|
+#define csi2_err(fmt, arg...) dev_err(csi2->v4l2_dev->dev, fmt, ##arg)
|
||
|
+
|
||
|
+/* CSI2-DMA registers */
|
||
|
+#define CSI2_STATUS 0x000
|
||
|
+#define CSI2_QOS 0x004
|
||
|
+#define CSI2_DISCARDS_OVERFLOW 0x008
|
||
|
+#define CSI2_DISCARDS_INACTIVE 0x00c
|
||
|
+#define CSI2_DISCARDS_UNMATCHED 0x010
|
||
|
+#define CSI2_DISCARDS_LEN_LIMIT 0x014
|
||
|
+#define CSI2_LLEV_PANICS 0x018
|
||
|
+#define CSI2_ULEV_PANICS 0x01c
|
||
|
+#define CSI2_IRQ_MASK 0x020
|
||
|
+#define CSI2_CTRL 0x024
|
||
|
+#define CSI2_CH_CTRL(x) ((x) * 0x40 + 0x28)
|
||
|
+#define CSI2_CH_ADDR0(x) ((x) * 0x40 + 0x2c)
|
||
|
+#define CSI2_CH_ADDR1(x) ((x) * 0x40 + 0x3c)
|
||
|
+#define CSI2_CH_STRIDE(x) ((x) * 0x40 + 0x30)
|
||
|
+#define CSI2_CH_LENGTH(x) ((x) * 0x40 + 0x34)
|
||
|
+#define CSI2_CH_DEBUG(x) ((x) * 0x40 + 0x38)
|
||
|
+#define CSI2_CH_FRAME_SIZE(x) ((x) * 0x40 + 0x40)
|
||
|
+#define CSI2_CH_COMP_CTRL(x) ((x) * 0x40 + 0x44)
|
||
|
+#define CSI2_CH_FE_FRAME_ID(x) ((x) * 0x40 + 0x48)
|
||
|
+
|
||
|
+/* CSI2_STATUS */
|
||
|
+#define IRQ_FS(x) (BIT(0) << (x))
|
||
|
+#define IRQ_FE(x) (BIT(4) << (x))
|
||
|
+#define IRQ_FE_ACK(x) (BIT(8) << (x))
|
||
|
+#define IRQ_LE(x) (BIT(12) << (x))
|
||
|
+#define IRQ_LE_ACK(x) (BIT(16) << (x))
|
||
|
+#define IRQ_CH_MASK(x) (IRQ_FS(x) | IRQ_FE(x) | IRQ_FE_ACK(x) | IRQ_LE(x) | IRQ_LE_ACK(x))
|
||
|
+#define IRQ_OVERFLOW BIT(20)
|
||
|
+#define IRQ_DISCARD_OVERFLOW BIT(21)
|
||
|
+#define IRQ_DISCARD_LEN_LIMIT BIT(22)
|
||
|
+#define IRQ_DISCARD_UNMATCHED BIT(23)
|
||
|
+#define IRQ_DISCARD_INACTIVE BIT(24)
|
||
|
+
|
||
|
+/* CSI2_CTRL */
|
||
|
+#define EOP_IS_EOL BIT(0)
|
||
|
+
|
||
|
+/* CSI2_CH_CTRL */
|
||
|
+#define DMA_EN BIT(0)
|
||
|
+#define FORCE BIT(3)
|
||
|
+#define AUTO_ARM BIT(4)
|
||
|
+#define IRQ_EN_FS BIT(13)
|
||
|
+#define IRQ_EN_FE BIT(14)
|
||
|
+#define IRQ_EN_FE_ACK BIT(15)
|
||
|
+#define IRQ_EN_LE BIT(16)
|
||
|
+#define IRQ_EN_LE_ACK BIT(17)
|
||
|
+#define FLUSH_FE BIT(28)
|
||
|
+#define PACK_LINE BIT(29)
|
||
|
+#define PACK_BYTES BIT(30)
|
||
|
+#define CH_MODE_MASK GENMASK(2, 1)
|
||
|
+#define VC_MASK GENMASK(6, 5)
|
||
|
+#define DT_MASK GENMASK(12, 7)
|
||
|
+#define LC_MASK GENMASK(27, 18)
|
||
|
+
|
||
|
+/* CHx_COMPRESSION_CONTROL */
|
||
|
+#define COMP_OFFSET_MASK GENMASK(15, 0)
|
||
|
+#define COMP_SHIFT_MASK GENMASK(19, 16)
|
||
|
+#define COMP_MODE_MASK GENMASK(25, 24)
|
||
|
+
|
||
|
+static inline u32 csi2_reg_read(struct csi2_device *csi2, u32 offset)
|
||
|
+{
|
||
|
+ return readl(csi2->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static inline void csi2_reg_write(struct csi2_device *csi2, u32 offset, u32 val)
|
||
|
+{
|
||
|
+ writel(val, csi2->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static inline void set_field(u32 *valp, u32 field, u32 mask)
|
||
|
+{
|
||
|
+ u32 val = *valp;
|
||
|
+
|
||
|
+ val &= ~mask;
|
||
|
+ val |= (field << __ffs(mask)) & mask;
|
||
|
+ *valp = val;
|
||
|
+}
|
||
|
+
|
||
|
+static int csi2_regs_show(struct seq_file *s, void *data)
|
||
|
+{
|
||
|
+ struct csi2_device *csi2 = s->private;
|
||
|
+ unsigned int i;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ ret = pm_runtime_resume_and_get(csi2->v4l2_dev->dev);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+#define DUMP(reg) seq_printf(s, #reg " \t0x%08x\n", csi2_reg_read(csi2, reg))
|
||
|
+#define DUMP_CH(idx, reg) seq_printf(s, #reg "(%u) \t0x%08x\n", idx, csi2_reg_read(csi2, reg(idx)))
|
||
|
+
|
||
|
+ DUMP(CSI2_STATUS);
|
||
|
+ DUMP(CSI2_DISCARDS_OVERFLOW);
|
||
|
+ DUMP(CSI2_DISCARDS_INACTIVE);
|
||
|
+ DUMP(CSI2_DISCARDS_UNMATCHED);
|
||
|
+ DUMP(CSI2_DISCARDS_LEN_LIMIT);
|
||
|
+ DUMP(CSI2_LLEV_PANICS);
|
||
|
+ DUMP(CSI2_ULEV_PANICS);
|
||
|
+ DUMP(CSI2_IRQ_MASK);
|
||
|
+ DUMP(CSI2_CTRL);
|
||
|
+
|
||
|
+ for (i = 0; i < CSI2_NUM_CHANNELS; ++i) {
|
||
|
+ DUMP_CH(i, CSI2_CH_CTRL);
|
||
|
+ DUMP_CH(i, CSI2_CH_ADDR0);
|
||
|
+ DUMP_CH(i, CSI2_CH_ADDR1);
|
||
|
+ DUMP_CH(i, CSI2_CH_STRIDE);
|
||
|
+ DUMP_CH(i, CSI2_CH_LENGTH);
|
||
|
+ DUMP_CH(i, CSI2_CH_DEBUG);
|
||
|
+ DUMP_CH(i, CSI2_CH_FRAME_SIZE);
|
||
|
+ DUMP_CH(i, CSI2_CH_COMP_CTRL);
|
||
|
+ DUMP_CH(i, CSI2_CH_FE_FRAME_ID);
|
||
|
+ }
|
||
|
+
|
||
|
+#undef DUMP
|
||
|
+#undef DUMP_CH
|
||
|
+
|
||
|
+ pm_runtime_put(csi2->v4l2_dev->dev);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+DEFINE_SHOW_ATTRIBUTE(csi2_regs);
|
||
|
+
|
||
|
+void csi2_isr(struct csi2_device *csi2, bool *sof, bool *eof, bool *lci)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+ u32 status;
|
||
|
+
|
||
|
+ status = csi2_reg_read(csi2, CSI2_STATUS);
|
||
|
+ csi2_dbg_irq("ISR: STA: 0x%x\n", status);
|
||
|
+
|
||
|
+ /* Write value back to clear the interrupts */
|
||
|
+ csi2_reg_write(csi2, CSI2_STATUS, status);
|
||
|
+
|
||
|
+ for (i = 0; i < CSI2_NUM_CHANNELS; i++) {
|
||
|
+ u32 dbg;
|
||
|
+
|
||
|
+ if ((status & IRQ_CH_MASK(i)) == 0)
|
||
|
+ continue;
|
||
|
+
|
||
|
+ dbg = csi2_reg_read(csi2, CSI2_CH_DEBUG(i));
|
||
|
+
|
||
|
+ csi2_dbg_irq("ISR: [%u], %s%s%s%s%s frame: %u line: %u\n", i,
|
||
|
+ (status & IRQ_FS(i)) ? "FS " : "",
|
||
|
+ (status & IRQ_FE(i)) ? "FE " : "",
|
||
|
+ (status & IRQ_FE_ACK(i)) ? "FE_ACK " : "",
|
||
|
+ (status & IRQ_LE(i)) ? "LE " : "",
|
||
|
+ (status & IRQ_LE_ACK(i)) ? "LE_ACK " : "",
|
||
|
+ dbg >> 16,
|
||
|
+ csi2->num_lines[i] ?
|
||
|
+ ((dbg & 0xffff) % csi2->num_lines[i]) :
|
||
|
+ 0);
|
||
|
+
|
||
|
+ sof[i] = !!(status & IRQ_FS(i));
|
||
|
+ eof[i] = !!(status & IRQ_FE_ACK(i));
|
||
|
+ lci[i] = !!(status & IRQ_LE_ACK(i));
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_set_buffer(struct csi2_device *csi2, unsigned int channel,
|
||
|
+ dma_addr_t dmaaddr, unsigned int stride, unsigned int size)
|
||
|
+{
|
||
|
+ u64 addr = dmaaddr;
|
||
|
+ /*
|
||
|
+ * ADDRESS0 must be written last as it triggers the double buffering
|
||
|
+ * mechanism for all buffer registers within the hardware.
|
||
|
+ */
|
||
|
+ addr >>= 4;
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_LENGTH(channel), size >> 4);
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_STRIDE(channel), stride >> 4);
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_ADDR1(channel), addr >> 32);
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_ADDR0(channel), addr & 0xffffffff);
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_set_compression(struct csi2_device *csi2, unsigned int channel,
|
||
|
+ enum csi2_compression_mode mode, unsigned int shift,
|
||
|
+ unsigned int offset)
|
||
|
+{
|
||
|
+ u32 compression = 0;
|
||
|
+
|
||
|
+ set_field(&compression, COMP_OFFSET_MASK, offset);
|
||
|
+ set_field(&compression, COMP_SHIFT_MASK, shift);
|
||
|
+ set_field(&compression, COMP_MODE_MASK, mode);
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_COMP_CTRL(channel), compression);
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_start_channel(struct csi2_device *csi2, unsigned int channel,
|
||
|
+ u16 dt, enum csi2_mode mode, bool auto_arm,
|
||
|
+ bool pack_bytes, unsigned int width,
|
||
|
+ unsigned int height)
|
||
|
+{
|
||
|
+ u32 ctrl;
|
||
|
+
|
||
|
+ csi2_dbg("%s [%u]\n", __func__, channel);
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Disable the channel, but ensure N != 0! Otherwise we end up with a
|
||
|
+ * spurious LE + LE_ACK interrupt when re-enabling the channel.
|
||
|
+ */
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_CTRL(channel), 0x100 << __ffs(LC_MASK));
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_DEBUG(channel), 0);
|
||
|
+ csi2_reg_write(csi2, CSI2_STATUS, IRQ_CH_MASK(channel));
|
||
|
+
|
||
|
+ /* Enable channel and FS/FE/LE interrupts. */
|
||
|
+ ctrl = DMA_EN | IRQ_EN_FS | IRQ_EN_FE_ACK | IRQ_EN_LE_ACK | PACK_LINE;
|
||
|
+ /* PACK_BYTES ensures no striding for embedded data. */
|
||
|
+ if (pack_bytes)
|
||
|
+ ctrl |= PACK_BYTES;
|
||
|
+
|
||
|
+ if (auto_arm)
|
||
|
+ ctrl |= AUTO_ARM;
|
||
|
+
|
||
|
+ if (width && height) {
|
||
|
+ int line_int_freq = height >> 2;
|
||
|
+
|
||
|
+ line_int_freq = min(max(0x80, line_int_freq), 0x3ff);
|
||
|
+ set_field(&ctrl, line_int_freq, LC_MASK);
|
||
|
+ set_field(&ctrl, mode, CH_MODE_MASK);
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_FRAME_SIZE(channel),
|
||
|
+ (height << 16) | width);
|
||
|
+ } else {
|
||
|
+ /*
|
||
|
+ * Do not disable line interrupts for the embedded data channel,
|
||
|
+ * set it to the maximum value. This avoids spamming the ISR
|
||
|
+ * with spurious line interrupts.
|
||
|
+ */
|
||
|
+ set_field(&ctrl, 0x3ff, LC_MASK);
|
||
|
+ set_field(&ctrl, 0x00, CH_MODE_MASK);
|
||
|
+ }
|
||
|
+
|
||
|
+ set_field(&ctrl, dt, DT_MASK);
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_CTRL(channel), ctrl);
|
||
|
+ csi2->num_lines[channel] = height;
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_stop_channel(struct csi2_device *csi2, unsigned int channel)
|
||
|
+{
|
||
|
+ csi2_dbg("%s [%u]\n", __func__, channel);
|
||
|
+
|
||
|
+ /* Channel disable. Use FORCE to allow stopping mid-frame. */
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_CTRL(channel),
|
||
|
+ (0x100 << __ffs(LC_MASK)) | FORCE);
|
||
|
+ /* Latch the above change by writing to the ADDR0 register. */
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_ADDR0(channel), 0);
|
||
|
+ /* Write this again, the HW needs it! */
|
||
|
+ csi2_reg_write(csi2, CSI2_CH_ADDR0(channel), 0);
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_open_rx(struct csi2_device *csi2)
|
||
|
+{
|
||
|
+ dphy_start(&csi2->dphy);
|
||
|
+
|
||
|
+ if (!csi2->multipacket_line)
|
||
|
+ csi2_reg_write(csi2, CSI2_CTRL, EOP_IS_EOL);
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_close_rx(struct csi2_device *csi2)
|
||
|
+{
|
||
|
+ dphy_stop(&csi2->dphy);
|
||
|
+}
|
||
|
+
|
||
|
+static struct csi2_device *to_csi2_device(struct v4l2_subdev *subdev)
|
||
|
+{
|
||
|
+ return container_of(subdev, struct csi2_device, sd);
|
||
|
+}
|
||
|
+
|
||
|
+static int csi2_init_cfg(struct v4l2_subdev *sd,
|
||
|
+ struct v4l2_subdev_state *state)
|
||
|
+{
|
||
|
+ struct v4l2_mbus_framefmt *fmt;
|
||
|
+
|
||
|
+ for (unsigned int i = 0; i < CSI2_NUM_CHANNELS; ++i) {
|
||
|
+ const struct v4l2_mbus_framefmt *def_fmt;
|
||
|
+
|
||
|
+ /* CSI2_CH1_EMBEDDED */
|
||
|
+ if (i == 1)
|
||
|
+ def_fmt = &cfe_default_meta_format;
|
||
|
+ else
|
||
|
+ def_fmt = &cfe_default_format;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, i);
|
||
|
+ *fmt = *def_fmt;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, i + CSI2_NUM_CHANNELS);
|
||
|
+ *fmt = *def_fmt;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int csi2_pad_set_fmt(struct v4l2_subdev *sd,
|
||
|
+ struct v4l2_subdev_state *state,
|
||
|
+ struct v4l2_subdev_format *format)
|
||
|
+{
|
||
|
+ struct v4l2_mbus_framefmt *fmt;
|
||
|
+ const struct cfe_fmt *cfe_fmt;
|
||
|
+
|
||
|
+ /* TODO: format validation */
|
||
|
+
|
||
|
+ cfe_fmt = find_format_by_code(format->format.code);
|
||
|
+ if (!cfe_fmt)
|
||
|
+ cfe_fmt = find_format_by_code(MEDIA_BUS_FMT_SBGGR10_1X10);
|
||
|
+
|
||
|
+ format->format.code = cfe_fmt->code;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, format->pad);
|
||
|
+ *fmt = format->format;
|
||
|
+
|
||
|
+ if (format->pad < CSI2_NUM_CHANNELS) {
|
||
|
+ /* Propagate to the source pad */
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state,
|
||
|
+ format->pad + CSI2_NUM_CHANNELS);
|
||
|
+ *fmt = format->format;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int csi2_link_validate(struct v4l2_subdev *sd, struct media_link *link,
|
||
|
+ struct v4l2_subdev_format *source_fmt,
|
||
|
+ struct v4l2_subdev_format *sink_fmt)
|
||
|
+{
|
||
|
+ struct csi2_device *csi2 = to_csi2_device(sd);
|
||
|
+
|
||
|
+ csi2_dbg("%s: link \"%s\":%u -> \"%s\":%u\n", __func__,
|
||
|
+ link->source->entity->name, link->source->index,
|
||
|
+ link->sink->entity->name, link->sink->index);
|
||
|
+
|
||
|
+ if ((link->source->entity == &csi2->sd.entity &&
|
||
|
+ link->source->index == 1) ||
|
||
|
+ (link->sink->entity == &csi2->sd.entity &&
|
||
|
+ link->sink->index == 1)) {
|
||
|
+ csi2_dbg("Ignore metadata pad for now\n");
|
||
|
+ return 0;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* The width, height and code must match. */
|
||
|
+ if (source_fmt->format.width != sink_fmt->format.width ||
|
||
|
+ source_fmt->format.width != sink_fmt->format.width ||
|
||
|
+ source_fmt->format.code != sink_fmt->format.code) {
|
||
|
+ csi2_err("%s: format does not match (source %ux%u 0x%x, sink %ux%u 0x%x)\n",
|
||
|
+ __func__,
|
||
|
+ source_fmt->format.width, source_fmt->format.height,
|
||
|
+ source_fmt->format.code,
|
||
|
+ sink_fmt->format.width, sink_fmt->format.height,
|
||
|
+ sink_fmt->format.code);
|
||
|
+ return -EPIPE;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static const struct v4l2_subdev_pad_ops csi2_subdev_pad_ops = {
|
||
|
+ .init_cfg = csi2_init_cfg,
|
||
|
+ .get_fmt = v4l2_subdev_get_fmt,
|
||
|
+ .set_fmt = csi2_pad_set_fmt,
|
||
|
+ .link_validate = csi2_link_validate,
|
||
|
+};
|
||
|
+
|
||
|
+static const struct media_entity_operations csi2_entity_ops = {
|
||
|
+ .link_validate = v4l2_subdev_link_validate,
|
||
|
+};
|
||
|
+
|
||
|
+static const struct v4l2_subdev_ops csi2_subdev_ops = {
|
||
|
+ .pad = &csi2_subdev_pad_ops,
|
||
|
+};
|
||
|
+
|
||
|
+int csi2_init(struct csi2_device *csi2, struct dentry *debugfs)
|
||
|
+{
|
||
|
+ unsigned int i, ret;
|
||
|
+
|
||
|
+ csi2->dphy.dev = csi2->v4l2_dev->dev;
|
||
|
+ dphy_probe(&csi2->dphy);
|
||
|
+
|
||
|
+ debugfs_create_file("csi2_regs", 0444, debugfs, csi2, &csi2_regs_fops);
|
||
|
+
|
||
|
+ for (i = 0; i < CSI2_NUM_CHANNELS * 2; i++)
|
||
|
+ csi2->pad[i].flags = i < CSI2_NUM_CHANNELS ?
|
||
|
+ MEDIA_PAD_FL_SINK : MEDIA_PAD_FL_SOURCE;
|
||
|
+
|
||
|
+ ret = media_entity_pads_init(&csi2->sd.entity, ARRAY_SIZE(csi2->pad),
|
||
|
+ csi2->pad);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ /* Initialize subdev */
|
||
|
+ v4l2_subdev_init(&csi2->sd, &csi2_subdev_ops);
|
||
|
+ csi2->sd.entity.function = MEDIA_ENT_F_VID_IF_BRIDGE;
|
||
|
+ csi2->sd.entity.ops = &csi2_entity_ops;
|
||
|
+ csi2->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
|
||
|
+ csi2->sd.owner = THIS_MODULE;
|
||
|
+ snprintf(csi2->sd.name, sizeof(csi2->sd.name), "csi2");
|
||
|
+
|
||
|
+ ret = v4l2_subdev_init_finalize(&csi2->sd);
|
||
|
+ if (ret)
|
||
|
+ goto err_entity_cleanup;
|
||
|
+
|
||
|
+ ret = v4l2_device_register_subdev(csi2->v4l2_dev, &csi2->sd);
|
||
|
+ if (ret) {
|
||
|
+ csi2_err("Failed register csi2 subdev (%d)\n", ret);
|
||
|
+ goto err_subdev_cleanup;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+
|
||
|
+err_subdev_cleanup:
|
||
|
+ v4l2_subdev_cleanup(&csi2->sd);
|
||
|
+err_entity_cleanup:
|
||
|
+ media_entity_cleanup(&csi2->sd.entity);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+void csi2_uninit(struct csi2_device *csi2)
|
||
|
+{
|
||
|
+ v4l2_device_unregister_subdev(&csi2->sd);
|
||
|
+ v4l2_subdev_cleanup(&csi2->sd);
|
||
|
+ media_entity_cleanup(&csi2->sd.entity);
|
||
|
+}
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/csi2.h
|
||
|
@@ -0,0 +1,75 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 CSI-2 driver.
|
||
|
+ * Copyright (c) 2021 Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _RP1_CSI2_
|
||
|
+#define _RP1_CSI2_
|
||
|
+
|
||
|
+#include <linux/debugfs.h>
|
||
|
+#include <linux/io.h>
|
||
|
+#include <linux/types.h>
|
||
|
+#include <media/v4l2-device.h>
|
||
|
+#include <media/v4l2-subdev.h>
|
||
|
+
|
||
|
+#include "dphy.h"
|
||
|
+
|
||
|
+#define CSI2_NUM_CHANNELS 4
|
||
|
+
|
||
|
+enum csi2_mode {
|
||
|
+ CSI2_MODE_NORMAL,
|
||
|
+ CSI2_MODE_REMAP,
|
||
|
+ CSI2_MODE_COMPRESSED,
|
||
|
+ CSI2_MODE_FE_STREAMING
|
||
|
+};
|
||
|
+
|
||
|
+enum csi2_compression_mode {
|
||
|
+ CSI2_COMPRESSION_DELTA = 1,
|
||
|
+ CSI2_COMPRESSION_SIMPLE = 2,
|
||
|
+ CSI2_COMPRESSION_COMBINED = 3,
|
||
|
+};
|
||
|
+
|
||
|
+struct csi2_cfg {
|
||
|
+ u16 width;
|
||
|
+ u16 height;
|
||
|
+ u32 stride;
|
||
|
+ u32 buffer_size;
|
||
|
+};
|
||
|
+
|
||
|
+struct csi2_device {
|
||
|
+ /* Parent V4l2 device */
|
||
|
+ struct v4l2_device *v4l2_dev;
|
||
|
+
|
||
|
+ void __iomem *base;
|
||
|
+
|
||
|
+ struct dphy_data dphy;
|
||
|
+
|
||
|
+ enum v4l2_mbus_type bus_type;
|
||
|
+ unsigned int bus_flags;
|
||
|
+ u32 active_data_lanes;
|
||
|
+ bool multipacket_line;
|
||
|
+ unsigned int num_lines[CSI2_NUM_CHANNELS];
|
||
|
+
|
||
|
+ struct media_pad pad[CSI2_NUM_CHANNELS * 2];
|
||
|
+ struct v4l2_subdev sd;
|
||
|
+};
|
||
|
+
|
||
|
+void csi2_isr(struct csi2_device *csi2, bool *sof, bool *eof, bool *lci);
|
||
|
+void csi2_set_buffer(struct csi2_device *csi2, unsigned int channel,
|
||
|
+ dma_addr_t dmaaddr, unsigned int stride,
|
||
|
+ unsigned int size);
|
||
|
+void csi2_set_compression(struct csi2_device *csi2, unsigned int channel,
|
||
|
+ enum csi2_compression_mode mode, unsigned int shift,
|
||
|
+ unsigned int offset);
|
||
|
+void csi2_start_channel(struct csi2_device *csi2, unsigned int channel,
|
||
|
+ u16 dt, enum csi2_mode mode, bool auto_arm,
|
||
|
+ bool pack_bytes, unsigned int width,
|
||
|
+ unsigned int height);
|
||
|
+void csi2_stop_channel(struct csi2_device *csi2, unsigned int channel);
|
||
|
+void csi2_open_rx(struct csi2_device *csi2);
|
||
|
+void csi2_close_rx(struct csi2_device *csi2);
|
||
|
+int csi2_init(struct csi2_device *csi2, struct dentry *debugfs);
|
||
|
+void csi2_uninit(struct csi2_device *csi2);
|
||
|
+
|
||
|
+#endif
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/dphy.c
|
||
|
@@ -0,0 +1,177 @@
|
||
|
+// SPDX-License-Identifier: GPL-2.0-only
|
||
|
+/*
|
||
|
+ * RP1 CSI-2 Driver
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+
|
||
|
+#include <linux/delay.h>
|
||
|
+#include <linux/dev_printk.h>
|
||
|
+#include <linux/pm_runtime.h>
|
||
|
+
|
||
|
+#include "dphy.h"
|
||
|
+
|
||
|
+#define dphy_dbg(fmt, arg...) dev_dbg(dphy->dev, fmt, ##arg)
|
||
|
+#define dphy_info(fmt, arg...) dev_info(dphy->dev, fmt, ##arg)
|
||
|
+#define dphy_err(fmt, arg...) dev_err(dphy->dev, fmt, ##arg)
|
||
|
+
|
||
|
+/* DW dphy Host registers */
|
||
|
+#define VERSION 0x000
|
||
|
+#define N_LANES 0x004
|
||
|
+#define RESETN 0x008
|
||
|
+#define PHY_SHUTDOWNZ 0x040
|
||
|
+#define PHY_RSTZ 0x044
|
||
|
+#define PHY_RX 0x048
|
||
|
+#define PHY_STOPSTATE 0x04c
|
||
|
+#define PHY_TST_CTRL0 0x050
|
||
|
+#define PHY_TST_CTRL1 0x054
|
||
|
+#define PHY2_TST_CTRL0 0x058
|
||
|
+#define PHY2_TST_CTRL1 0x05c
|
||
|
+
|
||
|
+/* DW dphy Host Transactions */
|
||
|
+#define DPHY_HS_RX_CTRL_LANE0_OFFSET 0x44
|
||
|
+#define DPHY_PLL_INPUT_DIV_OFFSET 0x17
|
||
|
+#define DPHY_PLL_LOOP_DIV_OFFSET 0x18
|
||
|
+#define DPHY_PLL_DIV_CTRL_OFFSET 0x19
|
||
|
+
|
||
|
+static u32 dw_csi2_host_read(struct dphy_data *dphy, u32 offset)
|
||
|
+{
|
||
|
+ return readl(dphy->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static void dw_csi2_host_write(struct dphy_data *dphy, u32 offset, u32 data)
|
||
|
+{
|
||
|
+ writel(data, dphy->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static void set_tstclr(struct dphy_data *dphy, u32 val)
|
||
|
+{
|
||
|
+ u32 ctrl0 = dw_csi2_host_read(dphy, PHY_TST_CTRL0);
|
||
|
+
|
||
|
+ dw_csi2_host_write(dphy, PHY_TST_CTRL0, (ctrl0 & ~1) | val);
|
||
|
+}
|
||
|
+
|
||
|
+static void set_tstclk(struct dphy_data *dphy, u32 val)
|
||
|
+{
|
||
|
+ u32 ctrl0 = dw_csi2_host_read(dphy, PHY_TST_CTRL0);
|
||
|
+
|
||
|
+ dw_csi2_host_write(dphy, PHY_TST_CTRL0, (ctrl0 & ~2) | (val << 1));
|
||
|
+}
|
||
|
+
|
||
|
+static uint8_t get_tstdout(struct dphy_data *dphy)
|
||
|
+{
|
||
|
+ u32 ctrl1 = dw_csi2_host_read(dphy, PHY_TST_CTRL1);
|
||
|
+
|
||
|
+ return ((ctrl1 >> 8) & 0xff);
|
||
|
+}
|
||
|
+
|
||
|
+static void set_testen(struct dphy_data *dphy, u32 val)
|
||
|
+{
|
||
|
+ u32 ctrl1 = dw_csi2_host_read(dphy, PHY_TST_CTRL1);
|
||
|
+
|
||
|
+ dw_csi2_host_write(dphy, PHY_TST_CTRL1,
|
||
|
+ (ctrl1 & ~(1 << 16)) | (val << 16));
|
||
|
+}
|
||
|
+
|
||
|
+static void set_testdin(struct dphy_data *dphy, u32 val)
|
||
|
+{
|
||
|
+ u32 ctrl1 = dw_csi2_host_read(dphy, PHY_TST_CTRL1);
|
||
|
+
|
||
|
+ dw_csi2_host_write(dphy, PHY_TST_CTRL1, (ctrl1 & ~0xff) | val);
|
||
|
+}
|
||
|
+
|
||
|
+static uint8_t dphy_transaction(struct dphy_data *dphy, u8 test_code,
|
||
|
+ uint8_t test_data)
|
||
|
+{
|
||
|
+ /* See page 101 of the MIPI DPHY databook. */
|
||
|
+ set_tstclk(dphy, 1);
|
||
|
+ set_testen(dphy, 0);
|
||
|
+ set_testdin(dphy, test_code);
|
||
|
+ set_testen(dphy, 1);
|
||
|
+ set_tstclk(dphy, 0);
|
||
|
+ set_testen(dphy, 0);
|
||
|
+ set_testdin(dphy, test_data);
|
||
|
+ set_tstclk(dphy, 1);
|
||
|
+ return get_tstdout(dphy);
|
||
|
+}
|
||
|
+
|
||
|
+static void dphy_set_hsfreqrange(struct dphy_data *dphy, uint32_t freq_mhz)
|
||
|
+{
|
||
|
+ /* See Table 5-1 on page 65 of dphy databook */
|
||
|
+ static const u16 hsfreqrange_table[][2] = {
|
||
|
+ { 89, 0b000000 }, { 99, 0b010000 }, { 109, 0b100000 },
|
||
|
+ { 129, 0b000001 }, { 139, 0b010001 }, { 149, 0b100001 },
|
||
|
+ { 169, 0b000010 }, { 179, 0b010010 }, { 199, 0b100010 },
|
||
|
+ { 219, 0b000011 }, { 239, 0b010011 }, { 249, 0b100011 },
|
||
|
+ { 269, 0b000100 }, { 299, 0b010100 }, { 329, 0b000101 },
|
||
|
+ { 359, 0b010101 }, { 399, 0b100101 }, { 449, 0b000110 },
|
||
|
+ { 499, 0b010110 }, { 549, 0b000111 }, { 599, 0b010111 },
|
||
|
+ { 649, 0b001000 }, { 699, 0b011000 }, { 749, 0b001001 },
|
||
|
+ { 799, 0b011001 }, { 849, 0b101001 }, { 899, 0b111001 },
|
||
|
+ { 949, 0b001010 }, { 999, 0b011010 }, { 1049, 0b101010 },
|
||
|
+ { 1099, 0b111010 }, { 1149, 0b001011 }, { 1199, 0b011011 },
|
||
|
+ { 1249, 0b101011 }, { 1299, 0b111011 }, { 1349, 0b001100 },
|
||
|
+ { 1399, 0b011100 }, { 1449, 0b101100 }, { 1500, 0b111100 },
|
||
|
+ };
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ if (freq_mhz < 80 || freq_mhz > 1500)
|
||
|
+ dphy_err("DPHY: Frequency %u MHz out of range\n", freq_mhz);
|
||
|
+
|
||
|
+ for (i = 0; i < ARRAY_SIZE(hsfreqrange_table) - 1; i++) {
|
||
|
+ if (freq_mhz <= hsfreqrange_table[i][0])
|
||
|
+ break;
|
||
|
+ }
|
||
|
+
|
||
|
+ dphy_transaction(dphy, DPHY_HS_RX_CTRL_LANE0_OFFSET,
|
||
|
+ hsfreqrange_table[i][1] << 1);
|
||
|
+}
|
||
|
+
|
||
|
+static void dphy_init(struct dphy_data *dphy)
|
||
|
+{
|
||
|
+ dw_csi2_host_write(dphy, PHY_RSTZ, 0);
|
||
|
+ dw_csi2_host_write(dphy, PHY_SHUTDOWNZ, 0);
|
||
|
+ set_tstclk(dphy, 1);
|
||
|
+ set_testen(dphy, 0);
|
||
|
+ set_tstclr(dphy, 1);
|
||
|
+ usleep_range(15, 20);
|
||
|
+ set_tstclr(dphy, 0);
|
||
|
+ usleep_range(15, 20);
|
||
|
+
|
||
|
+ dphy_set_hsfreqrange(dphy, dphy->dphy_freq);
|
||
|
+
|
||
|
+ usleep_range(5, 10);
|
||
|
+ dw_csi2_host_write(dphy, PHY_SHUTDOWNZ, 1);
|
||
|
+ usleep_range(5, 10);
|
||
|
+ dw_csi2_host_write(dphy, PHY_RSTZ, 1);
|
||
|
+}
|
||
|
+
|
||
|
+void dphy_start(struct dphy_data *dphy)
|
||
|
+{
|
||
|
+ dw_csi2_host_write(dphy, N_LANES, (dphy->num_lanes - 1));
|
||
|
+ dphy_init(dphy);
|
||
|
+ dw_csi2_host_write(dphy, RESETN, 0xffffffff);
|
||
|
+ usleep_range(10, 50);
|
||
|
+}
|
||
|
+
|
||
|
+void dphy_stop(struct dphy_data *dphy)
|
||
|
+{
|
||
|
+ /* Set only one lane (lane 0) as active (ON) */
|
||
|
+ dw_csi2_host_write(dphy, N_LANES, 0);
|
||
|
+ dw_csi2_host_write(dphy, RESETN, 0);
|
||
|
+}
|
||
|
+
|
||
|
+void dphy_probe(struct dphy_data *dphy)
|
||
|
+{
|
||
|
+ u32 host_ver;
|
||
|
+ u8 host_ver_major, host_ver_minor;
|
||
|
+
|
||
|
+ host_ver = dw_csi2_host_read(dphy, VERSION);
|
||
|
+ host_ver_major = (u8)((host_ver >> 24) - '0');
|
||
|
+ host_ver_minor = (u8)((host_ver >> 16) - '0');
|
||
|
+ host_ver_minor = host_ver_minor * 10;
|
||
|
+ host_ver_minor += (u8)((host_ver >> 8) - '0');
|
||
|
+
|
||
|
+ dphy_info("DW dphy Host HW v%u.%u\n", host_ver_major, host_ver_minor);
|
||
|
+}
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/dphy.h
|
||
|
@@ -0,0 +1,26 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * Copyright (c) 2021 Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+
|
||
|
+#ifndef _RP1_DPHY_
|
||
|
+#define _RP1_DPHY_
|
||
|
+
|
||
|
+#include <linux/io.h>
|
||
|
+#include <linux/types.h>
|
||
|
+
|
||
|
+struct dphy_data {
|
||
|
+ struct device *dev;
|
||
|
+
|
||
|
+ void __iomem *base;
|
||
|
+
|
||
|
+ u32 dphy_freq;
|
||
|
+ u32 num_lanes;
|
||
|
+};
|
||
|
+
|
||
|
+void dphy_probe(struct dphy_data *dphy);
|
||
|
+void dphy_start(struct dphy_data *dphy);
|
||
|
+void dphy_stop(struct dphy_data *dphy);
|
||
|
+
|
||
|
+#endif
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/pisp_common.h
|
||
|
@@ -0,0 +1,69 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 PiSP common definitions.
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _PISP_COMMON_H_
|
||
|
+#define _PISP_COMMON_H_
|
||
|
+
|
||
|
+#include "pisp_types.h"
|
||
|
+
|
||
|
+struct pisp_bla_config {
|
||
|
+ u16 black_level_r;
|
||
|
+ u16 black_level_gr;
|
||
|
+ u16 black_level_gb;
|
||
|
+ u16 black_level_b;
|
||
|
+ u16 output_black_level;
|
||
|
+ u8 pad[2];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_wbg_config {
|
||
|
+ u16 gain_r;
|
||
|
+ u16 gain_g;
|
||
|
+ u16 gain_b;
|
||
|
+ u8 pad[2];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_compress_config {
|
||
|
+ /* value subtracted from incoming data */
|
||
|
+ u16 offset;
|
||
|
+ u8 pad;
|
||
|
+ /* 1 => Companding; 2 => Delta (recommended); 3 => Combined (for HDR) */
|
||
|
+ u8 mode;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_decompress_config {
|
||
|
+ /* value added to reconstructed data */
|
||
|
+ u16 offset;
|
||
|
+ u8 pad;
|
||
|
+ /* 1 => Companding; 2 => Delta (recommended); 3 => Combined (for HDR) */
|
||
|
+ u8 mode;
|
||
|
+};
|
||
|
+
|
||
|
+enum pisp_axi_flags {
|
||
|
+ /*
|
||
|
+ * round down bursts to end at a 32-byte boundary, to align following
|
||
|
+ * bursts
|
||
|
+ */
|
||
|
+ PISP_AXI_FLAG_ALIGN = 128,
|
||
|
+ /* for FE writer: force WSTRB high, to pad output to 16-byte boundary */
|
||
|
+ PISP_AXI_FLAG_PAD = 64,
|
||
|
+ /* for FE writer: Use Output FIFO level to trigger "panic" */
|
||
|
+ PISP_AXI_FLAG_PANIC = 32,
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_axi_config {
|
||
|
+ /*
|
||
|
+ * burst length minus one, which must be in the range 0:15; OR'd with
|
||
|
+ * flags
|
||
|
+ */
|
||
|
+ u8 maxlen_flags;
|
||
|
+ /* { prot[2:0], cache[3:0] } fields, echoed on AXI bus */
|
||
|
+ u8 cache_prot;
|
||
|
+ /* QoS field(s) (4x4 bits for FE writer; 4 bits for other masters) */
|
||
|
+ u16 qos;
|
||
|
+};
|
||
|
+
|
||
|
+#endif /* _PISP_COMMON_H_ */
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/pisp_fe.c
|
||
|
@@ -0,0 +1,563 @@
|
||
|
+// SPDX-License-Identifier: GPL-2.0
|
||
|
+/*
|
||
|
+ * PiSP Front End driver.
|
||
|
+ * Copyright (c) 2021 Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+
|
||
|
+#include <linux/bitops.h>
|
||
|
+#include <linux/delay.h>
|
||
|
+#include <linux/moduleparam.h>
|
||
|
+#include <linux/pm_runtime.h>
|
||
|
+#include <linux/seq_file.h>
|
||
|
+
|
||
|
+#include <media/videobuf2-dma-contig.h>
|
||
|
+
|
||
|
+#include "pisp_fe.h"
|
||
|
+#include "cfe.h"
|
||
|
+
|
||
|
+#define FE_VERSION 0x000
|
||
|
+#define FE_CONTROL 0x004
|
||
|
+#define FE_STATUS 0x008
|
||
|
+#define FE_FRAME_STATUS 0x00c
|
||
|
+#define FE_ERROR_STATUS 0x010
|
||
|
+#define FE_OUTPUT_STATUS 0x014
|
||
|
+#define FE_INT_EN 0x018
|
||
|
+#define FE_INT_STATUS 0x01c
|
||
|
+
|
||
|
+/* CONTROL */
|
||
|
+#define FE_CONTROL_QUEUE BIT(0)
|
||
|
+#define FE_CONTROL_ABORT BIT(1)
|
||
|
+#define FE_CONTROL_RESET BIT(2)
|
||
|
+#define FE_CONTROL_LATCH_REGS BIT(3)
|
||
|
+
|
||
|
+/* INT_EN / INT_STATUS */
|
||
|
+#define FE_INT_EOF BIT(0)
|
||
|
+#define FE_INT_SOF BIT(1)
|
||
|
+#define FE_INT_LINES0 BIT(8)
|
||
|
+#define FE_INT_LINES1 BIT(9)
|
||
|
+#define FE_INT_STATS BIT(16)
|
||
|
+#define FE_INT_QREADY BIT(24)
|
||
|
+
|
||
|
+/* STATUS */
|
||
|
+#define FE_STATUS_QUEUED BIT(0)
|
||
|
+#define FE_STATUS_WAITING BIT(1)
|
||
|
+#define FE_STATUS_ACTIVE BIT(2)
|
||
|
+
|
||
|
+#define PISP_FE_CONFIG_BASE_OFFSET 0x0040
|
||
|
+
|
||
|
+#define PISP_FE_ENABLE_STATS_CLUSTER \
|
||
|
+ (PISP_FE_ENABLE_STATS_CROP | PISP_FE_ENABLE_DECIMATE | \
|
||
|
+ PISP_FE_ENABLE_BLC | PISP_FE_ENABLE_CDAF_STATS | \
|
||
|
+ PISP_FE_ENABLE_AWB_STATS | PISP_FE_ENABLE_RGBY | \
|
||
|
+ PISP_FE_ENABLE_LSC | PISP_FE_ENABLE_AGC_STATS)
|
||
|
+
|
||
|
+#define PISP_FE_ENABLE_OUTPUT_CLUSTER(i) \
|
||
|
+ ((PISP_FE_ENABLE_CROP0 | PISP_FE_ENABLE_DOWNSCALE0 | \
|
||
|
+ PISP_FE_ENABLE_COMPRESS0 | PISP_FE_ENABLE_OUTPUT0) << (4 * (i)))
|
||
|
+
|
||
|
+struct pisp_fe_config_param {
|
||
|
+ u32 dirty_flags;
|
||
|
+ u32 dirty_flags_extra;
|
||
|
+ size_t offset;
|
||
|
+ size_t size;
|
||
|
+};
|
||
|
+
|
||
|
+static const struct pisp_fe_config_param pisp_fe_config_map[] = {
|
||
|
+ /* *_dirty_flag_extra types */
|
||
|
+ { 0, PISP_FE_DIRTY_GLOBAL, offsetof(struct pisp_fe_config, global),
|
||
|
+ sizeof(struct pisp_fe_global_config) },
|
||
|
+ { 0, PISP_FE_DIRTY_FLOATING, offsetof(struct pisp_fe_config, floating_stats),
|
||
|
+ sizeof(struct pisp_fe_floating_stats_config) },
|
||
|
+ { 0, PISP_FE_DIRTY_OUTPUT_AXI, offsetof(struct pisp_fe_config, output_axi),
|
||
|
+ sizeof(struct pisp_fe_output_axi_config) },
|
||
|
+ /* *_dirty_flag types */
|
||
|
+ { PISP_FE_ENABLE_INPUT, 0, offsetof(struct pisp_fe_config, input),
|
||
|
+ sizeof(struct pisp_fe_input_config) },
|
||
|
+ { PISP_FE_ENABLE_DECOMPRESS, 0, offsetof(struct pisp_fe_config, decompress),
|
||
|
+ sizeof(struct pisp_decompress_config) },
|
||
|
+ { PISP_FE_ENABLE_DECOMPAND, 0, offsetof(struct pisp_fe_config, decompand),
|
||
|
+ sizeof(struct pisp_fe_decompand_config) },
|
||
|
+ { PISP_FE_ENABLE_BLA, 0, offsetof(struct pisp_fe_config, bla),
|
||
|
+ sizeof(struct pisp_bla_config) },
|
||
|
+ { PISP_FE_ENABLE_DPC, 0, offsetof(struct pisp_fe_config, dpc),
|
||
|
+ sizeof(struct pisp_fe_dpc_config) },
|
||
|
+ { PISP_FE_ENABLE_STATS_CROP, 0, offsetof(struct pisp_fe_config, stats_crop),
|
||
|
+ sizeof(struct pisp_fe_crop_config) },
|
||
|
+ { PISP_FE_ENABLE_BLC, 0, offsetof(struct pisp_fe_config, blc),
|
||
|
+ sizeof(struct pisp_bla_config) },
|
||
|
+ { PISP_FE_ENABLE_CDAF_STATS, 0, offsetof(struct pisp_fe_config, cdaf_stats),
|
||
|
+ sizeof(struct pisp_fe_cdaf_stats_config) },
|
||
|
+ { PISP_FE_ENABLE_AWB_STATS, 0, offsetof(struct pisp_fe_config, awb_stats),
|
||
|
+ sizeof(struct pisp_fe_awb_stats_config) },
|
||
|
+ { PISP_FE_ENABLE_RGBY, 0, offsetof(struct pisp_fe_config, rgby),
|
||
|
+ sizeof(struct pisp_fe_rgby_config) },
|
||
|
+ { PISP_FE_ENABLE_LSC, 0, offsetof(struct pisp_fe_config, lsc),
|
||
|
+ sizeof(struct pisp_fe_lsc_config) },
|
||
|
+ { PISP_FE_ENABLE_AGC_STATS, 0, offsetof(struct pisp_fe_config, agc_stats),
|
||
|
+ sizeof(struct pisp_agc_statistics) },
|
||
|
+ { PISP_FE_ENABLE_CROP0, 0, offsetof(struct pisp_fe_config, ch[0].crop),
|
||
|
+ sizeof(struct pisp_fe_crop_config) },
|
||
|
+ { PISP_FE_ENABLE_DOWNSCALE0, 0, offsetof(struct pisp_fe_config, ch[0].downscale),
|
||
|
+ sizeof(struct pisp_fe_downscale_config) },
|
||
|
+ { PISP_FE_ENABLE_COMPRESS0, 0, offsetof(struct pisp_fe_config, ch[0].compress),
|
||
|
+ sizeof(struct pisp_compress_config) },
|
||
|
+ { PISP_FE_ENABLE_OUTPUT0, 0, offsetof(struct pisp_fe_config, ch[0].output),
|
||
|
+ sizeof(struct pisp_fe_output_config) },
|
||
|
+ { PISP_FE_ENABLE_CROP1, 0, offsetof(struct pisp_fe_config, ch[1].crop),
|
||
|
+ sizeof(struct pisp_fe_crop_config) },
|
||
|
+ { PISP_FE_ENABLE_DOWNSCALE1, 0, offsetof(struct pisp_fe_config, ch[1].downscale),
|
||
|
+ sizeof(struct pisp_fe_downscale_config) },
|
||
|
+ { PISP_FE_ENABLE_COMPRESS1, 0, offsetof(struct pisp_fe_config, ch[1].compress),
|
||
|
+ sizeof(struct pisp_compress_config) },
|
||
|
+ { PISP_FE_ENABLE_OUTPUT1, 0, offsetof(struct pisp_fe_config, ch[1].output),
|
||
|
+ sizeof(struct pisp_fe_output_config) },
|
||
|
+};
|
||
|
+
|
||
|
+#define pisp_fe_dbg_irq(fmt, arg...) \
|
||
|
+ do { \
|
||
|
+ if (cfe_debug_irq) \
|
||
|
+ dev_dbg(fe->v4l2_dev->dev, fmt, ##arg); \
|
||
|
+ } while (0)
|
||
|
+#define pisp_fe_dbg(fmt, arg...) dev_dbg(fe->v4l2_dev->dev, fmt, ##arg)
|
||
|
+#define pisp_fe_info(fmt, arg...) dev_info(fe->v4l2_dev->dev, fmt, ##arg)
|
||
|
+#define pisp_fe_err(fmt, arg...) dev_err(fe->v4l2_dev->dev, fmt, ##arg)
|
||
|
+
|
||
|
+static inline u32 pisp_fe_reg_read(struct pisp_fe_device *fe, u32 offset)
|
||
|
+{
|
||
|
+ return readl(fe->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static inline void pisp_fe_reg_write(struct pisp_fe_device *fe, u32 offset,
|
||
|
+ u32 val)
|
||
|
+{
|
||
|
+ writel(val, fe->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static inline void pisp_fe_reg_write_relaxed(struct pisp_fe_device *fe, u32 offset,
|
||
|
+ u32 val)
|
||
|
+{
|
||
|
+ writel_relaxed(val, fe->base + offset);
|
||
|
+}
|
||
|
+
|
||
|
+static int pisp_regs_show(struct seq_file *s, void *data)
|
||
|
+{
|
||
|
+ struct pisp_fe_device *fe = s->private;
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ ret = pm_runtime_resume_and_get(fe->v4l2_dev->dev);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ pisp_fe_reg_write(fe, FE_CONTROL, FE_CONTROL_LATCH_REGS);
|
||
|
+
|
||
|
+#define DUMP(reg) seq_printf(s, #reg " \t0x%08x\n", pisp_fe_reg_read(fe, reg))
|
||
|
+ DUMP(FE_VERSION);
|
||
|
+ DUMP(FE_CONTROL);
|
||
|
+ DUMP(FE_STATUS);
|
||
|
+ DUMP(FE_FRAME_STATUS);
|
||
|
+ DUMP(FE_ERROR_STATUS);
|
||
|
+ DUMP(FE_OUTPUT_STATUS);
|
||
|
+ DUMP(FE_INT_EN);
|
||
|
+ DUMP(FE_INT_STATUS);
|
||
|
+#undef DUMP
|
||
|
+
|
||
|
+ pm_runtime_put(fe->v4l2_dev->dev);
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+DEFINE_SHOW_ATTRIBUTE(pisp_regs);
|
||
|
+
|
||
|
+static void pisp_config_write(struct pisp_fe_device *fe,
|
||
|
+ struct pisp_fe_config *config,
|
||
|
+ unsigned int start_offset,
|
||
|
+ unsigned int size)
|
||
|
+{
|
||
|
+ const unsigned int max_offset =
|
||
|
+ offsetof(struct pisp_fe_config, ch[PISP_FE_NUM_OUTPUTS]);
|
||
|
+ unsigned int i, end_offset;
|
||
|
+ u32 *cfg = (u32 *)config;
|
||
|
+
|
||
|
+ start_offset = min(start_offset, max_offset);
|
||
|
+ end_offset = min(start_offset + size, max_offset);
|
||
|
+
|
||
|
+ cfg += start_offset >> 2;
|
||
|
+ for (i = start_offset; i < end_offset; i += 4, cfg++)
|
||
|
+ pisp_fe_reg_write_relaxed(fe, PISP_FE_CONFIG_BASE_OFFSET + i,
|
||
|
+ *cfg);
|
||
|
+}
|
||
|
+
|
||
|
+void pisp_fe_isr(struct pisp_fe_device *fe, bool *sof, bool *eof)
|
||
|
+{
|
||
|
+ u32 status, int_status, out_status, frame_status, error_status;
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ pisp_fe_reg_write(fe, FE_CONTROL, FE_CONTROL_LATCH_REGS);
|
||
|
+ status = pisp_fe_reg_read(fe, FE_STATUS);
|
||
|
+ out_status = pisp_fe_reg_read(fe, FE_OUTPUT_STATUS);
|
||
|
+ frame_status = pisp_fe_reg_read(fe, FE_FRAME_STATUS);
|
||
|
+ error_status = pisp_fe_reg_read(fe, FE_ERROR_STATUS);
|
||
|
+
|
||
|
+ int_status = pisp_fe_reg_read(fe, FE_INT_STATUS);
|
||
|
+ pisp_fe_reg_write(fe, FE_INT_STATUS, int_status);
|
||
|
+
|
||
|
+ pisp_fe_dbg_irq("%s: status 0x%x out 0x%x frame 0x%x error 0x%x int 0x%x\n",
|
||
|
+ __func__, status, out_status, frame_status, error_status,
|
||
|
+ int_status);
|
||
|
+
|
||
|
+ /* We do not report interrupts for the input/stream pad. */
|
||
|
+ for (i = 0; i < FE_NUM_PADS - 1; i++) {
|
||
|
+ sof[i] = !!(int_status & FE_INT_SOF);
|
||
|
+ eof[i] = !!(int_status & FE_INT_EOF);
|
||
|
+ }
|
||
|
+}
|
||
|
+
|
||
|
+static bool pisp_fe_validate_output(struct pisp_fe_config const *cfg,
|
||
|
+ unsigned int c, struct v4l2_format const *f)
|
||
|
+{
|
||
|
+ unsigned int wbytes;
|
||
|
+
|
||
|
+ wbytes = cfg->ch[c].output.format.width;
|
||
|
+ if (cfg->ch[c].output.format.format & PISP_IMAGE_FORMAT_BPS_MASK)
|
||
|
+ wbytes *= 2;
|
||
|
+
|
||
|
+ /* Check output image dimensions are nonzero and not too big */
|
||
|
+ if (cfg->ch[c].output.format.width < 2 ||
|
||
|
+ cfg->ch[c].output.format.height < 2 ||
|
||
|
+ cfg->ch[c].output.format.height > f->fmt.pix.height ||
|
||
|
+ cfg->ch[c].output.format.stride > f->fmt.pix.bytesperline ||
|
||
|
+ wbytes > f->fmt.pix.bytesperline)
|
||
|
+ return false;
|
||
|
+
|
||
|
+ /* Check for zero-sized crops, which could cause lockup */
|
||
|
+ if ((cfg->global.enables & PISP_FE_ENABLE_CROP(c)) &&
|
||
|
+ ((cfg->ch[c].crop.offset_x >= (cfg->input.format.width & ~1) ||
|
||
|
+ cfg->ch[c].crop.offset_y >= cfg->input.format.height ||
|
||
|
+ cfg->ch[c].crop.width < 2 ||
|
||
|
+ cfg->ch[c].crop.height < 2)))
|
||
|
+ return false;
|
||
|
+
|
||
|
+ if ((cfg->global.enables & PISP_FE_ENABLE_DOWNSCALE(c)) &&
|
||
|
+ (cfg->ch[c].downscale.output_width < 2 ||
|
||
|
+ cfg->ch[c].downscale.output_height < 2))
|
||
|
+ return false;
|
||
|
+
|
||
|
+ return true;
|
||
|
+}
|
||
|
+
|
||
|
+static bool pisp_fe_validate_stats(struct pisp_fe_config const *cfg)
|
||
|
+{
|
||
|
+ /* Check for zero-sized crop, which could cause lockup */
|
||
|
+ return (!(cfg->global.enables & PISP_FE_ENABLE_STATS_CROP) ||
|
||
|
+ (cfg->stats_crop.offset_x < (cfg->input.format.width & ~1) &&
|
||
|
+ cfg->stats_crop.offset_y < cfg->input.format.height &&
|
||
|
+ cfg->stats_crop.width >= 2 &&
|
||
|
+ cfg->stats_crop.height >= 2));
|
||
|
+}
|
||
|
+
|
||
|
+int pisp_fe_validate_config(struct pisp_fe_device *fe,
|
||
|
+ struct pisp_fe_config *cfg,
|
||
|
+ struct v4l2_format const *f0,
|
||
|
+ struct v4l2_format const *f1)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Check the input is enabled, streaming and has nonzero size;
|
||
|
+ * to avoid cases where the hardware might lock up or try to
|
||
|
+ * read inputs from memory (which this driver doesn't support).
|
||
|
+ */
|
||
|
+ if (!(cfg->global.enables & PISP_FE_ENABLE_INPUT) ||
|
||
|
+ cfg->input.streaming != 1 || cfg->input.format.width < 2 ||
|
||
|
+ cfg->input.format.height < 2) {
|
||
|
+ pisp_fe_err("%s: Input config not valid", __func__);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ for (i = 0; i < PISP_FE_NUM_OUTPUTS; i++) {
|
||
|
+ if (!(cfg->global.enables & PISP_FE_ENABLE_OUTPUT(i))) {
|
||
|
+ if (cfg->global.enables &
|
||
|
+ PISP_FE_ENABLE_OUTPUT_CLUSTER(i)) {
|
||
|
+ pisp_fe_err("%s: Output %u not valid",
|
||
|
+ __func__, i);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+ continue;
|
||
|
+ }
|
||
|
+
|
||
|
+ if (!pisp_fe_validate_output(cfg, i, i ? f1 : f0))
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ if ((cfg->global.enables & PISP_FE_ENABLE_STATS_CLUSTER) &&
|
||
|
+ !pisp_fe_validate_stats(cfg)) {
|
||
|
+ pisp_fe_err("%s: Stats config not valid", __func__);
|
||
|
+ return -EINVAL;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+void pisp_fe_submit_job(struct pisp_fe_device *fe, struct vb2_buffer **vb2_bufs,
|
||
|
+ struct pisp_fe_config *cfg)
|
||
|
+{
|
||
|
+ unsigned int i;
|
||
|
+ u64 addr;
|
||
|
+ u32 status;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Check output buffers exist and outputs are correctly configured.
|
||
|
+ * If valid, set the buffer's DMA address; otherwise disable.
|
||
|
+ */
|
||
|
+ for (i = 0; i < PISP_FE_NUM_OUTPUTS; i++) {
|
||
|
+ struct vb2_buffer *buf = vb2_bufs[FE_OUTPUT0_PAD + i];
|
||
|
+
|
||
|
+ if (!(cfg->global.enables & PISP_FE_ENABLE_OUTPUT(i)))
|
||
|
+ continue;
|
||
|
+
|
||
|
+ addr = vb2_dma_contig_plane_dma_addr(buf, 0);
|
||
|
+ cfg->output_buffer[i].addr_lo = addr & 0xffffffff;
|
||
|
+ cfg->output_buffer[i].addr_hi = addr >> 32;
|
||
|
+ }
|
||
|
+
|
||
|
+ if (vb2_bufs[FE_STATS_PAD]) {
|
||
|
+ addr = vb2_dma_contig_plane_dma_addr(vb2_bufs[FE_STATS_PAD], 0);
|
||
|
+ cfg->stats_buffer.addr_lo = addr & 0xffffffff;
|
||
|
+ cfg->stats_buffer.addr_hi = addr >> 32;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* Set up ILINES interrupts 3/4 of the way down each output */
|
||
|
+ cfg->ch[0].output.ilines =
|
||
|
+ max(0x80u, (3u * cfg->ch[0].output.format.height) >> 2);
|
||
|
+ cfg->ch[1].output.ilines =
|
||
|
+ max(0x80u, (3u * cfg->ch[1].output.format.height) >> 2);
|
||
|
+
|
||
|
+ /*
|
||
|
+ * The hardware must have consumed the previous config by now.
|
||
|
+ * This read of status also serves as a memory barrier before the
|
||
|
+ * sequence of relaxed writes which follow.
|
||
|
+ */
|
||
|
+ status = pisp_fe_reg_read(fe, FE_STATUS);
|
||
|
+ pisp_fe_dbg_irq("%s: status = 0x%x\n", __func__, status);
|
||
|
+ if (WARN_ON(status & FE_STATUS_QUEUED))
|
||
|
+ return;
|
||
|
+
|
||
|
+ /*
|
||
|
+ * Unconditionally write buffers, global and input parameters.
|
||
|
+ * Write cropping and output parameters whenever they are enabled.
|
||
|
+ * Selectively write other parameters that have been marked as
|
||
|
+ * changed through the dirty flags.
|
||
|
+ */
|
||
|
+ pisp_config_write(fe, cfg, 0,
|
||
|
+ offsetof(struct pisp_fe_config, decompress));
|
||
|
+ cfg->dirty_flags_extra &= ~PISP_FE_DIRTY_GLOBAL;
|
||
|
+ cfg->dirty_flags &= ~PISP_FE_ENABLE_INPUT;
|
||
|
+ cfg->dirty_flags |= (cfg->global.enables &
|
||
|
+ (PISP_FE_ENABLE_STATS_CROP |
|
||
|
+ PISP_FE_ENABLE_OUTPUT_CLUSTER(0) |
|
||
|
+ PISP_FE_ENABLE_OUTPUT_CLUSTER(1)));
|
||
|
+ for (i = 0; i < ARRAY_SIZE(pisp_fe_config_map); i++) {
|
||
|
+ const struct pisp_fe_config_param *p = &pisp_fe_config_map[i];
|
||
|
+
|
||
|
+ if (cfg->dirty_flags & p->dirty_flags ||
|
||
|
+ cfg->dirty_flags_extra & p->dirty_flags_extra)
|
||
|
+ pisp_config_write(fe, cfg, p->offset, p->size);
|
||
|
+ }
|
||
|
+
|
||
|
+ /* This final non-relaxed write serves as a memory barrier */
|
||
|
+ pisp_fe_reg_write(fe, FE_CONTROL, FE_CONTROL_QUEUE);
|
||
|
+}
|
||
|
+
|
||
|
+void pisp_fe_start(struct pisp_fe_device *fe)
|
||
|
+{
|
||
|
+ pisp_fe_reg_write(fe, FE_CONTROL, FE_CONTROL_RESET);
|
||
|
+ pisp_fe_reg_write(fe, FE_INT_STATUS, -1);
|
||
|
+ pisp_fe_reg_write(fe, FE_INT_EN, FE_INT_EOF | FE_INT_SOF | FE_INT_LINES0 | FE_INT_LINES1);
|
||
|
+ fe->inframe_count = 0;
|
||
|
+}
|
||
|
+
|
||
|
+void pisp_fe_stop(struct pisp_fe_device *fe)
|
||
|
+{
|
||
|
+ pisp_fe_reg_write(fe, FE_INT_EN, 0);
|
||
|
+ pisp_fe_reg_write(fe, FE_CONTROL, FE_CONTROL_ABORT);
|
||
|
+ usleep_range(1000, 2000);
|
||
|
+ WARN_ON(pisp_fe_reg_read(fe, FE_STATUS));
|
||
|
+ pisp_fe_reg_write(fe, FE_INT_STATUS, -1);
|
||
|
+}
|
||
|
+
|
||
|
+static struct pisp_fe_device *to_pisp_fe_device(struct v4l2_subdev *subdev)
|
||
|
+{
|
||
|
+ return container_of(subdev, struct pisp_fe_device, sd);
|
||
|
+}
|
||
|
+
|
||
|
+static int pisp_fe_init_cfg(struct v4l2_subdev *sd,
|
||
|
+ struct v4l2_subdev_state *state)
|
||
|
+{
|
||
|
+ struct v4l2_mbus_framefmt *fmt;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, FE_STREAM_PAD);
|
||
|
+ *fmt = cfe_default_format;
|
||
|
+ fmt->code = MEDIA_BUS_FMT_SRGGB16_1X16;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, FE_CONFIG_PAD);
|
||
|
+ *fmt = cfe_default_meta_format;
|
||
|
+ fmt->code = MEDIA_BUS_FMT_PISP_FE_CONFIG;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, FE_OUTPUT0_PAD);
|
||
|
+ *fmt = cfe_default_format;
|
||
|
+ fmt->code = MEDIA_BUS_FMT_SRGGB16_1X16;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, FE_OUTPUT1_PAD);
|
||
|
+ *fmt = cfe_default_format;
|
||
|
+ fmt->code = MEDIA_BUS_FMT_SRGGB16_1X16;
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, FE_STATS_PAD);
|
||
|
+ *fmt = cfe_default_meta_format;
|
||
|
+ fmt->code = MEDIA_BUS_FMT_PISP_FE_STATS;
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int pisp_fe_pad_set_fmt(struct v4l2_subdev *sd,
|
||
|
+ struct v4l2_subdev_state *state,
|
||
|
+ struct v4l2_subdev_format *format)
|
||
|
+{
|
||
|
+ struct v4l2_mbus_framefmt *fmt;
|
||
|
+ const struct cfe_fmt *cfe_fmt;
|
||
|
+
|
||
|
+ /* TODO: format propagation to source pads */
|
||
|
+ /* TODO: format validation */
|
||
|
+
|
||
|
+ switch (format->pad) {
|
||
|
+ case FE_STREAM_PAD:
|
||
|
+ case FE_OUTPUT0_PAD:
|
||
|
+ case FE_OUTPUT1_PAD:
|
||
|
+ cfe_fmt = find_format_by_code(format->format.code);
|
||
|
+ if (!cfe_fmt || !(cfe_fmt->flags & CFE_FORMAT_FLAG_FE_OUT))
|
||
|
+ cfe_fmt = find_format_by_code(MEDIA_BUS_FMT_SBGGR10_1X10);
|
||
|
+
|
||
|
+ format->format.code = cfe_fmt->code;
|
||
|
+
|
||
|
+ break;
|
||
|
+
|
||
|
+ case FE_CONFIG_PAD:
|
||
|
+ format->format.code = MEDIA_BUS_FMT_PISP_FE_CONFIG;
|
||
|
+ break;
|
||
|
+
|
||
|
+ case FE_STATS_PAD:
|
||
|
+ format->format.code = MEDIA_BUS_FMT_PISP_FE_STATS;
|
||
|
+ break;
|
||
|
+ }
|
||
|
+
|
||
|
+ fmt = v4l2_subdev_get_pad_format(sd, state, format->pad);
|
||
|
+ *fmt = format->format;
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static int pisp_fe_link_validate(struct v4l2_subdev *sd,
|
||
|
+ struct media_link *link,
|
||
|
+ struct v4l2_subdev_format *source_fmt,
|
||
|
+ struct v4l2_subdev_format *sink_fmt)
|
||
|
+{
|
||
|
+ struct pisp_fe_device *fe = to_pisp_fe_device(sd);
|
||
|
+
|
||
|
+ pisp_fe_dbg("%s: link \"%s\":%u -> \"%s\":%u\n", __func__,
|
||
|
+ link->source->entity->name, link->source->index,
|
||
|
+ link->sink->entity->name, link->sink->index);
|
||
|
+
|
||
|
+ /* The width, height and code must match. */
|
||
|
+ if (source_fmt->format.width != sink_fmt->format.width ||
|
||
|
+ source_fmt->format.width != sink_fmt->format.width ||
|
||
|
+ source_fmt->format.code != sink_fmt->format.code) {
|
||
|
+ pisp_fe_err("%s: format does not match (source %ux%u 0x%x, sink %ux%u 0x%x)\n",
|
||
|
+ __func__,
|
||
|
+ source_fmt->format.width,
|
||
|
+ source_fmt->format.height,
|
||
|
+ source_fmt->format.code,
|
||
|
+ sink_fmt->format.width,
|
||
|
+ sink_fmt->format.height,
|
||
|
+ sink_fmt->format.code);
|
||
|
+ return -EPIPE;
|
||
|
+ }
|
||
|
+
|
||
|
+ return 0;
|
||
|
+}
|
||
|
+
|
||
|
+static const struct v4l2_subdev_pad_ops pisp_fe_subdev_pad_ops = {
|
||
|
+ .init_cfg = pisp_fe_init_cfg,
|
||
|
+ .get_fmt = v4l2_subdev_get_fmt,
|
||
|
+ .set_fmt = pisp_fe_pad_set_fmt,
|
||
|
+ .link_validate = pisp_fe_link_validate,
|
||
|
+};
|
||
|
+
|
||
|
+static const struct media_entity_operations pisp_fe_entity_ops = {
|
||
|
+ .link_validate = v4l2_subdev_link_validate,
|
||
|
+};
|
||
|
+
|
||
|
+static const struct v4l2_subdev_ops pisp_fe_subdev_ops = {
|
||
|
+ .pad = &pisp_fe_subdev_pad_ops,
|
||
|
+};
|
||
|
+
|
||
|
+int pisp_fe_init(struct pisp_fe_device *fe, struct dentry *debugfs)
|
||
|
+{
|
||
|
+ int ret;
|
||
|
+
|
||
|
+ debugfs_create_file("pisp_regs", 0444, debugfs, fe, &pisp_regs_fops);
|
||
|
+
|
||
|
+ fe->hw_revision = pisp_fe_reg_read(fe, FE_VERSION);
|
||
|
+ pisp_fe_info("PiSP FE HW v%u.%u\n",
|
||
|
+ (fe->hw_revision >> 24) & 0xff,
|
||
|
+ (fe->hw_revision >> 20) & 0x0f);
|
||
|
+
|
||
|
+ fe->pad[FE_STREAM_PAD].flags =
|
||
|
+ MEDIA_PAD_FL_SINK | MEDIA_PAD_FL_MUST_CONNECT;
|
||
|
+ fe->pad[FE_CONFIG_PAD].flags = MEDIA_PAD_FL_SINK;
|
||
|
+ fe->pad[FE_OUTPUT0_PAD].flags = MEDIA_PAD_FL_SOURCE;
|
||
|
+ fe->pad[FE_OUTPUT1_PAD].flags = MEDIA_PAD_FL_SOURCE;
|
||
|
+ fe->pad[FE_STATS_PAD].flags = MEDIA_PAD_FL_SOURCE;
|
||
|
+
|
||
|
+ ret = media_entity_pads_init(&fe->sd.entity, ARRAY_SIZE(fe->pad),
|
||
|
+ fe->pad);
|
||
|
+ if (ret)
|
||
|
+ return ret;
|
||
|
+
|
||
|
+ /* Initialize subdev */
|
||
|
+ v4l2_subdev_init(&fe->sd, &pisp_fe_subdev_ops);
|
||
|
+ fe->sd.entity.function = MEDIA_ENT_F_PROC_VIDEO_SCALER;
|
||
|
+ fe->sd.entity.ops = &pisp_fe_entity_ops;
|
||
|
+ fe->sd.entity.name = "pisp-fe";
|
||
|
+ fe->sd.flags = V4L2_SUBDEV_FL_HAS_DEVNODE;
|
||
|
+ fe->sd.owner = THIS_MODULE;
|
||
|
+ snprintf(fe->sd.name, sizeof(fe->sd.name), "pisp-fe");
|
||
|
+
|
||
|
+ ret = v4l2_subdev_init_finalize(&fe->sd);
|
||
|
+ if (ret)
|
||
|
+ goto err_entity_cleanup;
|
||
|
+
|
||
|
+ ret = v4l2_device_register_subdev(fe->v4l2_dev, &fe->sd);
|
||
|
+ if (ret) {
|
||
|
+ pisp_fe_err("Failed register pisp fe subdev (%d)\n", ret);
|
||
|
+ goto err_subdev_cleanup;
|
||
|
+ }
|
||
|
+
|
||
|
+ /* Must be in IDLE state (STATUS == 0) here. */
|
||
|
+ WARN_ON(pisp_fe_reg_read(fe, FE_STATUS));
|
||
|
+
|
||
|
+ return 0;
|
||
|
+
|
||
|
+err_subdev_cleanup:
|
||
|
+ v4l2_subdev_cleanup(&fe->sd);
|
||
|
+err_entity_cleanup:
|
||
|
+ media_entity_cleanup(&fe->sd.entity);
|
||
|
+
|
||
|
+ return ret;
|
||
|
+}
|
||
|
+
|
||
|
+void pisp_fe_uninit(struct pisp_fe_device *fe)
|
||
|
+{
|
||
|
+ v4l2_device_unregister_subdev(&fe->sd);
|
||
|
+ v4l2_subdev_cleanup(&fe->sd);
|
||
|
+ media_entity_cleanup(&fe->sd.entity);
|
||
|
+}
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/pisp_fe.h
|
||
|
@@ -0,0 +1,53 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * PiSP Front End driver.
|
||
|
+ * Copyright (c) 2021 Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _PISP_FE_H_
|
||
|
+#define _PISP_FE_H_
|
||
|
+
|
||
|
+#include <linux/debugfs.h>
|
||
|
+#include <linux/io.h>
|
||
|
+#include <linux/types.h>
|
||
|
+#include <linux/videodev2.h>
|
||
|
+
|
||
|
+#include <media/media-device.h>
|
||
|
+#include <media/v4l2-device.h>
|
||
|
+#include <media/v4l2-subdev.h>
|
||
|
+
|
||
|
+#include "pisp_fe_config.h"
|
||
|
+
|
||
|
+enum pisp_fe_pads {
|
||
|
+ FE_STREAM_PAD,
|
||
|
+ FE_CONFIG_PAD,
|
||
|
+ FE_OUTPUT0_PAD,
|
||
|
+ FE_OUTPUT1_PAD,
|
||
|
+ FE_STATS_PAD,
|
||
|
+ FE_NUM_PADS
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_device {
|
||
|
+ /* Parent V4l2 device */
|
||
|
+ struct v4l2_device *v4l2_dev;
|
||
|
+ void __iomem *base;
|
||
|
+ u32 hw_revision;
|
||
|
+
|
||
|
+ u16 inframe_count;
|
||
|
+ struct media_pad pad[FE_NUM_PADS];
|
||
|
+ struct v4l2_subdev sd;
|
||
|
+};
|
||
|
+
|
||
|
+void pisp_fe_isr(struct pisp_fe_device *fe, bool *sof, bool *eof);
|
||
|
+int pisp_fe_validate_config(struct pisp_fe_device *fe,
|
||
|
+ struct pisp_fe_config *cfg,
|
||
|
+ struct v4l2_format const *f0,
|
||
|
+ struct v4l2_format const *f1);
|
||
|
+void pisp_fe_submit_job(struct pisp_fe_device *fe, struct vb2_buffer **vb2_bufs,
|
||
|
+ struct pisp_fe_config *cfg);
|
||
|
+void pisp_fe_start(struct pisp_fe_device *fe);
|
||
|
+void pisp_fe_stop(struct pisp_fe_device *fe);
|
||
|
+int pisp_fe_init(struct pisp_fe_device *fe, struct dentry *debugfs);
|
||
|
+void pisp_fe_uninit(struct pisp_fe_device *fe);
|
||
|
+
|
||
|
+#endif
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/pisp_fe_config.h
|
||
|
@@ -0,0 +1,272 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 PiSP Front End Driver Configuration structures
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _PISP_FE_CONFIG_
|
||
|
+#define _PISP_FE_CONFIG_
|
||
|
+
|
||
|
+#include <media/raspberrypi/pisp_common.h>
|
||
|
+
|
||
|
+#include "pisp_statistics.h"
|
||
|
+
|
||
|
+#define PISP_FE_NUM_OUTPUTS 2
|
||
|
+
|
||
|
+enum pisp_fe_enable {
|
||
|
+ PISP_FE_ENABLE_INPUT = 0x000001,
|
||
|
+ PISP_FE_ENABLE_DECOMPRESS = 0x000002,
|
||
|
+ PISP_FE_ENABLE_DECOMPAND = 0x000004,
|
||
|
+ PISP_FE_ENABLE_BLA = 0x000008,
|
||
|
+ PISP_FE_ENABLE_DPC = 0x000010,
|
||
|
+ PISP_FE_ENABLE_STATS_CROP = 0x000020,
|
||
|
+ PISP_FE_ENABLE_DECIMATE = 0x000040,
|
||
|
+ PISP_FE_ENABLE_BLC = 0x000080,
|
||
|
+ PISP_FE_ENABLE_CDAF_STATS = 0x000100,
|
||
|
+ PISP_FE_ENABLE_AWB_STATS = 0x000200,
|
||
|
+ PISP_FE_ENABLE_RGBY = 0x000400,
|
||
|
+ PISP_FE_ENABLE_LSC = 0x000800,
|
||
|
+ PISP_FE_ENABLE_AGC_STATS = 0x001000,
|
||
|
+ PISP_FE_ENABLE_CROP0 = 0x010000,
|
||
|
+ PISP_FE_ENABLE_DOWNSCALE0 = 0x020000,
|
||
|
+ PISP_FE_ENABLE_COMPRESS0 = 0x040000,
|
||
|
+ PISP_FE_ENABLE_OUTPUT0 = 0x080000,
|
||
|
+ PISP_FE_ENABLE_CROP1 = 0x100000,
|
||
|
+ PISP_FE_ENABLE_DOWNSCALE1 = 0x200000,
|
||
|
+ PISP_FE_ENABLE_COMPRESS1 = 0x400000,
|
||
|
+ PISP_FE_ENABLE_OUTPUT1 = 0x800000
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_FE_ENABLE_CROP(i) (PISP_FE_ENABLE_CROP0 << (4 * (i)))
|
||
|
+#define PISP_FE_ENABLE_DOWNSCALE(i) (PISP_FE_ENABLE_DOWNSCALE0 << (4 * (i)))
|
||
|
+#define PISP_FE_ENABLE_COMPRESS(i) (PISP_FE_ENABLE_COMPRESS0 << (4 * (i)))
|
||
|
+#define PISP_FE_ENABLE_OUTPUT(i) (PISP_FE_ENABLE_OUTPUT0 << (4 * (i)))
|
||
|
+
|
||
|
+/*
|
||
|
+ * We use the enable flags to show when blocks are "dirty", but we need some
|
||
|
+ * extra ones too.
|
||
|
+ */
|
||
|
+enum pisp_fe_dirty {
|
||
|
+ PISP_FE_DIRTY_GLOBAL = 0x0001,
|
||
|
+ PISP_FE_DIRTY_FLOATING = 0x0002,
|
||
|
+ PISP_FE_DIRTY_OUTPUT_AXI = 0x0004
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_global_config {
|
||
|
+ u32 enables;
|
||
|
+ u8 bayer_order;
|
||
|
+ u8 pad[3];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_input_axi_config {
|
||
|
+ /* burst length minus one, in the range 0..15; OR'd with flags */
|
||
|
+ u8 maxlen_flags;
|
||
|
+ /* { prot[2:0], cache[3:0] } fields */
|
||
|
+ u8 cache_prot;
|
||
|
+ /* QoS (only 4 LS bits are used) */
|
||
|
+ u16 qos;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_output_axi_config {
|
||
|
+ /* burst length minus one, in the range 0..15; OR'd with flags */
|
||
|
+ u8 maxlen_flags;
|
||
|
+ /* { prot[2:0], cache[3:0] } fields */
|
||
|
+ u8 cache_prot;
|
||
|
+ /* QoS (4 bitfields of 4 bits each for different panic levels) */
|
||
|
+ u16 qos;
|
||
|
+ /* For Panic mode: Output FIFO panic threshold */
|
||
|
+ u16 thresh;
|
||
|
+ /* For Panic mode: Output FIFO statistics throttle threshold */
|
||
|
+ u16 throttle;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_input_config {
|
||
|
+ u8 streaming;
|
||
|
+ u8 pad[3];
|
||
|
+ struct pisp_image_format_config format;
|
||
|
+ struct pisp_fe_input_axi_config axi;
|
||
|
+ /* Extra cycles delay before issuing each burst request */
|
||
|
+ u8 holdoff;
|
||
|
+ u8 pad2[3];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_output_config {
|
||
|
+ struct pisp_image_format_config format;
|
||
|
+ u16 ilines;
|
||
|
+ u8 pad[2];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_input_buffer_config {
|
||
|
+ u32 addr_lo;
|
||
|
+ u32 addr_hi;
|
||
|
+ u16 frame_id;
|
||
|
+ u16 pad;
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_FE_DECOMPAND_LUT_SIZE 65
|
||
|
+
|
||
|
+struct pisp_fe_decompand_config {
|
||
|
+ u16 lut[PISP_FE_DECOMPAND_LUT_SIZE];
|
||
|
+ u16 pad;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_dpc_config {
|
||
|
+ u8 coeff_level;
|
||
|
+ u8 coeff_range;
|
||
|
+ u8 coeff_range2;
|
||
|
+#define PISP_FE_DPC_FLAG_FOLDBACK 1
|
||
|
+#define PISP_FE_DPC_FLAG_VFLAG 2
|
||
|
+ u8 flags;
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_FE_LSC_LUT_SIZE 16
|
||
|
+
|
||
|
+struct pisp_fe_lsc_config {
|
||
|
+ u8 shift;
|
||
|
+ u8 pad0;
|
||
|
+ u16 scale;
|
||
|
+ u16 centre_x;
|
||
|
+ u16 centre_y;
|
||
|
+ u16 lut[PISP_FE_LSC_LUT_SIZE];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_rgby_config {
|
||
|
+ u16 gain_r;
|
||
|
+ u16 gain_g;
|
||
|
+ u16 gain_b;
|
||
|
+ u8 maxflag;
|
||
|
+ u8 pad;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_agc_stats_config {
|
||
|
+ u16 offset_x;
|
||
|
+ u16 offset_y;
|
||
|
+ u16 size_x;
|
||
|
+ u16 size_y;
|
||
|
+ /* each weight only 4 bits */
|
||
|
+ u8 weights[PISP_AGC_STATS_NUM_ZONES / 2];
|
||
|
+ u16 row_offset_x;
|
||
|
+ u16 row_offset_y;
|
||
|
+ u16 row_size_x;
|
||
|
+ u16 row_size_y;
|
||
|
+ u8 row_shift;
|
||
|
+ u8 float_shift;
|
||
|
+ u8 pad1[2];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_awb_stats_config {
|
||
|
+ u16 offset_x;
|
||
|
+ u16 offset_y;
|
||
|
+ u16 size_x;
|
||
|
+ u16 size_y;
|
||
|
+ u8 shift;
|
||
|
+ u8 pad[3];
|
||
|
+ u16 r_lo;
|
||
|
+ u16 r_hi;
|
||
|
+ u16 g_lo;
|
||
|
+ u16 g_hi;
|
||
|
+ u16 b_lo;
|
||
|
+ u16 b_hi;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_floating_stats_region {
|
||
|
+ u16 offset_x;
|
||
|
+ u16 offset_y;
|
||
|
+ u16 size_x;
|
||
|
+ u16 size_y;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_floating_stats_config {
|
||
|
+ struct pisp_fe_floating_stats_region
|
||
|
+ regions[PISP_FLOATING_STATS_NUM_ZONES];
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_FE_CDAF_NUM_WEIGHTS 8
|
||
|
+
|
||
|
+struct pisp_fe_cdaf_stats_config {
|
||
|
+ u16 noise_constant;
|
||
|
+ u16 noise_slope;
|
||
|
+ u16 offset_x;
|
||
|
+ u16 offset_y;
|
||
|
+ u16 size_x;
|
||
|
+ u16 size_y;
|
||
|
+ u16 skip_x;
|
||
|
+ u16 skip_y;
|
||
|
+ u32 mode;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_stats_buffer_config {
|
||
|
+ u32 addr_lo;
|
||
|
+ u32 addr_hi;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_crop_config {
|
||
|
+ u16 offset_x;
|
||
|
+ u16 offset_y;
|
||
|
+ u16 width;
|
||
|
+ u16 height;
|
||
|
+};
|
||
|
+
|
||
|
+enum pisp_fe_downscale_flags {
|
||
|
+ DOWNSCALE_BAYER =
|
||
|
+ 1, /* downscale the four Bayer components independently... */
|
||
|
+ DOWNSCALE_BIN =
|
||
|
+ 2 /* ...without trying to preserve their spatial relationship */
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_downscale_config {
|
||
|
+ u8 xin;
|
||
|
+ u8 xout;
|
||
|
+ u8 yin;
|
||
|
+ u8 yout;
|
||
|
+ u8 flags; /* enum pisp_fe_downscale_flags */
|
||
|
+ u8 pad[3];
|
||
|
+ u16 output_width;
|
||
|
+ u16 output_height;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_fe_output_buffer_config {
|
||
|
+ u32 addr_lo;
|
||
|
+ u32 addr_hi;
|
||
|
+};
|
||
|
+
|
||
|
+/* Each of the two output channels/branches: */
|
||
|
+struct pisp_fe_output_branch_config {
|
||
|
+ struct pisp_fe_crop_config crop;
|
||
|
+ struct pisp_fe_downscale_config downscale;
|
||
|
+ struct pisp_compress_config compress;
|
||
|
+ struct pisp_fe_output_config output;
|
||
|
+ u32 pad;
|
||
|
+};
|
||
|
+
|
||
|
+/* And finally one to rule them all: */
|
||
|
+struct pisp_fe_config {
|
||
|
+ /* I/O configuration: */
|
||
|
+ struct pisp_fe_stats_buffer_config stats_buffer;
|
||
|
+ struct pisp_fe_output_buffer_config output_buffer[PISP_FE_NUM_OUTPUTS];
|
||
|
+ struct pisp_fe_input_buffer_config input_buffer;
|
||
|
+ /* processing configuration: */
|
||
|
+ struct pisp_fe_global_config global;
|
||
|
+ struct pisp_fe_input_config input;
|
||
|
+ struct pisp_decompress_config decompress;
|
||
|
+ struct pisp_fe_decompand_config decompand;
|
||
|
+ struct pisp_bla_config bla;
|
||
|
+ struct pisp_fe_dpc_config dpc;
|
||
|
+ struct pisp_fe_crop_config stats_crop;
|
||
|
+ u32 spare1; /* placeholder for future decimate configuration */
|
||
|
+ struct pisp_bla_config blc;
|
||
|
+ struct pisp_fe_rgby_config rgby;
|
||
|
+ struct pisp_fe_lsc_config lsc;
|
||
|
+ struct pisp_fe_agc_stats_config agc_stats;
|
||
|
+ struct pisp_fe_awb_stats_config awb_stats;
|
||
|
+ struct pisp_fe_cdaf_stats_config cdaf_stats;
|
||
|
+ struct pisp_fe_floating_stats_config floating_stats;
|
||
|
+ struct pisp_fe_output_axi_config output_axi;
|
||
|
+ struct pisp_fe_output_branch_config ch[PISP_FE_NUM_OUTPUTS];
|
||
|
+ /* non-register fields: */
|
||
|
+ u32 dirty_flags; /* these use pisp_fe_enable */
|
||
|
+ u32 dirty_flags_extra; /* these use pisp_fe_dirty */
|
||
|
+};
|
||
|
+
|
||
|
+#endif /* _PISP_FE_CONFIG_ */
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/pisp_statistics.h
|
||
|
@@ -0,0 +1,62 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 PiSP Front End statistics definitions
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _PISP_FE_STATISTICS_H_
|
||
|
+#define _PISP_FE_STATISTICS_H_
|
||
|
+
|
||
|
+#define PISP_FLOATING_STATS_NUM_ZONES 4
|
||
|
+#define PISP_AGC_STATS_NUM_BINS 1024
|
||
|
+#define PISP_AGC_STATS_SIZE 16
|
||
|
+#define PISP_AGC_STATS_NUM_ZONES (PISP_AGC_STATS_SIZE * PISP_AGC_STATS_SIZE)
|
||
|
+#define PISP_AGC_STATS_NUM_ROW_SUMS 512
|
||
|
+
|
||
|
+struct pisp_agc_statistics_zone {
|
||
|
+ u64 Y_sum;
|
||
|
+ u32 counted;
|
||
|
+ u32 pad;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_agc_statistics {
|
||
|
+ u32 row_sums[PISP_AGC_STATS_NUM_ROW_SUMS];
|
||
|
+ /*
|
||
|
+ * 32-bits per bin means an image (just less than) 16384x16384 pixels
|
||
|
+ * in size can weight every pixel from 0 to 15.
|
||
|
+ */
|
||
|
+ u32 histogram[PISP_AGC_STATS_NUM_BINS];
|
||
|
+ struct pisp_agc_statistics_zone floating[PISP_FLOATING_STATS_NUM_ZONES];
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_AWB_STATS_SIZE 32
|
||
|
+#define PISP_AWB_STATS_NUM_ZONES (PISP_AWB_STATS_SIZE * PISP_AWB_STATS_SIZE)
|
||
|
+
|
||
|
+struct pisp_awb_statistics_zone {
|
||
|
+ u32 R_sum;
|
||
|
+ u32 G_sum;
|
||
|
+ u32 B_sum;
|
||
|
+ u32 counted;
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_awb_statistics {
|
||
|
+ struct pisp_awb_statistics_zone zones[PISP_AWB_STATS_NUM_ZONES];
|
||
|
+ struct pisp_awb_statistics_zone floating[PISP_FLOATING_STATS_NUM_ZONES];
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_CDAF_STATS_SIZE 8
|
||
|
+#define PISP_CDAF_STATS_NUM_FOMS (PISP_CDAF_STATS_SIZE * PISP_CDAF_STATS_SIZE)
|
||
|
+
|
||
|
+struct pisp_cdaf_statistics {
|
||
|
+ u64 foms[PISP_CDAF_STATS_NUM_FOMS];
|
||
|
+ u64 floating[PISP_FLOATING_STATS_NUM_ZONES];
|
||
|
+};
|
||
|
+
|
||
|
+struct pisp_statistics {
|
||
|
+ struct pisp_awb_statistics awb;
|
||
|
+ struct pisp_agc_statistics agc;
|
||
|
+ struct pisp_cdaf_statistics cdaf;
|
||
|
+};
|
||
|
+
|
||
|
+#endif /* _PISP_FE_STATISTICS_H_ */
|
||
|
--- /dev/null
|
||
|
+++ b/drivers/media/platform/raspberrypi/rp1_cfe/pisp_types.h
|
||
|
@@ -0,0 +1,144 @@
|
||
|
+/* SPDX-License-Identifier: GPL-2.0 */
|
||
|
+/*
|
||
|
+ * RP1 PiSP Front End image definitions.
|
||
|
+ *
|
||
|
+ * Copyright (C) 2021 - Raspberry Pi Ltd.
|
||
|
+ *
|
||
|
+ */
|
||
|
+#ifndef _PISP_FE_TYPES_H_
|
||
|
+#define _PISP_FE_TYPES_H_
|
||
|
+
|
||
|
+/* This definition must match the format description in the hardware exactly! */
|
||
|
+struct pisp_image_format_config {
|
||
|
+ /* size in pixels */
|
||
|
+ u16 width, height;
|
||
|
+ /* must match struct pisp_image_format below */
|
||
|
+ u32 format;
|
||
|
+ s32 stride;
|
||
|
+ /* some planar image formats will need a second stride */
|
||
|
+ s32 stride2;
|
||
|
+};
|
||
|
+
|
||
|
+static_assert(sizeof(struct pisp_image_format_config) == 16);
|
||
|
+
|
||
|
+enum pisp_bayer_order {
|
||
|
+ /*
|
||
|
+ * Note how bayer_order&1 tells you if G is on the even pixels of the
|
||
|
+ * checkerboard or not, and bayer_order&2 tells you if R is on the even
|
||
|
+ * rows or is swapped with B. Note that if the top (of the 8) bits is
|
||
|
+ * set, this denotes a monochrome or greyscale image, and the lower bits
|
||
|
+ * should all be ignored.
|
||
|
+ */
|
||
|
+ PISP_BAYER_ORDER_RGGB = 0,
|
||
|
+ PISP_BAYER_ORDER_GBRG = 1,
|
||
|
+ PISP_BAYER_ORDER_BGGR = 2,
|
||
|
+ PISP_BAYER_ORDER_GRBG = 3,
|
||
|
+ PISP_BAYER_ORDER_GREYSCALE = 128
|
||
|
+};
|
||
|
+
|
||
|
+enum pisp_image_format {
|
||
|
+ /*
|
||
|
+ * Precise values are mostly tbd. Generally these will be portmanteau
|
||
|
+ * values comprising bit fields and flags. This format must be shared
|
||
|
+ * throughout the PiSP.
|
||
|
+ */
|
||
|
+ PISP_IMAGE_FORMAT_BPS_8 = 0x00000000,
|
||
|
+ PISP_IMAGE_FORMAT_BPS_10 = 0x00000001,
|
||
|
+ PISP_IMAGE_FORMAT_BPS_12 = 0x00000002,
|
||
|
+ PISP_IMAGE_FORMAT_BPS_16 = 0x00000003,
|
||
|
+ PISP_IMAGE_FORMAT_BPS_MASK = 0x00000003,
|
||
|
+
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_INTERLEAVED = 0x00000000,
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_SEMI_PLANAR = 0x00000010,
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_PLANAR = 0x00000020,
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_MASK = 0x00000030,
|
||
|
+
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_444 = 0x00000000,
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_422 = 0x00000100,
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_420 = 0x00000200,
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_MASK = 0x00000300,
|
||
|
+
|
||
|
+ PISP_IMAGE_FORMAT_ORDER_NORMAL = 0x00000000,
|
||
|
+ PISP_IMAGE_FORMAT_ORDER_SWAPPED = 0x00001000,
|
||
|
+
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_0 = 0x00000000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_1 = 0x00010000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_2 = 0x00020000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_3 = 0x00030000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_4 = 0x00040000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_5 = 0x00050000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_6 = 0x00060000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_7 = 0x00070000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_8 = 0x00080000,
|
||
|
+ PISP_IMAGE_FORMAT_SHIFT_MASK = 0x000f0000,
|
||
|
+
|
||
|
+ PISP_IMAGE_FORMAT_UNCOMPRESSED = 0x00000000,
|
||
|
+ PISP_IMAGE_FORMAT_COMPRESSION_MODE_1 = 0x01000000,
|
||
|
+ PISP_IMAGE_FORMAT_COMPRESSION_MODE_2 = 0x02000000,
|
||
|
+ PISP_IMAGE_FORMAT_COMPRESSION_MODE_3 = 0x03000000,
|
||
|
+ PISP_IMAGE_FORMAT_COMPRESSION_MASK = 0x03000000,
|
||
|
+
|
||
|
+ PISP_IMAGE_FORMAT_HOG_SIGNED = 0x04000000,
|
||
|
+ PISP_IMAGE_FORMAT_HOG_UNSIGNED = 0x08000000,
|
||
|
+ PISP_IMAGE_FORMAT_INTEGRAL_IMAGE = 0x10000000,
|
||
|
+ PISP_IMAGE_FORMAT_WALLPAPER_ROLL = 0x20000000,
|
||
|
+ PISP_IMAGE_FORMAT_THREE_CHANNEL = 0x40000000,
|
||
|
+
|
||
|
+ /* Lastly a few specific instantiations of the above. */
|
||
|
+ PISP_IMAGE_FORMAT_SINGLE_16 = PISP_IMAGE_FORMAT_BPS_16,
|
||
|
+ PISP_IMAGE_FORMAT_THREE_16 =
|
||
|
+ PISP_IMAGE_FORMAT_BPS_16 | PISP_IMAGE_FORMAT_THREE_CHANNEL
|
||
|
+};
|
||
|
+
|
||
|
+#define PISP_IMAGE_FORMAT_bps_8(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_BPS_MASK) == PISP_IMAGE_FORMAT_BPS_8)
|
||
|
+#define PISP_IMAGE_FORMAT_bps_10(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_BPS_MASK) == PISP_IMAGE_FORMAT_BPS_10)
|
||
|
+#define PISP_IMAGE_FORMAT_bps_12(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_BPS_MASK) == PISP_IMAGE_FORMAT_BPS_12)
|
||
|
+#define PISP_IMAGE_FORMAT_bps_16(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_BPS_MASK) == PISP_IMAGE_FORMAT_BPS_16)
|
||
|
+#define PISP_IMAGE_FORMAT_bps(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_BPS_MASK) ? \
|
||
|
+ 8 + (2 << (((fmt) & PISP_IMAGE_FORMAT_BPS_MASK) - 1)) : \
|
||
|
+ 8)
|
||
|
+#define PISP_IMAGE_FORMAT_shift(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_SHIFT_MASK) / PISP_IMAGE_FORMAT_SHIFT_1)
|
||
|
+#define PISP_IMAGE_FORMAT_three_channel(fmt) \
|
||
|
+ ((fmt) & PISP_IMAGE_FORMAT_THREE_CHANNEL)
|
||
|
+#define PISP_IMAGE_FORMAT_single_channel(fmt) \
|
||
|
+ (!((fmt) & PISP_IMAGE_FORMAT_THREE_CHANNEL))
|
||
|
+#define PISP_IMAGE_FORMAT_compressed(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_COMPRESSION_MASK) != \
|
||
|
+ PISP_IMAGE_FORMAT_UNCOMPRESSED)
|
||
|
+#define PISP_IMAGE_FORMAT_sampling_444(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_SAMPLING_MASK) == \
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_444)
|
||
|
+#define PISP_IMAGE_FORMAT_sampling_422(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_SAMPLING_MASK) == \
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_422)
|
||
|
+#define PISP_IMAGE_FORMAT_sampling_420(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_SAMPLING_MASK) == \
|
||
|
+ PISP_IMAGE_FORMAT_SAMPLING_420)
|
||
|
+#define PISP_IMAGE_FORMAT_order_normal(fmt) \
|
||
|
+ (!((fmt) & PISP_IMAGE_FORMAT_ORDER_SWAPPED))
|
||
|
+#define PISP_IMAGE_FORMAT_order_swapped(fmt) \
|
||
|
+ ((fmt) & PISP_IMAGE_FORMAT_ORDER_SWAPPED)
|
||
|
+#define PISP_IMAGE_FORMAT_interleaved(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_PLANARITY_MASK) == \
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_INTERLEAVED)
|
||
|
+#define PISP_IMAGE_FORMAT_semiplanar(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_PLANARITY_MASK) == \
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_SEMI_PLANAR)
|
||
|
+#define PISP_IMAGE_FORMAT_planar(fmt) \
|
||
|
+ (((fmt) & PISP_IMAGE_FORMAT_PLANARITY_MASK) == \
|
||
|
+ PISP_IMAGE_FORMAT_PLANARITY_PLANAR)
|
||
|
+#define PISP_IMAGE_FORMAT_wallpaper(fmt) \
|
||
|
+ ((fmt) & PISP_IMAGE_FORMAT_WALLPAPER_ROLL)
|
||
|
+#define PISP_IMAGE_FORMAT_HOG(fmt) \
|
||
|
+ ((fmt) & \
|
||
|
+ (PISP_IMAGE_FORMAT_HOG_SIGNED | PISP_IMAGE_FORMAT_HOG_UNSIGNED))
|
||
|
+
|
||
|
+#define PISP_WALLPAPER_WIDTH 128 // in bytes
|
||
|
+
|
||
|
+#endif /* _PISP_FE_TYPES_H_ */
|