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

media: rockchip: isp/ispp: support output isp/ispp reg on each frame

Browse Source 
Signed-off-by: Hu Kejun <william.hu@rock-chips.com>
Change-Id: Idff87c8af4e5a097e9279ea7a0247941246fec50
Signed-off-by: Xu Hongfei <xuhf@rock-chips.com>
This commit is contained in:
Hu Kejun
2020-10-20 20:56:41 +08:00
committed by Tao Huang
parent 8117cf5d6e
commit 7c3cdfb472
29 changed files with 864 additions and 78 deletions
Download Patch File Download Diff File Expand all files Collapse all files

402
drivers/media/platform/rockchip/isp/bridge.c
View File

@@ -48,14 +48,396 @@ static void update_mi(struct rkisp_bridge_device *dev)
rkisp_read(dev->ispdev, dev->cfg->reg.g0_base, true));
}
static void dump_dbg_reg(struct rkisp_bridge_device *dev, struct rkisp_ispp_reg *reg_buf)
{
struct rkisp_isp2x_stat_buffer *tmp_statsbuf;
struct rkisp_hw_dev *hw = dev->ispdev->hw_dev;
u32 offset = 0, size;
tmp_statsbuf = (struct rkisp_isp2x_stat_buffer *)dev->ispdev->stats_vdev.tmp_statsbuf.vaddr;
memset(reg_buf->isp_offset, -1, sizeof(reg_buf->isp_offset));
memset(reg_buf->ispp_offset, -1, sizeof(reg_buf->ispp_offset));
memset(reg_buf->isp_size, 0, sizeof(reg_buf->isp_offset));
memset(reg_buf->isp_stats_size, 0, sizeof(reg_buf->isp_offset));
memset(reg_buf->ispp_size, 0, sizeof(reg_buf->ispp_offset));
if (rkisp_debug_reg & ISP2X_MODULE_DPCC) {
size = 4 + ISP_DPCC0_PDAF_FORWARD_MED - ISP_DPCC0_MODE;
reg_buf->isp_size[ISP2X_ID_DPCC] = size;
reg_buf->isp_offset[ISP2X_ID_DPCC] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_DPCC0_MODE, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_BLS) {
size = 4 + ISP_BLS_D_MEASURED - ISP_BLS_CTRL;
reg_buf->isp_size[ISP2X_ID_BLS] = size;
reg_buf->isp_offset[ISP2X_ID_BLS] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_BLS_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_SDG) {
size = 4 + ISP_GAMMA_B_Y_16 - ISP_GAMMA_DX_LO;
reg_buf->isp_size[ISP2X_ID_SDG] = size;
reg_buf->isp_offset[ISP2X_ID_SDG] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GAMMA_DX_LO, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_SIHST) {
size = 4 + ISP_HIST_HIST3_DBG2 - ISP_HIST_HIST_CTRL;
reg_buf->isp_size[ISP2X_ID_SIHST] = size;
reg_buf->isp_offset[ISP2X_ID_SIHST] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_HIST_HIST_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_LSC) {
size = 4 + ISP_LSC_STATUS - ISP_LSC_CTRL;
reg_buf->isp_size[ISP2X_ID_LSC] = size;
reg_buf->isp_offset[ISP2X_ID_LSC] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_LSC_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_AWB_GAIN) {
size = 4 + CIF_ISP_AWB_GAIN_RB_V12 - CIF_ISP_AWB_GAIN_G_V12;
reg_buf->isp_size[ISP2X_ID_AWB_GAIN] = size;
reg_buf->isp_offset[ISP2X_ID_AWB_GAIN] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_ISP_AWB_GAIN_G_V12, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_CCM) {
size = 4 + ISP_CCM_BOUND_BIT - ISP_CCM_CTRL;
reg_buf->isp_size[ISP2X_ID_CCM] = size;
reg_buf->isp_offset[ISP2X_ID_CCM] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_CCM_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_GOC) {
size = 4 + ISP_GAMMA_OUT_Y40 - ISP_GAMMA_OUT_CTRL;
reg_buf->isp_size[ISP2X_ID_GOC] = size;
reg_buf->isp_offset[ISP2X_ID_GOC] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GAMMA_OUT_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_CPROC) {
size = 4 + CPROC_HUE - CPROC_CTRL;
reg_buf->isp_size[ISP2X_ID_CPROC] = size;
reg_buf->isp_offset[ISP2X_ID_CPROC] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CPROC_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_SIAF) {
size = 4 + ISP_AFM_LUM_C - ISP_AFM_CTRL;
reg_buf->isp_size[ISP2X_ID_SIAF] = size;
reg_buf->isp_offset[ISP2X_ID_SIAF] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_AFM_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_SIAWB) {
size = 4 + CIF_ISP_AWB_MEAN_V10 - CIF_ISP_AWB_PROP_V10;
reg_buf->isp_size[ISP2X_ID_SIAWB] = size;
reg_buf->isp_offset[ISP2X_ID_SIAWB] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_ISP_AWB_PROP_V10, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_IE) {
size = 4 + CIF_IMG_EFF_SHARPEN - CIF_IMG_EFF_CTRL;
reg_buf->isp_size[ISP2X_ID_IE] = size;
reg_buf->isp_offset[ISP2X_ID_IE] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_IMG_EFF_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_YUVAE) {
size = 4 + ISP_YUVAE_RO_DBG3 - ISP_YUVAE_CTRL;
reg_buf->isp_size[ISP2X_ID_YUVAE] = size;
reg_buf->isp_offset[ISP2X_ID_YUVAE] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_YUVAE_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_WDR) {
size = 4 + ISP_WDR_BLKMEAN8_ROW9_4TO7 - ISP_WDR_CTRL;
reg_buf->isp_size[ISP2X_ID_WDR] = size;
reg_buf->isp_offset[ISP2X_ID_WDR] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_WDR_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RK_IESHARP) {
size = 4 + CIF_RKSHARP_UV_GAUSS_OTHER_COE33_COE35 - CIF_RKSHARP_CTRL;
reg_buf->isp_size[ISP2X_ID_RK_IESHARP] = size;
reg_buf->isp_offset[ISP2X_ID_RK_IESHARP] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + CIF_RKSHARP_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWAF) {
size = 4 + ISP_RAWAF_INT_STATE - ISP_RAWAF_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWAF] = size;
reg_buf->isp_offset[ISP2X_ID_RAWAF] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWAF_CTRL, size);
offset += size;
size = ISP2X_RAWAF_SUMDATA_NUM * sizeof(tmp_statsbuf->params.rawaf.ramdata[0]);
reg_buf->isp_size[ISP2X_ID_RAWAF] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWAF] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id)
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawaf.ramdata[0], size);
else
memset(&reg_buf->reg[offset], 0, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWAE0) {
size = 4 + ISP_RAWAE_LITE_RO_DBG2 - ISP_RAWAE_LITE_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWAE0] = size;
reg_buf->isp_offset[ISP2X_ID_RAWAE0] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWAE_LITE_CTRL, size);
offset += size;
size = ISP2X_RAWAELITE_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae0.data[0]);
reg_buf->isp_size[ISP2X_ID_RAWAE0] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWAE0] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id) {
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae0.data[0], size);
} else {
memset(&reg_buf->reg[offset], 0, size);
}
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWAE1) {
size = 4 + RAWAE_BIG_RO_DBG3 - RAWAE_BIG_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWAE1] = size;
reg_buf->isp_offset[ISP2X_ID_RAWAE1] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + RAWAE_BIG1_BASE, size);
offset += size;
size = ISP2X_RAWAEBIG_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae1.data[0]);
reg_buf->isp_size[ISP2X_ID_RAWAE1] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWAE1] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id) {
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae1.data[0], size);
} else {
memset(&reg_buf->reg[offset], 0, size);
}
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWAE2) {
size = 4 + RAWAE_BIG_RO_DBG3 - RAWAE_BIG_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWAE2] = size;
reg_buf->isp_offset[ISP2X_ID_RAWAE2] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + RAWAE_BIG2_BASE, size);
offset += size;
size = ISP2X_RAWAEBIG_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae2.data[0]);
reg_buf->isp_size[ISP2X_ID_RAWAE2] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWAE2] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id) {
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae2.data[0], size);
} else {
memset(&reg_buf->reg[offset], 0, size);
}
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWAE3) {
size = 4 + RAWAE_BIG_RO_DBG3 - RAWAE_BIG_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWAE3] = size;
reg_buf->isp_offset[ISP2X_ID_RAWAE3] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + RAWAE_BIG3_BASE, size);
offset += size;
size = ISP2X_RAWAEBIG_MEAN_NUM * sizeof(tmp_statsbuf->params.rawae3.data[0]);
reg_buf->isp_size[ISP2X_ID_RAWAE3] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWAE3] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id) {
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawae3.data[0], size);
} else {
memset(&reg_buf->reg[offset], 0, size);
}
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWAWB) {
size = 4 + ISP_RAWAWB_RAM_CTRL - ISP_RAWAWB_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWAWB] = size;
reg_buf->isp_offset[ISP2X_ID_RAWAWB] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWAWB_CTRL, size);
offset += size;
size = ISP2X_RAWAWB_RAMDATA_NUM * sizeof(tmp_statsbuf->params.rawawb.ramdata[0]);
reg_buf->isp_size[ISP2X_ID_RAWAWB] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWAWB] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id)
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawawb.ramdata[0], size);
else
memset(&reg_buf->reg[offset], 0, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST0) {
size = 4 + ISP_RAWHIST_LITE_WEIGHT - ISP_RAWHIST_LITE_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWHIST0] = size;
reg_buf->isp_offset[ISP2X_ID_RAWHIST0] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_LITE_CTRL, size);
offset += size;
size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist0.hist_bin[0]);
reg_buf->isp_size[ISP2X_ID_RAWHIST0] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWHIST0] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id)
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist0.hist_bin[0], size);
else
memset(&reg_buf->reg[offset], 0, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST1) {
size = 4 + ISP_RAWHIST_BIG_WEIGHT_BASE - ISP_RAWHIST_BIG_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWHIST1] = size;
reg_buf->isp_offset[ISP2X_ID_RAWHIST1] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_BIG1_BASE, size);
offset += size;
size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist1.hist_bin[0]);
reg_buf->isp_size[ISP2X_ID_RAWHIST1] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWHIST1] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id)
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist1.hist_bin[0], size);
else
memset(&reg_buf->reg[offset], 0, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST2) {
size = 4 + ISP_RAWHIST_BIG_WEIGHT_BASE - ISP_RAWHIST_BIG_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWHIST2] = size;
reg_buf->isp_offset[ISP2X_ID_RAWHIST2] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_BIG2_BASE, size);
offset += size;
size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist2.hist_bin[0]);
reg_buf->isp_size[ISP2X_ID_RAWHIST2] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWHIST2] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id)
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist2.hist_bin[0], size);
else
memset(&reg_buf->reg[offset], 0, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWHIST3) {
size = 4 + ISP_RAWHIST_BIG_WEIGHT_BASE - ISP_RAWHIST_BIG_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWHIST3] = size;
reg_buf->isp_offset[ISP2X_ID_RAWHIST3] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWHIST_BIG3_BASE, size);
offset += size;
size = ISP2X_HIST_BIN_N_MAX * sizeof(tmp_statsbuf->params.rawhist3.hist_bin[0]);
reg_buf->isp_size[ISP2X_ID_RAWHIST3] += size;
reg_buf->isp_stats_size[ISP2X_ID_RAWHIST3] = size;
if (tmp_statsbuf->frame_id == reg_buf->frame_id)
memcpy(&reg_buf->reg[offset], &tmp_statsbuf->params.rawhist3.hist_bin[0], size);
else
memset(&reg_buf->reg[offset], 0, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_HDRMGE) {
size = 4 + ISP_HDRMGE_OVER_Y16 - ISP_HDRMGE_CTRL;
reg_buf->isp_size[ISP2X_ID_HDRMGE] = size;
reg_buf->isp_offset[ISP2X_ID_HDRMGE] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_HDRMGE_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_RAWNR) {
size = 4 + ISP_RAWNR_RGBAIN_FLIP - ISP_RAWNR_CTRL;
reg_buf->isp_size[ISP2X_ID_RAWNR] = size;
reg_buf->isp_offset[ISP2X_ID_RAWNR] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_RAWNR_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_HDRTMO) {
size = 4 + ISP_HDRTMO_HIST_RO31 - ISP_HDRTMO_CTRL;
reg_buf->isp_size[ISP2X_ID_HDRTMO] = size;
reg_buf->isp_offset[ISP2X_ID_HDRTMO] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_HDRTMO_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_GIC) {
size = 4 + ISP_GIC_NOISE_CTRL1 - ISP_GIC_CONTROL;
reg_buf->isp_size[ISP2X_ID_GIC] = size;
reg_buf->isp_offset[ISP2X_ID_GIC] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GIC_CONTROL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_DHAZ) {
size = 4 + ISP_DHAZ_HIST_REG95 - ISP_DHAZ_CTRL;
reg_buf->isp_size[ISP2X_ID_DHAZ] = size;
reg_buf->isp_offset[ISP2X_ID_DHAZ] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_DHAZ_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_3DLUT) {
size = 4 + ISP_3DLUT_UPDATE - ISP_3DLUT_CTRL;
reg_buf->isp_size[ISP2X_ID_3DLUT] = size;
reg_buf->isp_offset[ISP2X_ID_3DLUT] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_3DLUT_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_LDCH) {
size = 4 + ISP_LDCH_STS - ISP_LDCH_STS;
reg_buf->isp_size[ISP2X_ID_LDCH] = size;
reg_buf->isp_offset[ISP2X_ID_LDCH] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_LDCH_STS, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_GAIN) {
size = 4 + ISP_GAIN_LUT8 - ISP_GAIN_CTRL;
reg_buf->isp_size[ISP2X_ID_GAIN] = size;
reg_buf->isp_offset[ISP2X_ID_GAIN] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_GAIN_CTRL, size);
offset += size;
}
if (rkisp_debug_reg & ISP2X_MODULE_DEBAYER) {
size = 4 + ISP_DEBAYER_C_FILTER - ISP_DEBAYER_CONTROL;
reg_buf->isp_size[ISP2X_ID_DEBAYER] = size;
reg_buf->isp_offset[ISP2X_ID_DEBAYER] = offset;
memcpy_fromio(&reg_buf->reg[offset], hw->base_addr + ISP_DEBAYER_CONTROL, size);
offset += size;
}
reg_buf->reg_size = offset;
}
static int frame_end(struct rkisp_bridge_device *dev, bool en)
{
struct rkisp_hw_dev *hw = dev->ispdev->hw_dev;
struct v4l2_subdev *sd = v4l2_get_subdev_hostdata(&dev->sd);
struct rkisp_ispp_reg *reg_buf;
unsigned long lock_flags = 0;
u64 ns = ktime_get_ns();
rkisp_dmarx_get_frame(dev->ispdev, &dev->dbg.id, NULL, true);
rkisp_dmarx_get_frame(dev->ispdev, &dev->dbg.id, NULL, NULL, true);
dev->dbg.interval = ns - dev->dbg.timestamp;
dev->dbg.timestamp = ns;
if (hw->cur_buf && hw->nxt_buf) {
@@ -69,14 +451,27 @@ static int frame_end(struct rkisp_bridge_device *dev, bool en)
list_add_tail(&hw->cur_buf->list, &hw->list);
spin_unlock_irqrestore(&hw->buf_lock, lock_flags);
} else {
u64 sof_ns = 0;
ns = 0;
rkisp_dmarx_get_frame(dev->ispdev,
&hw->cur_buf->frame_id, &ns, true);
hw->cur_buf->frame_id++;
&hw->cur_buf->frame_id, &sof_ns, &ns, true);
if (!sof_ns)
sof_ns = 0;
if (!ns)
ns = ktime_get_ns();
hw->cur_buf->frame_timestamp = ns;
hw->cur_buf->index = dev->ispdev->dev_id;
rkispp_request_regbuf(sd, &reg_buf);
if (reg_buf) {
reg_buf->stat = ISP_ISPP_INUSE;
reg_buf->dev_id = hw->cur_buf->index;
reg_buf->frame_id = hw->cur_buf->frame_id;
reg_buf->sof_timestamp = sof_ns;
reg_buf->frame_timestamp = hw->cur_buf->frame_timestamp;
reg_buf->exposure = dev->ispdev->params_vdev.exposure;
dump_dbg_reg(dev, reg_buf);
}
v4l2_subdev_call(sd, video, s_rx_buffer, hw->cur_buf, NULL);
}
hw->cur_buf = NULL;
@@ -464,6 +859,7 @@ static int bridge_start(struct rkisp_bridge_device *dev)
update_mi(dev);
}
dev->ispdev->skip_frame = 0;
rkisp_stats_first_ddr_config(&dev->ispdev->stats_vdev);
dev->en = true;
return 0;
}

