631 lines
20 KiB
C
631 lines
20 KiB
C
/* SPDX-License-Identifier: (GPL-2.0+ OR MIT) */
|
|
/*
|
|
* Rockchip ISP1 Driver - Common definitions
|
|
*
|
|
* Copyright (C) 2019 Collabora, Ltd.
|
|
*
|
|
* Based on Rockchip ISP1 driver by Rockchip Electronics Co., Ltd.
|
|
* Copyright (C) 2017 Rockchip Electronics Co., Ltd.
|
|
*/
|
|
|
|
#ifndef _RKISP1_COMMON_H
|
|
#define _RKISP1_COMMON_H
|
|
|
|
#include <linux/clk.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/mutex.h>
|
|
#include <linux/rkisp1-config.h>
|
|
#include <media/media-device.h>
|
|
#include <media/media-entity.h>
|
|
#include <media/v4l2-ctrls.h>
|
|
#include <media/v4l2-device.h>
|
|
#include <media/videobuf2-v4l2.h>
|
|
|
|
#include "rkisp1-regs.h"
|
|
|
|
struct dentry;
|
|
|
|
/*
|
|
* flags on the 'direction' field in struct rkisp1_mbus_info' that indicate
|
|
* on which pad the media bus format is supported
|
|
*/
|
|
#define RKISP1_ISP_SD_SRC BIT(0)
|
|
#define RKISP1_ISP_SD_SINK BIT(1)
|
|
|
|
/* min and max values for the widths and heights of the entities */
|
|
#define RKISP1_ISP_MAX_WIDTH 4032
|
|
#define RKISP1_ISP_MAX_HEIGHT 3024
|
|
#define RKISP1_ISP_MIN_WIDTH 32
|
|
#define RKISP1_ISP_MIN_HEIGHT 32
|
|
|
|
#define RKISP1_RSZ_MP_SRC_MAX_WIDTH 4416
|
|
#define RKISP1_RSZ_MP_SRC_MAX_HEIGHT 3312
|
|
#define RKISP1_RSZ_SP_SRC_MAX_WIDTH 1920
|
|
#define RKISP1_RSZ_SP_SRC_MAX_HEIGHT 1920
|
|
#define RKISP1_RSZ_SRC_MIN_WIDTH 32
|
|
#define RKISP1_RSZ_SRC_MIN_HEIGHT 16
|
|
|
|
/* the default width and height of all the entities */
|
|
#define RKISP1_DEFAULT_WIDTH 800
|
|
#define RKISP1_DEFAULT_HEIGHT 600
|
|
|
|
#define RKISP1_DRIVER_NAME "rkisp1"
|
|
#define RKISP1_BUS_INFO "platform:" RKISP1_DRIVER_NAME
|
|
|
|
/* maximum number of clocks */
|
|
#define RKISP1_MAX_BUS_CLK 8
|
|
|
|
/* a bitmask of the ready stats */
|
|
#define RKISP1_STATS_MEAS_MASK (RKISP1_CIF_ISP_AWB_DONE | \
|
|
RKISP1_CIF_ISP_AFM_FIN | \
|
|
RKISP1_CIF_ISP_EXP_END | \
|
|
RKISP1_CIF_ISP_HIST_MEASURE_RDY)
|
|
|
|
/* enum for the resizer pads */
|
|
enum rkisp1_rsz_pad {
|
|
RKISP1_RSZ_PAD_SINK,
|
|
RKISP1_RSZ_PAD_SRC,
|
|
RKISP1_RSZ_PAD_MAX
|
|
};
|
|
|
|
/* enum for the csi receiver pads */
|
|
enum rkisp1_csi_pad {
|
|
RKISP1_CSI_PAD_SINK,
|
|
RKISP1_CSI_PAD_SRC,
|
|
RKISP1_CSI_PAD_NUM
|
|
};
|
|
|
|
/* enum for the capture id */
|
|
enum rkisp1_stream_id {
|
|
RKISP1_MAINPATH,
|
|
RKISP1_SELFPATH,
|
|
};
|
|
|
|
/* bayer patterns */
|
|
enum rkisp1_fmt_raw_pat_type {
|
|
RKISP1_RAW_RGGB = 0,
|
|
RKISP1_RAW_GRBG,
|
|
RKISP1_RAW_GBRG,
|
|
RKISP1_RAW_BGGR,
|
|
};
|
|
|
|
/* enum for the isp pads */
|
|
enum rkisp1_isp_pad {
|
|
RKISP1_ISP_PAD_SINK_VIDEO,
|
|
RKISP1_ISP_PAD_SINK_PARAMS,
|
|
RKISP1_ISP_PAD_SOURCE_VIDEO,
|
|
RKISP1_ISP_PAD_SOURCE_STATS,
|
|
RKISP1_ISP_PAD_MAX
|
|
};
|
|
|
|
/*
|
|
* enum rkisp1_feature - ISP features
|
|
*
|
|
* @RKISP1_FEATURE_MIPI_CSI2: The ISP has an internal MIPI CSI-2 receiver
|
|
*
|
|
* The ISP features are stored in a bitmask in &rkisp1_info.features and allow
|
|
* the driver to implement support for features present in some ISP versions
|
|
* only.
|
|
*/
|
|
enum rkisp1_feature {
|
|
RKISP1_FEATURE_MIPI_CSI2 = BIT(0),
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_info - Model-specific ISP Information
|
|
*
|
|
* @clks: array of ISP clock names
|
|
* @clk_size: number of entries in the @clks array
|
|
* @isrs: array of ISP interrupt descriptors
|
|
* @isr_size: number of entries in the @isrs array
|
|
* @isp_ver: ISP version
|
|
* @features: bitmask of rkisp1_feature features implemented by the ISP
|
|
*
|
|
* This structure contains information about the ISP specific to a particular
|
|
* ISP model, version, or integration in a particular SoC.
|
|
*/
|
|
struct rkisp1_info {
|
|
const char * const *clks;
|
|
unsigned int clk_size;
|
|
const struct rkisp1_isr_data *isrs;
|
|
unsigned int isr_size;
|
|
enum rkisp1_cif_isp_version isp_ver;
|
|
unsigned int features;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_sensor_async - A container for the v4l2_async_subdev to add to the notifier
|
|
* of the v4l2-async API
|
|
*
|
|
* @asd: async_subdev variable for the sensor
|
|
* @index: index of the sensor (counting sensor found in DT)
|
|
* @source_ep: fwnode for the sensor source endpoint
|
|
* @lanes: number of lanes
|
|
* @mbus_type: type of bus (currently only CSI2 is supported)
|
|
* @mbus_flags: media bus (V4L2_MBUS_*) flags
|
|
* @sd: a pointer to v4l2_subdev struct of the sensor
|
|
* @pixel_rate_ctrl: pixel rate of the sensor, used to initialize the phy
|
|
* @port: port number (0: MIPI, 1: Parallel)
|
|
*/
|
|
struct rkisp1_sensor_async {
|
|
struct v4l2_async_subdev asd;
|
|
unsigned int index;
|
|
struct fwnode_handle *source_ep;
|
|
unsigned int lanes;
|
|
enum v4l2_mbus_type mbus_type;
|
|
unsigned int mbus_flags;
|
|
struct v4l2_subdev *sd;
|
|
struct v4l2_ctrl *pixel_rate_ctrl;
|
|
unsigned int port;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_csi - CSI receiver subdev
|
|
*
|
|
* @rkisp1: pointer to the rkisp1 device
|
|
* @dphy: a pointer to the phy
|
|
* @is_dphy_errctrl_disabled: if dphy errctrl is disabled (avoid endless interrupt)
|
|
* @sd: v4l2_subdev variable
|
|
* @pads: media pads
|
|
* @pad_cfg: configurations for the pads
|
|
* @sink_fmt: input format
|
|
* @lock: protects pad_cfg and sink_fmt
|
|
* @source: source in-use, set when starting streaming
|
|
*/
|
|
struct rkisp1_csi {
|
|
struct rkisp1_device *rkisp1;
|
|
struct phy *dphy;
|
|
bool is_dphy_errctrl_disabled;
|
|
struct v4l2_subdev sd;
|
|
struct media_pad pads[RKISP1_CSI_PAD_NUM];
|
|
struct v4l2_subdev_pad_config pad_cfg[RKISP1_CSI_PAD_NUM];
|
|
const struct rkisp1_mbus_info *sink_fmt;
|
|
struct mutex lock;
|
|
struct v4l2_subdev *source;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_isp - ISP subdev entity
|
|
*
|
|
* @sd: v4l2_subdev variable
|
|
* @rkisp1: pointer to rkisp1_device
|
|
* @pads: media pads
|
|
* @pad_cfg: pads configurations
|
|
* @sink_fmt: input format
|
|
* @src_fmt: output format
|
|
* @ops_lock: ops serialization
|
|
* @frame_sequence: used to synchronize frame_id between video devices.
|
|
*/
|
|
struct rkisp1_isp {
|
|
struct v4l2_subdev sd;
|
|
struct rkisp1_device *rkisp1;
|
|
struct media_pad pads[RKISP1_ISP_PAD_MAX];
|
|
struct v4l2_subdev_pad_config pad_cfg[RKISP1_ISP_PAD_MAX];
|
|
const struct rkisp1_mbus_info *sink_fmt;
|
|
const struct rkisp1_mbus_info *src_fmt;
|
|
struct mutex ops_lock; /* serialize the subdevice ops */
|
|
__u32 frame_sequence;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_vdev_node - Container for the video nodes: params, stats, mainpath, selfpath
|
|
*
|
|
* @buf_queue: queue of buffers
|
|
* @vlock: lock of the video node
|
|
* @vdev: video node
|
|
* @pad: media pad
|
|
*/
|
|
struct rkisp1_vdev_node {
|
|
struct vb2_queue buf_queue;
|
|
struct mutex vlock; /* ioctl serialization mutex */
|
|
struct video_device vdev;
|
|
struct media_pad pad;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_buffer - A container for the vb2 buffers used by the video devices:
|
|
* params, stats, mainpath, selfpath
|
|
*
|
|
* @vb: vb2 buffer
|
|
* @queue: entry of the buffer in the queue
|
|
* @buff_addr: dma addresses of each plane, used only by the capture devices: selfpath, mainpath
|
|
*/
|
|
struct rkisp1_buffer {
|
|
struct vb2_v4l2_buffer vb;
|
|
struct list_head queue;
|
|
u32 buff_addr[VIDEO_MAX_PLANES];
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_dummy_buffer - A buffer to write the next frame to in case
|
|
* there are no vb2 buffers available.
|
|
*
|
|
* @vaddr: return value of call to dma_alloc_attrs.
|
|
* @dma_addr: dma address of the buffer.
|
|
* @size: size of the buffer.
|
|
*/
|
|
struct rkisp1_dummy_buffer {
|
|
void *vaddr;
|
|
dma_addr_t dma_addr;
|
|
u32 size;
|
|
};
|
|
|
|
struct rkisp1_device;
|
|
|
|
/*
|
|
* struct rkisp1_capture - ISP capture video device
|
|
*
|
|
* @vnode: video node
|
|
* @rkisp1: pointer to rkisp1_device
|
|
* @id: id of the capture, one of RKISP1_SELFPATH, RKISP1_MAINPATH
|
|
* @ops: list of callbacks to configure the capture device.
|
|
* @config: a pointer to the list of registers to configure the capture format.
|
|
* @is_streaming: device is streaming
|
|
* @is_stopping: stop_streaming callback was called and the device is in the process of
|
|
* stopping the streaming.
|
|
* @done: when stop_streaming callback is called, the device waits for the next irq
|
|
* handler to stop the streaming by waiting on the 'done' wait queue.
|
|
* If the irq handler is not called, the stream is stopped by the callback
|
|
* after timeout.
|
|
* @sp_y_stride: the selfpath allows to configure a y stride that is longer than the image width.
|
|
* @buf.lock: lock to protect buf.queue
|
|
* @buf.queue: queued buffer list
|
|
* @buf.dummy: dummy space to store dropped data
|
|
*
|
|
* rkisp1 uses shadow registers, so it needs two buffers at a time
|
|
* @buf.curr: the buffer used for current frame
|
|
* @buf.next: the buffer used for next frame
|
|
* @pix.cfg: pixel configuration
|
|
* @pix.info: a pointer to the v4l2_format_info of the pixel format
|
|
* @pix.fmt: buffer format
|
|
*/
|
|
struct rkisp1_capture {
|
|
struct rkisp1_vdev_node vnode;
|
|
struct rkisp1_device *rkisp1;
|
|
enum rkisp1_stream_id id;
|
|
const struct rkisp1_capture_ops *ops;
|
|
const struct rkisp1_capture_config *config;
|
|
bool is_streaming;
|
|
bool is_stopping;
|
|
wait_queue_head_t done;
|
|
unsigned int sp_y_stride;
|
|
struct {
|
|
/* protects queue, curr and next */
|
|
spinlock_t lock;
|
|
struct list_head queue;
|
|
struct rkisp1_dummy_buffer dummy;
|
|
struct rkisp1_buffer *curr;
|
|
struct rkisp1_buffer *next;
|
|
} buf;
|
|
struct {
|
|
const struct rkisp1_capture_fmt_cfg *cfg;
|
|
const struct v4l2_format_info *info;
|
|
struct v4l2_pix_format_mplane fmt;
|
|
} pix;
|
|
};
|
|
|
|
struct rkisp1_stats;
|
|
struct rkisp1_stats_ops {
|
|
void (*get_awb_meas)(struct rkisp1_stats *stats,
|
|
struct rkisp1_stat_buffer *pbuf);
|
|
void (*get_aec_meas)(struct rkisp1_stats *stats,
|
|
struct rkisp1_stat_buffer *pbuf);
|
|
void (*get_hst_meas)(struct rkisp1_stats *stats,
|
|
struct rkisp1_stat_buffer *pbuf);
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_stats - ISP Statistics device
|
|
*
|
|
* @vnode: video node
|
|
* @rkisp1: pointer to the rkisp1 device
|
|
* @lock: locks the buffer list 'stat'
|
|
* @stat: queue of rkisp1_buffer
|
|
* @vdev_fmt: v4l2_format of the metadata format
|
|
*/
|
|
struct rkisp1_stats {
|
|
struct rkisp1_vdev_node vnode;
|
|
struct rkisp1_device *rkisp1;
|
|
const struct rkisp1_stats_ops *ops;
|
|
|
|
spinlock_t lock; /* locks the buffers list 'stats' */
|
|
struct list_head stat;
|
|
struct v4l2_format vdev_fmt;
|
|
};
|
|
|
|
struct rkisp1_params;
|
|
struct rkisp1_params_ops {
|
|
void (*lsc_matrix_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_lsc_config *pconfig);
|
|
void (*goc_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_goc_config *arg);
|
|
void (*awb_meas_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_awb_meas_config *arg);
|
|
void (*awb_meas_enable)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_awb_meas_config *arg,
|
|
bool en);
|
|
void (*awb_gain_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_awb_gain_config *arg);
|
|
void (*aec_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_aec_config *arg);
|
|
void (*hst_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_hst_config *arg);
|
|
void (*hst_enable)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_hst_config *arg, bool en);
|
|
void (*afm_config)(struct rkisp1_params *params,
|
|
const struct rkisp1_cif_isp_afc_config *arg);
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_params - ISP input parameters device
|
|
*
|
|
* @vnode: video node
|
|
* @rkisp1: pointer to the rkisp1 device
|
|
* @ops: pointer to the variant-specific operations
|
|
* @config_lock: locks the buffer list 'params'
|
|
* @params: queue of rkisp1_buffer
|
|
* @vdev_fmt: v4l2_format of the metadata format
|
|
* @quantization: the quantization configured on the isp's src pad
|
|
* @raw_type: the bayer pattern on the isp video sink pad
|
|
*/
|
|
struct rkisp1_params {
|
|
struct rkisp1_vdev_node vnode;
|
|
struct rkisp1_device *rkisp1;
|
|
const struct rkisp1_params_ops *ops;
|
|
|
|
spinlock_t config_lock; /* locks the buffers list 'params' */
|
|
struct list_head params;
|
|
struct v4l2_format vdev_fmt;
|
|
|
|
enum v4l2_quantization quantization;
|
|
enum v4l2_ycbcr_encoding ycbcr_encoding;
|
|
enum rkisp1_fmt_raw_pat_type raw_type;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_resizer - Resizer subdev
|
|
*
|
|
* @sd: v4l2_subdev variable
|
|
* @regs_base: base register address offset
|
|
* @id: id of the resizer, one of RKISP1_SELFPATH, RKISP1_MAINPATH
|
|
* @rkisp1: pointer to the rkisp1 device
|
|
* @pads: media pads
|
|
* @pad_cfg: configurations for the pads
|
|
* @config: the set of registers to configure the resizer
|
|
* @pixel_enc: pixel encoding of the resizer
|
|
* @ops_lock: a lock for the subdev ops
|
|
*/
|
|
struct rkisp1_resizer {
|
|
struct v4l2_subdev sd;
|
|
u32 regs_base;
|
|
enum rkisp1_stream_id id;
|
|
struct rkisp1_device *rkisp1;
|
|
struct media_pad pads[RKISP1_RSZ_PAD_MAX];
|
|
struct v4l2_subdev_pad_config pad_cfg[RKISP1_RSZ_PAD_MAX];
|
|
const struct rkisp1_rsz_config *config;
|
|
enum v4l2_pixel_encoding pixel_enc;
|
|
struct mutex ops_lock; /* serialize the subdevice ops */
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_debug - Values to be exposed on debugfs.
|
|
* The parameters are counters of the number of times the
|
|
* event occurred since the driver was loaded.
|
|
*
|
|
* @data_loss: loss of data occurred within a line, processing failure
|
|
* @outform_size_error: size error is generated in outmux submodule
|
|
* @img_stabilization_size_error: size error is generated in image stabilization submodule
|
|
* @inform_size_err: size error is generated in inform submodule
|
|
* @mipi_error: mipi error occurred
|
|
* @stats_error: writing to the 'Interrupt clear register' did not clear
|
|
* it in the register 'Masked interrupt status'
|
|
* @stop_timeout: upon stream stop, the capture waits 1 second for the isr to stop
|
|
* the stream. This param is incremented in case of timeout.
|
|
* @frame_drop: a frame was ready but the buffer queue was empty so the frame
|
|
* was not sent to userspace
|
|
*/
|
|
struct rkisp1_debug {
|
|
struct dentry *debugfs_dir;
|
|
unsigned long data_loss;
|
|
unsigned long outform_size_error;
|
|
unsigned long img_stabilization_size_error;
|
|
unsigned long inform_size_error;
|
|
unsigned long irq_delay;
|
|
unsigned long mipi_error;
|
|
unsigned long stats_error;
|
|
unsigned long stop_timeout[2];
|
|
unsigned long frame_drop[2];
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_device - ISP platform device
|
|
*
|
|
* @base_addr: base register address
|
|
* @irq: the irq number
|
|
* @dev: a pointer to the struct device
|
|
* @clk_size: number of clocks
|
|
* @clks: array of clocks
|
|
* @v4l2_dev: v4l2_device variable
|
|
* @media_dev: media_device variable
|
|
* @notifier: a notifier to register on the v4l2-async API to be notified on the sensor
|
|
* @source: source subdev in-use, set when starting streaming
|
|
* @csi: internal CSI-2 receiver
|
|
* @isp: ISP sub-device
|
|
* @resizer_devs: resizer sub-devices
|
|
* @capture_devs: capture devices
|
|
* @stats: ISP statistics metadata capture device
|
|
* @params: ISP parameters metadata output device
|
|
* @pipe: media pipeline
|
|
* @stream_lock: serializes {start/stop}_streaming callbacks between the capture devices.
|
|
* @debug: debug params to be exposed on debugfs
|
|
* @info: version-specific ISP information
|
|
*/
|
|
struct rkisp1_device {
|
|
void __iomem *base_addr;
|
|
struct device *dev;
|
|
unsigned int clk_size;
|
|
struct clk_bulk_data clks[RKISP1_MAX_BUS_CLK];
|
|
struct v4l2_device v4l2_dev;
|
|
struct media_device media_dev;
|
|
struct v4l2_async_notifier notifier;
|
|
struct v4l2_subdev *source;
|
|
struct rkisp1_csi csi;
|
|
struct rkisp1_isp isp;
|
|
struct rkisp1_resizer resizer_devs[2];
|
|
struct rkisp1_capture capture_devs[2];
|
|
struct rkisp1_stats stats;
|
|
struct rkisp1_params params;
|
|
struct media_pipeline pipe;
|
|
struct mutex stream_lock; /* serialize {start/stop}_streaming cb between capture devices */
|
|
struct rkisp1_debug debug;
|
|
const struct rkisp1_info *info;
|
|
};
|
|
|
|
/*
|
|
* struct rkisp1_mbus_info - ISP media bus info, Translates media bus code to hardware
|
|
* format values
|
|
*
|
|
* @mbus_code: media bus code
|
|
* @pixel_enc: pixel encoding
|
|
* @mipi_dt: mipi data type
|
|
* @yuv_seq: the order of the Y, Cb, Cr values
|
|
* @bus_width: bus width
|
|
* @bayer_pat: bayer pattern
|
|
* @direction: a bitmask of the flags indicating on which pad the format is supported on
|
|
*/
|
|
struct rkisp1_mbus_info {
|
|
u32 mbus_code;
|
|
enum v4l2_pixel_encoding pixel_enc;
|
|
u32 mipi_dt;
|
|
u32 yuv_seq;
|
|
u8 bus_width;
|
|
enum rkisp1_fmt_raw_pat_type bayer_pat;
|
|
unsigned int direction;
|
|
};
|
|
|
|
static inline void
|
|
rkisp1_write(struct rkisp1_device *rkisp1, unsigned int addr, u32 val)
|
|
{
|
|
writel(val, rkisp1->base_addr + addr);
|
|
}
|
|
|
|
static inline u32 rkisp1_read(struct rkisp1_device *rkisp1, unsigned int addr)
|
|
{
|
|
return readl(rkisp1->base_addr + addr);
|
|
}
|
|
|
|
/*
|
|
* rkisp1_cap_enum_mbus_codes - A helper function that return the i'th supported mbus code
|
|
* of the capture entity. This is used to enumerate the supported
|
|
* mbus codes on the source pad of the resizer.
|
|
*
|
|
* @cap: the capture entity
|
|
* @code: the mbus code, the function reads the code->index and fills the code->code
|
|
*/
|
|
int rkisp1_cap_enum_mbus_codes(struct rkisp1_capture *cap,
|
|
struct v4l2_subdev_mbus_code_enum *code);
|
|
|
|
/*
|
|
* rkisp1_mbus_info_get_by_index - Retrieve the ith supported mbus info
|
|
*
|
|
* @index: index of the mbus info to fetch
|
|
*/
|
|
const struct rkisp1_mbus_info *rkisp1_mbus_info_get_by_index(unsigned int index);
|
|
|
|
/*
|
|
* rkisp1_sd_adjust_crop_rect - adjust a rectangle to fit into another rectangle.
|
|
*
|
|
* @crop: rectangle to adjust.
|
|
* @bounds: rectangle used as bounds.
|
|
*/
|
|
void rkisp1_sd_adjust_crop_rect(struct v4l2_rect *crop,
|
|
const struct v4l2_rect *bounds);
|
|
|
|
/*
|
|
* rkisp1_sd_adjust_crop - adjust a rectangle to fit into media bus format
|
|
*
|
|
* @crop: rectangle to adjust.
|
|
* @bounds: media bus format used as bounds.
|
|
*/
|
|
void rkisp1_sd_adjust_crop(struct v4l2_rect *crop,
|
|
const struct v4l2_mbus_framefmt *bounds);
|
|
|
|
/*
|
|
* rkisp1_mbus_info_get_by_code - get the isp info of the media bus code
|
|
*
|
|
* @mbus_code: the media bus code
|
|
*/
|
|
const struct rkisp1_mbus_info *rkisp1_mbus_info_get_by_code(u32 mbus_code);
|
|
|
|
/*
|
|
* rkisp1_params_pre_configure - Configure the params before stream start
|
|
*
|
|
* @params: pointer to rkisp1_params
|
|
* @bayer_pat: the bayer pattern on the isp video sink pad
|
|
* @quantization: the quantization configured on the isp's src pad
|
|
* @ycbcr_encoding: the ycbcr_encoding configured on the isp's src pad
|
|
*
|
|
* This function is called by the ISP entity just before the ISP gets started.
|
|
* It applies the initial ISP parameters from the first params buffer, but
|
|
* skips LSC as it needs to be configured after the ISP is started.
|
|
*/
|
|
void rkisp1_params_pre_configure(struct rkisp1_params *params,
|
|
enum rkisp1_fmt_raw_pat_type bayer_pat,
|
|
enum v4l2_quantization quantization,
|
|
enum v4l2_ycbcr_encoding ycbcr_encoding);
|
|
|
|
/*
|
|
* rkisp1_params_post_configure - Configure the params after stream start
|
|
*
|
|
* @params: pointer to rkisp1_params
|
|
*
|
|
* This function is called by the ISP entity just after the ISP gets started.
|
|
* It applies the initial ISP LSC parameters from the first params buffer.
|
|
*/
|
|
void rkisp1_params_post_configure(struct rkisp1_params *params);
|
|
|
|
/* rkisp1_params_disable - disable all parameters.
|
|
* This function is called by the isp entity upon stream start
|
|
* when capturing bayer format.
|
|
*
|
|
* @params: pointer to rkisp1_params.
|
|
*/
|
|
void rkisp1_params_disable(struct rkisp1_params *params);
|
|
|
|
/* irq handlers */
|
|
irqreturn_t rkisp1_isp_isr(int irq, void *ctx);
|
|
irqreturn_t rkisp1_csi_isr(int irq, void *ctx);
|
|
irqreturn_t rkisp1_capture_isr(int irq, void *ctx);
|
|
void rkisp1_stats_isr(struct rkisp1_stats *stats, u32 isp_ris);
|
|
void rkisp1_params_isr(struct rkisp1_device *rkisp1);
|
|
|
|
/* register/unregisters functions of the entities */
|
|
int rkisp1_capture_devs_register(struct rkisp1_device *rkisp1);
|
|
void rkisp1_capture_devs_unregister(struct rkisp1_device *rkisp1);
|
|
|
|
int rkisp1_isp_register(struct rkisp1_device *rkisp1);
|
|
void rkisp1_isp_unregister(struct rkisp1_device *rkisp1);
|
|
|
|
int rkisp1_resizer_devs_register(struct rkisp1_device *rkisp1);
|
|
void rkisp1_resizer_devs_unregister(struct rkisp1_device *rkisp1);
|
|
|
|
int rkisp1_stats_register(struct rkisp1_device *rkisp1);
|
|
void rkisp1_stats_unregister(struct rkisp1_device *rkisp1);
|
|
|
|
int rkisp1_params_register(struct rkisp1_device *rkisp1);
|
|
void rkisp1_params_unregister(struct rkisp1_device *rkisp1);
|
|
|
|
#if IS_ENABLED(CONFIG_DEBUG_FS)
|
|
void rkisp1_debug_init(struct rkisp1_device *rkisp1);
|
|
void rkisp1_debug_cleanup(struct rkisp1_device *rkisp1);
|
|
#else
|
|
static inline void rkisp1_debug_init(struct rkisp1_device *rkisp1)
|
|
{
|
|
}
|
|
static inline void rkisp1_debug_cleanup(struct rkisp1_device *rkisp1)
|
|
{
|
|
}
|
|
#endif
|
|
|
|
#endif /* _RKISP1_COMMON_H */
|