shinys000114/linux
1
0
Fork 0
mirror of https://github.com/hardkernel/linux.git synced 2026-06-08 03:40:35 +09:00
Code Issues Packages Projects Releases Wiki Activity

media: rockchip: isp: rkisp1 rename to rkisp

Browse Source 
Change-Id: I7fc332d314a19e09f4e2e8a81ee18fb61b41ee16
Signed-off-by: Cai YiWei <cyw@rock-chips.com>
This commit is contained in:
Cai YiWei
2019-12-31 18:36:41 +08:00
committed by Tao Huang
parent f851cf76f7
commit 87184fa353
22 changed files with 1718 additions and 1708 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
drivers/media/platform/Kconfig
View File

@@ -138,7 +138,7 @@ source "drivers/media/platform/xilinx/Kconfig"
source "drivers/media/platform/rcar-vin/Kconfig"
source "drivers/media/platform/atmel/Kconfig"
source "drivers/media/platform/rockchip/cif/Kconfig"
source "drivers/media/platform/rockchip/isp1/Kconfig"
source "drivers/media/platform/rockchip/isp/Kconfig"
config VIDEO_TI_CAL
tristate "TI CAL (Camera Adaptation Layer) driver"

2
drivers/media/platform/Makefile
View File

@@ -68,7 +68,7 @@ obj-$(CONFIG_VIDEO_RENESAS_VSP1) += vsp1/
obj-$(CONFIG_VIDEO_ROCKCHIP_RGA) += rockchip/rga/
obj-$(CONFIG_VIDEO_ROCKCHIP_CIF) += rockchip/cif/
obj-$(CONFIG_VIDEO_ROCKCHIP_ISP1) += rockchip/isp1/
obj-$(CONFIG_VIDEO_ROCKCHIP_ISP) += rockchip/isp/
obj-y += omap/

24
drivers/media/platform/rockchip/isp/Kconfig Normal file
View File

@@ -0,0 +1,24 @@
# SPDX-License-Identifier: GPL-2.0
config VIDEO_ROCKCHIP_ISP
tristate "Rockchip Image Signal Processing Unit driver"
depends on VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
depends on ARCH_ROCKCHIP || COMPILE_TEST
select VIDEOBUF2_DMA_CONTIG
select VIDEOBUF2_VMALLOC
select V4L2_FWNODE
select PHY_ROCKCHIP_MIPI_RX
default n
help
Support for ISP1 on the rockchip SoC.
config VIDEO_ROCKCHIP_ISP1
tristate "Rockchip Image Signal Processing V1 Unit driver (DEPRECATED)"
depends on VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
depends on ARCH_ROCKCHIP || COMPILE_TEST
select VIDEO_ROCKCHIP_ISP
default n
help
Support for ISP1 on the rockchip SoC.
This config option is here only for backward compatibility.
Use VIDEO_ROCKCHIP_ISP instead.

4
drivers/media/platform/rockchip/isp1/Makefile → drivers/media/platform/rockchip/isp/Makefile
View File

@@ -1,7 +1,7 @@
# SPDX-License-Identifier: GPL-2.0
obj-$(CONFIG_VIDEO_ROCKCHIP_ISP1) += video_rkisp1.o
obj-$(CONFIG_VIDEO_ROCKCHIP_ISP) += video_rkisp.o
video_rkisp1-objs += rkisp1.o \
video_rkisp-objs += rkisp.o \
dev.o \
regs.o \
isp_stats.o \

458
drivers/media/platform/rockchip/isp1/capture.c → drivers/media/platform/rockchip/isp/capture.c
View File

File diff suppressed because it is too large Load Diff

82
drivers/media/platform/rockchip/isp1/capture.h → drivers/media/platform/rockchip/isp/capture.h
View File