2
drivers/media/platform/rockchip/isp/capture_v20.c
View File

@@ -1310,7 +1310,7 @@ static int mi_frame_end(struct rkisp_stream *stream)
stream->id == RKISP_STREAM_SP)
rkisp_dmarx_get_frame(dev,
&stream->curr_buf->vb.sequence,
&ns, false);
NULL, &ns, false);
else
stream->curr_buf->vb.sequence =
atomic_read(&stream->sequence) - 1;

2
drivers/media/platform/rockchip/isp/capture_v21.c
View File

@@ -729,7 +729,7 @@ static int mi_frame_end(struct rkisp_stream *stream)
}
if (stream->id == RKISP_STREAM_MP ||
stream->id == RKISP_STREAM_SP) {
rkisp_dmarx_get_frame(dev, &i, &ns, true);
rkisp_dmarx_get_frame(dev, &i, NULL, &ns, true);
atomic_set(&stream->sequence, i);
stream->curr_buf->vb.sequence = i;
} else {

6
drivers/media/platform/rockchip/isp/common.c
View File

@@ -12,7 +12,7 @@ static const struct vb2_mem_ops *g_ops = &vb2_dma_contig_memops;
void rkisp_write(struct rkisp_device *dev, u32 reg, u32 val, bool is_direct)
{
u32 *mem = dev->sw_base_addr + reg;
u32 *flag = dev->sw_base_addr + reg + ISP_SW_REG_SIZE;
u32 *flag = dev->sw_base_addr + reg + RKISP_ISP_SW_REG_SIZE;
*mem = val;
*flag = SW_REG_CACHE;
@@ -52,13 +52,13 @@ void rkisp_update_regs(struct rkisp_device *dev, u32 start, u32 end)
void __iomem *base = dev->hw_dev->base_addr;
u32 i;
if (end > ISP_SW_REG_SIZE - 4) {
if (end > RKISP_ISP_SW_REG_SIZE - 4) {
dev_err(dev->dev, "%s out of range\n", __func__);
return;
}
for (i = start; i <= end; i += 4) {
u32 *val = dev->sw_base_addr + i;
u32 *flag = dev->sw_base_addr + i + ISP_SW_REG_SIZE;
u32 *flag = dev->sw_base_addr + i + RKISP_ISP_SW_REG_SIZE;
if (*flag == SW_REG_CACHE)
writel(*val, base + i);

1
drivers/media/platform/rockchip/isp/common.h
View File

@@ -131,6 +131,7 @@ struct rkisp_dummy_buffer {
};
extern int rkisp_debug;
extern u64 rkisp_debug_reg;
extern struct platform_driver rkisp_plat_drv;
static inline

3
drivers/media/platform/rockchip/isp/csi.c
View File

@@ -530,7 +530,7 @@ void rkisp_trigger_read_back(struct rkisp_csi_device *csi, u8 dma2frm, u32 mode)
bool is_upd = false;
hw->cur_dev_id = dev->dev_id;
rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, true);
rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, NULL, true);
if (dma2frm > 2)
dma2frm = 2;
if (dma2frm == 2)
@@ -630,6 +630,7 @@ static void rkisp_dev_trigger_handle(struct rkisp_device *dev, u32 cmd)
rkisp_csi_trigger_event(isp, T_CMD_DEQUEUE, &t);
isp->dmarx_dev.pre_frame = isp->dmarx_dev.cur_frame;
isp->dmarx_dev.cur_frame.id = t.frame_id;
isp->dmarx_dev.cur_frame.sof_timestamp = t.sof_timestamp;
isp->dmarx_dev.cur_frame.timestamp = t.frame_timestamp;
mode = t.mode;
times = t.times;

6
drivers/media/platform/rockchip/isp/dev.c
View File

@@ -67,6 +67,10 @@ static char rkisp_version[RKISP_VERNO_LEN];
module_param_string(version, rkisp_version, RKISP_VERNO_LEN, 0444);
MODULE_PARM_DESC(version, "version number");
u64 rkisp_debug_reg = 0xFFFFFFFFFLL;
module_param_named(debug_reg, rkisp_debug_reg, ullong, 0644);
MODULE_PARM_DESC(debug_reg, "rkisp debug register");
static DEFINE_MUTEX(rkisp_dev_mutex);
static LIST_HEAD(rkisp_device_list);
@@ -691,7 +695,7 @@ static int rkisp_plat_probe(struct platform_device *pdev)
isp_dev = devm_kzalloc(dev, sizeof(*isp_dev), GFP_KERNEL);
if (!isp_dev)
return -ENOMEM;
isp_dev->sw_base_addr = devm_kzalloc(dev, ISP_SW_MAX_SIZE, GFP_KERNEL);
isp_dev->sw_base_addr = devm_kzalloc(dev, RKISP_ISP_SW_MAX_SIZE, GFP_KERNEL);
if (!isp_dev->sw_base_addr)
return -ENOMEM;

11
drivers/media/platform/rockchip/isp/dmarx.c
View File

@@ -949,11 +949,12 @@ static int dmarx_init(struct rkisp_device *dev, u32 id)
RKISP_ISP_PAD_SINK, stream->linked);
}
void rkisp_dmarx_get_frame(struct rkisp_device *dev,
u32 *id, u64 *timestamp, bool sync)
void rkisp_dmarx_get_frame(struct rkisp_device *dev, u32 *id,
u64 *sof_timestamp, u64 *timestamp,
bool sync)
{
unsigned long flag = 0;
u64 frame_timestamp = 0;
u64 sof_time = 0, frame_timestamp = 0;
u32 frame_id = 0;
if (!dev->dmarx_dev.trigger && id) {
@@ -964,14 +965,18 @@ void rkisp_dmarx_get_frame(struct rkisp_device *dev,
spin_lock_irqsave(&dev->csi_dev.rdbk_lock, flag);
if (sync) {
frame_id = dev->dmarx_dev.cur_frame.id;
sof_time = dev->dmarx_dev.cur_frame.sof_timestamp;
frame_timestamp = dev->dmarx_dev.cur_frame.timestamp;
} else {
frame_id = dev->dmarx_dev.pre_frame.id;
sof_time = dev->dmarx_dev.pre_frame.sof_timestamp;
frame_timestamp = dev->dmarx_dev.pre_frame.timestamp;
}
spin_unlock_irqrestore(&dev->csi_dev.rdbk_lock, flag);
if (id)
*id = frame_id;
if (sof_timestamp)
*sof_timestamp = sof_time;
if (timestamp)
*timestamp = frame_timestamp;
}

6
drivers/media/platform/rockchip/isp/dmarx.h
View File

@@ -27,6 +27,7 @@ enum rkisp_dmarx_trigger {
};
struct rkisp_dmarx_frame {
u64 sof_timestamp;
u64 timestamp;
u32 id;
};
@@ -47,8 +48,9 @@ struct rkisp_dmarx_device {
void rkisp_dmarx_isr(u32 mis_val, struct rkisp_device *dev);
void rkisp2_rawrd_isr(u32 mis_val, struct rkisp_device *dev);
void rkisp_dmarx_get_frame(struct rkisp_device *dev,
u32 *id, u64 *timestamp, bool sync);
void rkisp_dmarx_get_frame(struct rkisp_device *dev, u32 *id,
u64 *sof_timestamp, u64 *timestamp,
bool sync);
void rkisp_unregister_dmarx_vdev(struct rkisp_device *dev);
int rkisp_register_dmarx_vdev(struct rkisp_device *dev);
#endif /* _RKISP_DMARX_H */

6
drivers/media/platform/rockchip/isp/hw.c
View File

@@ -82,7 +82,7 @@ static void default_sw_reg_flag(struct rkisp_device *dev)
u32 i, *flag;
for (i = 0; i < ARRAY_SIZE(reg); i++) {
flag = dev->sw_base_addr + reg[i] + ISP_SW_REG_SIZE;
flag = dev->sw_base_addr + reg[i] + RKISP_ISP_SW_REG_SIZE;
*flag = SW_REG_CACHE;
}
}
@@ -743,8 +743,8 @@ static int __maybe_unused rkisp_runtime_resume(struct device *dev)
for (i = 0; i < hw_dev->dev_num; i++) {
void *buf = hw_dev->isp[i]->sw_base_addr;
memset(buf, 0, ISP_SW_MAX_SIZE);
memcpy_fromio(buf, base, ISP_SW_REG_SIZE);
memset(buf, 0, RKISP_ISP_SW_MAX_SIZE);
memcpy_fromio(buf, base, RKISP_ISP_SW_REG_SIZE);
default_sw_reg_flag(hw_dev->isp[i]);
}
return 0;

45
drivers/media/platform/rockchip/isp/isp_ispp.h
View File

@@ -6,10 +6,18 @@
#include <linux/platform_device.h>
#include <media/v4l2-subdev.h>
#include <linux/rkisp1-config.h>
#include <linux/rkispp-config.h>
#define RKISPP_BUF_MAX 5
#define RKISP_ISPP_BUF_MAX (RKISPP_BUF_MAX + (2 * (DEV_MAX - 1)))
#define RKISP_ISPP_REGBUF_NUM RKISPP_BUF_POOL_MAX
#define RKISP_ISP_SW_REG_SIZE 0x6000
#define RKISP_ISP_SW_MAX_SIZE (RKISP_ISP_SW_REG_SIZE * 2)
#define RKISP_ISPP_SW_REG_SIZE 0x0d00
#define RKISP_ISPP_SW_MAX_SIZE (RKISP_ISPP_SW_REG_SIZE * 2)
#define RKISP_ISPP_CMD_SET_MODE \
_IOW('V', BASE_VIDIOC_PRIVATE + 0, struct rkisp_ispp_mode)
#define RKISP_ISPP_CMD_SET_FMT \
@@ -41,6 +49,11 @@ enum rkisp_ispp_work_mode {
ISP_ISPP_INIT_FAIL = BIT(7),
};
enum rkisp_ispp_reg_stat {
ISP_ISPP_FREE = 0,
ISP_ISPP_INUSE,
};
struct frame_debug_info {
u64 timestamp;
u32 interval;
@@ -59,6 +72,22 @@ struct rkisp_ispp_mode {
u8 buf_num;
};
struct rkisp_ispp_reg {
enum rkisp_ispp_reg_stat stat;
u32 dev_id;
u32 frame_id;
u32 reg_size;
s32 isp_offset[ISP2X_ID_MAX];
s32 ispp_offset[ISPP_ID_MAX];
u32 isp_size[ISP2X_ID_MAX];
u32 isp_stats_size[ISP2X_ID_MAX];
u32 ispp_size[ISPP_ID_MAX];
u64 sof_timestamp;
u64 frame_timestamp;
struct sensor_exposure_cfg exposure;
u8 reg[RKISP_ISP_SW_REG_SIZE + RKISP_ISPP_SW_REG_SIZE];
};
struct rkisp_ispp_buf {
struct list_head list;
struct dma_buf *dbuf[GROUP_BUF_MAX];
@@ -84,4 +113,20 @@ static inline void rkisp_get_bridge_sd(struct platform_device *dev,
}
#endif
#if IS_ENABLED(CONFIG_VIDEO_ROCKCHIP_ISPP)
void rkispp_request_regbuf(struct v4l2_subdev *sd, struct rkisp_ispp_reg **free_buf);
bool rkispp_get_reg_withstream(void);
#else
static inline void rkispp_request_regbuf(struct v4l2_subdev *sd,
struct rkisp_ispp_reg **free_buf)
{
*free_buf = NULL;
}
static inline bool rkispp_get_reg_withstream(void)
{
return false;
}
#endif
#endif

1
drivers/media/platform/rockchip/isp/isp_params.h
View File

@@ -76,6 +76,7 @@ struct rkisp_isp_params_vdev {
struct isp2x_hdrmge_cfg cur_hdrmge;
struct isp21_drc_cfg cur_hdrdrc;
struct isp2x_lsc_cfg cur_lsccfg;
struct sensor_exposure_cfg exposure;
};
/* config params before ISP streaming */

2
drivers/media/platform/rockchip/isp/isp_params_v21.c
View File

@@ -4165,7 +4165,7 @@ rkisp_params_isr_v2x(struct rkisp_isp_params_vdev *params_vdev,
struct rkisp_device *dev = params_vdev->dev;
u32 cur_frame_id;
rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, true);
rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, NULL, true);
if (isp_mis & CIF_ISP_V_START) {
if (!params_vdev->cur_buf)
return;

3
drivers/media/platform/rockchip/isp/isp_params_v2x.c
View File

@@ -4431,6 +4431,7 @@ rkisp_params_cfg_v2x(struct rkisp_isp_params_vdev *params_vdev,
params_vdev->rdbk_times = rdbk_times;
}
params_vdev->exposure = new_params->exposure;
unlock:
params_vdev->cur_buf = cur_buf;
spin_unlock(&params_vdev->config_lock);
@@ -4443,7 +4444,7 @@ rkisp_params_isr_v2x(struct rkisp_isp_params_vdev *params_vdev,
struct rkisp_device *dev = params_vdev->dev;
u32 cur_frame_id;
rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, true);
rkisp_dmarx_get_frame(dev, &cur_frame_id, NULL, NULL, true);
if (isp_mis & CIF_ISP_V_START) {
if (!params_vdev->cur_buf)
return;

2
drivers/media/platform/rockchip/isp/isp_stats.h
View File

@@ -68,6 +68,8 @@ struct rkisp_isp_stats_vdev {
bool rdbk_mode;
u32 isp_rdbk;
u32 isp3a_rdbk;
struct rkisp_dummy_buffer tmp_statsbuf;
};
void rkisp_stats_rdbk_enable(struct rkisp_isp_stats_vdev *stats_vdev, bool en);

2
drivers/media/platform/rockchip/isp/isp_stats_v21.c
View File

@@ -915,7 +915,7 @@ rkisp_stats_isr_v2x(struct rkisp_isp_stats_vdev *stats_vdev,
u32 wr_buf_idx;
u32 temp_isp_ris, temp_isp3a_ris;
rkisp_dmarx_get_frame(stats_vdev->dev, &cur_frame_id, NULL, true);
rkisp_dmarx_get_frame(stats_vdev->dev, &cur_frame_id, NULL, NULL, true);
#ifdef LOG_ISR_EXE_TIME
ktime_t in_t = ktime_get();
#endif

15
drivers/media/platform/rockchip/isp/isp_stats_v2x.c
View File

@@ -1261,6 +1261,13 @@ rkisp_stats_send_meas_v2x(struct rkisp_isp_stats_vdev *stats_vdev,
sizeof(struct rkisp_isp2x_stat_buffer));
cur_buf->vb.sequence = cur_frame_id;
cur_buf->vb.vb2_buf.timestamp = meas_work->timestamp;
if (rkispp_get_reg_withstream()) {
struct rkisp_isp2x_stat_buffer *tmp_statsbuf;
tmp_statsbuf = (struct rkisp_isp2x_stat_buffer *)stats_vdev->tmp_statsbuf.vaddr;
if (tmp_statsbuf)
memcpy(tmp_statsbuf, cur_stat_buf, sizeof(*cur_stat_buf));
}
vb2_buffer_done(&cur_buf->vb.vb2_buf, VB2_BUF_STATE_DONE);
}
}
@@ -1330,7 +1337,7 @@ rkisp_stats_isr_v2x(struct rkisp_isp_stats_vdev *stats_vdev,
u32 wr_buf_idx;
u32 temp_isp_ris, temp_isp3a_ris;
rkisp_dmarx_get_frame(stats_vdev->dev, &cur_frame_id, NULL, true);
rkisp_dmarx_get_frame(stats_vdev->dev, &cur_frame_id, NULL, NULL, true);
#ifdef LOG_ISR_EXE_TIME
ktime_t in_t = ktime_get();
#endif
@@ -1466,6 +1473,12 @@ void rkisp_stats_first_ddr_config_v2x(struct rkisp_isp_stats_vdev *stats_vdev)
rkisp_set_bits(stats_vdev->dev, CTRL_SWS_CFG, SW_3A_DDR_WRITE_EN,
SW_3A_DDR_WRITE_EN, false);
}
if (rkispp_get_reg_withstream()) {
stats_vdev->tmp_statsbuf.is_need_vaddr = true;
stats_vdev->tmp_statsbuf.size = sizeof(struct rkisp_isp2x_stat_buffer);
rkisp_alloc_buffer(stats_vdev->dev, &stats_vdev->tmp_statsbuf);
}
}
void rkisp_init_stats_vdev_v2x(struct rkisp_isp_stats_vdev *stats_vdev)

2
drivers/media/platform/rockchip/isp/isp_stats_v2x.h
View File

@@ -9,7 +9,7 @@
#include <linux/kfifo.h>
#include "common.h"
//#define RKISP_RD_STATS_FROM_DDR
// #define RKISP_RD_STATS_FROM_DDR
#define RKISP_RD_STATS_BUF_SIZE 0x35000
struct rkisp_isp_stats_vdev;

3
drivers/media/platform/rockchip/isp/regs_v2x.h
View File

@@ -6,9 +6,6 @@
#ifndef _RKISP_REGS_V2X_H
#define _RKISP_REGS_V2X_H
#define ISP_SW_REG_SIZE 0x6000
#define ISP_SW_MAX_SIZE (ISP_SW_REG_SIZE * 2)
#define CTRL_BASE 0x00000000
#define CTRL_VI_ISP_EN (CTRL_BASE + 0x00000)
#define CTRL_VI_ISP_PATH (CTRL_BASE + 0x00004)

141
drivers/media/platform/rockchip/ispp/common.c
View File

@@ -13,7 +13,7 @@ static const struct vb2_mem_ops *g_ops = &vb2_dma_contig_memops;
void rkispp_write(struct rkispp_device *dev, u32 reg, u32 val)
{
u32 *mem = dev->sw_base_addr + reg;
u32 *flag = dev->sw_base_addr + reg + ISPP_SW_REG_SIZE;
u32 *flag = dev->sw_base_addr + reg + RKISP_ISPP_SW_REG_SIZE;
*mem = val;
*flag = SW_REG_CACHE;
@@ -51,13 +51,13 @@ void rkispp_update_regs(struct rkispp_device *dev, u32 start, u32 end)
void __iomem *base = dev->hw_dev->base_addr;
u32 i;
if (end > ISPP_SW_REG_SIZE - 4) {
if (end > RKISP_ISPP_SW_REG_SIZE - 4) {
dev_err(dev->dev, "%s out of range\n", __func__);
return;
}
for (i = start; i <= end; i += 4) {
u32 *val = dev->sw_base_addr + i;
u32 *flag = dev->sw_base_addr + i + ISPP_SW_REG_SIZE;
u32 *flag = dev->sw_base_addr + i + RKISP_ISPP_SW_REG_SIZE;
if (*flag == SW_REG_CACHE)
writel(*val, base + i);
@@ -164,6 +164,66 @@ int rkispp_attach_hw(struct rkispp_device *ispp)
return 0;
}
static int rkispp_init_regbuf(struct rkispp_hw_dev *hw)
{
struct rkisp_ispp_reg *reg_buf;
u32 i, buf_size;
if (!rkispp_reg_withstream) {
hw->reg_buf = NULL;
return 0;
}
buf_size = RKISP_ISPP_REGBUF_NUM * sizeof(struct rkisp_ispp_reg);
hw->reg_buf = vmalloc(buf_size);
if (!hw->reg_buf)
return -ENOMEM;
reg_buf = hw->reg_buf;
for (i = 0; i < RKISP_ISPP_REGBUF_NUM; i++) {
reg_buf[i].stat = ISP_ISPP_FREE;
reg_buf[i].dev_id = 0xFF;
reg_buf[i].frame_id = 0;
reg_buf[i].reg_size = 0;
reg_buf[i].sof_timestamp = 0LL;
reg_buf[i].frame_timestamp = 0LL;
}
return 0;
}
static void rkispp_free_regbuf(struct rkispp_hw_dev *hw)
{
if (hw->reg_buf) {
vfree(hw->reg_buf);
hw->reg_buf = NULL;
}
}
static int rkispp_find_regbuf_by_stat(struct rkispp_hw_dev *hw, struct rkisp_ispp_reg **free_buf,
enum rkisp_ispp_reg_stat stat)
{
struct rkisp_ispp_reg *reg_buf = hw->reg_buf;
int i = 0, ret;
*free_buf = NULL;
if (!hw->reg_buf || !rkispp_reg_withstream)
return -EINVAL;
for (i = 0; i < RKISP_ISPP_REGBUF_NUM; i++) {
if (reg_buf[i].stat == stat)
break;
}
ret = -ENODATA;
if (i < RKISP_ISPP_REGBUF_NUM) {
ret = 0;
*free_buf = &reg_buf[i];
}
return ret;
}
static void rkispp_free_pool(struct rkispp_hw_dev *hw)
{
struct rkispp_isp_buf_pool *buf;
@@ -188,6 +248,8 @@ static void rkispp_free_pool(struct rkispp_hw_dev *hw)
}
buf->dbufs = NULL;
}
rkispp_free_regbuf(hw);
}
static int rkispp_init_pool(struct rkispp_hw_dev *hw, struct rkisp_ispp_buf *dbufs)
@@ -224,6 +286,7 @@ static int rkispp_init_pool(struct rkispp_hw_dev *hw, struct rkisp_ispp_buf *dbu
dev_info(hw->dev, "%s dma[%d]:0x%x\n",
__func__, i, (u32)pool->dma[i]);
}
rkispp_init_regbuf(hw);
return ret;
err:
rkispp_free_pool(hw);
@@ -347,3 +410,75 @@ void rkispp_free_common_dummy_buf(struct rkispp_device *dev)
return;
rkispp_free_buffer(dev, &dev->hw_dev->dummy_buf);
}
int rkispp_find_regbuf_by_id(struct rkispp_device *ispp, struct rkisp_ispp_reg **free_buf,
u32 dev_id, u32 frame_id)
{
struct rkispp_hw_dev *hw = ispp->hw_dev;
struct rkisp_ispp_reg *reg_buf = hw->reg_buf;
int i = 0, ret;
*free_buf = NULL;
if (!hw->reg_buf)
return -EINVAL;
for (i = 0; i < RKISP_ISPP_REGBUF_NUM; i++) {
if (reg_buf[i].dev_id == dev_id && reg_buf[i].frame_id == frame_id)
break;
}
ret = -ENODATA;
if (i < RKISP_ISPP_REGBUF_NUM) {
ret = 0;
*free_buf = &reg_buf[i];
}
return ret;
}
void rkispp_release_regbuf(struct rkispp_device *ispp, struct rkisp_ispp_reg *freebuf)
{
struct rkispp_hw_dev *hw = ispp->hw_dev;
struct rkisp_ispp_reg *reg_buf = hw->reg_buf;
int i;
if (!hw->reg_buf)
return;
for (i = 0; i < RKISP_ISPP_REGBUF_NUM; i++) {
if (reg_buf[i].dev_id == freebuf->dev_id &&
reg_buf[i].frame_timestamp < freebuf->frame_timestamp) {
reg_buf[i].frame_id = 0;
reg_buf[i].stat = ISP_ISPP_FREE;
}
}
freebuf->frame_id = 0;
freebuf->stat = ISP_ISPP_FREE;
}
void rkispp_request_regbuf(struct v4l2_subdev *sd, struct rkisp_ispp_reg **free_buf)
{
struct rkispp_subdev *ispp_sdev = v4l2_get_subdevdata(sd);
struct rkispp_device *dev = ispp_sdev->dev;
struct rkispp_hw_dev *hw = dev->hw_dev;
int ret;
if (!hw->reg_buf) {
*free_buf = NULL;
return;
}
ret = rkispp_find_regbuf_by_stat(hw, free_buf, ISP_ISPP_FREE);
if (!ret) {
(*free_buf)->stat = ISP_ISPP_INUSE;
}
}
EXPORT_SYMBOL(rkispp_request_regbuf);
bool rkispp_get_reg_withstream(void)
{
return rkispp_reg_withstream;
}
EXPORT_SYMBOL(rkispp_get_reg_withstream);

5
drivers/media/platform/rockchip/ispp/common.h
View File

@@ -99,6 +99,8 @@ static inline struct vb2_queue *to_vb2_queue(struct file *file)
extern int rkispp_debug;
extern bool rkispp_clk_dbg;
extern bool rkispp_monitor;
extern bool rkispp_reg_withstream;
extern unsigned int rkispp_debug_reg;
extern struct platform_driver rkispp_plat_drv;
void rkispp_write(struct rkispp_device *dev, u32 reg, u32 val);
@@ -116,4 +118,7 @@ int rkispp_event_handle(struct rkispp_device *ispp, u32 cmd, void *arg);
void rkispp_soft_reset(struct rkispp_device *ispp);
int rkispp_alloc_common_dummy_buf(struct rkispp_device *dev);
void rkispp_free_common_dummy_buf(struct rkispp_device *dev);
int rkispp_find_regbuf_by_id(struct rkispp_device *ispp, struct rkisp_ispp_reg **free_buf,
u32 dev_id, u32 frame_id);
void rkispp_release_regbuf(struct rkispp_device *ispp, struct rkisp_ispp_reg *freebuf);
#endif

10
drivers/media/platform/rockchip/ispp/dev.c
View File

@@ -47,6 +47,14 @@ static char rkispp_version[RKISPP_VERNO_LEN];
module_param_string(version, rkispp_version, RKISPP_VERNO_LEN, 0444);
MODULE_PARM_DESC(version, "version number");
bool rkispp_reg_withstream;
module_param_named(sendreg_withstream, rkispp_reg_withstream, bool, 0644);
MODULE_PARM_DESC(sendreg_withstream, "rkispp send reg out with stream");
unsigned int rkispp_debug_reg = 0x1F;
module_param_named(debug_reg, rkispp_debug_reg, uint, 0644);
MODULE_PARM_DESC(debug_reg, "rkispp debug register");
static void get_remote_node_dev(struct rkispp_device *ispp_dev)
{
struct device *dev = ispp_dev->dev;
@@ -225,7 +233,7 @@ static int rkispp_plat_probe(struct platform_device *pdev)
ispp_dev = devm_kzalloc(dev, sizeof(*ispp_dev), GFP_KERNEL);
if (!ispp_dev)
return -ENOMEM;
ispp_dev->sw_base_addr = devm_kzalloc(dev, ISPP_SW_MAX_SIZE, GFP_KERNEL);
ispp_dev->sw_base_addr = devm_kzalloc(dev, RKISP_ISPP_SW_MAX_SIZE, GFP_KERNEL);
if (!ispp_dev->sw_base_addr)
return -ENOMEM;

6
drivers/media/platform/rockchip/ispp/hw.c
View File

@@ -54,7 +54,7 @@ static void default_sw_reg_flag(struct rkispp_device *dev)
u32 i, *flag;
for (i = 0; i < ARRAY_SIZE(reg); i++) {
flag = dev->sw_base_addr + reg[i] + ISPP_SW_REG_SIZE;
flag = dev->sw_base_addr + reg[i] + RKISP_ISPP_SW_REG_SIZE;
*flag = 0xffffffff;
}
}
@@ -338,8 +338,8 @@ static int __maybe_unused rkispp_runtime_resume(struct device *dev)
for (i = 0; i < hw_dev->dev_num; i++) {
void *buf = hw_dev->ispp[i]->sw_base_addr;
memset(buf, 0, ISPP_SW_MAX_SIZE);
memcpy_fromio(buf, base, ISPP_SW_REG_SIZE);
memset(buf, 0, RKISP_ISPP_SW_MAX_SIZE);
memcpy_fromio(buf, base, RKISP_ISPP_SW_REG_SIZE);
default_sw_reg_flag(hw_dev->ispp[i]);
}
hw_dev->is_idle = true;

1
drivers/media/platform/rockchip/ispp/hw.h
View File

@@ -51,5 +51,6 @@ struct rkispp_hw_dev {
bool is_idle;
bool is_single;
bool is_fec_ext;
struct rkisp_ispp_reg *reg_buf;
};
#endif

3
drivers/media/platform/rockchip/ispp/regs.h
View File

@@ -4,9 +4,6 @@
#ifndef _RKISPP_REGS_H
#define _RKISPP_REGS_H
#define ISPP_SW_REG_SIZE 0x0d00
#define ISPP_SW_MAX_SIZE (ISPP_SW_REG_SIZE * 2)
/* registers */
#define RKISPP_CTRL 0x0000
#define RKISPP_CTRL_STRT (RKISPP_CTRL + 0x0000)

111
drivers/media/platform/rockchip/ispp/stream.c
View File

@@ -325,6 +325,7 @@ static int rkispp_frame_end(struct rkispp_stream *stream)
{
struct rkispp_device *dev = stream->isppdev;
struct capture_fmt *fmt = &stream->out_cap_fmt;
struct rkisp_ispp_reg *reg_buf;
unsigned long lock_flags = 0;
int i = 0;
@@ -343,8 +344,29 @@ static int rkispp_frame_end(struct rkispp_stream *stream)
payload_size);
}
stream->curr_buf->vb.sequence =
atomic_read(&dev->ispp_sdev.frm_sync_seq) - 1;
atomic_read(&dev->ispp_sdev.frm_sync_seq);
stream->curr_buf->vb.vb2_buf.timestamp = ns;
if (rkispp_reg_withstream && (fmt->wr_fmt & FMT_FBC)) {
void *addr = vb2_plane_vaddr(&stream->curr_buf->vb.vb2_buf, i);
rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id,
stream->curr_buf->vb.sequence);
if (reg_buf) {
u32 cpy_size = offsetof(struct rkisp_ispp_reg, reg);
cpy_size += reg_buf->reg_size;
memcpy(addr, reg_buf, cpy_size);
rkispp_release_regbuf(dev, reg_buf);
vb2_set_plane_payload(&stream->curr_buf->vb.vb2_buf, 1, cpy_size);
} else {
v4l2_err(&dev->v4l2_dev,
"%s can not find reg buf: dev_id %d, sequence %d\n",
__func__, dev->dev_id, stream->curr_buf->vb.sequence);
}
}
vb2_buffer_done(&stream->curr_buf->vb.vb2_buf,
VB2_BUF_STATE_DONE);
@@ -355,6 +377,17 @@ static int rkispp_frame_end(struct rkispp_stream *stream)
stream->dbg.id = stream->curr_buf->vb.sequence;
stream->curr_buf = NULL;
} else if (rkispp_reg_withstream && (fmt->wr_fmt & FMT_FBC)) {
u32 frame_id;
frame_id = atomic_read(&dev->ispp_sdev.frm_sync_seq);
rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, frame_id);
if (reg_buf) {
rkispp_release_regbuf(dev, reg_buf);
v4l2_info(&dev->v4l2_dev,
"%s: current frame use dummy buffer(dev_id %d, sequence %d)\n",
__func__, dev->dev_id, frame_id);
}
}
spin_lock_irqsave(&stream->vbq_lock, lock_flags);
@@ -1308,6 +1341,11 @@ static int rkispp_queue_setup(struct vb2_queue *queue,
plane_fmt->sizeimage;
}
if (rkispp_reg_withstream && (cap_fmt->wr_fmt & FMT_FBC)) {
(*num_planes)++;
sizes[1] = sizeof(struct rkisp_ispp_reg);
}
v4l2_dbg(1, rkispp_debug, &dev->v4l2_dev,
"%s stream:%d count %d, size %d\n",
v4l2_type_names[queue->type],
@@ -1696,6 +1734,9 @@ static int rkispp_set_fmt(struct rkispp_stream *stream,
if (fmt->mplanes == 1)
pixm->plane_fmt[0].sizeimage = imagsize;
if ((fmt->wr_fmt & FMT_FBC) && rkispp_reg_withstream)
pixm->num_planes++;
if (!try) {
stream->out_cap_fmt = *fmt;
stream->out_fmt = *pixm;
@@ -2063,6 +2104,7 @@ static void fec_work_event(struct rkispp_device *dev,
struct rkispp_dummy_buffer *dummy;
unsigned long lock_flags = 0, lock_flags1 = 0;
bool is_start = false, is_quick = false;
struct rkisp_ispp_reg *reg_buf;
u32 val;
if (!(vdev->module_ens & ISPP_MODULE_FEC))
@@ -2154,6 +2196,20 @@ static void fec_work_event(struct rkispp_device *dev,
if (!completion_done(&monitor->fec.cmpl))
complete(&monitor->fec.cmpl);
}
rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, seq);
if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_FEC)) {
u32 offset, size;
offset = reg_buf->reg_size;
size = 4 + RKISPP_FEC_CROP - RKISPP_FEC_CTRL;
reg_buf->ispp_size[ISPP_ID_FEC] = size;
reg_buf->ispp_offset[ISPP_ID_FEC] = offset;
memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_FEC_CTRL, size);
offset += size;
reg_buf->reg_size = offset;
}
writel(FEC_ST, base + RKISPP_CTRL_STRT);
vdev->fec.is_end = false;
}
@@ -2180,6 +2236,7 @@ static void nr_work_event(struct rkispp_device *dev,
bool is_start = false, is_quick = false;
bool is_tnr_en = vdev->module_ens & ISPP_MODULE_TNR;
bool is_fec_en = (vdev->module_ens & ISPP_MODULE_FEC);
struct rkisp_ispp_reg *reg_buf;
u32 val;
if (!(vdev->module_ens & (ISPP_MODULE_NR | ISPP_MODULE_SHP)))
@@ -2353,6 +2410,44 @@ static void nr_work_event(struct rkispp_device *dev,
if (!completion_done(&monitor->nr.cmpl))
complete(&monitor->nr.cmpl);
}
rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, seq);
if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_NR)) {
u32 offset, size;
offset = reg_buf->reg_size;
size = 4 + RKISPP_NR_BUFFER_READY - RKISPP_NR_CTRL;
reg_buf->ispp_size[ISPP_ID_NR] = size;
reg_buf->ispp_offset[ISPP_ID_NR] = offset;
memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_NR_CTRL, size);
offset += size;
reg_buf->reg_size = offset;
}
if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_SHP)) {
u32 offset, size;
offset = reg_buf->reg_size;
size = 4 + RKISPP_SHARP_GRAD_RATIO - RKISPP_SHARP_CTRL;
reg_buf->ispp_size[ISPP_ID_SHP] = size;
reg_buf->ispp_offset[ISPP_ID_SHP] = offset;
memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_SHARP_CTRL, size);
offset += size;
reg_buf->reg_size = offset;
}
if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_ORB)) {
u32 offset, size;
offset = reg_buf->reg_size;
size = 4 + RKISPP_ORB_MAX_FEATURE - RKISPP_ORB_WR_BASE;
reg_buf->ispp_size[ISPP_ID_ORB] = size;
reg_buf->ispp_offset[ISPP_ID_ORB] = offset;
memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_ORB_WR_BASE, size);
offset += size;
reg_buf->reg_size = offset;
}
if (!is_quick)
writel(NR_SHP_ST, base + RKISPP_CTRL_STRT);
vdev->nr.is_end = false;
@@ -2387,6 +2482,7 @@ static void tnr_work_event(struct rkispp_device *dev,
u32 val, size = sizeof(vdev->tnr.buf) / sizeof(*dummy);
bool is_3to1 = vdev->tnr.is_3to1, is_start = false, is_skip = false;
bool is_en = rkispp_read(dev, RKISPP_TNR_CORE_CTRL) & SW_TNR_EN;
struct rkisp_ispp_reg *reg_buf;
if (!(vdev->module_ens & ISPP_MODULE_TNR) ||
(dev->inp == INP_ISP && dev->isp_mode & ISP_ISPP_QUICK))
@@ -2574,6 +2670,19 @@ static void tnr_work_event(struct rkispp_device *dev,
if (!completion_done(&monitor->tnr.cmpl))
complete(&monitor->tnr.cmpl);
}
rkispp_find_regbuf_by_id(dev, &reg_buf, dev->dev_id, seq);
if (reg_buf && (rkispp_debug_reg & ISPP_MODULE_TNR)) {
u32 offset, size;
offset = reg_buf->reg_size;
size = 4 + RKISPP_TNR_STATE - RKISPP_TNR_CTRL;
reg_buf->ispp_size[ISPP_ID_TNR] = size;
reg_buf->ispp_offset[ISPP_ID_TNR] = offset;
memcpy_fromio(&reg_buf->reg[offset], base + RKISPP_TNR_CTRL, size);
offset += size;
reg_buf->reg_size = offset;
}
writel(TNR_ST, base + RKISPP_CTRL_STRT);
vdev->tnr.is_end = false;
}

