1 // SPDX-License-Identifier: (GPL-2.0+ OR MIT) 2 /* 3 * Rockchip ISP1 Driver - ISP Subdevice 4 * 5 * Copyright (C) 2019 Collabora, Ltd. 6 * 7 * Based on Rockchip ISP1 driver by Rockchip Electronics Co., Ltd. 8 * Copyright (C) 2017 Rockchip Electronics Co., Ltd. 9 */ 10 11 #include <linux/iopoll.h> 12 #include <linux/pm_runtime.h> 13 #include <linux/videodev2.h> 14 #include <linux/vmalloc.h> 15 16 #include <media/v4l2-event.h> 17 18 #include "rkisp1-common.h" 19 20 #define RKISP1_DEF_SINK_PAD_FMT MEDIA_BUS_FMT_SRGGB10_1X10 21 #define RKISP1_DEF_SRC_PAD_FMT MEDIA_BUS_FMT_YUYV8_2X8 22 23 #define RKISP1_ISP_DEV_NAME RKISP1_DRIVER_NAME "_isp" 24 25 /* 26 * NOTE: MIPI controller and input MUX are also configured in this file. 27 * This is because ISP Subdev describes not only ISP submodule (input size, 28 * format, output size, format), but also a virtual route device. 29 */ 30 31 /* 32 * There are many variables named with format/frame in below code, 33 * please see here for their meaning. 34 * Cropping in the sink pad defines the image region from the sensor. 35 * Cropping in the source pad defines the region for the Image Stabilizer (IS) 36 * 37 * Cropping regions of ISP 38 * 39 * +---------------------------------------------------------+ 40 * | Sensor image | 41 * | +---------------------------------------------------+ | 42 * | | CIF_ISP_ACQ (for black level) | | 43 * | | sink pad format | | 44 * | | +--------------------------------------------+ | | 45 * | | | CIF_ISP_OUT | | | 46 * | | | sink pad crop | | | 47 * | | | +---------------------------------+ | | | 48 * | | | | CIF_ISP_IS | | | | 49 * | | | | source pad crop and format | | | | 50 * | | | +---------------------------------+ | | | 51 * | | +--------------------------------------------+ | | 52 * | +---------------------------------------------------+ | 53 * +---------------------------------------------------------+ 54 */ 55 56 /* ---------------------------------------------------------------------------- 57 * Helpers 58 */ 59 60 static struct v4l2_mbus_framefmt * 61 rkisp1_isp_get_pad_fmt(struct rkisp1_isp *isp, 62 struct v4l2_subdev_state *sd_state, 63 unsigned int pad, u32 which) 64 { 65 struct v4l2_subdev_state state = { 66 .pads = isp->pad_cfg 67 }; 68 69 if (which == V4L2_SUBDEV_FORMAT_TRY) 70 return v4l2_subdev_get_try_format(&isp->sd, sd_state, pad); 71 else 72 return v4l2_subdev_get_try_format(&isp->sd, &state, pad); 73 } 74 75 static struct v4l2_rect * 76 rkisp1_isp_get_pad_crop(struct rkisp1_isp *isp, 77 struct v4l2_subdev_state *sd_state, 78 unsigned int pad, u32 which) 79 { 80 struct v4l2_subdev_state state = { 81 .pads = isp->pad_cfg 82 }; 83 84 if (which == V4L2_SUBDEV_FORMAT_TRY) 85 return v4l2_subdev_get_try_crop(&isp->sd, sd_state, pad); 86 else 87 return v4l2_subdev_get_try_crop(&isp->sd, &state, pad); 88 } 89 90 /* ---------------------------------------------------------------------------- 91 * Camera Interface registers configurations 92 */ 93 94 /* 95 * Image Stabilization. 96 * This should only be called when configuring CIF 97 * or at the frame end interrupt 98 */ 99 static void rkisp1_config_ism(struct rkisp1_isp *isp) 100 { 101 const struct v4l2_rect *src_crop = 102 rkisp1_isp_get_pad_crop(isp, NULL, 103 RKISP1_ISP_PAD_SOURCE_VIDEO, 104 V4L2_SUBDEV_FORMAT_ACTIVE); 105 struct rkisp1_device *rkisp1 = isp->rkisp1; 106 u32 val; 107 108 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_RECENTER, 0); 109 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_MAX_DX, 0); 110 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_MAX_DY, 0); 111 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_DISPLACE, 0); 112 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_H_OFFS, src_crop->left); 113 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_V_OFFS, src_crop->top); 114 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_H_SIZE, src_crop->width); 115 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_V_SIZE, src_crop->height); 116 117 /* IS(Image Stabilization) is always on, working as output crop */ 118 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IS_CTRL, 1); 119 val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL); 120 val |= RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD; 121 rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, val); 122 } 123 124 /* 125 * configure ISP blocks with input format, size...... 126 */ 127 static int rkisp1_config_isp(struct rkisp1_isp *isp, 128 enum v4l2_mbus_type mbus_type, u32 mbus_flags) 129 { 130 struct rkisp1_device *rkisp1 = isp->rkisp1; 131 u32 isp_ctrl = 0, irq_mask = 0, acq_mult = 0, acq_prop = 0; 132 const struct rkisp1_mbus_info *sink_fmt = isp->sink_fmt; 133 const struct rkisp1_mbus_info *src_fmt = isp->src_fmt; 134 const struct v4l2_mbus_framefmt *sink_frm; 135 const struct v4l2_rect *sink_crop; 136 137 sink_frm = rkisp1_isp_get_pad_fmt(isp, NULL, 138 RKISP1_ISP_PAD_SINK_VIDEO, 139 V4L2_SUBDEV_FORMAT_ACTIVE); 140 sink_crop = rkisp1_isp_get_pad_crop(isp, NULL, 141 RKISP1_ISP_PAD_SINK_VIDEO, 142 V4L2_SUBDEV_FORMAT_ACTIVE); 143 144 if (sink_fmt->pixel_enc == V4L2_PIXEL_ENC_BAYER) { 145 acq_mult = 1; 146 if (src_fmt->pixel_enc == V4L2_PIXEL_ENC_BAYER) { 147 if (mbus_type == V4L2_MBUS_BT656) 148 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_RAW_PICT_ITU656; 149 else 150 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_RAW_PICT; 151 } else { 152 rkisp1_write(rkisp1, RKISP1_CIF_ISP_DEMOSAIC, 153 RKISP1_CIF_ISP_DEMOSAIC_TH(0xc)); 154 155 if (mbus_type == V4L2_MBUS_BT656) 156 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_BAYER_ITU656; 157 else 158 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_BAYER_ITU601; 159 } 160 } else if (sink_fmt->pixel_enc == V4L2_PIXEL_ENC_YUV) { 161 acq_mult = 2; 162 if (mbus_type == V4L2_MBUS_CSI2_DPHY) { 163 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_ITU601; 164 } else { 165 if (mbus_type == V4L2_MBUS_BT656) 166 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_ITU656; 167 else 168 isp_ctrl = RKISP1_CIF_ISP_CTRL_ISP_MODE_ITU601; 169 } 170 171 irq_mask |= RKISP1_CIF_ISP_DATA_LOSS; 172 } 173 174 /* Set up input acquisition properties */ 175 if (mbus_type == V4L2_MBUS_BT656 || mbus_type == V4L2_MBUS_PARALLEL) { 176 if (mbus_flags & V4L2_MBUS_PCLK_SAMPLE_RISING) 177 acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_POS_EDGE; 178 179 switch (sink_fmt->bus_width) { 180 case 8: 181 acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_IN_SEL_8B_ZERO; 182 break; 183 case 10: 184 acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_IN_SEL_10B_ZERO; 185 break; 186 case 12: 187 acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_IN_SEL_12B; 188 break; 189 default: 190 dev_err(rkisp1->dev, "Invalid bus width %u\n", 191 sink_fmt->bus_width); 192 return -EINVAL; 193 } 194 } 195 196 if (mbus_type == V4L2_MBUS_PARALLEL) { 197 if (mbus_flags & V4L2_MBUS_VSYNC_ACTIVE_LOW) 198 acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_VSYNC_LOW; 199 200 if (mbus_flags & V4L2_MBUS_HSYNC_ACTIVE_LOW) 201 acq_prop |= RKISP1_CIF_ISP_ACQ_PROP_HSYNC_LOW; 202 } 203 204 rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, isp_ctrl); 205 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_PROP, 206 acq_prop | sink_fmt->yuv_seq | 207 RKISP1_CIF_ISP_ACQ_PROP_BAYER_PAT(sink_fmt->bayer_pat) | 208 RKISP1_CIF_ISP_ACQ_PROP_FIELD_SEL_ALL); 209 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_NR_FRAMES, 0); 210 211 /* Acquisition Size */ 212 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_H_OFFS, 0); 213 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_V_OFFS, 0); 214 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_H_SIZE, 215 acq_mult * sink_frm->width); 216 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ACQ_V_SIZE, sink_frm->height); 217 218 /* ISP Out Area */ 219 rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_H_OFFS, sink_crop->left); 220 rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_V_OFFS, sink_crop->top); 221 rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_H_SIZE, sink_crop->width); 222 rkisp1_write(rkisp1, RKISP1_CIF_ISP_OUT_V_SIZE, sink_crop->height); 223 224 irq_mask |= RKISP1_CIF_ISP_FRAME | RKISP1_CIF_ISP_V_START | 225 RKISP1_CIF_ISP_PIC_SIZE_ERROR; 226 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IMSC, irq_mask); 227 228 if (src_fmt->pixel_enc == V4L2_PIXEL_ENC_BAYER) { 229 rkisp1_params_disable(&rkisp1->params); 230 } else { 231 struct v4l2_mbus_framefmt *src_frm; 232 233 src_frm = rkisp1_isp_get_pad_fmt(isp, NULL, 234 RKISP1_ISP_PAD_SOURCE_VIDEO, 235 V4L2_SUBDEV_FORMAT_ACTIVE); 236 rkisp1_params_pre_configure(&rkisp1->params, sink_fmt->bayer_pat, 237 src_frm->quantization, 238 src_frm->ycbcr_enc); 239 } 240 241 return 0; 242 } 243 244 /* Configure MUX */ 245 static void rkisp1_config_path(struct rkisp1_isp *isp, 246 enum v4l2_mbus_type mbus_type) 247 { 248 struct rkisp1_device *rkisp1 = isp->rkisp1; 249 u32 dpcl = rkisp1_read(rkisp1, RKISP1_CIF_VI_DPCL); 250 251 if (mbus_type == V4L2_MBUS_BT656 || mbus_type == V4L2_MBUS_PARALLEL) 252 dpcl |= RKISP1_CIF_VI_DPCL_IF_SEL_PARALLEL; 253 else if (mbus_type == V4L2_MBUS_CSI2_DPHY) 254 dpcl |= RKISP1_CIF_VI_DPCL_IF_SEL_MIPI; 255 256 rkisp1_write(rkisp1, RKISP1_CIF_VI_DPCL, dpcl); 257 } 258 259 /* Hardware configure Entry */ 260 static int rkisp1_config_cif(struct rkisp1_isp *isp, 261 enum v4l2_mbus_type mbus_type, u32 mbus_flags) 262 { 263 int ret; 264 265 ret = rkisp1_config_isp(isp, mbus_type, mbus_flags); 266 if (ret) 267 return ret; 268 269 rkisp1_config_path(isp, mbus_type); 270 rkisp1_config_ism(isp); 271 272 return 0; 273 } 274 275 static void rkisp1_isp_stop(struct rkisp1_isp *isp) 276 { 277 struct rkisp1_device *rkisp1 = isp->rkisp1; 278 u32 val; 279 280 /* 281 * ISP(mi) stop in mi frame end -> Stop ISP(mipi) -> 282 * Stop ISP(isp) ->wait for ISP isp off 283 */ 284 /* stop and clear MI and ISP interrupts */ 285 rkisp1_write(rkisp1, RKISP1_CIF_ISP_IMSC, 0); 286 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ICR, ~0); 287 288 rkisp1_write(rkisp1, RKISP1_CIF_MI_IMSC, 0); 289 rkisp1_write(rkisp1, RKISP1_CIF_MI_ICR, ~0); 290 291 /* stop ISP */ 292 val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL); 293 val &= ~(RKISP1_CIF_ISP_CTRL_ISP_INFORM_ENABLE | 294 RKISP1_CIF_ISP_CTRL_ISP_ENABLE); 295 rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, val); 296 297 val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL); 298 rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, 299 val | RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD); 300 301 readx_poll_timeout(readl, rkisp1->base_addr + RKISP1_CIF_ISP_RIS, 302 val, val & RKISP1_CIF_ISP_OFF, 20, 100); 303 rkisp1_write(rkisp1, RKISP1_CIF_VI_IRCL, 304 RKISP1_CIF_VI_IRCL_MIPI_SW_RST | 305 RKISP1_CIF_VI_IRCL_ISP_SW_RST); 306 rkisp1_write(rkisp1, RKISP1_CIF_VI_IRCL, 0x0); 307 } 308 309 static void rkisp1_config_clk(struct rkisp1_isp *isp) 310 { 311 struct rkisp1_device *rkisp1 = isp->rkisp1; 312 313 u32 val = RKISP1_CIF_VI_ICCL_ISP_CLK | RKISP1_CIF_VI_ICCL_CP_CLK | 314 RKISP1_CIF_VI_ICCL_MRSZ_CLK | RKISP1_CIF_VI_ICCL_SRSZ_CLK | 315 RKISP1_CIF_VI_ICCL_JPEG_CLK | RKISP1_CIF_VI_ICCL_MI_CLK | 316 RKISP1_CIF_VI_ICCL_IE_CLK | RKISP1_CIF_VI_ICCL_MIPI_CLK | 317 RKISP1_CIF_VI_ICCL_DCROP_CLK; 318 319 rkisp1_write(rkisp1, RKISP1_CIF_VI_ICCL, val); 320 321 /* ensure sp and mp can run at the same time in V12 */ 322 if (rkisp1->info->isp_ver == RKISP1_V12) { 323 val = RKISP1_CIF_CLK_CTRL_MI_Y12 | RKISP1_CIF_CLK_CTRL_MI_SP | 324 RKISP1_CIF_CLK_CTRL_MI_RAW0 | RKISP1_CIF_CLK_CTRL_MI_RAW1 | 325 RKISP1_CIF_CLK_CTRL_MI_READ | RKISP1_CIF_CLK_CTRL_MI_RAWRD | 326 RKISP1_CIF_CLK_CTRL_CP | RKISP1_CIF_CLK_CTRL_IE; 327 rkisp1_write(rkisp1, RKISP1_CIF_VI_ISP_CLK_CTRL_V12, val); 328 } 329 } 330 331 static void rkisp1_isp_start(struct rkisp1_isp *isp) 332 { 333 struct rkisp1_device *rkisp1 = isp->rkisp1; 334 u32 val; 335 336 rkisp1_config_clk(isp); 337 338 /* Activate ISP */ 339 val = rkisp1_read(rkisp1, RKISP1_CIF_ISP_CTRL); 340 val |= RKISP1_CIF_ISP_CTRL_ISP_CFG_UPD | 341 RKISP1_CIF_ISP_CTRL_ISP_ENABLE | 342 RKISP1_CIF_ISP_CTRL_ISP_INFORM_ENABLE; 343 rkisp1_write(rkisp1, RKISP1_CIF_ISP_CTRL, val); 344 345 if (isp->src_fmt->pixel_enc != V4L2_PIXEL_ENC_BAYER) 346 rkisp1_params_post_configure(&rkisp1->params); 347 } 348 349 /* ---------------------------------------------------------------------------- 350 * Subdev pad operations 351 */ 352 353 static inline struct rkisp1_isp *to_rkisp1_isp(struct v4l2_subdev *sd) 354 { 355 return container_of(sd, struct rkisp1_isp, sd); 356 } 357 358 static int rkisp1_isp_enum_mbus_code(struct v4l2_subdev *sd, 359 struct v4l2_subdev_state *sd_state, 360 struct v4l2_subdev_mbus_code_enum *code) 361 { 362 unsigned int i, dir; 363 int pos = 0; 364 365 if (code->pad == RKISP1_ISP_PAD_SINK_VIDEO) { 366 dir = RKISP1_ISP_SD_SINK; 367 } else if (code->pad == RKISP1_ISP_PAD_SOURCE_VIDEO) { 368 dir = RKISP1_ISP_SD_SRC; 369 } else { 370 if (code->index > 0) 371 return -EINVAL; 372 code->code = MEDIA_BUS_FMT_METADATA_FIXED; 373 return 0; 374 } 375 376 for (i = 0; ; i++) { 377 const struct rkisp1_mbus_info *fmt = 378 rkisp1_mbus_info_get_by_index(i); 379 380 if (!fmt) 381 return -EINVAL; 382 383 if (fmt->direction & dir) 384 pos++; 385 386 if (code->index == pos - 1) { 387 code->code = fmt->mbus_code; 388 if (fmt->pixel_enc == V4L2_PIXEL_ENC_YUV && 389 dir == RKISP1_ISP_SD_SRC) 390 code->flags = 391 V4L2_SUBDEV_MBUS_CODE_CSC_QUANTIZATION; 392 return 0; 393 } 394 } 395 396 return -EINVAL; 397 } 398 399 static int rkisp1_isp_enum_frame_size(struct v4l2_subdev *sd, 400 struct v4l2_subdev_state *sd_state, 401 struct v4l2_subdev_frame_size_enum *fse) 402 { 403 const struct rkisp1_mbus_info *mbus_info; 404 405 if (fse->pad == RKISP1_ISP_PAD_SINK_PARAMS || 406 fse->pad == RKISP1_ISP_PAD_SOURCE_STATS) 407 return -ENOTTY; 408 409 if (fse->index > 0) 410 return -EINVAL; 411 412 mbus_info = rkisp1_mbus_info_get_by_code(fse->code); 413 if (!mbus_info) 414 return -EINVAL; 415 416 if (!(mbus_info->direction & RKISP1_ISP_SD_SINK) && 417 fse->pad == RKISP1_ISP_PAD_SINK_VIDEO) 418 return -EINVAL; 419 420 if (!(mbus_info->direction & RKISP1_ISP_SD_SRC) && 421 fse->pad == RKISP1_ISP_PAD_SOURCE_VIDEO) 422 return -EINVAL; 423 424 fse->min_width = RKISP1_ISP_MIN_WIDTH; 425 fse->max_width = RKISP1_ISP_MAX_WIDTH; 426 fse->min_height = RKISP1_ISP_MIN_HEIGHT; 427 fse->max_height = RKISP1_ISP_MAX_HEIGHT; 428 429 return 0; 430 } 431 432 static int rkisp1_isp_init_config(struct v4l2_subdev *sd, 433 struct v4l2_subdev_state *sd_state) 434 { 435 struct v4l2_mbus_framefmt *sink_fmt, *src_fmt; 436 struct v4l2_rect *sink_crop, *src_crop; 437 438 /* Video. */ 439 sink_fmt = v4l2_subdev_get_try_format(sd, sd_state, 440 RKISP1_ISP_PAD_SINK_VIDEO); 441 sink_fmt->width = RKISP1_DEFAULT_WIDTH; 442 sink_fmt->height = RKISP1_DEFAULT_HEIGHT; 443 sink_fmt->field = V4L2_FIELD_NONE; 444 sink_fmt->code = RKISP1_DEF_SINK_PAD_FMT; 445 sink_fmt->colorspace = V4L2_COLORSPACE_RAW; 446 sink_fmt->xfer_func = V4L2_XFER_FUNC_NONE; 447 sink_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601; 448 sink_fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE; 449 450 sink_crop = v4l2_subdev_get_try_crop(sd, sd_state, 451 RKISP1_ISP_PAD_SINK_VIDEO); 452 sink_crop->width = RKISP1_DEFAULT_WIDTH; 453 sink_crop->height = RKISP1_DEFAULT_HEIGHT; 454 sink_crop->left = 0; 455 sink_crop->top = 0; 456 457 src_fmt = v4l2_subdev_get_try_format(sd, sd_state, 458 RKISP1_ISP_PAD_SOURCE_VIDEO); 459 *src_fmt = *sink_fmt; 460 src_fmt->code = RKISP1_DEF_SRC_PAD_FMT; 461 src_fmt->colorspace = V4L2_COLORSPACE_SRGB; 462 src_fmt->xfer_func = V4L2_XFER_FUNC_SRGB; 463 src_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601; 464 src_fmt->quantization = V4L2_QUANTIZATION_LIM_RANGE; 465 466 src_crop = v4l2_subdev_get_try_crop(sd, sd_state, 467 RKISP1_ISP_PAD_SOURCE_VIDEO); 468 *src_crop = *sink_crop; 469 470 /* Parameters and statistics. */ 471 sink_fmt = v4l2_subdev_get_try_format(sd, sd_state, 472 RKISP1_ISP_PAD_SINK_PARAMS); 473 src_fmt = v4l2_subdev_get_try_format(sd, sd_state, 474 RKISP1_ISP_PAD_SOURCE_STATS); 475 sink_fmt->width = 0; 476 sink_fmt->height = 0; 477 sink_fmt->field = V4L2_FIELD_NONE; 478 sink_fmt->code = MEDIA_BUS_FMT_METADATA_FIXED; 479 *src_fmt = *sink_fmt; 480 481 return 0; 482 } 483 484 static void rkisp1_isp_set_src_fmt(struct rkisp1_isp *isp, 485 struct v4l2_subdev_state *sd_state, 486 struct v4l2_mbus_framefmt *format, 487 unsigned int which) 488 { 489 const struct rkisp1_mbus_info *sink_info; 490 const struct rkisp1_mbus_info *src_info; 491 struct v4l2_mbus_framefmt *sink_fmt; 492 struct v4l2_mbus_framefmt *src_fmt; 493 const struct v4l2_rect *src_crop; 494 bool set_csc; 495 496 sink_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, 497 RKISP1_ISP_PAD_SINK_VIDEO, which); 498 src_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, 499 RKISP1_ISP_PAD_SOURCE_VIDEO, which); 500 src_crop = rkisp1_isp_get_pad_crop(isp, sd_state, 501 RKISP1_ISP_PAD_SOURCE_VIDEO, which); 502 503 /* 504 * Media bus code. The ISP can operate in pass-through mode (Bayer in, 505 * Bayer out or YUV in, YUV out) or process Bayer data to YUV, but 506 * can't convert from YUV to Bayer. 507 */ 508 sink_info = rkisp1_mbus_info_get_by_code(sink_fmt->code); 509 510 src_fmt->code = format->code; 511 src_info = rkisp1_mbus_info_get_by_code(src_fmt->code); 512 if (!src_info || !(src_info->direction & RKISP1_ISP_SD_SRC)) { 513 src_fmt->code = RKISP1_DEF_SRC_PAD_FMT; 514 src_info = rkisp1_mbus_info_get_by_code(src_fmt->code); 515 } 516 517 if (sink_info->pixel_enc == V4L2_PIXEL_ENC_YUV && 518 src_info->pixel_enc == V4L2_PIXEL_ENC_BAYER) { 519 src_fmt->code = sink_fmt->code; 520 src_info = sink_info; 521 } 522 523 /* 524 * The source width and height must be identical to the source crop 525 * size. 526 */ 527 src_fmt->width = src_crop->width; 528 src_fmt->height = src_crop->height; 529 530 /* 531 * Copy the color space for the sink pad. When converting from Bayer to 532 * YUV, default to a limited quantization range. 533 */ 534 src_fmt->colorspace = sink_fmt->colorspace; 535 src_fmt->xfer_func = sink_fmt->xfer_func; 536 src_fmt->ycbcr_enc = sink_fmt->ycbcr_enc; 537 538 if (sink_info->pixel_enc == V4L2_PIXEL_ENC_BAYER && 539 src_info->pixel_enc == V4L2_PIXEL_ENC_YUV) 540 src_fmt->quantization = V4L2_QUANTIZATION_LIM_RANGE; 541 else 542 src_fmt->quantization = sink_fmt->quantization; 543 544 /* 545 * Allow setting the source color space fields when the SET_CSC flag is 546 * set and the source format is YUV. If the sink format is YUV, don't 547 * set the color primaries, transfer function or YCbCr encoding as the 548 * ISP is bypassed in that case and passes YUV data through without 549 * modifications. 550 * 551 * The color primaries and transfer function are configured through the 552 * cross-talk matrix and tone curve respectively. Settings for those 553 * hardware blocks are conveyed through the ISP parameters buffer, as 554 * they need to combine color space information with other image tuning 555 * characteristics and can't thus be computed by the kernel based on the 556 * color space. The source pad colorspace and xfer_func fields are thus 557 * ignored by the driver, but can be set by userspace to propagate 558 * accurate color space information down the pipeline. 559 */ 560 set_csc = format->flags & V4L2_MBUS_FRAMEFMT_SET_CSC; 561 562 if (set_csc && src_info->pixel_enc == V4L2_PIXEL_ENC_YUV) { 563 if (sink_info->pixel_enc == V4L2_PIXEL_ENC_BAYER) { 564 if (format->colorspace != V4L2_COLORSPACE_DEFAULT) 565 src_fmt->colorspace = format->colorspace; 566 if (format->xfer_func != V4L2_XFER_FUNC_DEFAULT) 567 src_fmt->xfer_func = format->xfer_func; 568 if (format->ycbcr_enc != V4L2_YCBCR_ENC_DEFAULT) 569 src_fmt->ycbcr_enc = format->ycbcr_enc; 570 } 571 572 if (format->quantization != V4L2_QUANTIZATION_DEFAULT) 573 src_fmt->quantization = format->quantization; 574 } 575 576 *format = *src_fmt; 577 578 /* 579 * Restore the SET_CSC flag if it was set to indicate support for the 580 * CSC setting API. 581 */ 582 if (set_csc) 583 format->flags |= V4L2_MBUS_FRAMEFMT_SET_CSC; 584 585 /* Store the source format info when setting the active format. */ 586 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) 587 isp->src_fmt = src_info; 588 } 589 590 static void rkisp1_isp_set_src_crop(struct rkisp1_isp *isp, 591 struct v4l2_subdev_state *sd_state, 592 struct v4l2_rect *r, unsigned int which) 593 { 594 struct v4l2_mbus_framefmt *src_fmt; 595 const struct v4l2_rect *sink_crop; 596 struct v4l2_rect *src_crop; 597 598 src_crop = rkisp1_isp_get_pad_crop(isp, sd_state, 599 RKISP1_ISP_PAD_SOURCE_VIDEO, 600 which); 601 sink_crop = rkisp1_isp_get_pad_crop(isp, sd_state, 602 RKISP1_ISP_PAD_SINK_VIDEO, 603 which); 604 605 src_crop->left = ALIGN(r->left, 2); 606 src_crop->width = ALIGN(r->width, 2); 607 src_crop->top = r->top; 608 src_crop->height = r->height; 609 rkisp1_sd_adjust_crop_rect(src_crop, sink_crop); 610 611 *r = *src_crop; 612 613 /* Propagate to out format */ 614 src_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, 615 RKISP1_ISP_PAD_SOURCE_VIDEO, which); 616 rkisp1_isp_set_src_fmt(isp, sd_state, src_fmt, which); 617 } 618 619 static void rkisp1_isp_set_sink_crop(struct rkisp1_isp *isp, 620 struct v4l2_subdev_state *sd_state, 621 struct v4l2_rect *r, unsigned int which) 622 { 623 struct v4l2_rect *sink_crop, *src_crop; 624 const struct v4l2_mbus_framefmt *sink_fmt; 625 626 sink_crop = rkisp1_isp_get_pad_crop(isp, sd_state, 627 RKISP1_ISP_PAD_SINK_VIDEO, 628 which); 629 sink_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, 630 RKISP1_ISP_PAD_SINK_VIDEO, 631 which); 632 633 sink_crop->left = ALIGN(r->left, 2); 634 sink_crop->width = ALIGN(r->width, 2); 635 sink_crop->top = r->top; 636 sink_crop->height = r->height; 637 rkisp1_sd_adjust_crop(sink_crop, sink_fmt); 638 639 *r = *sink_crop; 640 641 /* Propagate to out crop */ 642 src_crop = rkisp1_isp_get_pad_crop(isp, sd_state, 643 RKISP1_ISP_PAD_SOURCE_VIDEO, which); 644 rkisp1_isp_set_src_crop(isp, sd_state, src_crop, which); 645 } 646 647 static void rkisp1_isp_set_sink_fmt(struct rkisp1_isp *isp, 648 struct v4l2_subdev_state *sd_state, 649 struct v4l2_mbus_framefmt *format, 650 unsigned int which) 651 { 652 const struct rkisp1_mbus_info *mbus_info; 653 struct v4l2_mbus_framefmt *sink_fmt; 654 struct v4l2_rect *sink_crop; 655 bool is_yuv; 656 657 sink_fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, 658 RKISP1_ISP_PAD_SINK_VIDEO, 659 which); 660 sink_fmt->code = format->code; 661 mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code); 662 if (!mbus_info || !(mbus_info->direction & RKISP1_ISP_SD_SINK)) { 663 sink_fmt->code = RKISP1_DEF_SINK_PAD_FMT; 664 mbus_info = rkisp1_mbus_info_get_by_code(sink_fmt->code); 665 } 666 if (which == V4L2_SUBDEV_FORMAT_ACTIVE) 667 isp->sink_fmt = mbus_info; 668 669 sink_fmt->width = clamp_t(u32, format->width, 670 RKISP1_ISP_MIN_WIDTH, 671 RKISP1_ISP_MAX_WIDTH); 672 sink_fmt->height = clamp_t(u32, format->height, 673 RKISP1_ISP_MIN_HEIGHT, 674 RKISP1_ISP_MAX_HEIGHT); 675 676 /* 677 * Adjust the color space fields. Accept any color primaries and 678 * transfer function for both YUV and Bayer. For YUV any YCbCr encoding 679 * and quantization range is also accepted. For Bayer formats, the YCbCr 680 * encoding isn't applicable, and the quantization range can only be 681 * full. 682 */ 683 is_yuv = mbus_info->pixel_enc == V4L2_PIXEL_ENC_YUV; 684 685 sink_fmt->colorspace = format->colorspace ? : 686 (is_yuv ? V4L2_COLORSPACE_SRGB : 687 V4L2_COLORSPACE_RAW); 688 sink_fmt->xfer_func = format->xfer_func ? : 689 V4L2_MAP_XFER_FUNC_DEFAULT(sink_fmt->colorspace); 690 if (is_yuv) { 691 sink_fmt->ycbcr_enc = format->ycbcr_enc ? : 692 V4L2_MAP_YCBCR_ENC_DEFAULT(sink_fmt->colorspace); 693 sink_fmt->quantization = format->quantization ? : 694 V4L2_MAP_QUANTIZATION_DEFAULT(false, sink_fmt->colorspace, 695 sink_fmt->ycbcr_enc); 696 } else { 697 /* 698 * The YCbCr encoding isn't applicable for non-YUV formats, but 699 * V4L2 has no "no encoding" value. Hardcode it to Rec. 601, it 700 * should be ignored by userspace. 701 */ 702 sink_fmt->ycbcr_enc = V4L2_YCBCR_ENC_601; 703 sink_fmt->quantization = V4L2_QUANTIZATION_FULL_RANGE; 704 } 705 706 *format = *sink_fmt; 707 708 /* Propagate to in crop */ 709 sink_crop = rkisp1_isp_get_pad_crop(isp, sd_state, 710 RKISP1_ISP_PAD_SINK_VIDEO, 711 which); 712 rkisp1_isp_set_sink_crop(isp, sd_state, sink_crop, which); 713 } 714 715 static int rkisp1_isp_get_fmt(struct v4l2_subdev *sd, 716 struct v4l2_subdev_state *sd_state, 717 struct v4l2_subdev_format *fmt) 718 { 719 struct rkisp1_isp *isp = to_rkisp1_isp(sd); 720 721 mutex_lock(&isp->ops_lock); 722 fmt->format = *rkisp1_isp_get_pad_fmt(isp, sd_state, fmt->pad, 723 fmt->which); 724 mutex_unlock(&isp->ops_lock); 725 return 0; 726 } 727 728 static int rkisp1_isp_set_fmt(struct v4l2_subdev *sd, 729 struct v4l2_subdev_state *sd_state, 730 struct v4l2_subdev_format *fmt) 731 { 732 struct rkisp1_isp *isp = to_rkisp1_isp(sd); 733 734 mutex_lock(&isp->ops_lock); 735 if (fmt->pad == RKISP1_ISP_PAD_SINK_VIDEO) 736 rkisp1_isp_set_sink_fmt(isp, sd_state, &fmt->format, 737 fmt->which); 738 else if (fmt->pad == RKISP1_ISP_PAD_SOURCE_VIDEO) 739 rkisp1_isp_set_src_fmt(isp, sd_state, &fmt->format, 740 fmt->which); 741 else 742 fmt->format = *rkisp1_isp_get_pad_fmt(isp, sd_state, fmt->pad, 743 fmt->which); 744 745 mutex_unlock(&isp->ops_lock); 746 return 0; 747 } 748 749 static int rkisp1_isp_get_selection(struct v4l2_subdev *sd, 750 struct v4l2_subdev_state *sd_state, 751 struct v4l2_subdev_selection *sel) 752 { 753 struct rkisp1_isp *isp = to_rkisp1_isp(sd); 754 int ret = 0; 755 756 if (sel->pad != RKISP1_ISP_PAD_SOURCE_VIDEO && 757 sel->pad != RKISP1_ISP_PAD_SINK_VIDEO) 758 return -EINVAL; 759 760 mutex_lock(&isp->ops_lock); 761 switch (sel->target) { 762 case V4L2_SEL_TGT_CROP_BOUNDS: 763 if (sel->pad == RKISP1_ISP_PAD_SINK_VIDEO) { 764 struct v4l2_mbus_framefmt *fmt; 765 766 fmt = rkisp1_isp_get_pad_fmt(isp, sd_state, sel->pad, 767 sel->which); 768 sel->r.height = fmt->height; 769 sel->r.width = fmt->width; 770 sel->r.left = 0; 771 sel->r.top = 0; 772 } else { 773 sel->r = *rkisp1_isp_get_pad_crop(isp, sd_state, 774 RKISP1_ISP_PAD_SINK_VIDEO, 775 sel->which); 776 } 777 break; 778 case V4L2_SEL_TGT_CROP: 779 sel->r = *rkisp1_isp_get_pad_crop(isp, sd_state, sel->pad, 780 sel->which); 781 break; 782 default: 783 ret = -EINVAL; 784 } 785 mutex_unlock(&isp->ops_lock); 786 return ret; 787 } 788 789 static int rkisp1_isp_set_selection(struct v4l2_subdev *sd, 790 struct v4l2_subdev_state *sd_state, 791 struct v4l2_subdev_selection *sel) 792 { 793 struct rkisp1_isp *isp = to_rkisp1_isp(sd); 794 int ret = 0; 795 796 if (sel->target != V4L2_SEL_TGT_CROP) 797 return -EINVAL; 798 799 dev_dbg(isp->rkisp1->dev, "%s: pad: %d sel(%d,%d)/%dx%d\n", __func__, 800 sel->pad, sel->r.left, sel->r.top, sel->r.width, sel->r.height); 801 mutex_lock(&isp->ops_lock); 802 if (sel->pad == RKISP1_ISP_PAD_SINK_VIDEO) 803 rkisp1_isp_set_sink_crop(isp, sd_state, &sel->r, sel->which); 804 else if (sel->pad == RKISP1_ISP_PAD_SOURCE_VIDEO) 805 rkisp1_isp_set_src_crop(isp, sd_state, &sel->r, sel->which); 806 else 807 ret = -EINVAL; 808 809 mutex_unlock(&isp->ops_lock); 810 return ret; 811 } 812 813 static int rkisp1_subdev_link_validate(struct media_link *link) 814 { 815 if (link->sink->index == RKISP1_ISP_PAD_SINK_PARAMS) 816 return 0; 817 818 return v4l2_subdev_link_validate(link); 819 } 820 821 static const struct v4l2_subdev_pad_ops rkisp1_isp_pad_ops = { 822 .enum_mbus_code = rkisp1_isp_enum_mbus_code, 823 .enum_frame_size = rkisp1_isp_enum_frame_size, 824 .get_selection = rkisp1_isp_get_selection, 825 .set_selection = rkisp1_isp_set_selection, 826 .init_cfg = rkisp1_isp_init_config, 827 .get_fmt = rkisp1_isp_get_fmt, 828 .set_fmt = rkisp1_isp_set_fmt, 829 .link_validate = v4l2_subdev_link_validate_default, 830 }; 831 832 /* ---------------------------------------------------------------------------- 833 * Stream operations 834 */ 835 836 static int rkisp1_isp_s_stream(struct v4l2_subdev *sd, int enable) 837 { 838 struct rkisp1_isp *isp = to_rkisp1_isp(sd); 839 struct rkisp1_device *rkisp1 = isp->rkisp1; 840 struct media_pad *source_pad; 841 struct media_pad *sink_pad; 842 enum v4l2_mbus_type mbus_type; 843 u32 mbus_flags; 844 int ret; 845 846 if (!enable) { 847 v4l2_subdev_call(rkisp1->source, video, s_stream, false); 848 rkisp1_isp_stop(isp); 849 return 0; 850 } 851 852 sink_pad = &isp->pads[RKISP1_ISP_PAD_SINK_VIDEO]; 853 source_pad = media_pad_remote_pad_unique(sink_pad); 854 if (IS_ERR(source_pad)) { 855 dev_dbg(rkisp1->dev, "Failed to get source for ISP: %ld\n", 856 PTR_ERR(source_pad)); 857 return -EPIPE; 858 } 859 860 rkisp1->source = media_entity_to_v4l2_subdev(source_pad->entity); 861 if (!rkisp1->source) { 862 /* This should really not happen, so is not worth a message. */ 863 return -EPIPE; 864 } 865 866 if (rkisp1->source == &rkisp1->csi.sd) { 867 mbus_type = V4L2_MBUS_CSI2_DPHY; 868 mbus_flags = 0; 869 } else { 870 const struct rkisp1_sensor_async *asd; 871 struct v4l2_async_connection *asc; 872 873 asc = v4l2_async_connection_unique(rkisp1->source); 874 if (!asc) 875 return -EPIPE; 876 877 asd = container_of(asc, struct rkisp1_sensor_async, asd); 878 879 mbus_type = asd->mbus_type; 880 mbus_flags = asd->mbus_flags; 881 } 882 883 isp->frame_sequence = -1; 884 mutex_lock(&isp->ops_lock); 885 ret = rkisp1_config_cif(isp, mbus_type, mbus_flags); 886 if (ret) 887 goto mutex_unlock; 888 889 rkisp1_isp_start(isp); 890 891 ret = v4l2_subdev_call(rkisp1->source, video, s_stream, true); 892 if (ret) { 893 rkisp1_isp_stop(isp); 894 goto mutex_unlock; 895 } 896 897 mutex_unlock: 898 mutex_unlock(&isp->ops_lock); 899 return ret; 900 } 901 902 static int rkisp1_isp_subs_evt(struct v4l2_subdev *sd, struct v4l2_fh *fh, 903 struct v4l2_event_subscription *sub) 904 { 905 if (sub->type != V4L2_EVENT_FRAME_SYNC) 906 return -EINVAL; 907 908 /* V4L2_EVENT_FRAME_SYNC doesn't require an id, so zero should be set */ 909 if (sub->id != 0) 910 return -EINVAL; 911 912 return v4l2_event_subscribe(fh, sub, 0, NULL); 913 } 914 915 static const struct media_entity_operations rkisp1_isp_media_ops = { 916 .link_validate = rkisp1_subdev_link_validate, 917 }; 918 919 static const struct v4l2_subdev_video_ops rkisp1_isp_video_ops = { 920 .s_stream = rkisp1_isp_s_stream, 921 }; 922 923 static const struct v4l2_subdev_core_ops rkisp1_isp_core_ops = { 924 .subscribe_event = rkisp1_isp_subs_evt, 925 .unsubscribe_event = v4l2_event_subdev_unsubscribe, 926 }; 927 928 static const struct v4l2_subdev_ops rkisp1_isp_ops = { 929 .core = &rkisp1_isp_core_ops, 930 .video = &rkisp1_isp_video_ops, 931 .pad = &rkisp1_isp_pad_ops, 932 }; 933 934 int rkisp1_isp_register(struct rkisp1_device *rkisp1) 935 { 936 struct v4l2_subdev_state state = { 937 .pads = rkisp1->isp.pad_cfg 938 }; 939 struct rkisp1_isp *isp = &rkisp1->isp; 940 struct media_pad *pads = isp->pads; 941 struct v4l2_subdev *sd = &isp->sd; 942 int ret; 943 944 isp->rkisp1 = rkisp1; 945 946 v4l2_subdev_init(sd, &rkisp1_isp_ops); 947 sd->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE | V4L2_SUBDEV_FL_HAS_EVENTS; 948 sd->entity.ops = &rkisp1_isp_media_ops; 949 sd->entity.function = MEDIA_ENT_F_PROC_VIDEO_PIXEL_FORMATTER; 950 sd->owner = THIS_MODULE; 951 strscpy(sd->name, RKISP1_ISP_DEV_NAME, sizeof(sd->name)); 952 953 pads[RKISP1_ISP_PAD_SINK_VIDEO].flags = MEDIA_PAD_FL_SINK | 954 MEDIA_PAD_FL_MUST_CONNECT; 955 pads[RKISP1_ISP_PAD_SINK_PARAMS].flags = MEDIA_PAD_FL_SINK; 956 pads[RKISP1_ISP_PAD_SOURCE_VIDEO].flags = MEDIA_PAD_FL_SOURCE; 957 pads[RKISP1_ISP_PAD_SOURCE_STATS].flags = MEDIA_PAD_FL_SOURCE; 958 959 isp->sink_fmt = rkisp1_mbus_info_get_by_code(RKISP1_DEF_SINK_PAD_FMT); 960 isp->src_fmt = rkisp1_mbus_info_get_by_code(RKISP1_DEF_SRC_PAD_FMT); 961 962 mutex_init(&isp->ops_lock); 963 ret = media_entity_pads_init(&sd->entity, RKISP1_ISP_PAD_MAX, pads); 964 if (ret) 965 goto error; 966 967 ret = v4l2_device_register_subdev(&rkisp1->v4l2_dev, sd); 968 if (ret) { 969 dev_err(rkisp1->dev, "Failed to register isp subdev\n"); 970 goto error; 971 } 972 973 rkisp1_isp_init_config(sd, &state); 974 975 return 0; 976 977 error: 978 media_entity_cleanup(&sd->entity); 979 mutex_destroy(&isp->ops_lock); 980 isp->sd.v4l2_dev = NULL; 981 return ret; 982 } 983 984 void rkisp1_isp_unregister(struct rkisp1_device *rkisp1) 985 { 986 struct rkisp1_isp *isp = &rkisp1->isp; 987 988 if (!isp->sd.v4l2_dev) 989 return; 990 991 v4l2_device_unregister_subdev(&isp->sd); 992 media_entity_cleanup(&isp->sd.entity); 993 mutex_destroy(&isp->ops_lock); 994 } 995 996 /* ---------------------------------------------------------------------------- 997 * Interrupt handlers 998 */ 999 1000 static void rkisp1_isp_queue_event_sof(struct rkisp1_isp *isp) 1001 { 1002 struct v4l2_event event = { 1003 .type = V4L2_EVENT_FRAME_SYNC, 1004 }; 1005 1006 event.u.frame_sync.frame_sequence = isp->frame_sequence; 1007 v4l2_event_queue(isp->sd.devnode, &event); 1008 } 1009 1010 irqreturn_t rkisp1_isp_isr(int irq, void *ctx) 1011 { 1012 struct device *dev = ctx; 1013 struct rkisp1_device *rkisp1 = dev_get_drvdata(dev); 1014 u32 status, isp_err; 1015 1016 status = rkisp1_read(rkisp1, RKISP1_CIF_ISP_MIS); 1017 if (!status) 1018 return IRQ_NONE; 1019 1020 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ICR, status); 1021 1022 /* Vertical sync signal, starting generating new frame */ 1023 if (status & RKISP1_CIF_ISP_V_START) { 1024 rkisp1->isp.frame_sequence++; 1025 rkisp1_isp_queue_event_sof(&rkisp1->isp); 1026 if (status & RKISP1_CIF_ISP_FRAME) { 1027 WARN_ONCE(1, "irq delay is too long, buffers might not be in sync\n"); 1028 rkisp1->debug.irq_delay++; 1029 } 1030 } 1031 if (status & RKISP1_CIF_ISP_PIC_SIZE_ERROR) { 1032 /* Clear pic_size_error */ 1033 isp_err = rkisp1_read(rkisp1, RKISP1_CIF_ISP_ERR); 1034 if (isp_err & RKISP1_CIF_ISP_ERR_INFORM_SIZE) 1035 rkisp1->debug.inform_size_error++; 1036 if (isp_err & RKISP1_CIF_ISP_ERR_IS_SIZE) 1037 rkisp1->debug.img_stabilization_size_error++; 1038 if (isp_err & RKISP1_CIF_ISP_ERR_OUTFORM_SIZE) 1039 rkisp1->debug.outform_size_error++; 1040 rkisp1_write(rkisp1, RKISP1_CIF_ISP_ERR_CLR, isp_err); 1041 } else if (status & RKISP1_CIF_ISP_DATA_LOSS) { 1042 /* keep track of data_loss in debugfs */ 1043 rkisp1->debug.data_loss++; 1044 } 1045 1046 if (status & RKISP1_CIF_ISP_FRAME) { 1047 u32 isp_ris; 1048 1049 /* New frame from the sensor received */ 1050 isp_ris = rkisp1_read(rkisp1, RKISP1_CIF_ISP_RIS); 1051 if (isp_ris & RKISP1_STATS_MEAS_MASK) 1052 rkisp1_stats_isr(&rkisp1->stats, isp_ris); 1053 /* 1054 * Then update changed configs. Some of them involve 1055 * lot of register writes. Do those only one per frame. 1056 * Do the updates in the order of the processing flow. 1057 */ 1058 rkisp1_params_isr(rkisp1); 1059 } 1060 1061 return IRQ_HANDLED; 1062 } 1063