@@ -32,12 +32,12 @@
* SOFTWARE.
*/
#ifndef _RKISP1_PATH_VIDEO_H
#define _RKISP1_PATH_VIDEO_H
#ifndef _RKISP_PATH_VIDEO_H
#define _RKISP_PATH_VIDEO_H
#include "common.h"
struct rkisp1_stream;
struct rkisp_stream;
/*
* @fourcc: pixel format
@@ -64,35 +64,35 @@ struct capture_fmt {
u8 bpp[VIDEO_MAX_PLANES];
};
enum rkisp1_sp_inp {
RKISP1_SP_INP_ISP,
RKISP1_SP_INP_DMA_SP,
RKISP1_SP_INP_MAX
enum rkisp_sp_inp {
RKISP_SP_INP_ISP,
RKISP_SP_INP_DMA_SP,
RKISP_SP_INP_MAX
};
enum rkisp1_field {
enum rkisp_field {
RKISP_FIELD_ODD,
RKISP_FIELD_EVEN,
RKISP_FIELD_INVAL,
};
struct rkisp1_stream_sp {
struct rkisp_stream_sp {
int y_stride;
int vir_offs;
enum rkisp1_sp_inp input_sel;
enum rkisp1_field field;
enum rkisp1_field field_rec;
enum rkisp_sp_inp input_sel;
enum rkisp_field field;
enum rkisp_field field_rec;
};
struct rkisp1_stream_mp {
struct rkisp_stream_mp {
bool raw_enable;
};
struct rkisp1_stream_raw {
struct rkisp_stream_raw {
u8 pre_stop;
};
struct rkisp1_stream_dmarx {
struct rkisp_stream_dmarx {
int y_stride;
};
@@ -154,17 +154,17 @@ struct stream_config {
/* Different reg ops between selfpath and mainpath */
struct streams_ops {
int (*config_mi)(struct rkisp1_stream *stream);
void (*stop_mi)(struct rkisp1_stream *stream);
void (*enable_mi)(struct rkisp1_stream *stream);
void (*disable_mi)(struct rkisp1_stream *stream);
int (*config_mi)(struct rkisp_stream *stream);
void (*stop_mi)(struct rkisp_stream *stream);
void (*enable_mi)(struct rkisp_stream *stream);
void (*disable_mi)(struct rkisp_stream *stream);
void (*set_data_path)(void __iomem *base);
bool (*is_stream_stopped)(void __iomem *base);
void (*update_mi)(struct rkisp1_stream *stream);
void (*update_mi)(struct rkisp_stream *stream);
};
/*
* struct rkisp1_stream - ISP capture video device
* struct rkisp_stream - ISP capture video device
*
* @out_isp_fmt: output isp format
* @out_fmt: output buffer size
@@ -174,15 +174,15 @@ struct streams_ops {
* @buf_queue: queued buffer list
* @dummy_buf: dummy space to store dropped data
*
* rkisp1 use shadowsock registers, so it need two buffer at a time
* rkisp use shadowsock registers, so it need two buffer at a time
* @curr_buf: the buffer used for current frame
* @next_buf: the buffer used for next frame
*/
struct rkisp1_stream {
struct rkisp_stream {
unsigned id:2;
unsigned interlaced:1;
struct rkisp1_device *ispdev;
struct rkisp1_vdev_node vnode;
struct rkisp_device *ispdev;
struct rkisp_vdev_node vnode;
struct capture_fmt out_isp_fmt;
struct v4l2_pix_format_mplane out_fmt;
struct v4l2_rect dcrop;
@@ -190,30 +190,30 @@ struct rkisp1_stream {
struct stream_config *config;
spinlock_t vbq_lock;
struct list_head buf_queue;
struct rkisp1_dummy_buffer dummy_buf;
struct rkisp1_buffer *curr_buf;
struct rkisp1_buffer *next_buf;
struct rkisp_dummy_buffer dummy_buf;
struct rkisp_buffer *curr_buf;
struct rkisp_buffer *next_buf;
bool streaming;
bool stopping;
bool frame_end;
wait_queue_head_t done;
unsigned int burst;
union {
struct rkisp1_stream_sp sp;
struct rkisp1_stream_mp mp;
struct rkisp1_stream_raw raw;
struct rkisp1_stream_dmarx dmarx;
struct rkisp_stream_sp sp;
struct rkisp_stream_mp mp;
struct rkisp_stream_raw raw;
struct rkisp_stream_dmarx dmarx;
} u;
};
void rkisp1_unregister_stream_vdevs(struct rkisp1_device *dev);
int rkisp1_register_stream_vdevs(struct rkisp1_device *dev);
void rkisp1_mi_isr(u32 mis_val, struct rkisp1_device *dev);
void rkisp1_stream_init(struct rkisp1_device *dev, u32 id);
void rkisp1_set_stream_def_fmt(struct rkisp1_device *dev, u32 id,
void rkisp_unregister_stream_vdevs(struct rkisp_device *dev);
int rkisp_register_stream_vdevs(struct rkisp_device *dev);
void rkisp_mi_isr(u32 mis_val, struct rkisp_device *dev);
void rkisp_stream_init(struct rkisp_device *dev, u32 id);
void rkisp_set_stream_def_fmt(struct rkisp_device *dev, u32 id,
u32 width, u32 height, u32 pixelformat);
void rkisp1_mipi_dmatx0_end(u32 status, struct rkisp1_device *dev);
void rkisp_mipi_dmatx0_end(u32 status, struct rkisp_device *dev);
int fcc_xysubs(u32 fcc, u32 *xsubs, u32 *ysubs);
int rkisp1_fh_open(struct file *filp);
int rkisp1_fop_release(struct file *file);
#endif /* _RKISP1_PATH_VIDEO_H */
int rkisp_fh_open(struct file *filp);
int rkisp_fop_release(struct file *file);
#endif /* _RKISP_PATH_VIDEO_H */

68
drivers/media/platform/rockchip/isp1/common.h → drivers/media/platform/rockchip/isp/common.h
View File

@@ -32,8 +32,8 @@
* SOFTWARE.
*/
#ifndef _RKISP1_COMMON_H
#define _RKISP1_COMMON_H
#ifndef _RKISP_COMMON_H
#define _RKISP_COMMON_H
#include <linux/mutex.h>
#include <linux/media.h>
@@ -44,38 +44,38 @@
#include <media/videobuf2-v4l2.h>
#include <media/v4l2-mc.h>
#define RKISP1_DEFAULT_WIDTH 800
#define RKISP1_DEFAULT_HEIGHT 600
#define RKISP_DEFAULT_WIDTH 800
#define RKISP_DEFAULT_HEIGHT 600
#define RKISP1_MAX_STREAM 3
#define RKISP1_STREAM_MP 0
#define RKISP1_STREAM_SP 1
#define RKISP1_STREAM_RAW 2
#define RKISP_MAX_STREAM 3
#define RKISP_STREAM_MP 0
#define RKISP_STREAM_SP 1
#define RKISP_STREAM_RAW 2
#define RKISP1_PLANE_Y 0
#define RKISP1_PLANE_CB 1
#define RKISP1_PLANE_CR 2
#define RKISP_PLANE_Y 0
#define RKISP_PLANE_CB 1
#define RKISP_PLANE_CR 2
#define RKISP1_EMDDATA_FIFO_MAX 4
#define RKISP1_DMATX_CHECK 0xA5A5A5A5
#define RKISP1_RK3326_USE_OLDMIPI 0
#define RKISP_EMDDATA_FIFO_MAX 4
#define RKISP_DMATX_CHECK 0xA5A5A5A5
#define RKISP_RK3326_USE_OLDMIPI 0
enum rkisp1_sd_type {
RKISP1_SD_SENSOR,
RKISP1_SD_PHY_CSI,
RKISP1_SD_VCM,
RKISP1_SD_FLASH,
RKISP1_SD_MAX,
enum rkisp_sd_type {
RKISP_SD_SENSOR,
RKISP_SD_PHY_CSI,
RKISP_SD_VCM,
RKISP_SD_FLASH,
RKISP_SD_MAX,
};
/* One structure per video node */
struct rkisp1_vdev_node {
struct rkisp_vdev_node {
struct vb2_queue buf_queue;
struct video_device vdev;
struct media_pad pad;
};
enum rkisp1_fmt_pix_type {
enum rkisp_fmt_pix_type {
FMT_YUV,
FMT_RGB,
FMT_BAYER,
@@ -83,14 +83,14 @@ enum rkisp1_fmt_pix_type {
FMT_MAX
};
enum rkisp1_fmt_raw_pat_type {
enum rkisp_fmt_raw_pat_type {
RAW_RGGB = 0,
RAW_GRBG,
RAW_GBRG,
RAW_BGGR,
};
struct rkisp1_buffer {
struct rkisp_buffer {
struct vb2_v4l2_buffer vb;
struct list_head queue;
union {
@@ -99,35 +99,35 @@ struct rkisp1_buffer {
};
};
struct rkisp1_dummy_buffer {
struct rkisp_dummy_buffer {
void *vaddr;
dma_addr_t dma_addr;
u32 size;
};
extern int rkisp1_debug;
extern int rkisp_debug;
static inline
struct rkisp1_vdev_node *vdev_to_node(struct video_device *vdev)
struct rkisp_vdev_node *vdev_to_node(struct video_device *vdev)
{
return container_of(vdev, struct rkisp1_vdev_node, vdev);
return container_of(vdev, struct rkisp_vdev_node, vdev);
}
static inline struct rkisp1_vdev_node *queue_to_node(struct vb2_queue *q)
static inline struct rkisp_vdev_node *queue_to_node(struct vb2_queue *q)
{
return container_of(q, struct rkisp1_vdev_node, buf_queue);
return container_of(q, struct rkisp_vdev_node, buf_queue);
}
static inline struct rkisp1_buffer *to_rkisp1_buffer(struct vb2_v4l2_buffer *vb)
static inline struct rkisp_buffer *to_rkisp_buffer(struct vb2_v4l2_buffer *vb)
{
return container_of(vb, struct rkisp1_buffer, vb);
return container_of(vb, struct rkisp_buffer, vb);
}
static inline struct vb2_queue *to_vb2_queue(struct file *file)
{
struct rkisp1_vdev_node *vnode = video_drvdata(file);
struct rkisp_vdev_node *vnode = video_drvdata(file);
return &vnode->buf_queue;
}
#endif /* _RKISP1_COMMON_H */
#endif /* _RKISP_COMMON_H */

361
drivers/media/platform/rockchip/isp1/dev.c → drivers/media/platform/rockchip/isp/dev.c
View File

@@ -48,7 +48,7 @@
#include <dt-bindings/soc/rockchip-system-status.h>
#include <soc/rockchip/rockchip-system-status.h>
#include "regs.h"
#include "rkisp1.h"
#include "rkisp.h"
#include "common.h"
#include "version.h"
@@ -62,30 +62,30 @@ struct isp_irqs_data {
struct isp_match_data {
const char * const *clks;
int num_clks;
enum rkisp1_isp_ver isp_ver;
enum rkisp_isp_ver isp_ver;
const unsigned int *clk_rate_tbl;
int num_clk_rate_tbl;
struct isp_irqs_data *irqs;
int num_irqs;
};
int rkisp1_debug;
module_param_named(debug, rkisp1_debug, int, 0644);
int rkisp_debug;
module_param_named(debug, rkisp_debug, int, 0644);
MODULE_PARM_DESC(debug, "Debug level (0-1)");
static char rkisp1_version[RKISP_VERNO_LEN];
module_param_string(version, rkisp1_version, RKISP_VERNO_LEN, 0444);
static char rkisp_version[RKISP_VERNO_LEN];
module_param_string(version, rkisp_version, RKISP_VERNO_LEN, 0444);
MODULE_PARM_DESC(version, "version number");
static DEFINE_MUTEX(rkisp1_dev_mutex);
static LIST_HEAD(rkisp1_device_list);
static DEFINE_MUTEX(rkisp_dev_mutex);
static LIST_HEAD(rkisp_device_list);
/**************************** pipeline operations *****************************/
static int __isp_pipeline_prepare(struct rkisp1_pipeline *p,
static int __isp_pipeline_prepare(struct rkisp_pipeline *p,
struct media_entity *me)
{
struct rkisp1_device *dev = container_of(p, struct rkisp1_device, pipe);
struct rkisp_device *dev = container_of(p, struct rkisp_device, pipe);
struct v4l2_subdev *sd;
int i;
@@ -127,9 +127,9 @@ static int __isp_pipeline_prepare(struct rkisp1_pipeline *p,
return 0;
}
static int __isp_pipeline_s_isp_clk(struct rkisp1_pipeline *p)
static int __isp_pipeline_s_isp_clk(struct rkisp_pipeline *p)
{
struct rkisp1_device *dev = container_of(p, struct rkisp1_device, pipe);
struct rkisp_device *dev = container_of(p, struct rkisp_device, pipe);
struct v4l2_subdev *sd;
struct v4l2_ctrl *ctrl;
u64 data_rate;
@@ -177,13 +177,13 @@ static int __isp_pipeline_s_isp_clk(struct rkisp1_pipeline *p)
/* set isp clock rate */
clk_set_rate(dev->clks[0], dev->clk_rate_tbl[i] * 1000000UL);
v4l2_dbg(1, rkisp1_debug, sd, "set isp clk = %luHz\n",
v4l2_dbg(1, rkisp_debug, sd, "set isp clk = %luHz\n",
clk_get_rate(dev->clks[0]));
return 0;
}
static int rkisp1_pipeline_open(struct rkisp1_pipeline *p,
static int rkisp_pipeline_open(struct rkisp_pipeline *p,
struct media_entity *me,
bool prepare)
{
@@ -208,7 +208,7 @@ static int rkisp1_pipeline_open(struct rkisp1_pipeline *p,
return 0;
}
static int rkisp1_pipeline_close(struct rkisp1_pipeline *p)
static int rkisp_pipeline_close(struct rkisp_pipeline *p)
{
atomic_dec(&p->power_cnt);
@@ -219,9 +219,9 @@ static int rkisp1_pipeline_close(struct rkisp1_pipeline *p)
* stream-on order: isp_subdev, mipi dphy, sensor
* stream-off order: mipi dphy, sensor, isp_subdev
*/
static int rkisp1_pipeline_set_stream(struct rkisp1_pipeline *p, bool on)
static int rkisp_pipeline_set_stream(struct rkisp_pipeline *p, bool on)
{
struct rkisp1_device *dev = container_of(p, struct rkisp1_device, pipe);
struct rkisp_device *dev = container_of(p, struct rkisp_device, pipe);
int i, ret;
if ((on && atomic_inc_return(&p->stream_cnt) > 1) ||
@@ -262,7 +262,7 @@ err_stream_off:
/***************************** media controller *******************************/
/* See http://opensource.rock-chips.com/wiki_Rockchip-isp1 for Topology */
static int rkisp1_create_links(struct rkisp1_device *dev)
static int rkisp_create_links(struct rkisp_device *dev)
{
struct media_entity *source, *sink;
unsigned int flags, s, pad;
@@ -270,7 +270,7 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
/* sensor links(or mipi-phy) */
for (s = 0; s < dev->num_sensors; ++s) {
struct rkisp1_sensor_info *sensor = &dev->sensors[s];
struct rkisp_sensor_info *sensor = &dev->sensors[s];
for (pad = 0; pad < sensor->sd->entity.num_pads; pad++)
if (sensor->sd->entity.pads[pad].flags &
@@ -288,7 +288,7 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
ret = media_create_pad_link(
&sensor->sd->entity, pad,
&dev->isp_sdev.sd.entity,
RKISP1_ISP_PAD_SINK,
RKISP_ISP_PAD_SINK,
s ? 0 : MEDIA_LNK_FL_ENABLED);
if (ret) {
dev_err(dev->dev,
@@ -303,7 +303,7 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
sink = &dev->isp_sdev.sd.entity;
flags = MEDIA_LNK_FL_ENABLED;
ret = media_create_pad_link(source, 0, sink,
RKISP1_ISP_PAD_SINK_PARAMS, flags);
RKISP_ISP_PAD_SINK_PARAMS, flags);
if (ret < 0)
return ret;
@@ -311,9 +311,9 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
if (dev->isp_ver != ISP_V10_1) {
/* SP links */
source = &dev->isp_sdev.sd.entity;
sink = &dev->stream[RKISP1_STREAM_SP].vnode.vdev.entity;
sink = &dev->stream[RKISP_STREAM_SP].vnode.vdev.entity;
ret = media_create_pad_link(source,
RKISP1_ISP_PAD_SOURCE_PATH,
RKISP_ISP_PAD_SOURCE_PATH,
sink, 0, flags);
if (ret < 0)
return ret;
@@ -321,13 +321,13 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
/* MP links */
source = &dev->isp_sdev.sd.entity;
sink = &dev->stream[RKISP1_STREAM_MP].vnode.vdev.entity;
ret = media_create_pad_link(source, RKISP1_ISP_PAD_SOURCE_PATH,
sink, 0, flags);
sink = &dev->stream[RKISP_STREAM_MP].vnode.vdev.entity;
ret = media_create_pad_link(source, RKISP_ISP_PAD_SOURCE_PATH,
sink, 0, flags);
if (ret < 0)
return ret;
#if RKISP1_RK3326_USE_OLDMIPI
#if RKISP_RK3326_USE_OLDMIPI
if (dev->isp_ver == ISP_V13) {
#else
if (dev->isp_ver == ISP_V12 ||
@@ -335,9 +335,9 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
#endif
/* MIPI RAW links */
source = &dev->isp_sdev.sd.entity;
sink = &dev->stream[RKISP1_STREAM_RAW].vnode.vdev.entity;
sink = &dev->stream[RKISP_STREAM_RAW].vnode.vdev.entity;
ret = media_create_pad_link(source,
RKISP1_ISP_PAD_SOURCE_PATH, sink, 0, flags);
RKISP_ISP_PAD_SOURCE_PATH, sink, 0, flags);
if (ret < 0)
return ret;
}
@@ -345,11 +345,11 @@ static int rkisp1_create_links(struct rkisp1_device *dev)
/* 3A stats links */
source = &dev->isp_sdev.sd.entity;
sink = &dev->stats_vdev.vnode.vdev.entity;
return media_create_pad_link(source, RKISP1_ISP_PAD_SOURCE_STATS,
return media_create_pad_link(source, RKISP_ISP_PAD_SOURCE_STATS,
sink, 0, flags);
}
static int _set_pipeline_default_fmt(struct rkisp1_device *dev)
static int _set_pipeline_default_fmt(struct rkisp_device *dev)
{
struct v4l2_subdev *isp;
struct v4l2_subdev_format fmt;
@@ -399,51 +399,51 @@ static int _set_pipeline_default_fmt(struct rkisp1_device *dev)
fmt.which = V4L2_SUBDEV_FORMAT_ACTIVE;
memset(&cfg, 0, sizeof(cfg));
/* change fmt&size for RKISP1_ISP_PAD_SINK */
fmt.pad = RKISP1_ISP_PAD_SINK;
sel.pad = RKISP1_ISP_PAD_SINK;
/* change fmt&size for RKISP_ISP_PAD_SINK */
fmt.pad = RKISP_ISP_PAD_SINK;
sel.pad = RKISP_ISP_PAD_SINK;
v4l2_subdev_call(isp, pad, set_fmt, &cfg, &fmt);
v4l2_subdev_call(isp, pad, set_selection, &cfg, &sel);
/* change fmt&size for RKISP1_ISP_PAD_SOURCE_PATH */
if ((fmt.format.code & RKISP1_MEDIA_BUS_FMT_MASK) ==
RKISP1_MEDIA_BUS_FMT_BAYER)
/* change fmt&size for RKISP_ISP_PAD_SOURCE_PATH */
if ((fmt.format.code & RKISP_MEDIA_BUS_FMT_MASK) ==
RKISP_MEDIA_BUS_FMT_BAYER)
fmt.format.code = MEDIA_BUS_FMT_YUYV8_2X8;
fmt.pad = RKISP1_ISP_PAD_SOURCE_PATH;
sel.pad = RKISP1_ISP_PAD_SOURCE_PATH;
fmt.pad = RKISP_ISP_PAD_SOURCE_PATH;
sel.pad = RKISP_ISP_PAD_SOURCE_PATH;
v4l2_subdev_call(isp, pad, set_fmt, &cfg, &fmt);
v4l2_subdev_call(isp, pad, set_selection, &cfg, &sel);
/* change fmt&size of MP/SP */
rkisp1_set_stream_def_fmt(dev, RKISP1_STREAM_MP,
width, height, V4L2_PIX_FMT_YUYV);
rkisp_set_stream_def_fmt(dev, RKISP_STREAM_MP,
width, height, V4L2_PIX_FMT_YUYV);
if (dev->isp_ver != ISP_V10_1)
rkisp1_set_stream_def_fmt(dev, RKISP1_STREAM_SP,
width, height, V4L2_PIX_FMT_YUYV);
rkisp_set_stream_def_fmt(dev, RKISP_STREAM_SP,
width, height, V4L2_PIX_FMT_YUYV);
if (dev->isp_ver == ISP_V12 || dev->isp_ver == ISP_V13)
rkisp1_set_stream_def_fmt(dev, RKISP1_STREAM_RAW, ori_width,
ori_height, rkisp1_mbus_pixelcode_to_v4l2(ori_code));
rkisp_set_stream_def_fmt(dev, RKISP_STREAM_RAW, ori_width,
ori_height, rkisp_mbus_pixelcode_to_v4l2(ori_code));
return 0;
}
static int subdev_notifier_complete(struct v4l2_async_notifier *notifier)
{
struct rkisp1_device *dev;
struct rkisp_device *dev;
int ret;
dev = container_of(notifier, struct rkisp1_device, notifier);
dev = container_of(notifier, struct rkisp_device, notifier);
mutex_lock(&dev->media_dev.graph_mutex);
ret = rkisp1_create_links(dev);
ret = rkisp_create_links(dev);
if (ret < 0)
goto unlock;
ret = v4l2_device_register_subdev_nodes(&dev->v4l2_dev);
if (ret < 0)
goto unlock;
ret = rkisp1_update_sensor_info(dev);
ret = rkisp_update_sensor_info(dev);
if (ret < 0) {
v4l2_err(&dev->v4l2_dev, "update sensor failed\n");
goto unlock;
@@ -460,7 +460,7 @@ unlock:
return ret;
}
struct rkisp1_async_subdev {
struct rkisp_async_subdev {
struct v4l2_async_subdev asd;
struct v4l2_mbus_config mbus;
};
@@ -469,10 +469,10 @@ static int subdev_notifier_bound(struct v4l2_async_notifier *notifier,
struct v4l2_subdev *subdev,
struct v4l2_async_subdev *asd)
{
struct rkisp1_device *isp_dev = container_of(notifier,
struct rkisp1_device, notifier);
struct rkisp1_async_subdev *s_asd = container_of(asd,
struct rkisp1_async_subdev, asd);
struct rkisp_device *isp_dev = container_of(notifier,
struct rkisp_device, notifier);
struct rkisp_async_subdev *s_asd = container_of(asd,
struct rkisp_async_subdev, asd);
if (isp_dev->num_sensors == ARRAY_SIZE(isp_dev->sensors))
return -EBUSY;
@@ -481,17 +481,17 @@ static int subdev_notifier_bound(struct v4l2_async_notifier *notifier,
isp_dev->sensors[isp_dev->num_sensors].sd = subdev;
++isp_dev->num_sensors;
v4l2_dbg(1, rkisp1_debug, subdev, "Async registered subdev\n");
v4l2_dbg(1, rkisp_debug, subdev, "Async registered subdev\n");
return 0;
}
static int rkisp1_fwnode_parse(struct device *dev,
static int rkisp_fwnode_parse(struct device *dev,
struct v4l2_fwnode_endpoint *vep,
struct v4l2_async_subdev *asd)
{
struct rkisp1_async_subdev *rk_asd =
container_of(asd, struct rkisp1_async_subdev, asd);
struct rkisp_async_subdev *rk_asd =
container_of(asd, struct rkisp_async_subdev, asd);
struct v4l2_fwnode_bus_parallel *bus = &vep->bus.parallel;
/*
@@ -513,15 +513,15 @@ static const struct v4l2_async_notifier_operations subdev_notifier_ops = {
.complete = subdev_notifier_complete,
};
static int isp_subdev_notifier(struct rkisp1_device *isp_dev)
static int isp_subdev_notifier(struct rkisp_device *isp_dev)
{
struct v4l2_async_notifier *ntf = &isp_dev->notifier;
struct device *dev = isp_dev->dev;
int ret;
ret = v4l2_async_notifier_parse_fwnode_endpoints(
dev, ntf, sizeof(struct rkisp1_async_subdev),
rkisp1_fwnode_parse);
dev, ntf, sizeof(struct rkisp_async_subdev),
rkisp_fwnode_parse);
if (ret < 0)
return ret;
@@ -535,28 +535,27 @@ static int isp_subdev_notifier(struct rkisp1_device *isp_dev)
/***************************** platform deive *******************************/
static int rkisp1_register_platform_subdevs(struct rkisp1_device *dev)
static int rkisp_register_platform_subdevs(struct rkisp_device *dev)
{
int ret;
ret = rkisp1_register_isp_subdev(dev, &dev->v4l2_dev);
ret = rkisp_register_isp_subdev(dev, &dev->v4l2_dev);
if (ret < 0)
return ret;
ret = rkisp1_register_stream_vdevs(dev);
ret = rkisp_register_stream_vdevs(dev);
if (ret < 0)
goto err_unreg_isp_subdev;
ret = rkisp1_register_dmarx_vdev(dev);
ret = rkisp_register_dmarx_vdev(dev);
if (ret < 0)
goto err_unreg_stream_vdev;
ret = rkisp1_register_stats_vdev(&dev->stats_vdev, &dev->v4l2_dev, dev);
ret = rkisp_register_stats_vdev(&dev->stats_vdev, &dev->v4l2_dev, dev);
if (ret < 0)
goto err_unreg_dmarx_vdev;
ret = rkisp1_register_params_vdev(&dev->params_vdev, &dev->v4l2_dev,
dev);
ret = rkisp_register_params_vdev(&dev->params_vdev, &dev->v4l2_dev, dev);
if (ret < 0)
goto err_unreg_stats_vdev;
@@ -569,103 +568,103 @@ static int rkisp1_register_platform_subdevs(struct rkisp1_device *dev)
return 0;
err_unreg_params_vdev:
rkisp1_unregister_params_vdev(&dev->params_vdev);
rkisp_unregister_params_vdev(&dev->params_vdev);
err_unreg_stats_vdev:
rkisp1_unregister_stats_vdev(&dev->stats_vdev);
rkisp_unregister_stats_vdev(&dev->stats_vdev);
err_unreg_dmarx_vdev:
rkisp1_unregister_dmarx_vdev(dev);
rkisp_unregister_dmarx_vdev(dev);
err_unreg_stream_vdev:
rkisp1_unregister_stream_vdevs(dev);
rkisp_unregister_stream_vdevs(dev);
err_unreg_isp_subdev:
rkisp1_unregister_isp_subdev(dev);
rkisp_unregister_isp_subdev(dev);
return ret;
}
static irqreturn_t rkisp1_irq_handler(int irq, void *ctx)
static irqreturn_t rkisp_irq_handler(int irq, void *ctx)
{
struct device *dev = ctx;
struct rkisp1_device *rkisp1_dev = dev_get_drvdata(dev);
struct rkisp_device *rkisp_dev = dev_get_drvdata(dev);
unsigned int mis_val;
mis_val = readl(rkisp1_dev->base_addr + CIF_ISP_MIS);
mis_val = readl(rkisp_dev->base_addr + CIF_ISP_MIS);
if (mis_val)
rkisp1_isp_isr(mis_val, rkisp1_dev);
rkisp_isp_isr(mis_val, rkisp_dev);
mis_val = readl(rkisp1_dev->base_addr + CIF_MIPI_MIS);
mis_val = readl(rkisp_dev->base_addr + CIF_MIPI_MIS);
if (mis_val)
rkisp1_mipi_isr(mis_val, rkisp1_dev);
rkisp_mipi_isr(mis_val, rkisp_dev);
mis_val = readl(rkisp1_dev->base_addr + CIF_MI_MIS);
mis_val = readl(rkisp_dev->base_addr + CIF_MI_MIS);
if (mis_val)
rkisp1_mi_isr(mis_val, rkisp1_dev);
rkisp_mi_isr(mis_val, rkisp_dev);
return IRQ_HANDLED;
}
static irqreturn_t rkisp1_isp_irq_hdl(int irq, void *ctx)
static irqreturn_t rkisp_isp_irq_hdl(int irq, void *ctx)
{
struct device *dev = ctx;
struct rkisp1_device *rkisp1_dev = dev_get_drvdata(dev);
struct rkisp_device *rkisp_dev = dev_get_drvdata(dev);
unsigned int mis_val;
mis_val = readl(rkisp1_dev->base_addr + CIF_ISP_MIS);
mis_val = readl(rkisp_dev->base_addr + CIF_ISP_MIS);
if (mis_val)
rkisp1_isp_isr(mis_val, rkisp1_dev);
rkisp_isp_isr(mis_val, rkisp_dev);
return IRQ_HANDLED;
}
static irqreturn_t rkisp1_mi_irq_hdl(int irq, void *ctx)
static irqreturn_t rkisp_mi_irq_hdl(int irq, void *ctx)
{
struct device *dev = ctx;
struct rkisp1_device *rkisp1_dev = dev_get_drvdata(dev);
struct rkisp_device *rkisp_dev = dev_get_drvdata(dev);
unsigned int mis_val;
mis_val = readl(rkisp1_dev->base_addr + CIF_MI_MIS);
mis_val = readl(rkisp_dev->base_addr + CIF_MI_MIS);
if (mis_val)
rkisp1_mi_isr(mis_val, rkisp1_dev);
rkisp_mi_isr(mis_val, rkisp_dev);
return IRQ_HANDLED;
}
static irqreturn_t rkisp1_mipi_irq_hdl(int irq, void *ctx)
static irqreturn_t rkisp_mipi_irq_hdl(int irq, void *ctx)
{
struct device *dev = ctx;
struct rkisp1_device *rkisp1_dev = dev_get_drvdata(dev);
struct rkisp_device *rkisp_dev = dev_get_drvdata(dev);
unsigned int mis_val;
unsigned int err1, err2, err3;
#if RKISP1_RK3326_USE_OLDMIPI
if (rkisp1_dev->isp_ver == ISP_V13) {
#if RKISP_RK3326_USE_OLDMIPI
if (rkisp_dev->isp_ver == ISP_V13) {
#else
if (rkisp1_dev->isp_ver == ISP_V13 ||
rkisp1_dev->isp_ver == ISP_V12) {
if (rkisp_dev->isp_ver == ISP_V13 ||
rkisp_dev->isp_ver == ISP_V12) {
#endif
err1 = readl(rkisp1_dev->base_addr + CIF_ISP_CSI0_ERR1);
err2 = readl(rkisp1_dev->base_addr + CIF_ISP_CSI0_ERR2);
err3 = readl(rkisp1_dev->base_addr + CIF_ISP_CSI0_ERR3);
err1 = readl(rkisp_dev->base_addr + CIF_ISP_CSI0_ERR1);
err2 = readl(rkisp_dev->base_addr + CIF_ISP_CSI0_ERR2);
err3 = readl(rkisp_dev->base_addr + CIF_ISP_CSI0_ERR3);
if (err3 & 0x1)
rkisp1_mipi_dmatx0_end(err3, rkisp1_dev);
rkisp_mipi_dmatx0_end(err3, rkisp_dev);
if (err1 || err2 || err3)
rkisp1_mipi_v13_isr(err1, err2, err3, rkisp1_dev);
rkisp_mipi_v13_isr(err1, err2, err3, rkisp_dev);
} else {
mis_val = readl(rkisp1_dev->base_addr + CIF_MIPI_MIS);
mis_val = readl(rkisp_dev->base_addr + CIF_MIPI_MIS);
if (mis_val)
rkisp1_mipi_isr(mis_val, rkisp1_dev);
rkisp_mipi_isr(mis_val, rkisp_dev);
/*
* As default interrupt mask for csi_rx are on,
* when resetting isp, interrupt from csi_rx maybe arise,
* we should clear them.
*/
#if RKISP1_RK3326_USE_OLDMIPI
if (rkisp1_dev->isp_ver == ISP_V12) {
#if RKISP_RK3326_USE_OLDMIPI
if (rkisp_dev->isp_ver == ISP_V12) {
/* read error state register to clear interrupt state */
readl(rkisp1_dev->base_addr + CIF_ISP_CSI0_ERR1);
readl(rkisp1_dev->base_addr + CIF_ISP_CSI0_ERR2);
readl(rkisp1_dev->base_addr + CIF_ISP_CSI0_ERR3);
readl(rkisp_dev->base_addr + CIF_ISP_CSI0_ERR1);
readl(rkisp_dev->base_addr + CIF_ISP_CSI0_ERR2);
readl(rkisp_dev->base_addr + CIF_ISP_CSI0_ERR3);
}
#endif
}
@@ -737,27 +736,27 @@ static const unsigned int rk3399_isp_clk_rate[] = {
};
static struct isp_irqs_data rk1808_isp_irqs[] = {
{"isp_irq", rkisp1_isp_irq_hdl},
{"mi_irq", rkisp1_mi_irq_hdl},
{"mipi_irq", rkisp1_mipi_irq_hdl}
{"isp_irq", rkisp_isp_irq_hdl},
{"mi_irq", rkisp_mi_irq_hdl},
{"mipi_irq", rkisp_mipi_irq_hdl}
};
static struct isp_irqs_data rk3288_isp_irqs[] = {
{"isp_irq", rkisp1_irq_handler}
{"isp_irq", rkisp_irq_handler}
};
static struct isp_irqs_data rk3326_isp_irqs[] = {
{"isp_irq", rkisp1_isp_irq_hdl},
{"mi_irq", rkisp1_mi_irq_hdl},
{"mipi_irq", rkisp1_mipi_irq_hdl}
{"isp_irq", rkisp_isp_irq_hdl},
{"mi_irq", rkisp_mi_irq_hdl},
{"mipi_irq", rkisp_mipi_irq_hdl}
};
static struct isp_irqs_data rk3368_isp_irqs[] = {
{"isp_irq", rkisp1_irq_handler}
{"isp_irq", rkisp_irq_handler}
};
static struct isp_irqs_data rk3399_isp_irqs[] = {
{"isp_irq", rkisp1_irq_handler}
{"isp_irq", rkisp_irq_handler}
};
static const struct isp_match_data rk1808_isp_match_data = {
@@ -810,7 +809,7 @@ static const struct isp_match_data rk3399_isp_match_data = {
.num_irqs = ARRAY_SIZE(rk3399_isp_irqs)
};
static const struct of_device_id rkisp1_plat_of_match[] = {
static const struct of_device_id rkisp_plat_of_match[] = {
{
.compatible = "rockchip,rk1808-rkisp1",
.data = &rk1808_isp_match_data,
@@ -830,22 +829,22 @@ static const struct of_device_id rkisp1_plat_of_match[] = {
{},
};
static void rkisp1_disable_sys_clk(struct rkisp1_device *rkisp1_dev)
static void rkisp_disable_sys_clk(struct rkisp_device *rkisp_dev)
{
int i;
for (i = rkisp1_dev->num_clks - 1; i >= 0; i--)
if (!IS_ERR(rkisp1_dev->clks[i]))
clk_disable_unprepare(rkisp1_dev->clks[i]);
for (i = rkisp_dev->num_clks - 1; i >= 0; i--)
if (!IS_ERR(rkisp_dev->clks[i]))
clk_disable_unprepare(rkisp_dev->clks[i]);
}
static int rkisp1_enable_sys_clk(struct rkisp1_device *rkisp1_dev)
static int rkisp_enable_sys_clk(struct rkisp_device *rkisp_dev)
{
int i, ret = -EINVAL;
for (i = 0; i < rkisp1_dev->num_clks; i++) {
if (!IS_ERR(rkisp1_dev->clks[i])) {
ret = clk_prepare_enable(rkisp1_dev->clks[i]);
for (i = 0; i < rkisp_dev->num_clks; i++) {
if (!IS_ERR(rkisp_dev->clks[i])) {
ret = clk_prepare_enable(rkisp_dev->clks[i]);
if (ret < 0)
goto err;
}
@@ -853,8 +852,8 @@ static int rkisp1_enable_sys_clk(struct rkisp1_device *rkisp1_dev)
return 0;
err:
for (--i; i >= 0; --i)
if (!IS_ERR(rkisp1_dev->clks[i]))
clk_disable_unprepare(rkisp1_dev->clks[i]);
if (!IS_ERR(rkisp_dev->clks[i]))
clk_disable_unprepare(rkisp_dev->clks[i]);
return ret;
}
@@ -876,14 +875,14 @@ static inline bool is_iommu_enable(struct device *dev)
return true;
}
static int rkisp1_vs_irq_parse(struct platform_device *pdev)
static int rkisp_vs_irq_parse(struct platform_device *pdev)
{
int ret;
int vs_irq;
unsigned long vs_irq_flags;
struct gpio_desc *vs_irq_gpio;
struct device *dev = &pdev->dev;
struct rkisp1_device *isp_dev = dev_get_drvdata(dev);
struct rkisp_device *isp_dev = dev_get_drvdata(dev);
/* this irq recevice the message of sensor vs from preisp */
isp_dev->vs_irq = -1;
@@ -901,7 +900,7 @@ static int rkisp1_vs_irq_parse(struct platform_device *pdev)
dev_info(dev, "register_irq: %d\n", vs_irq);
ret = devm_request_irq(dev,
vs_irq,
rkisp1_vs_isr_handler,
rkisp_vs_isr_handler,
vs_irq_flags,
"vs_irq_gpio_int",
dev);
@@ -919,29 +918,29 @@ static int rkisp1_vs_irq_parse(struct platform_device *pdev)
return 0;
}
static const struct media_device_ops rkisp1_media_ops = {
static const struct media_device_ops rkisp_media_ops = {
.link_notify = v4l2_pipeline_link_notify,
};
static int rkisp1_plat_probe(struct platform_device *pdev)
static int rkisp_plat_probe(struct platform_device *pdev)
{
const struct of_device_id *match;
struct device_node *node = pdev->dev.of_node;
struct device *dev = &pdev->dev;
struct v4l2_device *v4l2_dev;
struct rkisp1_device *isp_dev;
struct rkisp_device *isp_dev;
const struct isp_match_data *match_data;
struct resource *res;
int i, ret, irq;
sprintf(rkisp1_version, "v%02x.%02x.%02x",
RKISP1_DRIVER_VERSION >> 16,
(RKISP1_DRIVER_VERSION & 0xff00) >> 8,
RKISP1_DRIVER_VERSION & 0x00ff);
sprintf(rkisp_version, "v%02x.%02x.%02x",
RKISP_DRIVER_VERSION >> 16,
(RKISP_DRIVER_VERSION & 0xff00) >> 8,
RKISP_DRIVER_VERSION & 0x00ff);
dev_info(dev, "rkisp1 driver version: %s\n", rkisp1_version);
dev_info(dev, "rkisp driver version: %s\n", rkisp_version);
match = of_match_node(rkisp1_plat_of_match, node);
match = of_match_node(rkisp_plat_of_match, node);
isp_dev = devm_kzalloc(dev, sizeof(*isp_dev), GFP_KERNEL);
if (!isp_dev)
return -ENOMEM;
@@ -1001,7 +1000,7 @@ static int rkisp1_plat_probe(struct platform_device *pdev)
}
ret = devm_request_irq(dev, irq,
rkisp1_irq_handler,
rkisp_irq_handler,
IRQF_SHARED,
dev_driver_string(dev),
dev);
@@ -1029,21 +1028,21 @@ static int rkisp1_plat_probe(struct platform_device *pdev)
atomic_set(&isp_dev->pipe.stream_cnt, 0);
atomic_set(&isp_dev->open_cnt, 0);
init_waitqueue_head(&isp_dev->sync_onoff);
isp_dev->pipe.open = rkisp1_pipeline_open;
isp_dev->pipe.close = rkisp1_pipeline_close;
isp_dev->pipe.set_stream = rkisp1_pipeline_set_stream;
isp_dev->pipe.open = rkisp_pipeline_open;
isp_dev->pipe.close = rkisp_pipeline_close;
isp_dev->pipe.set_stream = rkisp_pipeline_set_stream;
rkisp1_stream_init(isp_dev, RKISP1_STREAM_SP);
rkisp1_stream_init(isp_dev, RKISP1_STREAM_MP);
rkisp1_stream_init(isp_dev, RKISP1_STREAM_RAW);
rkisp_stream_init(isp_dev, RKISP_STREAM_SP);
rkisp_stream_init(isp_dev, RKISP_STREAM_MP);
rkisp_stream_init(isp_dev, RKISP_STREAM_RAW);
strlcpy(isp_dev->media_dev.model, "rkisp1",
strlcpy(isp_dev->media_dev.model, DRIVER_NAME,
sizeof(isp_dev->media_dev.model));
isp_dev->media_dev.dev = &pdev->dev;
isp_dev->media_dev.ops = &rkisp1_media_ops;
isp_dev->media_dev.ops = &rkisp_media_ops;
v4l2_dev = &isp_dev->v4l2_dev;
v4l2_dev->mdev = &isp_dev->media_dev;
strlcpy(v4l2_dev->name, "rkisp1", sizeof(v4l2_dev->name));
strlcpy(v4l2_dev->name, DRIVER_NAME, sizeof(v4l2_dev->name));
v4l2_ctrl_handler_init(&isp_dev->ctrl_handler, 5);
v4l2_dev->ctrl_handler = &isp_dev->ctrl_handler;
@@ -1063,7 +1062,7 @@ static int rkisp1_plat_probe(struct platform_device *pdev)
}
/* create & register platefom subdev (from of_node) */
ret = rkisp1_register_platform_subdevs(isp_dev);
ret = rkisp_register_platform_subdevs(isp_dev);
if (ret < 0)
goto err_unreg_media_dev;
@@ -1076,13 +1075,13 @@ static int rkisp1_plat_probe(struct platform_device *pdev)
pm_runtime_enable(&pdev->dev);
ret = rkisp1_vs_irq_parse(pdev);
ret = rkisp_vs_irq_parse(pdev);
if (ret)
goto err_runtime_disable;
mutex_lock(&rkisp1_dev_mutex);
list_add_tail(&isp_dev->list, &rkisp1_device_list);
mutex_unlock(&rkisp1_dev_mutex);
mutex_lock(&rkisp_dev_mutex);
list_add_tail(&isp_dev->list, &rkisp_device_list);
mutex_unlock(&rkisp_dev_mutex);
return 0;
err_runtime_disable:
@@ -1095,44 +1094,44 @@ err_unreg_v4l2_dev:
return ret;
}
static int rkisp1_plat_remove(struct platform_device *pdev)
static int rkisp_plat_remove(struct platform_device *pdev)
{
struct rkisp1_device *isp_dev = platform_get_drvdata(pdev);
struct rkisp_device *isp_dev = platform_get_drvdata(pdev);
pm_runtime_disable(&pdev->dev);
media_device_unregister(&isp_dev->media_dev);
v4l2_device_unregister(&isp_dev->v4l2_dev);
rkisp1_unregister_params_vdev(&isp_dev->params_vdev);
rkisp1_unregister_stats_vdev(&isp_dev->stats_vdev);
rkisp1_unregister_stream_vdevs(isp_dev);
rkisp1_unregister_isp_subdev(isp_dev);
rkisp_unregister_params_vdev(&isp_dev->params_vdev);
rkisp_unregister_stats_vdev(&isp_dev->stats_vdev);
rkisp_unregister_stream_vdevs(isp_dev);
rkisp_unregister_isp_subdev(isp_dev);
media_device_cleanup(&isp_dev->media_dev);
return 0;
}
static int __maybe_unused rkisp1_runtime_suspend(struct device *dev)
static int __maybe_unused rkisp_runtime_suspend(struct device *dev)
{
struct rkisp1_device *isp_dev = dev_get_drvdata(dev);
struct rkisp_device *isp_dev = dev_get_drvdata(dev);
if (isp_dev->isp_ver == ISP_V12 || isp_dev->isp_ver == ISP_V13) {
if (isp_dev->mipi_irq >= 0)
disable_irq(isp_dev->mipi_irq);
}
rkisp1_disable_sys_clk(isp_dev);
rkisp_disable_sys_clk(isp_dev);
return pinctrl_pm_select_sleep_state(dev);
}
static int __maybe_unused rkisp1_runtime_resume(struct device *dev)
static int __maybe_unused rkisp_runtime_resume(struct device *dev)
{
struct rkisp1_device *isp_dev = dev_get_drvdata(dev);
struct rkisp_device *isp_dev = dev_get_drvdata(dev);
int ret;
ret = pinctrl_pm_select_default_state(dev);
if (ret < 0)
return ret;
rkisp1_enable_sys_clk(isp_dev);
rkisp_enable_sys_clk(isp_dev);
if (isp_dev->isp_ver == ISP_V12 || isp_dev->isp_ver == ISP_V13) {
writel(0, isp_dev->base_addr + CIF_ISP_CSI0_MASK1);
@@ -1145,36 +1144,36 @@ static int __maybe_unused rkisp1_runtime_resume(struct device *dev)
return 0;
}
static int __init rkisp1_clr_unready_dev(void)
static int __init rkisp_clr_unready_dev(void)
{
struct rkisp1_device *isp_dev;
struct rkisp_device *isp_dev;
mutex_lock(&rkisp1_dev_mutex);
list_for_each_entry(isp_dev, &rkisp1_device_list, list)
mutex_lock(&rkisp_dev_mutex);
list_for_each_entry(isp_dev, &rkisp_device_list, list)
v4l2_async_notifier_clr_unready_dev(&isp_dev->notifier);
mutex_unlock(&rkisp1_dev_mutex);
mutex_unlock(&rkisp_dev_mutex);
return 0;
}
late_initcall_sync(rkisp1_clr_unready_dev);
late_initcall_sync(rkisp_clr_unready_dev);
static const struct dev_pm_ops rkisp1_plat_pm_ops = {
static const struct dev_pm_ops rkisp_plat_pm_ops = {
SET_SYSTEM_SLEEP_PM_OPS(pm_runtime_force_suspend,
pm_runtime_force_resume)
SET_RUNTIME_PM_OPS(rkisp1_runtime_suspend, rkisp1_runtime_resume, NULL)
SET_RUNTIME_PM_OPS(rkisp_runtime_suspend, rkisp_runtime_resume, NULL)
};
static struct platform_driver rkisp1_plat_drv = {
static struct platform_driver rkisp_plat_drv = {
.driver = {
.name = DRIVER_NAME,
.of_match_table = of_match_ptr(rkisp1_plat_of_match),
.pm = &rkisp1_plat_pm_ops,
.of_match_table = of_match_ptr(rkisp_plat_of_match),
.pm = &rkisp_plat_pm_ops,
},
.probe = rkisp1_plat_probe,
.remove = rkisp1_plat_remove,
.probe = rkisp_plat_probe,
.remove = rkisp_plat_remove,
};
module_platform_driver(rkisp1_plat_drv);
module_platform_driver(rkisp_plat_drv);
MODULE_AUTHOR("Rockchip Camera/ISP team");
MODULE_DESCRIPTION("Rockchip ISP1 platform driver");
MODULE_DESCRIPTION("Rockchip ISP platform driver");
MODULE_LICENSE("Dual BSD/GPL");

74
drivers/media/platform/rockchip/isp1/dev.h → drivers/media/platform/rockchip/isp/dev.h
View File

@@ -32,12 +32,12 @@
* SOFTWARE.
*/
#ifndef _RKISP1_DEV_H
#define _RKISP1_DEV_H
#ifndef _RKISP_DEV_H
#define _RKISP_DEV_H
#include "capture.h"
#include "dmarx.h"
#include "rkisp1.h"
#include "rkisp.h"
#include "isp_params.h"
#include "isp_stats.h"
@@ -55,17 +55,17 @@
#define GRP_ID_ISP_SP BIT(4)
#define GRP_ID_ISP_DMARX BIT(5)
#define RKISP1_MAX_BUS_CLK 8
#define RKISP1_MAX_SENSOR 2
#define RKISP1_MAX_PIPELINE 4
#define RKISP_MAX_BUS_CLK 8
#define RKISP_MAX_SENSOR 2
#define RKISP_MAX_PIPELINE 4
#define RKISP1_MEDIA_BUS_FMT_MASK 0xF000
#define RKISP1_MEDIA_BUS_FMT_BAYER 0x3000
#define RKISP_MEDIA_BUS_FMT_MASK 0xF000
#define RKISP_MEDIA_BUS_FMT_BAYER 0x3000
#define RKISP1_CONTI_ERR_MAX 50
#define RKISP_CONTI_ERR_MAX 50
/* ISP_V10_1 for only support MP */
enum rkisp1_isp_ver {
enum rkisp_isp_ver {
ISP_V10 = 0x00,
ISP_V10_1 = 0x01,
ISP_V11 = 0x10,
@@ -73,13 +73,13 @@ enum rkisp1_isp_ver {
ISP_V13 = 0x30,
};
enum rkisp1_isp_state {
enum rkisp_isp_state {
ISP_STOP = 0,
ISP_START,
ISP_ERROR
};
enum rkisp1_isp_inp {
enum rkisp_isp_inp {
INP_INVAL = 0,
INP_CSI,
INP_DVP,
@@ -87,7 +87,7 @@ enum rkisp1_isp_inp {
};
/*
* struct rkisp1_pipeline - An ISP hardware pipeline
* struct rkisp_pipeline - An ISP hardware pipeline
*
* Capture device call other devices via pipeline
*
@@ -95,23 +95,23 @@ enum rkisp1_isp_inp {
* @power_cnt: pipeline power count
* @stream_cnt: stream power count
*/
struct rkisp1_pipeline {
struct rkisp_pipeline {
struct media_pipeline pipe;
int num_subdevs;
atomic_t power_cnt;
atomic_t stream_cnt;
struct v4l2_subdev *subdevs[RKISP1_MAX_PIPELINE];
int (*open)(struct rkisp1_pipeline *p,
struct v4l2_subdev *subdevs[RKISP_MAX_PIPELINE];
int (*open)(struct rkisp_pipeline *p,
struct media_entity *me, bool prepare);
int (*close)(struct rkisp1_pipeline *p);
int (*set_stream)(struct rkisp1_pipeline *p, bool on);
int (*close)(struct rkisp_pipeline *p);
int (*set_stream)(struct rkisp_pipeline *p, bool on);
};
/*
* struct rkisp1_sensor_info - Sensor infomations
* struct rkisp_sensor_info - Sensor infomations
* @mbus: media bus configuration
*/
struct rkisp1_sensor_info {
struct rkisp_sensor_info {
struct v4l2_subdev *sd;
struct v4l2_mbus_config mbus;
struct v4l2_subdev_format fmt;
@@ -119,42 +119,42 @@ struct rkisp1_sensor_info {
};
/*
* struct rkisp1_device - ISP platform device
* struct rkisp_device - ISP platform device
* @base_addr: base register address
* @active_sensor: sensor in-use, set when streaming on
* @isp_sdev: ISP sub-device
* @rkisp1_stream: capture video device
* @rkisp_stream: capture video device
* @stats_vdev: ISP statistics output device
* @params_vdev: ISP input parameters device
*/
struct rkisp1_device {
struct rkisp_device {
struct list_head list;
struct regmap *grf;
void __iomem *base_addr;
int irq;
struct device *dev;
struct clk *clks[RKISP1_MAX_BUS_CLK];
struct clk *clks[RKISP_MAX_BUS_CLK];
int num_clks;
struct v4l2_device v4l2_dev;
struct v4l2_ctrl_handler ctrl_handler;
struct media_device media_dev;
struct v4l2_async_notifier notifier;
struct v4l2_subdev *subdevs[RKISP1_SD_MAX];
struct rkisp1_sensor_info *active_sensor;
struct rkisp1_sensor_info sensors[RKISP1_MAX_SENSOR];
struct v4l2_subdev *subdevs[RKISP_SD_MAX];
struct rkisp_sensor_info *active_sensor;
struct rkisp_sensor_info sensors[RKISP_MAX_SENSOR];
int num_sensors;
struct rkisp1_isp_subdev isp_sdev;
struct rkisp1_stream stream[RKISP1_MAX_STREAM];
struct rkisp1_isp_stats_vdev stats_vdev;
struct rkisp1_isp_params_vdev params_vdev;
struct rkisp1_dmarx_device dmarx_dev;
struct rkisp1_pipeline pipe;
struct rkisp_isp_subdev isp_sdev;
struct rkisp_stream stream[RKISP_MAX_STREAM];
struct rkisp_isp_stats_vdev stats_vdev;
struct rkisp_isp_params_vdev params_vdev;
struct rkisp_dmarx_device dmarx_dev;
struct rkisp_pipeline pipe;
struct iommu_domain *domain;
enum rkisp1_isp_ver isp_ver;
enum rkisp_isp_ver isp_ver;
const unsigned int *clk_rate_tbl;
int num_clk_rate_tbl;
atomic_t open_cnt;
struct rkisp1_emd_data emd_data_fifo[RKISP1_EMDDATA_FIFO_MAX];
struct rkisp_emd_data emd_data_fifo[RKISP_EMDDATA_FIFO_MAX];
unsigned int emd_data_idx;
unsigned int emd_vc;
unsigned int emd_dt;
@@ -162,9 +162,9 @@ struct rkisp1_device {
int mipi_irq;
struct gpio_desc *vs_irq_gpio;
struct v4l2_subdev *hdr_sensor;
enum rkisp1_isp_state isp_state;
enum rkisp_isp_state isp_state;
unsigned int isp_err_cnt;
enum rkisp1_isp_inp isp_inp;
enum rkisp_isp_inp isp_inp;
struct mutex apilock; /* mutex to serialize the calls of stream */
struct mutex iqlock; /* mutex to serialize the calls of iq */
wait_queue_head_t sync_onoff;

164
drivers/media/platform/rockchip/isp1/dmarx.c → drivers/media/platform/rockchip/isp/dmarx.c
View File

@@ -100,7 +100,7 @@ static const struct capture_fmt dmarx_fmts[] = {
}
};
static struct stream_config rkisp1_dmarx_stream_config = {
static struct stream_config rkisp_dmarx_stream_config = {
.fmts = dmarx_fmts,
.fmt_size = ARRAY_SIZE(dmarx_fmts),
.mi = {
@@ -112,7 +112,7 @@ static struct stream_config rkisp1_dmarx_stream_config = {
};
static const
struct capture_fmt *find_fmt(struct rkisp1_stream *stream,
struct capture_fmt *find_fmt(struct rkisp_stream *stream,
const u32 pixelfmt)
{
const struct capture_fmt *fmt;
@@ -126,13 +126,13 @@ struct capture_fmt *find_fmt(struct rkisp1_stream *stream,
return NULL;
}
static int dmarx_config_mi(struct rkisp1_stream *stream)
static int dmarx_config_mi(struct rkisp_stream *stream)
{
struct rkisp1_device *dev = stream->ispdev;
struct rkisp_device *dev = stream->ispdev;
void __iomem *base = dev->base_addr;
struct capture_fmt *dmarx_in_fmt = &stream->out_isp_fmt;
v4l2_dbg(1, rkisp1_debug, &dev->v4l2_dev,
v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
"%s %dx%x y_stride:%d\n", __func__,
stream->out_fmt.width,
stream->out_fmt.height,
@@ -155,34 +155,34 @@ static int dmarx_config_mi(struct rkisp1_stream *stream)
return 0;
}
static void update_dmarx(struct rkisp1_stream *stream)
static void update_dmarx(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
if (stream->curr_buf) {
mi_set_y_addr(stream,
stream->curr_buf->buff_addr[RKISP1_PLANE_Y]);
stream->curr_buf->buff_addr[RKISP_PLANE_Y]);
mi_set_cb_addr(stream,
stream->curr_buf->buff_addr[RKISP1_PLANE_CB]);
stream->curr_buf->buff_addr[RKISP_PLANE_CB]);
mi_set_cr_addr(stream,
stream->curr_buf->buff_addr[RKISP1_PLANE_CR]);
stream->curr_buf->buff_addr[RKISP_PLANE_CR]);
mi_dmarx_start(base);
stream->frame_end = false;
}
}
static void dmarx_stop_mi(struct rkisp1_stream *stream)
static void dmarx_stop_mi(struct rkisp_stream *stream)
{
mi_dmarx_ready_disable(stream);
}
static struct streams_ops rkisp1_dmarx_streams_ops = {
static struct streams_ops rkisp_dmarx_streams_ops = {
.config_mi = dmarx_config_mi,
.stop_mi = dmarx_stop_mi,
.update_mi = update_dmarx,
};
static int dmarx_frame_end(struct rkisp1_stream *stream)
static int dmarx_frame_end(struct rkisp_stream *stream)
{
unsigned long lock_flags = 0;
@@ -196,7 +196,7 @@ static int dmarx_frame_end(struct rkisp1_stream *stream)
if (!list_empty(&stream->buf_queue)) {
stream->curr_buf =
list_first_entry(&stream->buf_queue,
struct rkisp1_buffer,
struct rkisp_buffer,
queue);
list_del(&stream->curr_buf->queue);
}
@@ -208,9 +208,9 @@ static int dmarx_frame_end(struct rkisp1_stream *stream)
/***************************** vb2 operations*******************************/
static void dmarx_stop(struct rkisp1_stream *stream)
static void dmarx_stop(struct rkisp_stream *stream)
{
struct rkisp1_device *dev = stream->ispdev;
struct rkisp_device *dev = stream->ispdev;
struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
int ret = 0;
@@ -232,7 +232,7 @@ static void dmarx_stop(struct rkisp1_stream *stream)
stream->frame_end = false;
}
static int dmarx_start(struct rkisp1_stream *stream)
static int dmarx_start(struct rkisp_stream *stream)
{
int ret;
@@ -246,14 +246,14 @@ static int dmarx_start(struct rkisp1_stream *stream)
return 0;
}
static int rkisp1_queue_setup(struct vb2_queue *queue,
static int rkisp_queue_setup(struct vb2_queue *queue,
unsigned int *num_buffers,
unsigned int *num_planes,
unsigned int sizes[],
struct device *alloc_ctxs[])
{
struct rkisp1_stream *stream = queue->drv_priv;
struct rkisp1_device *dev = stream->ispdev;
struct rkisp_stream *stream = queue->drv_priv;
struct rkisp_device *dev = stream->ispdev;
const struct v4l2_pix_format_mplane *pixm = NULL;
const struct capture_fmt *isp_fmt = NULL;
u32 i;
@@ -270,22 +270,22 @@ static int rkisp1_queue_setup(struct vb2_queue *queue,
sizes[i] = plane_fmt->sizeimage;
}
v4l2_dbg(1, rkisp1_debug, &dev->v4l2_dev, "%s count %d, size %d\n",
v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev, "%s count %d, size %d\n",
v4l2_type_names[queue->type], *num_buffers, sizes[0]);
return 0;
}
/*
* The vb2_buffer are stored in rkisp1_buffer, in order to unify
* The vb2_buffer are stored in rkisp_buffer, in order to unify
* mplane buffer and none-mplane buffer.
*/
static void rkisp1_buf_queue(struct vb2_buffer *vb)
static void rkisp_buf_queue(struct vb2_buffer *vb)
{
struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
struct rkisp1_buffer *ispbuf = to_rkisp1_buffer(vbuf);
struct rkisp_buffer *ispbuf = to_rkisp_buffer(vbuf);
struct vb2_queue *queue = vb->vb2_queue;
struct rkisp1_stream *stream = queue->drv_priv;
struct rkisp_stream *stream = queue->drv_priv;
unsigned long lock_flags = 0;
struct v4l2_pix_format_mplane *pixm = &stream->out_fmt;
struct capture_fmt *isp_fmt = &stream->out_isp_fmt;
@@ -324,8 +324,8 @@ static void rkisp1_buf_queue(struct vb2_buffer *vb)
static void dmarx_stop_streaming(struct vb2_queue *queue)
{
struct rkisp1_stream *stream = queue->drv_priv;
struct rkisp1_buffer *buf;
struct rkisp_stream *stream = queue->drv_priv;
struct rkisp_buffer *buf;
unsigned long lock_flags = 0;
dmarx_stop(stream);
@@ -337,7 +337,7 @@ static void dmarx_stop_streaming(struct vb2_queue *queue)
}
while (!list_empty(&stream->buf_queue)) {
buf = list_first_entry(&stream->buf_queue,
struct rkisp1_buffer, queue);
struct rkisp_buffer, queue);
list_del(&buf->queue);
vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
}
@@ -347,8 +347,8 @@ static void dmarx_stop_streaming(struct vb2_queue *queue)
static int dmarx_start_streaming(struct vb2_queue *queue,
unsigned int count)
{
struct rkisp1_stream *stream = queue->drv_priv;
struct rkisp1_device *dev = stream->ispdev;
struct rkisp_stream *stream = queue->drv_priv;
struct rkisp_device *dev = stream->ispdev;
struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
int ret = 0;
@@ -371,8 +371,8 @@ static int dmarx_start_streaming(struct vb2_queue *queue,
}
static struct vb2_ops dmarx_vb2_ops = {
.queue_setup = rkisp1_queue_setup,
.buf_queue = rkisp1_buf_queue,
.queue_setup = rkisp_queue_setup,
.buf_queue = rkisp_buf_queue,
.wait_prepare = vb2_ops_wait_prepare,
.wait_finish = vb2_ops_wait_finish,
.stop_streaming = dmarx_stop_streaming,
@@ -380,10 +380,10 @@ static struct vb2_ops dmarx_vb2_ops = {
};
static int rkisp_init_vb2_queue(struct vb2_queue *q,
struct rkisp1_stream *stream,
struct rkisp_stream *stream,
enum v4l2_buf_type buf_type)
{
struct rkisp1_vdev_node *node;
struct rkisp_vdev_node *node;
node = queue_to_node(q);
@@ -392,7 +392,7 @@ static int rkisp_init_vb2_queue(struct vb2_queue *q,
q->drv_priv = stream;
q->ops = &dmarx_vb2_ops;
q->mem_ops = &vb2_dma_contig_memops;
q->buf_struct_size = sizeof(struct rkisp1_buffer);
q->buf_struct_size = sizeof(struct rkisp_buffer);
q->min_buffers_needed = CIF_ISP_REQ_BUFS_MIN;
q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
q->lock = &stream->ispdev->apilock;
@@ -400,7 +400,7 @@ static int rkisp_init_vb2_queue(struct vb2_queue *q,
return vb2_queue_init(q);
}
static int rkisp1_set_fmt(struct rkisp1_stream *stream,
static int rkisp_set_fmt(struct rkisp_stream *stream,
struct v4l2_pix_format_mplane *pixm,
bool try)
{
@@ -469,7 +469,7 @@ static int rkisp1_set_fmt(struct rkisp1_stream *stream,
pixm->plane_fmt[0].bytesperline /
DIV_ROUND_UP(fmt->bpp[0], 8);
v4l2_dbg(1, rkisp1_debug, &stream->ispdev->v4l2_dev,
v4l2_dbg(1, rkisp_debug, &stream->ispdev->v4l2_dev,
"%s: stream: %d req(%d, %d) out(%d, %d)\n", __func__,
stream->id, pixm->width, pixm->height,
stream->out_fmt.width, stream->out_fmt.height);
@@ -480,26 +480,26 @@ static int rkisp1_set_fmt(struct rkisp1_stream *stream,
/************************* v4l2_file_operations***************************/
static const struct v4l2_file_operations rkisp1_fops = {
.open = rkisp1_fh_open,
.release = rkisp1_fop_release,
static const struct v4l2_file_operations rkisp_fops = {
.open = rkisp_fh_open,
.release = rkisp_fop_release,
.unlocked_ioctl = video_ioctl2,
.poll = vb2_fop_poll,
.mmap = vb2_fop_mmap,
};
static int rkisp1_try_fmt_vid_out_mplane(struct file *file, void *fh,
static int rkisp_try_fmt_vid_out_mplane(struct file *file, void *fh,
struct v4l2_format *f)
{
struct rkisp1_stream *stream = video_drvdata(file);
struct rkisp_stream *stream = video_drvdata(file);
return rkisp1_set_fmt(stream, &f->fmt.pix_mp, true);
return rkisp_set_fmt(stream, &f->fmt.pix_mp, true);
}
static int rkisp1_enum_fmt_vid_out_mplane(struct file *file, void *priv,
static int rkisp_enum_fmt_vid_out_mplane(struct file *file, void *priv,
struct v4l2_fmtdesc *f)
{
struct rkisp1_stream *stream = video_drvdata(file);
struct rkisp_stream *stream = video_drvdata(file);
const struct capture_fmt *fmt = NULL;
if (f->index >= stream->config->fmt_size)
@@ -511,36 +511,36 @@ static int rkisp1_enum_fmt_vid_out_mplane(struct file *file, void *priv,
return 0;
}
static int rkisp1_s_fmt_vid_out_mplane(struct file *file,
static int rkisp_s_fmt_vid_out_mplane(struct file *file,
void *priv, struct v4l2_format *f)
{
struct rkisp1_stream *stream = video_drvdata(file);
struct rkisp_stream *stream = video_drvdata(file);
struct video_device *vdev = &stream->vnode.vdev;
struct rkisp1_vdev_node *node = vdev_to_node(vdev);
struct rkisp1_device *dev = stream->ispdev;
struct rkisp_vdev_node *node = vdev_to_node(vdev);
struct rkisp_device *dev = stream->ispdev;
if (vb2_is_busy(&node->buf_queue)) {
v4l2_err(&dev->v4l2_dev, "%s queue busy\n", __func__);
return -EBUSY;
}
return rkisp1_set_fmt(stream, &f->fmt.pix_mp, false);
return rkisp_set_fmt(stream, &f->fmt.pix_mp, false);
}
static int rkisp1_g_fmt_vid_out_mplane(struct file *file, void *fh,
static int rkisp_g_fmt_vid_out_mplane(struct file *file, void *fh,
struct v4l2_format *f)
{
struct rkisp1_stream *stream = video_drvdata(file);
struct rkisp_stream *stream = video_drvdata(file);
f->fmt.pix_mp = stream->out_fmt;
return 0;
}
static int rkisp1_querycap(struct file *file, void *priv,
static int rkisp_querycap(struct file *file, void *priv,
struct v4l2_capability *cap)
{
struct rkisp1_stream *stream = video_drvdata(file);
struct rkisp_stream *stream = video_drvdata(file);
struct device *dev = stream->ispdev->dev;
struct video_device *vdev = video_devdata(file);
@@ -554,7 +554,7 @@ static int rkisp1_querycap(struct file *file, void *priv,
return 0;
}
static const struct v4l2_ioctl_ops rkisp1_dmarx_ioctl = {
static const struct v4l2_ioctl_ops rkisp_dmarx_ioctl = {
.vidioc_reqbufs = vb2_ioctl_reqbufs,
.vidioc_querybuf = vb2_ioctl_querybuf,
.vidioc_create_bufs = vb2_ioctl_create_bufs,
@@ -564,37 +564,37 @@ static const struct v4l2_ioctl_ops rkisp1_dmarx_ioctl = {
.vidioc_prepare_buf = vb2_ioctl_prepare_buf,
.vidioc_streamon = vb2_ioctl_streamon,
.vidioc_streamoff = vb2_ioctl_streamoff,
.vidioc_try_fmt_vid_out_mplane = rkisp1_try_fmt_vid_out_mplane,
.vidioc_enum_fmt_vid_out_mplane = rkisp1_enum_fmt_vid_out_mplane,
.vidioc_s_fmt_vid_out_mplane = rkisp1_s_fmt_vid_out_mplane,
.vidioc_g_fmt_vid_out_mplane = rkisp1_g_fmt_vid_out_mplane,
.vidioc_querycap = rkisp1_querycap,
.vidioc_try_fmt_vid_out_mplane = rkisp_try_fmt_vid_out_mplane,
.vidioc_enum_fmt_vid_out_mplane = rkisp_enum_fmt_vid_out_mplane,
.vidioc_s_fmt_vid_out_mplane = rkisp_s_fmt_vid_out_mplane,
.vidioc_g_fmt_vid_out_mplane = rkisp_g_fmt_vid_out_mplane,
.vidioc_querycap = rkisp_querycap,
};
static void rkisp1_unregister_dmarx_video(struct rkisp1_stream *stream)
static void rkisp_unregister_dmarx_video(struct rkisp_stream *stream)
{
media_entity_cleanup(&stream->vnode.vdev.entity);
video_unregister_device(&stream->vnode.vdev);
}
static int rkisp1_register_dmarx_video(struct rkisp1_stream *stream)
static int rkisp_register_dmarx_video(struct rkisp_stream *stream)
{
struct rkisp1_device *dev = stream->ispdev;
struct rkisp_device *dev = stream->ispdev;
struct v4l2_device *v4l2_dev = &dev->v4l2_dev;
struct video_device *vdev = &stream->vnode.vdev;
struct rkisp1_vdev_node *node;
struct rkisp_vdev_node *node;
int ret = 0;
node = vdev_to_node(vdev);
vdev->release = video_device_release_empty;
vdev->fops = &rkisp1_fops;
vdev->fops = &rkisp_fops;
vdev->minor = -1;
vdev->v4l2_dev = v4l2_dev;
vdev->lock = &dev->apilock;
video_set_drvdata(vdev, stream);
vdev->ioctl_ops = &rkisp1_dmarx_ioctl;
vdev->ioctl_ops = &rkisp_dmarx_ioctl;
vdev->device_caps = V4L2_CAP_VIDEO_OUTPUT_MPLANE |
V4L2_CAP_STREAMING;
vdev->vfl_dir = VFL_DIR_TX;
@@ -623,13 +623,13 @@ unreg:
/**************** Interrupter Handler ****************/
void rkisp1_dmarx_isr(u32 mis_val, struct rkisp1_device *dev)
void rkisp_dmarx_isr(u32 mis_val, struct rkisp_device *dev)
{
void __iomem *base = dev->base_addr;
struct rkisp1_stream *stream;
struct rkisp_stream *stream;
if (mis_val & CIF_MI_DMA_READY) {
stream = &dev->dmarx_dev.stream[RKISP1_STREAM_DMARX];
stream = &dev->dmarx_dev.stream[RKISP_STREAM_DMARX];
stream->frame_end = true;
writel(CIF_MI_DMA_READY, base + CIF_MI_ICR);
@@ -643,10 +643,10 @@ void rkisp1_dmarx_isr(u32 mis_val, struct rkisp1_device *dev)
}
}
int rkisp1_register_dmarx_vdev(struct rkisp1_device *dev)
int rkisp_register_dmarx_vdev(struct rkisp_device *dev)
{
struct rkisp1_dmarx_device *dmarx_dev = &dev->dmarx_dev;
struct rkisp1_stream *stream;
struct rkisp_dmarx_device *dmarx_dev = &dev->dmarx_dev;
struct rkisp_stream *stream;
struct video_device *vdev;
struct media_entity *source, *sink;
int ret = 0;
@@ -655,17 +655,17 @@ int rkisp1_register_dmarx_vdev(struct rkisp1_device *dev)
dmarx_dev->ispdev = dev;
if (dev->isp_ver <= ISP_V13) {
stream = &dmarx_dev->stream[RKISP1_STREAM_DMARX];
stream = &dmarx_dev->stream[RKISP_STREAM_DMARX];
INIT_LIST_HEAD(&stream->buf_queue);
init_waitqueue_head(&stream->done);
spin_lock_init(&stream->vbq_lock);
stream->id = RKISP1_STREAM_DMARX;
stream->id = RKISP_STREAM_DMARX;
stream->ispdev = dev;
stream->ops = &rkisp1_dmarx_streams_ops;
stream->config = &rkisp1_dmarx_stream_config;
stream->ops = &rkisp_dmarx_streams_ops;
stream->config = &rkisp_dmarx_stream_config;
vdev = &stream->vnode.vdev;
strlcpy(vdev->name, DMA_VDEV_NAME, sizeof(vdev->name));
ret = rkisp1_register_dmarx_video(stream);
ret = rkisp_register_dmarx_video(stream);
if (ret < 0)
return ret;
@@ -673,19 +673,19 @@ int rkisp1_register_dmarx_vdev(struct rkisp1_device *dev)
source = &vdev->entity;
sink = &dev->isp_sdev.sd.entity;
ret = media_create_pad_link(source, 0,
sink, RKISP1_ISP_PAD_SINK, 0);
sink, RKISP_ISP_PAD_SINK, 0);
}
return ret;
}
void rkisp1_unregister_dmarx_vdev(struct rkisp1_device *dev)
void rkisp_unregister_dmarx_vdev(struct rkisp_device *dev)
{
struct rkisp1_dmarx_device *dmarx_dev = &dev->dmarx_dev;
struct rkisp1_stream *stream;
struct rkisp_dmarx_device *dmarx_dev = &dev->dmarx_dev;
struct rkisp_stream *stream;
if (dev->isp_ver <= ISP_V13) {
stream = &dmarx_dev->stream[RKISP1_STREAM_DMARX];
rkisp1_unregister_dmarx_video(stream);
stream = &dmarx_dev->stream[RKISP_STREAM_DMARX];
rkisp_unregister_dmarx_video(stream);
}
}

29
drivers/media/platform/rockchip/isp/dmarx.h Normal file
View File

@@ -0,0 +1,29 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd. */
#ifndef _RKISP_DMARX_H
#define _RKISP_DMARX_H
#include "capture.h"
#include "common.h"
#define RKISP_STREAM_DMARX 0
#define RKISP_MAX_DMARX_STREAM 1
struct rkisp_dmarx_device;
enum rkisp_dmarx_pad {
RKISP_DMARX_PAD_SINK,
RKISP_DMARX_PAD_SOURCE,
RKISP_DMARX_PAD_MAX
};
struct rkisp_dmarx_device {
struct rkisp_device *ispdev;
struct rkisp_stream stream[RKISP_MAX_DMARX_STREAM];
};
void rkisp_dmarx_isr(u32 mis_val, struct rkisp_device *dev);
void rkisp_unregister_dmarx_vdev(struct rkisp_device *dev);
int rkisp_register_dmarx_vdev(struct rkisp_device *dev);
#endif /* _RKISP_DMARX_H */

1240
drivers/media/platform/rockchip/isp1/isp_params.c → drivers/media/platform/rockchip/isp/isp_params.c
View File

File diff suppressed because it is too large Load Diff

97
drivers/media/platform/rockchip/isp1/isp_params.h → drivers/media/platform/rockchip/isp/isp_params.h
View File

@@ -32,90 +32,89 @@
* SOFTWARE.
*/
#ifndef _RKISP1_ISP_H
#define _RKISP1_ISP_H
#ifndef _RKISP_ISP_H
#define _RKISP_ISP_H
#include <linux/rkisp1-config.h>
#include <linux/rk-preisp.h>
#include "common.h"
struct rkisp1_isp_params_vdev;
struct rkisp1_isp_params_ops {
void (*dpcc_config)(struct rkisp1_isp_params_vdev *params_vdev,
struct rkisp_isp_params_vdev;
struct rkisp_isp_params_ops {
void (*dpcc_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_dpcc_config *arg);
void (*bls_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*bls_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_bls_config *arg);
void (*lsc_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*lsc_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_lsc_config *arg);
void (*lsc_matrix_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*lsc_matrix_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_lsc_config *pconfig);
void (*flt_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*flt_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_flt_config *arg);
void (*bdm_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*bdm_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_bdm_config *arg);
void (*sdg_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*sdg_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_sdg_config *arg);
void (*goc_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*goc_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_goc_config *arg);
void (*ctk_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*ctk_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_ctk_config *arg);
void (*ctk_enable)(struct rkisp1_isp_params_vdev *params_vdev,
void (*ctk_enable)(struct rkisp_isp_params_vdev *params_vdev,
bool en);
void (*awb_meas_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*awb_meas_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_awb_meas_config *arg);
void (*awb_meas_enable)(struct rkisp1_isp_params_vdev *params_vdev,
void (*awb_meas_enable)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_awb_meas_config *arg,
bool en);
void (*awb_gain_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*awb_gain_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_awb_gain_config *arg);
void (*aec_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*aec_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_aec_config *arg);
void (*cproc_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*cproc_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_cproc_config *arg);
void (*hst_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*hst_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_hst_config *arg);
void (*hst_enable)(struct rkisp1_isp_params_vdev *params_vdev,
void (*hst_enable)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_hst_config *arg, bool en);
void (*afm_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*afm_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_afc_config *arg);
void (*ie_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*ie_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_ie_config *arg);
void (*ie_enable)(struct rkisp1_isp_params_vdev *params_vdev,
void (*ie_enable)(struct rkisp_isp_params_vdev *params_vdev,
bool en);
void (*csm_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*csm_config)(struct rkisp_isp_params_vdev *params_vdev,
bool full_range);
void (*dpf_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*dpf_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_dpf_config *arg);
void (*dpf_strength_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*dpf_strength_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_dpf_strength_config *arg);
void (*wdr_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*wdr_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_wdr_config *arg);
void (*wdr_enable)(struct rkisp1_isp_params_vdev *params_vdev,
bool en);
void (*demosaiclp_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*wdr_enable)(struct rkisp_isp_params_vdev *params_vdev, bool en);
void (*demosaiclp_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_demosaiclp_config *arg);
void (*demosaiclp_enable)(struct rkisp1_isp_params_vdev *params_vdev,
void (*demosaiclp_enable)(struct rkisp_isp_params_vdev *params_vdev,
bool en);
void (*rkiesharp_config)(struct rkisp1_isp_params_vdev *params_vdev,
void (*rkiesharp_config)(struct rkisp_isp_params_vdev *params_vdev,
const struct cifisp_rkiesharp_config *arg);
void (*rkiesharp_enable)(struct rkisp1_isp_params_vdev *params_vdev,
void (*rkiesharp_enable)(struct rkisp_isp_params_vdev *params_vdev,
bool en);
};
struct rkisp1_isp_params_config {
struct rkisp_isp_params_config {
const int gamma_out_max_samples;
const int hst_weight_grids_size;
};
/*
* struct rkisp1_isp_subdev - ISP input parameters device
* struct rkisp_isp_subdev - ISP input parameters device
*
* @cur_params: Current ISP parameters
* @first_params: the first params should take effect immediately
*/
struct rkisp1_isp_params_vdev {
struct rkisp1_vdev_node vnode;
struct rkisp1_device *dev;
struct rkisp_isp_params_vdev {
struct rkisp_vdev_node vnode;
struct rkisp_device *dev;
spinlock_t config_lock;
struct list_head params;
@@ -125,27 +124,27 @@ struct rkisp1_isp_params_vdev {
bool first_params;
enum v4l2_quantization quantization;
enum rkisp1_fmt_raw_pat_type raw_type;
enum rkisp_fmt_raw_pat_type raw_type;
u32 in_mbus_code;
struct preisp_hdrae_para_s hdrae_para;
struct rkisp1_isp_params_ops *ops;
struct rkisp1_isp_params_config *config;
struct rkisp_isp_params_ops *ops;
struct rkisp_isp_params_config *config;
};
/* config params before ISP streaming */
void rkisp1_params_configure_isp(struct rkisp1_isp_params_vdev *params_vdev,
void rkisp_params_configure_isp(struct rkisp_isp_params_vdev *params_vdev,
struct ispsd_in_fmt *in_fmt,
enum v4l2_quantization quantization);
void rkisp1_params_disable_isp(struct rkisp1_isp_params_vdev *params_vdev);
void rkisp_params_disable_isp(struct rkisp_isp_params_vdev *params_vdev);
int rkisp1_register_params_vdev(struct rkisp1_isp_params_vdev *params_vdev,
int rkisp_register_params_vdev(struct rkisp_isp_params_vdev *params_vdev,
struct v4l2_device *v4l2_dev,
struct rkisp1_device *dev);
struct rkisp_device *dev);
void rkisp1_unregister_params_vdev(struct rkisp1_isp_params_vdev *params_vdev);
void rkisp_unregister_params_vdev(struct rkisp_isp_params_vdev *params_vdev);
void rkisp1_params_isr(struct rkisp1_isp_params_vdev *params_vdev, u32 isp_mis);
void rkisp_params_isr(struct rkisp_isp_params_vdev *params_vdev, u32 isp_mis);
#endif /* _RKISP1_ISP_H */
#endif /* _RKISP_ISP_H */

202
drivers/media/platform/rockchip/isp1/isp_stats.c → drivers/media/platform/rockchip/isp/isp_stats.c
View File

@@ -40,14 +40,14 @@
#include "dev.h"
#include "regs.h"
#define RKISP1_ISP_STATS_REQ_BUFS_MIN 2
#define RKISP1_ISP_STATS_REQ_BUFS_MAX 8
#define RKISP_ISP_STATS_REQ_BUFS_MIN 2
#define RKISP_ISP_STATS_REQ_BUFS_MAX 8
static int rkisp1_stats_enum_fmt_meta_cap(struct file *file, void *priv,
static int rkisp_stats_enum_fmt_meta_cap(struct file *file, void *priv,
struct v4l2_fmtdesc *f)
{
struct video_device *video = video_devdata(file);
struct rkisp1_isp_stats_vdev *stats_vdev = video_get_drvdata(video);
struct rkisp_isp_stats_vdev *stats_vdev = video_get_drvdata(video);
if (f->index > 0 || f->type != video->queue->type)
return -EINVAL;
@@ -56,11 +56,11 @@ static int rkisp1_stats_enum_fmt_meta_cap(struct file *file, void *priv,
return 0;
}
static int rkisp1_stats_g_fmt_meta_cap(struct file *file, void *priv,
static int rkisp_stats_g_fmt_meta_cap(struct file *file, void *priv,
struct v4l2_format *f)
{
struct video_device *video = video_devdata(file);
struct rkisp1_isp_stats_vdev *stats_vdev = video_get_drvdata(video);
struct rkisp_isp_stats_vdev *stats_vdev = video_get_drvdata(video);
struct v4l2_meta_format *meta = &f->fmt.meta;
if (f->type != video->queue->type)
@@ -73,11 +73,11 @@ static int rkisp1_stats_g_fmt_meta_cap(struct file *file, void *priv,
return 0;
}
static int rkisp1_stats_querycap(struct file *file,
static int rkisp_stats_querycap(struct file *file,
void *priv, struct v4l2_capability *cap)
{
struct video_device *vdev = video_devdata(file);
struct rkisp1_isp_stats_vdev *stats_vdev = video_get_drvdata(vdev);
struct rkisp_isp_stats_vdev *stats_vdev = video_get_drvdata(vdev);
strcpy(cap->driver, DRIVER_NAME);
snprintf(cap->driver, sizeof(cap->driver),
@@ -90,7 +90,7 @@ static int rkisp1_stats_querycap(struct file *file,
}
/* ISP video device IOCTLs */
static const struct v4l2_ioctl_ops rkisp1_stats_ioctl = {
static const struct v4l2_ioctl_ops rkisp_stats_ioctl = {
.vidioc_reqbufs = vb2_ioctl_reqbufs,
.vidioc_querybuf = vb2_ioctl_querybuf,
.vidioc_create_bufs = vb2_ioctl_create_bufs,
@@ -100,14 +100,14 @@ static const struct v4l2_ioctl_ops rkisp1_stats_ioctl = {
.vidioc_expbuf = vb2_ioctl_expbuf,
.vidioc_streamon = vb2_ioctl_streamon,
.vidioc_streamoff = vb2_ioctl_streamoff,
.vidioc_enum_fmt_meta_cap = rkisp1_stats_enum_fmt_meta_cap,
.vidioc_g_fmt_meta_cap = rkisp1_stats_g_fmt_meta_cap,
.vidioc_s_fmt_meta_cap = rkisp1_stats_g_fmt_meta_cap,
.vidioc_try_fmt_meta_cap = rkisp1_stats_g_fmt_meta_cap,
.vidioc_querycap = rkisp1_stats_querycap
.vidioc_enum_fmt_meta_cap = rkisp_stats_enum_fmt_meta_cap,
.vidioc_g_fmt_meta_cap = rkisp_stats_g_fmt_meta_cap,
.vidioc_s_fmt_meta_cap = rkisp_stats_g_fmt_meta_cap,
.vidioc_try_fmt_meta_cap = rkisp_stats_g_fmt_meta_cap,
.vidioc_querycap = rkisp_stats_querycap
};
struct v4l2_file_operations rkisp1_stats_fops = {
struct v4l2_file_operations rkisp_stats_fops = {
.mmap = vb2_fop_mmap,
.unlocked_ioctl = video_ioctl2,
.poll = vb2_fop_poll,
@@ -115,18 +115,18 @@ struct v4l2_file_operations rkisp1_stats_fops = {
.release = vb2_fop_release
};
static int rkisp1_stats_vb2_queue_setup(struct vb2_queue *vq,
static int rkisp_stats_vb2_queue_setup(struct vb2_queue *vq,
unsigned int *num_buffers,
unsigned int *num_planes,
unsigned int sizes[],
struct device *alloc_ctxs[])
{
struct rkisp1_isp_stats_vdev *stats_vdev = vq->drv_priv;
struct rkisp_isp_stats_vdev *stats_vdev = vq->drv_priv;
*num_planes = 1;
*num_buffers = clamp_t(u32, *num_buffers, RKISP1_ISP_STATS_REQ_BUFS_MIN,
RKISP1_ISP_STATS_REQ_BUFS_MAX);
*num_buffers = clamp_t(u32, *num_buffers, RKISP_ISP_STATS_REQ_BUFS_MIN,
RKISP_ISP_STATS_REQ_BUFS_MAX);
sizes[0] = sizeof(struct rkisp1_stat_buffer);
@@ -135,12 +135,12 @@ static int rkisp1_stats_vb2_queue_setup(struct vb2_queue *vq,
return 0;
}
static void rkisp1_stats_vb2_buf_queue(struct vb2_buffer *vb)
static void rkisp_stats_vb2_buf_queue(struct vb2_buffer *vb)
{
struct vb2_v4l2_buffer *vbuf = to_vb2_v4l2_buffer(vb);
struct rkisp1_buffer *stats_buf = to_rkisp1_buffer(vbuf);
struct rkisp_buffer *stats_buf = to_rkisp_buffer(vbuf);
struct vb2_queue *vq = vb->vb2_queue;
struct rkisp1_isp_stats_vdev *stats_dev = vq->drv_priv;
struct rkisp_isp_stats_vdev *stats_dev = vq->drv_priv;
stats_buf->vaddr[0] = vb2_plane_vaddr(vb, 0);
@@ -149,10 +149,10 @@ static void rkisp1_stats_vb2_buf_queue(struct vb2_buffer *vb)
spin_unlock_bh(&stats_dev->rd_lock);
}
static void rkisp1_stats_vb2_stop_streaming(struct vb2_queue *vq)
static void rkisp_stats_vb2_stop_streaming(struct vb2_queue *vq)
{
struct rkisp1_isp_stats_vdev *stats_vdev = vq->drv_priv;
struct rkisp1_buffer *buf;
struct rkisp_isp_stats_vdev *stats_vdev = vq->drv_priv;
struct rkisp_buffer *buf;
unsigned long flags;
int i;
@@ -164,11 +164,11 @@ static void rkisp1_stats_vb2_stop_streaming(struct vb2_queue *vq)
tasklet_disable(&stats_vdev->rd_tasklet);
spin_lock_bh(&stats_vdev->rd_lock);
for (i = 0; i < RKISP1_ISP_STATS_REQ_BUFS_MAX; i++) {
for (i = 0; i < RKISP_ISP_STATS_REQ_BUFS_MAX; i++) {
if (list_empty(&stats_vdev->stat))
break;
buf = list_first_entry(&stats_vdev->stat,
struct rkisp1_buffer, queue);
struct rkisp_buffer, queue);
list_del(&buf->queue);
vb2_buffer_done(&buf->vb.vb2_buf, VB2_BUF_STATE_ERROR);
}
@@ -176,10 +176,10 @@ static void rkisp1_stats_vb2_stop_streaming(struct vb2_queue *vq)
}
static int
rkisp1_stats_vb2_start_streaming(struct vb2_queue *queue,
rkisp_stats_vb2_start_streaming(struct vb2_queue *queue,
unsigned int count)
{
struct rkisp1_isp_stats_vdev *stats_vdev = queue->drv_priv;
struct rkisp_isp_stats_vdev *stats_vdev = queue->drv_priv;
stats_vdev->streamon = true;
kfifo_reset(&stats_vdev->rd_kfifo);
@@ -188,28 +188,28 @@ rkisp1_stats_vb2_start_streaming(struct vb2_queue *queue,
return 0;
}
static struct vb2_ops rkisp1_stats_vb2_ops = {
.queue_setup = rkisp1_stats_vb2_queue_setup,
.buf_queue = rkisp1_stats_vb2_buf_queue,
static struct vb2_ops rkisp_stats_vb2_ops = {
.queue_setup = rkisp_stats_vb2_queue_setup,
.buf_queue = rkisp_stats_vb2_buf_queue,
.wait_prepare = vb2_ops_wait_prepare,
.wait_finish = vb2_ops_wait_finish,
.stop_streaming = rkisp1_stats_vb2_stop_streaming,
.start_streaming = rkisp1_stats_vb2_start_streaming,
.stop_streaming = rkisp_stats_vb2_stop_streaming,
.start_streaming = rkisp_stats_vb2_start_streaming,
};
static int rkisp1_stats_init_vb2_queue(struct vb2_queue *q,
struct rkisp1_isp_stats_vdev *stats_vdev)
static int rkisp_stats_init_vb2_queue(struct vb2_queue *q,
struct rkisp_isp_stats_vdev *stats_vdev)
{
struct rkisp1_vdev_node *node;
struct rkisp_vdev_node *node;
node = queue_to_node(q);
q->type = V4L2_BUF_TYPE_META_CAPTURE;
q->io_modes = VB2_MMAP | VB2_USERPTR;
q->drv_priv = stats_vdev;
q->ops = &rkisp1_stats_vb2_ops;
q->ops = &rkisp_stats_vb2_ops;
q->mem_ops = &vb2_vmalloc_memops;
q->buf_struct_size = sizeof(struct rkisp1_buffer);
q->buf_struct_size = sizeof(struct rkisp_buffer);
q->timestamp_flags = V4L2_BUF_FLAG_TIMESTAMP_MONOTONIC;
q->lock = &stats_vdev->dev->iqlock;
q->dev = stats_vdev->dev->dev;
@@ -217,7 +217,7 @@ static int rkisp1_stats_init_vb2_queue(struct vb2_queue *q,
return vb2_queue_init(q);
}
static void rkisp1_stats_get_awb_meas_v10(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_awb_meas_v10(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
/* Protect against concurrent access from ISR? */
@@ -236,7 +236,7 @@ static void rkisp1_stats_get_awb_meas_v10(struct rkisp1_isp_stats_vdev *stats_vd
CIF_ISP_AWB_GET_MEAN_Y_G(reg_val);
}
static void rkisp1_stats_get_awb_meas_v12(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_awb_meas_v12(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
/* Protect against concurrent access from ISR? */
@@ -255,7 +255,7 @@ static void rkisp1_stats_get_awb_meas_v12(struct rkisp1_isp_stats_vdev *stats_vd
CIF_ISP_AWB_GET_MEAN_Y_G(reg_val);
}
static void rkisp1_stats_get_aec_meas_v10(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_aec_meas_v10(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
unsigned int i;
@@ -266,7 +266,7 @@ static void rkisp1_stats_get_aec_meas_v10(struct rkisp1_isp_stats_vdev *stats_vd
pbuf->params.ae.exp_mean[i] = (u8)readl(addr + i * 4);
}
static void rkisp1_stats_get_aec_meas_v12(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_aec_meas_v12(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
int i;
@@ -285,7 +285,7 @@ static void rkisp1_stats_get_aec_meas_v12(struct rkisp1_isp_stats_vdev *stats_vd
pbuf->params.ae.exp_mean[4 * i + 0] = CIF_ISP_EXP_GET_MEAN_xy0_V12(value);
}
static void rkisp1_stats_get_afc_meas(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_afc_meas(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
void __iomem *base_addr;
@@ -303,7 +303,7 @@ static void rkisp1_stats_get_afc_meas(struct rkisp1_isp_stats_vdev *stats_vdev,
af->window[2].lum = readl(base_addr + CIF_ISP_AFM_LUM_C);
}
static void rkisp1_stats_get_hst_meas_v10(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_hst_meas_v10(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
int i;
@@ -314,7 +314,7 @@ static void rkisp1_stats_get_hst_meas_v10(struct rkisp1_isp_stats_vdev *stats_vd
pbuf->params.hist.hist_bins[i] = readl(addr + (i * 4));
}
static void rkisp1_stats_get_hst_meas_v12(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_hst_meas_v12(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
int i;
@@ -329,12 +329,12 @@ static void rkisp1_stats_get_hst_meas_v12(struct rkisp1_isp_stats_vdev *stats_vd
}
}
static void rkisp1_stats_get_bls_meas(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_bls_meas(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
struct rkisp1_device *dev = stats_vdev->dev;
struct rkisp_device *dev = stats_vdev->dev;
const struct ispsd_in_fmt *in_fmt =
rkisp1_get_ispsd_in_fmt(&dev->isp_sdev);
rkisp_get_ispsd_in_fmt(&dev->isp_sdev);
void __iomem *base = stats_vdev->dev->base_addr;
struct cifisp_bls_meas_val *bls_val;
@@ -362,25 +362,25 @@ static void rkisp1_stats_get_bls_meas(struct rkisp1_isp_stats_vdev *stats_vdev,
}
}
static void rkisp1_stats_get_emb_data(struct rkisp1_isp_stats_vdev *stats_vdev,
static void rkisp_stats_get_emb_data(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf)
{
unsigned int i;
struct rkisp1_device *dev = stats_vdev->dev;
struct rkisp_device *dev = stats_vdev->dev;
unsigned int ph = 0, out = 0, packet_len = 0, playload_len = 0;
unsigned int mipi_kfifo_len;
unsigned int idx;
unsigned char *fifo_data;
idx = RKISP1_EMDDATA_FIFO_MAX;
for (i = 0; i < RKISP1_EMDDATA_FIFO_MAX; i++) {
idx = RKISP_EMDDATA_FIFO_MAX;
for (i = 0; i < RKISP_EMDDATA_FIFO_MAX; i++) {
if (dev->emd_data_fifo[i].frame_id == pbuf->frame_id) {
idx = i;
break;
}
}
if (idx == RKISP1_EMDDATA_FIFO_MAX)
if (idx == RKISP_EMDDATA_FIFO_MAX)
return;
if (kfifo_is_empty(&dev->emd_data_fifo[idx].mipi_kfifo))
@@ -407,53 +407,53 @@ static void rkisp1_stats_get_emb_data(struct rkisp1_isp_stats_vdev *stats_vdev,
playload_len += packet_len;
fifo_data += packet_len;
v4l2_dbg(1, rkisp1_debug, &dev->v4l2_dev,
v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
"packet_len: 0x%x, ph: 0x%x\n",
packet_len, ph);
}
pbuf->meas_type |= CIFISP_STAT_EMB_DATA;
v4l2_dbg(1, rkisp1_debug, &dev->v4l2_dev,
v4l2_dbg(1, rkisp_debug, &dev->v4l2_dev,
"playload_len: %d, pbuf->frame_id %d\n",
playload_len, pbuf->frame_id);
}
static struct rkisp1_stats_ops rkisp1_v10_stats_ops = {
.get_awb_meas = rkisp1_stats_get_awb_meas_v10,
.get_aec_meas = rkisp1_stats_get_aec_meas_v10,
.get_afc_meas = rkisp1_stats_get_afc_meas,
.get_hst_meas = rkisp1_stats_get_hst_meas_v10,
.get_bls_meas = rkisp1_stats_get_bls_meas,
.get_emb_data = rkisp1_stats_get_emb_data,
static struct rkisp_stats_ops rkisp_v10_stats_ops = {
.get_awb_meas = rkisp_stats_get_awb_meas_v10,
.get_aec_meas = rkisp_stats_get_aec_meas_v10,
.get_afc_meas = rkisp_stats_get_afc_meas,
.get_hst_meas = rkisp_stats_get_hst_meas_v10,
.get_bls_meas = rkisp_stats_get_bls_meas,
.get_emb_data = rkisp_stats_get_emb_data,
};
static struct rkisp1_stats_ops rkisp1_v12_stats_ops = {
.get_awb_meas = rkisp1_stats_get_awb_meas_v12,
.get_aec_meas = rkisp1_stats_get_aec_meas_v12,
.get_afc_meas = rkisp1_stats_get_afc_meas,
.get_hst_meas = rkisp1_stats_get_hst_meas_v12,
.get_bls_meas = rkisp1_stats_get_bls_meas,
static struct rkisp_stats_ops rkisp_v12_stats_ops = {
.get_awb_meas = rkisp_stats_get_awb_meas_v12,
.get_aec_meas = rkisp_stats_get_aec_meas_v12,
.get_afc_meas = rkisp_stats_get_afc_meas,
.get_hst_meas = rkisp_stats_get_hst_meas_v12,
.get_bls_meas = rkisp_stats_get_bls_meas,
};
static struct rkisp1_stats_config rkisp1_v10_stats_config = {
static struct rkisp_stats_config rkisp_v10_stats_config = {
.ae_mean_max = 25,
.hist_bin_n_max = 16,
};
static struct rkisp1_stats_config rkisp1_v12_stats_config = {
static struct rkisp_stats_config rkisp_v12_stats_config = {
.ae_mean_max = 81,
.hist_bin_n_max = 32,
};
static void
rkisp1_stats_send_measurement(struct rkisp1_isp_stats_vdev *stats_vdev,
struct rkisp1_isp_readout_work *meas_work)
rkisp_stats_send_measurement(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp_isp_readout_work *meas_work)
{
unsigned int cur_frame_id = -1;
struct rkisp1_stat_buffer *cur_stat_buf;
struct rkisp1_buffer *cur_buf = NULL;
struct rkisp1_stats_ops *ops = stats_vdev->ops;
struct rkisp_buffer *cur_buf = NULL;
struct rkisp_stats_ops *ops = stats_vdev->ops;
cur_frame_id = atomic_read(&stats_vdev->dev->isp_sdev.frm_sync_seq) - 1;
if (cur_frame_id != meas_work->frame_id) {
@@ -467,7 +467,7 @@ rkisp1_stats_send_measurement(struct rkisp1_isp_stats_vdev *stats_vdev,
/* get one empty buffer */
if (!list_empty(&stats_vdev->stat)) {
cur_buf = list_first_entry(&stats_vdev->stat,
struct rkisp1_buffer, queue);
struct rkisp_buffer, queue);
list_del(&cur_buf->queue);
}
spin_unlock(&stats_vdev->rd_lock);
@@ -511,12 +511,12 @@ rkisp1_stats_send_measurement(struct rkisp1_isp_stats_vdev *stats_vdev,
vb2_buffer_done(&cur_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
}
static void rkisp1_stats_readout_task(unsigned long data)
static void rkisp_stats_readout_task(unsigned long data)
{
unsigned int out = 0;
struct rkisp1_isp_readout_work work;
struct rkisp1_isp_stats_vdev *vdev =
(struct rkisp1_isp_stats_vdev *)data;
struct rkisp_isp_readout_work work;
struct rkisp_isp_stats_vdev *vdev =
(struct rkisp_isp_stats_vdev *)data;
while (!kfifo_is_empty(&vdev->rd_kfifo)) {
out = kfifo_out(&vdev->rd_kfifo,
@@ -524,15 +524,15 @@ static void rkisp1_stats_readout_task(unsigned long data)
if (!out)
break;
if (work.readout == RKISP1_ISP_READOUT_MEAS)
rkisp1_stats_send_measurement(vdev, &work);
if (work.readout == RKISP_ISP_READOUT_MEAS)
rkisp_stats_send_measurement(vdev, &work);
}
}
int rkisp1_stats_isr(struct rkisp1_isp_stats_vdev *stats_vdev, u32 isp_ris)
int rkisp_stats_isr(struct rkisp_isp_stats_vdev *stats_vdev, u32 isp_ris)
{
unsigned int isp_mis_tmp = 0;
struct rkisp1_isp_readout_work work;
struct rkisp_isp_readout_work work;
unsigned int cur_frame_id =
atomic_read(&stats_vdev->dev->isp_sdev.frm_sync_seq) - 1;
#ifdef LOG_ISR_EXE_TIME
@@ -560,7 +560,7 @@ int rkisp1_stats_isr(struct rkisp1_isp_stats_vdev *stats_vdev, u32 isp_ris)
if (isp_ris & (CIF_ISP_FRAME | CIF_ISP_AWB_DONE |
CIF_ISP_AFM_FIN | CIF_ISP_EXP_END |
CIF_ISP_HIST_MEASURE_RDY)) {
work.readout = RKISP1_ISP_READOUT_MEAS;
work.readout = RKISP_ISP_READOUT_MEAS;
work.frame_id = cur_frame_id;
work.isp_ris = isp_ris;
work.timestamp = ktime_get_ns();
@@ -594,7 +594,7 @@ unlock:
return 0;
}
static void rkisp1_init_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev)
static void rkisp_init_stats_vdev(struct rkisp_isp_stats_vdev *stats_vdev)
{
stats_vdev->vdev_fmt.fmt.meta.dataformat =
V4L2_META_FMT_RK_ISP1_STAT_3A;
@@ -603,20 +603,20 @@ static void rkisp1_init_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev)
if (stats_vdev->dev->isp_ver == ISP_V12 ||
stats_vdev->dev->isp_ver == ISP_V13) {
stats_vdev->ops = &rkisp1_v12_stats_ops;
stats_vdev->config = &rkisp1_v12_stats_config;
stats_vdev->ops = &rkisp_v12_stats_ops;
stats_vdev->config = &rkisp_v12_stats_config;
} else {
stats_vdev->ops = &rkisp1_v10_stats_ops;
stats_vdev->config = &rkisp1_v10_stats_config;
stats_vdev->ops = &rkisp_v10_stats_ops;
stats_vdev->config = &rkisp_v10_stats_config;
}
}
int rkisp1_register_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev,
int rkisp_register_stats_vdev(struct rkisp_isp_stats_vdev *stats_vdev,
struct v4l2_device *v4l2_dev,
struct rkisp1_device *dev)
struct rkisp_device *dev)
{
int ret;
struct rkisp1_vdev_node *node = &stats_vdev->vnode;
struct rkisp_vdev_node *node = &stats_vdev->vnode;
struct video_device *vdev = &node->vdev;
stats_vdev->dev = dev;
@@ -627,16 +627,16 @@ int rkisp1_register_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev,
strlcpy(vdev->name, "rkisp1-statistics", sizeof(vdev->name));
video_set_drvdata(vdev, stats_vdev);
vdev->ioctl_ops = &rkisp1_stats_ioctl;
vdev->fops = &rkisp1_stats_fops;
vdev->ioctl_ops = &rkisp_stats_ioctl;
vdev->fops = &rkisp_stats_fops;
vdev->release = video_device_release_empty;
vdev->lock = &dev->iqlock;
vdev->v4l2_dev = v4l2_dev;
vdev->queue = &node->buf_queue;
vdev->device_caps = V4L2_CAP_META_CAPTURE | V4L2_CAP_STREAMING;
vdev->vfl_dir = VFL_DIR_RX;
rkisp1_stats_init_vb2_queue(vdev->queue, stats_vdev);
rkisp1_init_stats_vdev(stats_vdev);
rkisp_stats_init_vb2_queue(vdev->queue, stats_vdev);
rkisp_init_stats_vdev(stats_vdev);
video_set_drvdata(vdev, stats_vdev);
node->pad.flags = MEDIA_PAD_FL_SINK;
@@ -652,7 +652,7 @@ int rkisp1_register_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev,
}
ret = kfifo_alloc(&stats_vdev->rd_kfifo,
RKISP1_READOUT_WORK_SIZE,
RKISP_READOUT_WORK_SIZE,
GFP_KERNEL);
if (ret) {
dev_err(&vdev->dev,
@@ -662,7 +662,7 @@ int rkisp1_register_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev,
}
tasklet_init(&stats_vdev->rd_tasklet,
rkisp1_stats_readout_task,
rkisp_stats_readout_task,
(unsigned long)stats_vdev);
tasklet_disable(&stats_vdev->rd_tasklet);
@@ -675,9 +675,9 @@ err_release_queue:
return ret;
}
void rkisp1_unregister_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev)
void rkisp_unregister_stats_vdev(struct rkisp_isp_stats_vdev *stats_vdev)
{
struct rkisp1_vdev_node *node = &stats_vdev->vnode;
struct rkisp_vdev_node *node = &stats_vdev->vnode;
struct video_device *vdev = &node->vdev;
kfifo_free(&stats_vdev->rd_kfifo);

58
drivers/media/platform/rockchip/isp1/isp_stats.h → drivers/media/platform/rockchip/isp/isp_stats.h
View File

@@ -32,61 +32,61 @@
* SOFTWARE.
*/
#ifndef _RKISP1_ISP_STATS_H
#define _RKISP1_ISP_STATS_H
#ifndef _RKISP_ISP_STATS_H
#define _RKISP_ISP_STATS_H
#include <linux/rkisp1-config.h>
#include <linux/interrupt.h>
#include <linux/kfifo.h>
#include "common.h"
#define RKISP1_READOUT_WORK_SIZE \
(8 * sizeof(struct rkisp1_isp_readout_work))
#define RKISP_READOUT_WORK_SIZE \
(8 * sizeof(struct rkisp_isp_readout_work))
struct rkisp1_isp_stats_vdev;
struct rkisp_isp_stats_vdev;
enum rkisp1_isp_readout_cmd {
RKISP1_ISP_READOUT_MEAS,
RKISP1_ISP_READOUT_META,
enum rkisp_isp_readout_cmd {
RKISP_ISP_READOUT_MEAS,
RKISP_ISP_READOUT_META,
};
struct rkisp1_isp_readout_work {
struct rkisp_isp_readout_work {
unsigned int frame_id;
unsigned int isp_ris;
enum rkisp1_isp_readout_cmd readout;
enum rkisp_isp_readout_cmd readout;
unsigned long long timestamp;
};
struct rkisp1_stats_ops {
void (*get_awb_meas)(struct rkisp1_isp_stats_vdev *stats_vdev,
struct rkisp_stats_ops {
void (*get_awb_meas)(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf);
void (*get_aec_meas)(struct rkisp1_isp_stats_vdev *stats_vdev,
void (*get_aec_meas)(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf);
void (*get_afc_meas)(struct rkisp1_isp_stats_vdev *stats_vdev,
void (*get_afc_meas)(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf);
void (*get_hst_meas)(struct rkisp1_isp_stats_vdev *stats_vdev,
void (*get_hst_meas)(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf);
void (*get_bls_meas)(struct rkisp1_isp_stats_vdev *stats_vdev,
void (*get_bls_meas)(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf);
void (*get_emb_data)(struct rkisp1_isp_stats_vdev *stats_vdev,
void (*get_emb_data)(struct rkisp_isp_stats_vdev *stats_vdev,
struct rkisp1_stat_buffer *pbuf);
};
struct rkisp1_stats_config {
struct rkisp_stats_config {
const int ae_mean_max;
const int hist_bin_n_max;
};
/*
* struct rkisp1_isp_stats_vdev - ISP Statistics device
* struct rkisp_isp_stats_vdev - ISP Statistics device
*
* @irq_lock: buffer queue lock
* @stat: stats buffer list
* @readout_wq: workqueue for statistics information read
*/
struct rkisp1_isp_stats_vdev {
struct rkisp1_vdev_node vnode;
struct rkisp1_device *dev;
struct rkisp_isp_stats_vdev {
struct rkisp_vdev_node vnode;
struct rkisp_device *dev;
spinlock_t irq_lock;
struct list_head stat;
@@ -97,16 +97,16 @@ struct rkisp1_isp_stats_vdev {
struct kfifo rd_kfifo;
struct tasklet_struct rd_tasklet;
struct rkisp1_stats_ops *ops;
struct rkisp1_stats_config *config;
struct rkisp_stats_ops *ops;
struct rkisp_stats_config *config;
};
int rkisp1_stats_isr(struct rkisp1_isp_stats_vdev *stats_vdev, u32 isp_ris);
int rkisp_stats_isr(struct rkisp_isp_stats_vdev *stats_vdev, u32 isp_ris);
int rkisp1_register_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev,
int rkisp_register_stats_vdev(struct rkisp_isp_stats_vdev *stats_vdev,
struct v4l2_device *v4l2_dev,
struct rkisp1_device *dev);
struct rkisp_device *dev);
void rkisp1_unregister_stats_vdev(struct rkisp1_isp_stats_vdev *stats_vdev);
void rkisp_unregister_stats_vdev(struct rkisp_isp_stats_vdev *stats_vdev);
#endif /* _RKISP1_ISP_STATS_H */
#endif /* _RKISP_ISP_STATS_H */

16
drivers/media/platform/rockchip/isp1/regs.c → drivers/media/platform/rockchip/isp/regs.c
View File

@@ -35,7 +35,7 @@
#include <media/v4l2-common.h>
#include "regs.h"
void disable_dcrop(struct rkisp1_stream *stream, bool async)
void disable_dcrop(struct rkisp_stream *stream, bool async)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *dc_ctrl_addr = base + stream->config->dual_crop.ctrl;
@@ -51,7 +51,7 @@ void disable_dcrop(struct rkisp1_stream *stream, bool async)
writel(val, dc_ctrl_addr);
}
void config_dcrop(struct rkisp1_stream *stream, struct v4l2_rect *rect, bool async)
void config_dcrop(struct rkisp_stream *stream, struct v4l2_rect *rect, bool async)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *dc_ctrl_addr = base + stream->config->dual_crop.ctrl;
@@ -69,7 +69,7 @@ void config_dcrop(struct rkisp1_stream *stream, struct v4l2_rect *rect, bool asy
writel(dc_ctrl, dc_ctrl_addr);
}
void dump_rsz_regs(struct rkisp1_stream *stream)
void dump_rsz_regs(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
@@ -105,7 +105,7 @@ void dump_rsz_regs(struct rkisp1_stream *stream)
readl(base + stream->config->rsz.phase_vc_shd));
}
static void update_rsz_shadow(struct rkisp1_stream *stream, bool async)
static void update_rsz_shadow(struct rkisp_stream *stream, bool async)
{
void *addr = stream->ispdev->base_addr + stream->config->rsz.ctrl;
u32 ctrl_cfg = readl(addr);
@@ -116,7 +116,7 @@ static void update_rsz_shadow(struct rkisp1_stream *stream, bool async)
writel(CIF_RSZ_CTRL_CFG_UPD | ctrl_cfg, addr);
}
static void set_scale(struct rkisp1_stream *stream, struct v4l2_rect *in_y,
static void set_scale(struct rkisp_stream *stream, struct v4l2_rect *in_y,
struct v4l2_rect *in_c, struct v4l2_rect *out_y,
struct v4l2_rect *out_c)
{
@@ -185,7 +185,7 @@ static void set_scale(struct rkisp1_stream *stream, struct v4l2_rect *in_y,
writel(rsz_ctrl, rsz_ctrl_addr);
}
void config_rsz(struct rkisp1_stream *stream, struct v4l2_rect *in_y,
void config_rsz(struct rkisp_stream *stream, struct v4l2_rect *in_y,
struct v4l2_rect *in_c, struct v4l2_rect *out_y,
struct v4l2_rect *out_c, bool async)
{
@@ -208,7 +208,7 @@ void config_rsz(struct rkisp1_stream *stream, struct v4l2_rect *in_y,
update_rsz_shadow(stream, async);
}
void disable_rsz(struct rkisp1_stream *stream, bool async)
void disable_rsz(struct rkisp_stream *stream, bool async)
{
writel(0, stream->ispdev->base_addr + stream->config->rsz.ctrl);
@@ -216,7 +216,7 @@ void disable_rsz(struct rkisp1_stream *stream, bool async)
update_rsz_shadow(stream, async);
}
void config_mi_ctrl(struct rkisp1_stream *stream, u32 burst)
void config_mi_ctrl(struct rkisp_stream *stream, u32 burst)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *addr = base + CIF_MI_CTRL;

46
drivers/media/platform/rockchip/isp1/regs.h → drivers/media/platform/rockchip/isp/regs.h
View File

@@ -32,8 +32,8 @@
* SOFTWARE.
*/
#ifndef _RKISP1_REGS_H
#define _RKISP1_REGS_H
#ifndef _RKISP_REGS_H
#define _RKISP_REGS_H
#include "dev.h"
#define CIF_ISP_PACK_4BYTE(a, b, c, d) \
@@ -1608,17 +1608,17 @@
#define CIF_ISP_CSI0_TX_IBUF_STATUS_RO (CIF_ISP_CSI0_BASE + 0x00000078)
#define CIF_ISP_CSI0_VERSION (CIF_ISP_CSI0_BASE + 0x0000007c)
void disable_dcrop(struct rkisp1_stream *stream, bool async);
void config_dcrop(struct rkisp1_stream *stream, struct v4l2_rect *rect,
void disable_dcrop(struct rkisp_stream *stream, bool async);
void config_dcrop(struct rkisp_stream *stream, struct v4l2_rect *rect,
bool async);
void dump_rsz_regs(struct rkisp1_stream *stream);
void disable_rsz(struct rkisp1_stream *stream, bool async);
void config_rsz(struct rkisp1_stream *stream, struct v4l2_rect *in_y,
void dump_rsz_regs(struct rkisp_stream *stream);
void disable_rsz(struct rkisp_stream *stream, bool async);
void config_rsz(struct rkisp_stream *stream, struct v4l2_rect *in_y,
struct v4l2_rect *in_c, struct v4l2_rect *out_y,
struct v4l2_rect *out_c, bool async);
void config_mi_ctrl(struct rkisp1_stream *stream, u32 burst);
void config_mi_ctrl(struct rkisp_stream *stream, u32 burst);
void mp_clr_frame_end_int(void __iomem *base);
void sp_clr_frame_end_int(void __iomem *base);
@@ -1628,70 +1628,70 @@ bool sp_is_frame_end_int_masked(void __iomem *base);
bool mp_is_stream_stopped(void __iomem *base);
bool sp_is_stream_stopped(void __iomem *base);
static inline void mi_set_y_size(struct rkisp1_stream *stream, int val)
static inline void mi_set_y_size(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.y_size_init);
}
static inline void mi_set_cb_size(struct rkisp1_stream *stream, int val)
static inline void mi_set_cb_size(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.cb_size_init);
}
static inline void mi_set_cr_size(struct rkisp1_stream *stream, int val)
static inline void mi_set_cr_size(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.cr_size_init);
}
static inline void mi_set_y_addr(struct rkisp1_stream *stream, int val)
static inline void mi_set_y_addr(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.y_base_ad_init);
}
static inline void mi_set_cb_addr(struct rkisp1_stream *stream, int val)
static inline void mi_set_cb_addr(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.cb_base_ad_init);
}
static inline void mi_set_cr_addr(struct rkisp1_stream *stream, int val)
static inline void mi_set_cr_addr(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.cr_base_ad_init);
}
static inline void mi_set_y_offset(struct rkisp1_stream *stream, int val)
static inline void mi_set_y_offset(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.y_offs_cnt_init);
}
static inline void mi_set_cb_offset(struct rkisp1_stream *stream, int val)
static inline void mi_set_cb_offset(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.cb_offs_cnt_init);
}
static inline void mi_set_cr_offset(struct rkisp1_stream *stream, int val)
static inline void mi_set_cr_offset(struct rkisp_stream *stream, int val)
{
void __iomem *base = stream->ispdev->base_addr;
writel(val, base + stream->config->mi.cr_offs_cnt_init);
}
static inline void mi_frame_end_int_enable(struct rkisp1_stream *stream)
static inline void mi_frame_end_int_enable(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *addr = base + CIF_MI_IMSC;
@@ -1699,7 +1699,7 @@ static inline void mi_frame_end_int_enable(struct rkisp1_stream *stream)
writel(CIF_MI_FRAME(stream) | readl(addr), addr);
}
static inline void mi_frame_end_int_disable(struct rkisp1_stream *stream)
static inline void mi_frame_end_int_disable(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *addr = base + CIF_MI_IMSC;
@@ -1707,7 +1707,7 @@ static inline void mi_frame_end_int_disable(struct rkisp1_stream *stream)
writel(~CIF_MI_FRAME(stream) & readl(addr), addr);
}
static inline void mi_frame_end_int_clear(struct rkisp1_stream *stream)
static inline void mi_frame_end_int_clear(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *addr = base + CIF_MI_ICR;
@@ -1943,7 +1943,7 @@ static inline void mi_ctrl2(void __iomem *base, u32 val)
writel(val, base + CIF_MI_CTRL2);
}
static inline void mi_dmarx_ready_enable(struct rkisp1_stream *stream)
static inline void mi_dmarx_ready_enable(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *addr = base + CIF_MI_IMSC;
@@ -1951,7 +1951,7 @@ static inline void mi_dmarx_ready_enable(struct rkisp1_stream *stream)
writel(CIF_MI_DMA_READY | readl(addr), addr);
}
static inline void mi_dmarx_ready_disable(struct rkisp1_stream *stream)
static inline void mi_dmarx_ready_disable(struct rkisp_stream *stream)
{
void __iomem *base = stream->ispdev->base_addr;
void __iomem *addr = base + CIF_MI_IMSC;
@@ -1991,4 +1991,4 @@ static inline void mi_dmarx_start(void __iomem *base)
writel(CIF_MI_DMA_START_ENABLE, addr);
}
#endif /* _RKISP1_REGS_H */
#endif /* _RKISP_REGS_H */

392
drivers/media/platform/rockchip/isp1/rkisp1.c → drivers/media/platform/rockchip/isp/rkisp.c
View File

File diff suppressed because it is too large Load Diff

58
drivers/media/platform/rockchip/isp1/rkisp1.h → drivers/media/platform/rockchip/isp/rkisp.h
View File

@@ -32,8 +32,8 @@
* SOFTWARE.
*/
#ifndef _RKISP1_H
#define _RKISP1_H
#ifndef _RKISP_H
#define _RKISP_H
#include <linux/kfifo.h>
#include <linux/platform_device.h>
@@ -55,7 +55,7 @@
#define CIF_ISP_OUTPUT_H_MIN CIF_ISP_INPUT_H_MIN
#define CIF_ISP_ADD_DATA_VC_MAX 3
struct rkisp1_stream;
struct rkisp_stream;
/*
* struct ispsd_in_fmt - ISP intput-pad format
@@ -69,7 +69,7 @@ struct ispsd_in_fmt {
u8 fmt_type;
u32 mipi_dt;
u32 yuv_seq;
enum rkisp1_fmt_raw_pat_type bayer_pat;
enum rkisp_fmt_raw_pat_type bayer_pat;
u8 bus_width;
};
@@ -78,22 +78,22 @@ struct ispsd_out_fmt {
u8 fmt_type;
};
struct rkisp1_ie_config {
struct rkisp_ie_config {
unsigned int effect;
};
enum rkisp1_isp_pad {
RKISP1_ISP_PAD_SINK,
RKISP1_ISP_PAD_SINK_PARAMS,
RKISP1_ISP_PAD_SOURCE_PATH,
RKISP1_ISP_PAD_SOURCE_STATS,
RKISP1_ISP_PAD_MAX
enum rkisp_isp_pad {
RKISP_ISP_PAD_SINK,
RKISP_ISP_PAD_SINK_PARAMS,
RKISP_ISP_PAD_SOURCE_PATH,
RKISP_ISP_PAD_SOURCE_STATS,
RKISP_ISP_PAD_MAX
};
/*
* struct rkisp1_isp_subdev - ISP sub-device
* struct rkisp_isp_subdev - ISP sub-device
*
* See Cropping regions of ISP in rkisp1.c for details
* See Cropping regions of ISP in rkisp.c for details
* @in_frm: input size, don't have to be equal to sensor size
* @in_fmt: intput format
* @in_crop: crop for sink pad
@@ -104,9 +104,9 @@ enum rkisp1_isp_pad {
* @frm_sync_seq: frame sequence, to sync frame_id between video devices.
* @quantization: output quantization
*/
struct rkisp1_isp_subdev {
struct rkisp_isp_subdev {
struct v4l2_subdev sd;
struct media_pad pads[RKISP1_ISP_PAD_MAX];
struct media_pad pads[RKISP_ISP_PAD_MAX];
struct v4l2_ctrl_handler ctrl_handler;
struct v4l2_mbus_framefmt in_frm;
struct ispsd_in_fmt in_fmt;
@@ -118,46 +118,46 @@ struct rkisp1_isp_subdev {
enum v4l2_quantization quantization;
};
struct rkisp1_emd_data {
struct rkisp_emd_data {
struct kfifo mipi_kfifo;
unsigned int data_len;
unsigned int frame_id;
};
int rkisp1_register_isp_subdev(struct rkisp1_device *isp_dev,
int rkisp_register_isp_subdev(struct rkisp_device *isp_dev,
struct v4l2_device *v4l2_dev);
void rkisp1_unregister_isp_subdev(struct rkisp1_device *isp_dev);
void rkisp_unregister_isp_subdev(struct rkisp_device *isp_dev);
void rkisp1_mipi_isr(unsigned int mipi_mis, struct rkisp1_device *dev);
void rkisp_mipi_isr(unsigned int mipi_mis, struct rkisp_device *dev);
void rkisp1_mipi_v13_isr(unsigned int err1, unsigned int err2,
unsigned int err3, struct rkisp1_device *dev);
void rkisp_mipi_v13_isr(unsigned int err1, unsigned int err2,
unsigned int err3, struct rkisp_device *dev);
void rkisp1_isp_isr(unsigned int isp_mis, struct rkisp1_device *dev);
void rkisp_isp_isr(unsigned int isp_mis, struct rkisp_device *dev);
irqreturn_t rkisp1_vs_isr_handler(int irq, void *ctx);
irqreturn_t rkisp_vs_isr_handler(int irq, void *ctx);
int rkisp1_update_sensor_info(struct rkisp1_device *dev);
int rkisp_update_sensor_info(struct rkisp_device *dev);
u32 rkisp1_mbus_pixelcode_to_v4l2(u32 pixelcode);
u32 rkisp_mbus_pixelcode_to_v4l2(u32 pixelcode);
static inline
struct ispsd_out_fmt *rkisp1_get_ispsd_out_fmt(struct rkisp1_isp_subdev *isp_sdev)
struct ispsd_out_fmt *rkisp_get_ispsd_out_fmt(struct rkisp_isp_subdev *isp_sdev)
{
return &isp_sdev->out_fmt;
}
static inline
struct ispsd_in_fmt *rkisp1_get_ispsd_in_fmt(struct rkisp1_isp_subdev *isp_sdev)
struct ispsd_in_fmt *rkisp_get_ispsd_in_fmt(struct rkisp_isp_subdev *isp_sdev)
{
return &isp_sdev->in_fmt;
}
static inline
struct v4l2_rect *rkisp1_get_isp_sd_win(struct rkisp1_isp_subdev *isp_sdev)
struct v4l2_rect *rkisp_get_isp_sd_win(struct rkisp_isp_subdev *isp_sdev)
{
return &isp_sdev->out_crop;
}
#endif /* _RKISP1_H */
#endif /* _RKISP_H */

8
drivers/media/platform/rockchip/isp1/version.h → drivers/media/platform/rockchip/isp/version.h
View File

@@ -1,12 +1,12 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright (c) 2018 Fuzhou Rockchip Electronics Co., Ltd. */
#ifndef _RKISP1_VERSION_H
#define _RKISP1_VERSION_H
#ifndef _RKISP_VERSION_H
#define _RKISP_VERSION_H
#include <linux/version.h>
/*
*RKISP1 DRIVER VERSION NOTE
*RKISP DRIVER VERSION NOTE
*
*v0.1.0:
*1. First version;
@@ -56,6 +56,6 @@
*3. fix isp iommu work after suspend;
*/
#define RKISP1_DRIVER_VERSION KERNEL_VERSION(0, 1, 0x5)
#define RKISP_DRIVER_VERSION KERNEL_VERSION(0, 1, 0x5)
#endif

12
drivers/media/platform/rockchip/isp1/Kconfig
View File

@@ -1,12 +0,0 @@
# SPDX-License-Identifier: GPL-2.0
config VIDEO_ROCKCHIP_ISP1
tristate "Rockchip Image Signal Processing v1 Unit driver"
depends on VIDEO_V4L2 && VIDEO_V4L2_SUBDEV_API
depends on ARCH_ROCKCHIP || COMPILE_TEST
select VIDEOBUF2_DMA_CONTIG
select VIDEOBUF2_VMALLOC
select V4L2_FWNODE
select PHY_ROCKCHIP_MIPI_RX
default n
help
Support for ISP1 on the rockchip SoC.

29
drivers/media/platform/rockchip/isp1/dmarx.h
View File

@@ -1,29 +0,0 @@
/* SPDX-License-Identifier: GPL-2.0 */
/* Copyright (c) 2019 Fuzhou Rockchip Electronics Co., Ltd. */
#ifndef _RKISP1_DMARX_H
#define _RKISP1_DMARX_H
#include "capture.h"
#include "common.h"
#define RKISP1_STREAM_DMARX 0
#define RKISP1_MAX_DMARX_STREAM 1
struct rkisp1_dmarx_device;
enum rkisp1_dmarx_pad {
RKISP1_DMARX_PAD_SINK,
RKISP1_DMARX_PAD_SOURCE,
RKISP1_DMARX_PAD_MAX
};
struct rkisp1_dmarx_device {
struct rkisp1_device *ispdev;
struct rkisp1_stream stream[RKISP1_MAX_DMARX_STREAM];
};
void rkisp1_dmarx_isr(u32 mis_val, struct rkisp1_device *dev);
void rkisp1_unregister_dmarx_vdev(struct rkisp1_device *dev);
int rkisp1_register_dmarx_vdev(struct rkisp1_device *dev);
#endif /* _RKISP1_DMARX_H */