3
drivers/media/platform/rockchip/ispp/stream.h
View File

@@ -94,6 +94,7 @@ struct tnr_module {
struct rkisp_ispp_buf *cur_rd;
struct rkisp_ispp_buf *nxt_rd;
struct rkisp_ispp_buf *cur_wr;
struct rkisp_ispp_reg *reg_buf;
struct frame_debug_info dbg;
u32 uv_offset;
bool is_end;
@@ -107,6 +108,7 @@ struct nr_module {
spinlock_t buf_lock;
struct rkisp_ispp_buf *cur_rd;
struct rkispp_dummy_buffer *cur_wr;
struct rkisp_ispp_reg *reg_buf;
struct frame_debug_info dbg;
u32 uv_offset;
bool is_end;
@@ -115,6 +117,7 @@ struct nr_module {
struct fec_module {
struct list_head list_rd;
struct rkispp_dummy_buffer *cur_rd;
struct rkisp_ispp_reg *reg_buf;
struct frame_debug_info dbg;
spinlock_t buf_lock;
u32 uv_offset;

124
include/uapi/linux/rkisp2-config.h
View File

@@ -30,41 +30,78 @@
#define RKISP_CMD_SET_LDCHBUF_SIZE \
_IOW('V', BASE_VIDIOC_PRIVATE + 5, struct rkisp_ldchbuf_size)
#define ISP2X_MODULE_DPCC BIT_ULL(0)
#define ISP2X_MODULE_BLS BIT_ULL(1)
#define ISP2X_MODULE_SDG BIT_ULL(2)
#define ISP2X_MODULE_SIHST BIT_ULL(3)
#define ISP2X_MODULE_LSC BIT_ULL(4)
#define ISP2X_MODULE_AWB_GAIN BIT_ULL(5)
#define ISP2X_MODULE_BDM BIT_ULL(7)
#define ISP2X_MODULE_CCM BIT_ULL(8)
#define ISP2X_MODULE_GOC BIT_ULL(9)
#define ISP2X_MODULE_CPROC BIT_ULL(10)
#define ISP2X_MODULE_SIAF BIT_ULL(11)
#define ISP2X_MODULE_SIAWB BIT_ULL(12)
#define ISP2X_MODULE_IE BIT_ULL(13)
#define ISP2X_MODULE_YUVAE BIT_ULL(14)
#define ISP2X_MODULE_WDR BIT_ULL(15)
#define ISP2X_MODULE_RK_IESHARP BIT_ULL(16)
#define ISP2X_MODULE_RAWAF BIT_ULL(17)
#define ISP2X_MODULE_RAWAE0 BIT_ULL(18)
#define ISP2X_MODULE_RAWAE1 BIT_ULL(19)
#define ISP2X_MODULE_RAWAE2 BIT_ULL(20)
#define ISP2X_MODULE_RAWAE3 BIT_ULL(21)
#define ISP2X_MODULE_RAWAWB BIT_ULL(22)
#define ISP2X_MODULE_RAWHIST0 BIT_ULL(23)
#define ISP2X_MODULE_RAWHIST1 BIT_ULL(24)
#define ISP2X_MODULE_RAWHIST2 BIT_ULL(25)
#define ISP2X_MODULE_RAWHIST3 BIT_ULL(26)
#define ISP2X_MODULE_HDRMGE BIT_ULL(27)
#define ISP2X_MODULE_RAWNR BIT_ULL(28)
#define ISP2X_MODULE_HDRTMO BIT_ULL(29)
#define ISP2X_MODULE_GIC BIT_ULL(30)
#define ISP2X_MODULE_DHAZ BIT_ULL(31)
#define ISP2X_MODULE_3DLUT BIT_ULL(32)
#define ISP2X_MODULE_LDCH BIT_ULL(33)
#define ISP2X_MODULE_GAIN BIT_ULL(34)
#define ISP2X_MODULE_DEBAYER BIT_ULL(35)
#define ISP2X_ID_DPCC (0)
#define ISP2X_ID_BLS (1)
#define ISP2X_ID_SDG (2)
#define ISP2X_ID_SIHST (3)
#define ISP2X_ID_LSC (4)
#define ISP2X_ID_AWB_GAIN (5)
#define ISP2X_ID_BDM (7)
#define ISP2X_ID_CCM (8)
#define ISP2X_ID_GOC (9)
#define ISP2X_ID_CPROC (10)
#define ISP2X_ID_SIAF (11)
#define ISP2X_ID_SIAWB (12)
#define ISP2X_ID_IE (13)
#define ISP2X_ID_YUVAE (14)
#define ISP2X_ID_WDR (15)
#define ISP2X_ID_RK_IESHARP (16)
#define ISP2X_ID_RAWAF (17)
#define ISP2X_ID_RAWAE0 (18)
#define ISP2X_ID_RAWAE1 (19)
#define ISP2X_ID_RAWAE2 (20)
#define ISP2X_ID_RAWAE3 (21)
#define ISP2X_ID_RAWAWB (22)
#define ISP2X_ID_RAWHIST0 (23)
#define ISP2X_ID_RAWHIST1 (24)
#define ISP2X_ID_RAWHIST2 (25)
#define ISP2X_ID_RAWHIST3 (26)
#define ISP2X_ID_HDRMGE (27)
#define ISP2X_ID_RAWNR (28)
#define ISP2X_ID_HDRTMO (29)
#define ISP2X_ID_GIC (30)
#define ISP2X_ID_DHAZ (31)
#define ISP2X_ID_3DLUT (32)
#define ISP2X_ID_LDCH (33)
#define ISP2X_ID_GAIN (34)
#define ISP2X_ID_DEBAYER (35)
#define ISP2X_ID_MAX (36)
#define ISP2X_MODULE_DPCC BIT_ULL(ISP2X_ID_DPCC)
#define ISP2X_MODULE_BLS BIT_ULL(ISP2X_ID_BLS)
#define ISP2X_MODULE_SDG BIT_ULL(ISP2X_ID_SDG)
#define ISP2X_MODULE_SIHST BIT_ULL(ISP2X_ID_SIHST)
#define ISP2X_MODULE_LSC BIT_ULL(ISP2X_ID_LSC)
#define ISP2X_MODULE_AWB_GAIN BIT_ULL(ISP2X_ID_AWB_GAIN)
#define ISP2X_MODULE_BDM BIT_ULL(ISP2X_ID_BDM)
#define ISP2X_MODULE_CCM BIT_ULL(ISP2X_ID_CCM)
#define ISP2X_MODULE_GOC BIT_ULL(ISP2X_ID_GOC)
#define ISP2X_MODULE_CPROC BIT_ULL(ISP2X_ID_CPROC)
#define ISP2X_MODULE_SIAF BIT_ULL(ISP2X_ID_SIAF)
#define ISP2X_MODULE_SIAWB BIT_ULL(ISP2X_ID_SIAWB)
#define ISP2X_MODULE_IE BIT_ULL(ISP2X_ID_IE)
#define ISP2X_MODULE_YUVAE BIT_ULL(ISP2X_ID_YUVAE)
#define ISP2X_MODULE_WDR BIT_ULL(ISP2X_ID_WDR)
#define ISP2X_MODULE_RK_IESHARP BIT_ULL(ISP2X_ID_RK_IESHARP)
#define ISP2X_MODULE_RAWAF BIT_ULL(ISP2X_ID_RAWAF)
#define ISP2X_MODULE_RAWAE0 BIT_ULL(ISP2X_ID_RAWAE0)
#define ISP2X_MODULE_RAWAE1 BIT_ULL(ISP2X_ID_RAWAE1)
#define ISP2X_MODULE_RAWAE2 BIT_ULL(ISP2X_ID_RAWAE2)
#define ISP2X_MODULE_RAWAE3 BIT_ULL(ISP2X_ID_RAWAE3)
#define ISP2X_MODULE_RAWAWB BIT_ULL(ISP2X_ID_RAWAWB)
#define ISP2X_MODULE_RAWHIST0 BIT_ULL(ISP2X_ID_RAWHIST0)
#define ISP2X_MODULE_RAWHIST1 BIT_ULL(ISP2X_ID_RAWHIST1)
#define ISP2X_MODULE_RAWHIST2 BIT_ULL(ISP2X_ID_RAWHIST2)
#define ISP2X_MODULE_RAWHIST3 BIT_ULL(ISP2X_ID_RAWHIST3)
#define ISP2X_MODULE_HDRMGE BIT_ULL(ISP2X_ID_HDRMGE)
#define ISP2X_MODULE_RAWNR BIT_ULL(ISP2X_ID_RAWNR)
#define ISP2X_MODULE_HDRTMO BIT_ULL(ISP2X_ID_HDRTMO)
#define ISP2X_MODULE_GIC BIT_ULL(ISP2X_ID_GIC)
#define ISP2X_MODULE_DHAZ BIT_ULL(ISP2X_ID_DHAZ)
#define ISP2X_MODULE_3DLUT BIT_ULL(ISP2X_ID_3DLUT)
#define ISP2X_MODULE_LDCH BIT_ULL(ISP2X_ID_LDCH)
#define ISP2X_MODULE_GAIN BIT_ULL(ISP2X_ID_GAIN)
#define ISP2X_MODULE_DEBAYER BIT_ULL(ISP2X_ID_DEBAYER)
/*
* Measurement types
@@ -179,6 +216,7 @@ enum isp2x_trigger_mode {
struct isp2x_csi_trigger {
/* timestamp in ns */
u64 sof_timestamp;
u64 frame_timestamp;
u32 frame_id;
int times;
@@ -1439,6 +1477,19 @@ struct isp2x_isp_meas_cfg {
struct isp2x_sihst_cfg sihst;
} __attribute__ ((packed));
struct sensor_exposure_s {
u32 fine_integration_time;
u32 coarse_integration_time;
u32 analog_gain_code_global;
u32 digital_gain_global;
u32 isp_digital_gain;
} __attribute__ ((packed));
struct sensor_exposure_cfg {
struct sensor_exposure_s linear_exp;
struct sensor_exposure_s hdr_exp[3];
} __attribute__ ((packed));
struct isp2x_isp_params_cfg {
u64 module_en_update;
u64 module_ens;
@@ -1446,7 +1497,8 @@ struct isp2x_isp_params_cfg {
u32 frame_id;
struct isp2x_isp_meas_cfg meas;
struct isp2x_isp_other_cfg others; // must be last item
struct isp2x_isp_other_cfg others;
struct sensor_exposure_cfg exposure;
} __attribute__ ((packed));
struct isp2x_siawb_meas {

18
include/uapi/linux/rkispp-config.h
View File

@@ -11,11 +11,19 @@
#define ISPP_API_VERSION KERNEL_VERSION(1, 2, 1)
#define ISPP_MODULE_TNR BIT(0)//2TO1
#define ISPP_MODULE_NR BIT(1)
#define ISPP_MODULE_SHP BIT(2)
#define ISPP_MODULE_FEC BIT(3)//CALIBRATION
#define ISPP_MODULE_ORB BIT(4)
#define ISPP_ID_TNR (0)
#define ISPP_ID_NR (1)
#define ISPP_ID_SHP (2)
#define ISPP_ID_FEC (3)
#define ISPP_ID_ORB (4)
#define ISPP_ID_MAX (5)
#define ISPP_MODULE_TNR BIT(ISPP_ID_TNR)//2TO1
#define ISPP_MODULE_NR BIT(ISPP_ID_NR)
#define ISPP_MODULE_SHP BIT(ISPP_ID_SHP)
#define ISPP_MODULE_FEC BIT(ISPP_ID_FEC)//CALIBRATION
#define ISPP_MODULE_ORB BIT(ISPP_ID_ORB)
//extra function
#define ISPP_MODULE_TNR_3TO1 (BIT(16) | ISPP_MODULE_TNR)
#define ISPP_MODULE_FEC_ST (BIT(17) | ISPP_MODULE_FEC)//STABILIZATION