1 // SPDX-License-Identifier: GPL-2.0
3 * Support for Medifield PNW Camera Imaging ISP subsystem.
5 * Copyright (c) 2010 Intel Corporation. All Rights Reserved.
7 * Copyright (c) 2010 Silicon Hive www.siliconhive.com.
9 * This program is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU General Public License version
11 * 2 as published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
21 #include <linux/delay.h>
22 #include <linux/pci.h>
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-event.h>
26 #include <media/videobuf-vmalloc.h>
28 #include "atomisp_acc.h"
29 #include "atomisp_cmd.h"
30 #include "atomisp_common.h"
31 #include "atomisp_fops.h"
32 #include "atomisp_internal.h"
33 #include "atomisp_ioctl.h"
34 #include "atomisp-regs.h"
35 #include "atomisp_compat.h"
37 #include "sh_css_hrt.h"
39 #include "gp_device.h"
40 #include "device_access.h"
43 static const char *DRIVER = "atomisp"; /* max size 15 */
44 static const char *CARD = "ATOM ISP"; /* max size 31 */
47 * FIXME: ISP should not know beforehand all CIDs supported by sensor.
48 * Instead, it needs to propagate to sensor unkonwn CIDs.
50 static struct v4l2_queryctrl ci_v4l2_controls[] = {
52 .id = V4L2_CID_AUTO_WHITE_BALANCE,
53 .type = V4L2_CTRL_TYPE_BOOLEAN,
54 .name = "Automatic White Balance",
61 .id = V4L2_CID_RED_BALANCE,
62 .type = V4L2_CTRL_TYPE_INTEGER,
63 .name = "Red Balance",
67 .default_value = 0x00,
70 .id = V4L2_CID_BLUE_BALANCE,
71 .type = V4L2_CTRL_TYPE_INTEGER,
72 .name = "Blue Balance",
76 .default_value = 0x00,
80 .type = V4L2_CTRL_TYPE_INTEGER,
85 .default_value = 0x00,
88 .id = V4L2_CID_POWER_LINE_FREQUENCY,
89 .type = V4L2_CTRL_TYPE_MENU,
90 .name = "Light frequency filter",
97 .id = V4L2_CID_COLORFX,
98 .type = V4L2_CTRL_TYPE_INTEGER,
99 .name = "Image Color Effect",
106 .id = V4L2_CID_COLORFX_CBCR,
107 .type = V4L2_CTRL_TYPE_INTEGER,
108 .name = "Image Color Effect CbCr",
115 .id = V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION,
116 .type = V4L2_CTRL_TYPE_INTEGER,
117 .name = "Bad Pixel Correction",
124 .id = V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC,
125 .type = V4L2_CTRL_TYPE_INTEGER,
133 .id = V4L2_CID_ATOMISP_VIDEO_STABLIZATION,
134 .type = V4L2_CTRL_TYPE_INTEGER,
135 .name = "Video Stablization",
142 .id = V4L2_CID_ATOMISP_FIXED_PATTERN_NR,
143 .type = V4L2_CTRL_TYPE_INTEGER,
144 .name = "Fixed Pattern Noise Reduction",
151 .id = V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION,
152 .type = V4L2_CTRL_TYPE_INTEGER,
153 .name = "False Color Correction",
160 .id = V4L2_CID_REQUEST_FLASH,
161 .type = V4L2_CTRL_TYPE_INTEGER,
162 .name = "Request flash frames",
169 .id = V4L2_CID_ATOMISP_LOW_LIGHT,
170 .type = V4L2_CTRL_TYPE_BOOLEAN,
171 .name = "Low light mode",
178 .id = V4L2_CID_BIN_FACTOR_HORZ,
179 .type = V4L2_CTRL_TYPE_INTEGER,
180 .name = "Horizontal binning factor",
187 .id = V4L2_CID_BIN_FACTOR_VERT,
188 .type = V4L2_CTRL_TYPE_INTEGER,
189 .name = "Vertical binning factor",
196 .id = V4L2_CID_2A_STATUS,
197 .type = V4L2_CTRL_TYPE_BITMASK,
198 .name = "AE and AWB status",
200 .maximum = V4L2_2A_STATUS_AE_READY | V4L2_2A_STATUS_AWB_READY,
205 .id = V4L2_CID_EXPOSURE,
206 .type = V4L2_CTRL_TYPE_INTEGER,
214 .id = V4L2_CID_EXPOSURE_ZONE_NUM,
215 .type = V4L2_CTRL_TYPE_INTEGER,
216 .name = "one-time exposure zone number",
223 .id = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
224 .type = V4L2_CTRL_TYPE_INTEGER,
225 .name = "Exposure auto priority",
226 .minimum = V4L2_EXPOSURE_AUTO,
227 .maximum = V4L2_EXPOSURE_APERTURE_PRIORITY,
229 .default_value = V4L2_EXPOSURE_AUTO,
232 .id = V4L2_CID_SCENE_MODE,
233 .type = V4L2_CTRL_TYPE_INTEGER,
234 .name = "scene mode",
241 .id = V4L2_CID_ISO_SENSITIVITY,
242 .type = V4L2_CTRL_TYPE_INTEGER,
250 .id = V4L2_CID_ISO_SENSITIVITY_AUTO,
251 .type = V4L2_CTRL_TYPE_INTEGER,
253 .minimum = V4L2_ISO_SENSITIVITY_MANUAL,
254 .maximum = V4L2_ISO_SENSITIVITY_AUTO,
256 .default_value = V4L2_ISO_SENSITIVITY_AUTO,
259 .id = V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
260 .type = V4L2_CTRL_TYPE_INTEGER,
261 .name = "white balance",
268 .id = V4L2_CID_EXPOSURE_METERING,
269 .type = V4L2_CTRL_TYPE_MENU,
277 .id = V4L2_CID_3A_LOCK,
278 .type = V4L2_CTRL_TYPE_BITMASK,
281 .maximum = V4L2_LOCK_EXPOSURE | V4L2_LOCK_WHITE_BALANCE
287 .id = V4L2_CID_TEST_PATTERN,
288 .type = V4L2_CTRL_TYPE_INTEGER,
289 .name = "Test Pattern",
296 .id = V4L2_CID_TEST_PATTERN_COLOR_R,
297 .type = V4L2_CTRL_TYPE_INTEGER,
298 .name = "Test Pattern Solid Color R",
305 .id = V4L2_CID_TEST_PATTERN_COLOR_GR,
306 .type = V4L2_CTRL_TYPE_INTEGER,
307 .name = "Test Pattern Solid Color GR",
314 .id = V4L2_CID_TEST_PATTERN_COLOR_GB,
315 .type = V4L2_CTRL_TYPE_INTEGER,
316 .name = "Test Pattern Solid Color GB",
323 .id = V4L2_CID_TEST_PATTERN_COLOR_B,
324 .type = V4L2_CTRL_TYPE_INTEGER,
325 .name = "Test Pattern Solid Color B",
333 static const u32 ctrls_num = ARRAY_SIZE(ci_v4l2_controls);
336 * supported V4L2 fmts and resolutions
338 const struct atomisp_format_bridge atomisp_output_fmts[] = {
340 .pixelformat = V4L2_PIX_FMT_YUV420,
342 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV420,
343 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV420,
344 .description = "YUV420, planar",
347 .pixelformat = V4L2_PIX_FMT_YVU420,
349 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YVU420,
350 .sh_fmt = IA_CSS_FRAME_FORMAT_YV12,
351 .description = "YVU420, planar",
354 .pixelformat = V4L2_PIX_FMT_YUV422P,
356 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV422P,
357 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV422,
358 .description = "YUV422, planar",
361 .pixelformat = V4L2_PIX_FMT_YUV444,
363 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV444,
364 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV444,
365 .description = "YUV444"
367 .pixelformat = V4L2_PIX_FMT_NV12,
369 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV12,
370 .sh_fmt = IA_CSS_FRAME_FORMAT_NV12,
371 .description = "NV12, Y-plane, CbCr interleaved",
374 .pixelformat = V4L2_PIX_FMT_NV21,
376 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV21,
377 .sh_fmt = IA_CSS_FRAME_FORMAT_NV21,
378 .description = "NV21, Y-plane, CbCr interleaved",
381 .pixelformat = V4L2_PIX_FMT_NV16,
383 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV16,
384 .sh_fmt = IA_CSS_FRAME_FORMAT_NV16,
385 .description = "NV16, Y-plane, CbCr interleaved",
388 .pixelformat = V4L2_PIX_FMT_YUYV,
390 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUYV,
391 .sh_fmt = IA_CSS_FRAME_FORMAT_YUYV,
392 .description = "YUYV, interleaved"
394 .pixelformat = V4L2_PIX_FMT_UYVY,
396 .mbus_code = MEDIA_BUS_FMT_UYVY8_1X16,
397 .sh_fmt = IA_CSS_FRAME_FORMAT_UYVY,
398 .description = "UYVY, interleaved"
399 }, { /* This one is for parallel sensors! DO NOT USE! */
400 .pixelformat = V4L2_PIX_FMT_UYVY,
402 .mbus_code = MEDIA_BUS_FMT_UYVY8_2X8,
403 .sh_fmt = IA_CSS_FRAME_FORMAT_UYVY,
404 .description = "UYVY, interleaved"
406 .pixelformat = V4L2_PIX_FMT_SBGGR16,
408 .mbus_code = V4L2_MBUS_FMT_CUSTOM_SBGGR16,
409 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
410 .description = "Bayer 16"
412 .pixelformat = V4L2_PIX_FMT_SBGGR8,
414 .mbus_code = MEDIA_BUS_FMT_SBGGR8_1X8,
415 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
416 .description = "Bayer 8"
418 .pixelformat = V4L2_PIX_FMT_SGBRG8,
420 .mbus_code = MEDIA_BUS_FMT_SGBRG8_1X8,
421 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
422 .description = "Bayer 8"
424 .pixelformat = V4L2_PIX_FMT_SGRBG8,
426 .mbus_code = MEDIA_BUS_FMT_SGRBG8_1X8,
427 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
428 .description = "Bayer 8"
430 .pixelformat = V4L2_PIX_FMT_SRGGB8,
432 .mbus_code = MEDIA_BUS_FMT_SRGGB8_1X8,
433 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
434 .description = "Bayer 8"
436 .pixelformat = V4L2_PIX_FMT_SBGGR10,
438 .mbus_code = MEDIA_BUS_FMT_SBGGR10_1X10,
439 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
440 .description = "Bayer 10"
442 .pixelformat = V4L2_PIX_FMT_SGBRG10,
444 .mbus_code = MEDIA_BUS_FMT_SGBRG10_1X10,
445 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
446 .description = "Bayer 10"
448 .pixelformat = V4L2_PIX_FMT_SGRBG10,
450 .mbus_code = MEDIA_BUS_FMT_SGRBG10_1X10,
451 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
452 .description = "Bayer 10"
454 .pixelformat = V4L2_PIX_FMT_SRGGB10,
456 .mbus_code = MEDIA_BUS_FMT_SRGGB10_1X10,
457 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
458 .description = "Bayer 10"
460 .pixelformat = V4L2_PIX_FMT_SBGGR12,
462 .mbus_code = MEDIA_BUS_FMT_SBGGR12_1X12,
463 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
464 .description = "Bayer 12"
466 .pixelformat = V4L2_PIX_FMT_SGBRG12,
468 .mbus_code = MEDIA_BUS_FMT_SGBRG12_1X12,
469 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
470 .description = "Bayer 12"
472 .pixelformat = V4L2_PIX_FMT_SGRBG12,
474 .mbus_code = MEDIA_BUS_FMT_SGRBG12_1X12,
475 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
476 .description = "Bayer 12"
478 .pixelformat = V4L2_PIX_FMT_SRGGB12,
480 .mbus_code = MEDIA_BUS_FMT_SRGGB12_1X12,
481 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
482 .description = "Bayer 12"
484 .pixelformat = V4L2_PIX_FMT_RGB32,
486 .mbus_code = V4L2_MBUS_FMT_CUSTOM_RGB32,
487 .sh_fmt = IA_CSS_FRAME_FORMAT_RGBA888,
488 .description = "32 RGB 8-8-8-8"
490 .pixelformat = V4L2_PIX_FMT_RGB565,
492 .mbus_code = MEDIA_BUS_FMT_BGR565_2X8_LE,
493 .sh_fmt = IA_CSS_FRAME_FORMAT_RGB565,
494 .description = "16 RGB 5-6-5"
496 .pixelformat = V4L2_PIX_FMT_JPEG,
498 .mbus_code = MEDIA_BUS_FMT_JPEG_1X8,
499 .sh_fmt = IA_CSS_FRAME_FORMAT_BINARY_8,
500 .description = "JPEG"
504 /* This is a custom format being used by M10MO to send the RAW data */
505 .pixelformat = V4L2_PIX_FMT_CUSTOM_M10MO_RAW,
507 .mbus_code = V4L2_MBUS_FMT_CUSTOM_M10MO_RAW,
508 .sh_fmt = IA_CSS_FRAME_FORMAT_BINARY_8,
509 .description = "Custom RAW for M10MO"
514 const struct atomisp_format_bridge *atomisp_get_format_bridge(
515 unsigned int pixelformat)
519 for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
520 if (atomisp_output_fmts[i].pixelformat == pixelformat)
521 return &atomisp_output_fmts[i];
527 const struct atomisp_format_bridge *atomisp_get_format_bridge_from_mbus(
532 for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
533 if (mbus_code == atomisp_output_fmts[i].mbus_code)
534 return &atomisp_output_fmts[i];
542 * return ISP capabilities
544 static int atomisp_querycap(struct file *file, void *fh,
545 struct v4l2_capability *cap)
547 struct video_device *vdev = video_devdata(file);
548 struct atomisp_device *isp = video_get_drvdata(vdev);
550 strscpy(cap->driver, DRIVER, sizeof(cap->driver));
551 strscpy(cap->card, CARD, sizeof(cap->card));
552 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s",
553 pci_name(isp->pdev));
559 * enum input are used to check primary/secondary camera
561 static int atomisp_enum_input(struct file *file, void *fh,
562 struct v4l2_input *input)
564 struct video_device *vdev = video_devdata(file);
565 struct atomisp_device *isp = video_get_drvdata(vdev);
566 int index = input->index;
567 struct v4l2_subdev *motor;
569 if (index >= isp->input_cnt)
572 if (!isp->inputs[index].camera)
575 memset(input, 0, sizeof(struct v4l2_input));
576 strscpy(input->name, isp->inputs[index].camera->name,
577 sizeof(input->name));
580 * HACK: append actuator's name to sensor's
581 * As currently userspace can't talk directly to subdev nodes, this
582 * ioctl is the only way to enum inputs + possible external actuators
583 * for 3A tuning purpose.
586 motor = isp->inputs[index].motor;
590 if (motor && strlen(motor->name) > 0) {
591 const int cur_len = strlen(input->name);
592 const int max_size = sizeof(input->name) - cur_len - 1;
595 input->name[cur_len] = '+';
596 strscpy(&input->name[cur_len + 1],
597 motor->name, max_size);
601 input->type = V4L2_INPUT_TYPE_CAMERA;
602 input->index = index;
603 input->reserved[0] = isp->inputs[index].type;
604 input->reserved[1] = isp->inputs[index].port;
609 static unsigned int atomisp_subdev_streaming_count(
610 struct atomisp_sub_device *asd)
612 return asd->video_out_preview.capq.streaming
613 + asd->video_out_capture.capq.streaming
614 + asd->video_out_video_capture.capq.streaming
615 + asd->video_out_vf.capq.streaming
616 + asd->video_in.capq.streaming;
619 unsigned int atomisp_streaming_count(struct atomisp_device *isp)
623 for (i = 0, sum = 0; i < isp->num_of_streams; i++)
624 sum += isp->asd[i].streaming ==
625 ATOMISP_DEVICE_STREAMING_ENABLED;
630 unsigned int atomisp_is_acc_enabled(struct atomisp_device *isp)
634 for (i = 0; i < isp->num_of_streams; i++)
635 if (isp->asd[i].acc.pipeline)
642 * get input are used to get current primary/secondary camera
644 static int atomisp_g_input(struct file *file, void *fh, unsigned int *input)
646 struct video_device *vdev = video_devdata(file);
647 struct atomisp_device *isp = video_get_drvdata(vdev);
648 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
650 rt_mutex_lock(&isp->mutex);
651 *input = asd->input_curr;
652 rt_mutex_unlock(&isp->mutex);
658 * set input are used to set current primary/secondary camera
660 static int atomisp_s_input(struct file *file, void *fh, unsigned int input)
662 struct video_device *vdev = video_devdata(file);
663 struct atomisp_device *isp = video_get_drvdata(vdev);
664 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
665 struct v4l2_subdev *camera = NULL;
666 struct v4l2_subdev *motor;
669 rt_mutex_lock(&isp->mutex);
670 if (input >= ATOM_ISP_MAX_INPUTS || input >= isp->input_cnt) {
671 dev_dbg(isp->dev, "input_cnt: %d\n", isp->input_cnt);
677 * check whether the request camera:
679 * 2: if in use, whether it is used by other streams
681 if (isp->inputs[input].asd && isp->inputs[input].asd != asd) {
683 "%s, camera is already used by stream: %d\n", __func__,
684 isp->inputs[input].asd->index);
689 camera = isp->inputs[input].camera;
691 dev_err(isp->dev, "%s, no camera\n", __func__);
696 if (atomisp_subdev_streaming_count(asd)) {
698 "ISP is still streaming, stop first\n");
703 /* power off the current owned sensor, as it is not used this time */
704 if (isp->inputs[asd->input_curr].asd == asd &&
705 asd->input_curr != input) {
706 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
710 "Failed to power-off sensor\n");
711 /* clear the asd field to show this camera is not used */
712 isp->inputs[asd->input_curr].asd = NULL;
715 /* powe on the new sensor */
716 ret = v4l2_subdev_call(isp->inputs[input].camera, core, s_power, 1);
718 dev_err(isp->dev, "Failed to power-on sensor\n");
722 * Some sensor driver resets the run mode during power-on, thus force
723 * update the run mode to sensor after power-on.
725 atomisp_update_run_mode(asd);
727 /* select operating sensor */
728 ret = v4l2_subdev_call(isp->inputs[input].camera, video, s_routing,
729 0, isp->inputs[input].sensor_index, 0);
730 if (ret && (ret != -ENOIOCTLCMD)) {
731 dev_err(isp->dev, "Failed to select sensor\n");
736 motor = isp->inputs[input].motor;
740 ret = v4l2_subdev_call(motor, core, s_power, 1);
743 if (!isp->sw_contex.file_input && motor)
744 ret = v4l2_subdev_call(motor, core, init, 1);
746 asd->input_curr = input;
747 /* mark this camera is used by the current stream */
748 isp->inputs[input].asd = asd;
749 rt_mutex_unlock(&isp->mutex);
754 rt_mutex_unlock(&isp->mutex);
759 static int atomisp_enum_fmt_cap(struct file *file, void *fh,
760 struct v4l2_fmtdesc *f)
762 struct video_device *vdev = video_devdata(file);
763 struct atomisp_device *isp = video_get_drvdata(vdev);
764 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
765 struct v4l2_subdev_mbus_code_enum code = { 0 };
766 unsigned int i, fi = 0;
769 rt_mutex_lock(&isp->mutex);
770 rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, pad,
771 enum_mbus_code, NULL, &code);
772 if (rval == -ENOIOCTLCMD) {
774 "enum_mbus_code pad op not supported. Please fix your sensor driver!\n");
775 // rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
776 // video, enum_mbus_fmt, 0, &code.code);
778 rt_mutex_unlock(&isp->mutex);
783 for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
784 const struct atomisp_format_bridge *format =
785 &atomisp_output_fmts[i];
788 * Is the atomisp-supported format is valid for the
789 * sensor (configuration)? If not, skip it.
791 if (format->sh_fmt == IA_CSS_FRAME_FORMAT_RAW
792 && format->mbus_code != code.code)
795 /* Found a match. Now let's pick f->index'th one. */
801 strlcpy(f->description, format->description,
802 sizeof(f->description));
803 f->pixelformat = format->pixelformat;
810 static int atomisp_g_fmt_cap(struct file *file, void *fh,
811 struct v4l2_format *f)
813 struct video_device *vdev = video_devdata(file);
814 struct atomisp_device *isp = video_get_drvdata(vdev);
818 rt_mutex_lock(&isp->mutex);
819 ret = atomisp_get_fmt(vdev, f);
820 rt_mutex_unlock(&isp->mutex);
824 static int atomisp_g_fmt_file(struct file *file, void *fh,
825 struct v4l2_format *f)
827 struct video_device *vdev = video_devdata(file);
828 struct atomisp_device *isp = video_get_drvdata(vdev);
829 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
831 rt_mutex_lock(&isp->mutex);
832 f->fmt.pix = pipe->pix;
833 rt_mutex_unlock(&isp->mutex);
838 /* This function looks up the closest available resolution. */
839 static int atomisp_try_fmt_cap(struct file *file, void *fh,
840 struct v4l2_format *f)
842 struct video_device *vdev = video_devdata(file);
843 struct atomisp_device *isp = video_get_drvdata(vdev);
846 rt_mutex_lock(&isp->mutex);
847 ret = atomisp_try_fmt(vdev, f, NULL);
848 rt_mutex_unlock(&isp->mutex);
852 static int atomisp_s_fmt_cap(struct file *file, void *fh,
853 struct v4l2_format *f)
855 struct video_device *vdev = video_devdata(file);
856 struct atomisp_device *isp = video_get_drvdata(vdev);
859 rt_mutex_lock(&isp->mutex);
860 if (isp->isp_fatal_error) {
862 rt_mutex_unlock(&isp->mutex);
865 ret = atomisp_set_fmt(vdev, f);
866 rt_mutex_unlock(&isp->mutex);
870 static int atomisp_s_fmt_file(struct file *file, void *fh,
871 struct v4l2_format *f)
873 struct video_device *vdev = video_devdata(file);
874 struct atomisp_device *isp = video_get_drvdata(vdev);
877 rt_mutex_lock(&isp->mutex);
878 ret = atomisp_set_fmt_file(vdev, f);
879 rt_mutex_unlock(&isp->mutex);
884 * Free videobuffer buffer priv data
886 void atomisp_videobuf_free_buf(struct videobuf_buffer *vb)
888 struct videobuf_vmalloc_memory *vm_mem;
894 if (vm_mem && vm_mem->vaddr) {
895 ia_css_frame_free(vm_mem->vaddr);
896 vm_mem->vaddr = NULL;
901 * this function is used to free video buffer queue
903 static void atomisp_videobuf_free_queue(struct videobuf_queue *q)
907 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
908 atomisp_videobuf_free_buf(q->bufs[i]);
914 int atomisp_alloc_css_stat_bufs(struct atomisp_sub_device *asd,
917 struct atomisp_device *isp = asd->isp;
918 struct atomisp_s3a_buf *s3a_buf = NULL, *_s3a_buf;
919 struct atomisp_dis_buf *dis_buf = NULL, *_dis_buf;
920 struct atomisp_metadata_buf *md_buf = NULL, *_md_buf;
922 struct ia_css_dvs_grid_info *dvs_grid_info =
923 atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info);
926 if (list_empty(&asd->s3a_stats) &&
927 asd->params.curr_grid_info.s3a_grid.enable) {
928 count = ATOMISP_CSS_Q_DEPTH +
929 ATOMISP_S3A_BUF_QUEUE_DEPTH_FOR_HAL;
930 dev_dbg(isp->dev, "allocating %d 3a buffers\n", count);
932 s3a_buf = kzalloc(sizeof(struct atomisp_s3a_buf), GFP_KERNEL);
936 if (atomisp_css_allocate_stat_buffers(
937 asd, stream_id, s3a_buf, NULL, NULL)) {
942 list_add_tail(&s3a_buf->list, &asd->s3a_stats);
946 if (list_empty(&asd->dis_stats) && dvs_grid_info &&
947 dvs_grid_info->enable) {
948 count = ATOMISP_CSS_Q_DEPTH + 1;
949 dev_dbg(isp->dev, "allocating %d dis buffers\n", count);
951 dis_buf = kzalloc(sizeof(struct atomisp_dis_buf), GFP_KERNEL);
956 if (atomisp_css_allocate_stat_buffers(
957 asd, stream_id, NULL, dis_buf, NULL)) {
962 list_add_tail(&dis_buf->list, &asd->dis_stats);
966 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
967 if (list_empty(&asd->metadata[i]) &&
968 list_empty(&asd->metadata_ready[i]) &&
969 list_empty(&asd->metadata_in_css[i])) {
970 count = ATOMISP_CSS_Q_DEPTH +
971 ATOMISP_METADATA_QUEUE_DEPTH_FOR_HAL;
972 dev_dbg(isp->dev, "allocating %d metadata buffers for type %d\n",
975 md_buf = kzalloc(sizeof(struct atomisp_metadata_buf),
980 if (atomisp_css_allocate_stat_buffers(
981 asd, stream_id, NULL, NULL, md_buf)) {
985 list_add_tail(&md_buf->list, &asd->metadata[i]);
992 dev_err(isp->dev, "failed to allocate statistics buffers\n");
994 list_for_each_entry_safe(dis_buf, _dis_buf, &asd->dis_stats, list) {
995 atomisp_css_free_dis_buffer(dis_buf);
996 list_del(&dis_buf->list);
1000 list_for_each_entry_safe(s3a_buf, _s3a_buf, &asd->s3a_stats, list) {
1001 atomisp_css_free_3a_buffer(s3a_buf);
1002 list_del(&s3a_buf->list);
1006 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
1007 list_for_each_entry_safe(md_buf, _md_buf, &asd->metadata[i],
1009 atomisp_css_free_metadata_buffer(md_buf);
1010 list_del(&md_buf->list);
1018 * Initiate Memory Mapping or User Pointer I/O
1020 int __atomisp_reqbufs(struct file *file, void *fh,
1021 struct v4l2_requestbuffers *req)
1023 struct video_device *vdev = video_devdata(file);
1024 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1025 struct atomisp_sub_device *asd = pipe->asd;
1026 struct ia_css_frame_info frame_info;
1027 struct ia_css_frame *frame;
1028 struct videobuf_vmalloc_memory *vm_mem;
1029 u16 source_pad = atomisp_subdev_source_pad(vdev);
1030 u16 stream_id = atomisp_source_pad_to_stream_id(asd, source_pad);
1033 if (req->count == 0) {
1034 mutex_lock(&pipe->capq.vb_lock);
1035 if (!list_empty(&pipe->capq.stream))
1036 videobuf_queue_cancel(&pipe->capq);
1038 atomisp_videobuf_free_queue(&pipe->capq);
1039 mutex_unlock(&pipe->capq.vb_lock);
1040 /* clear request config id */
1041 memset(pipe->frame_request_config_id, 0,
1042 VIDEO_MAX_FRAME * sizeof(unsigned int));
1043 memset(pipe->frame_params, 0,
1045 sizeof(struct atomisp_css_params_with_list *));
1049 ret = videobuf_reqbufs(&pipe->capq, req);
1053 atomisp_alloc_css_stat_bufs(asd, stream_id);
1056 * for user pointer type, buffers are not really allocated here,
1057 * buffers are setup in QBUF operation through v4l2_buffer structure
1059 if (req->memory == V4L2_MEMORY_USERPTR)
1062 ret = atomisp_get_css_frame_info(asd, source_pad, &frame_info);
1067 * Allocate the real frame here for selected node using our
1068 * memory management function
1070 for (i = 0; i < req->count; i++) {
1071 if (ia_css_frame_allocate_from_info(&frame, &frame_info))
1073 vm_mem = pipe->capq.bufs[i]->priv;
1074 vm_mem->vaddr = frame;
1081 vm_mem = pipe->capq.bufs[i]->priv;
1082 ia_css_frame_free(vm_mem->vaddr);
1086 ia_css_frame_free(asd->vf_frame);
1091 int atomisp_reqbufs(struct file *file, void *fh,
1092 struct v4l2_requestbuffers *req)
1094 struct video_device *vdev = video_devdata(file);
1095 struct atomisp_device *isp = video_get_drvdata(vdev);
1098 rt_mutex_lock(&isp->mutex);
1099 ret = __atomisp_reqbufs(file, fh, req);
1100 rt_mutex_unlock(&isp->mutex);
1105 static int atomisp_reqbufs_file(struct file *file, void *fh,
1106 struct v4l2_requestbuffers *req)
1108 struct video_device *vdev = video_devdata(file);
1109 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1111 if (req->count == 0) {
1112 mutex_lock(&pipe->outq.vb_lock);
1113 atomisp_videobuf_free_queue(&pipe->outq);
1114 mutex_unlock(&pipe->outq.vb_lock);
1118 return videobuf_reqbufs(&pipe->outq, req);
1121 /* application query the status of a buffer */
1122 static int atomisp_querybuf(struct file *file, void *fh,
1123 struct v4l2_buffer *buf)
1125 struct video_device *vdev = video_devdata(file);
1126 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1128 return videobuf_querybuf(&pipe->capq, buf);
1131 static int atomisp_querybuf_file(struct file *file, void *fh,
1132 struct v4l2_buffer *buf)
1134 struct video_device *vdev = video_devdata(file);
1135 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1137 return videobuf_querybuf(&pipe->outq, buf);
1141 * Applications call the VIDIOC_QBUF ioctl to enqueue an empty (capturing) or
1142 * filled (output) buffer in the drivers incoming queue.
1144 static int atomisp_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1146 static const int NOFLUSH_FLAGS = V4L2_BUF_FLAG_NO_CACHE_INVALIDATE |
1147 V4L2_BUF_FLAG_NO_CACHE_CLEAN;
1148 struct video_device *vdev = video_devdata(file);
1149 struct atomisp_device *isp = video_get_drvdata(vdev);
1150 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1151 struct atomisp_sub_device *asd = pipe->asd;
1152 struct videobuf_buffer *vb;
1153 struct videobuf_vmalloc_memory *vm_mem;
1154 struct ia_css_frame_info frame_info;
1155 struct ia_css_frame *handle = NULL;
1160 rt_mutex_lock(&isp->mutex);
1161 if (isp->isp_fatal_error) {
1166 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) {
1167 dev_err(isp->dev, "%s: reject, as ISP at stopping.\n",
1173 if (!buf || buf->index >= VIDEO_MAX_FRAME ||
1174 !pipe->capq.bufs[buf->index]) {
1175 dev_err(isp->dev, "Invalid index for qbuf.\n");
1181 * For userptr type frame, we convert user space address to physic
1182 * address and reprograme out page table properly
1184 if (buf->memory == V4L2_MEMORY_USERPTR) {
1185 vb = pipe->capq.bufs[buf->index];
1193 pgnr = (length + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1195 if (vb->baddr == buf->m.userptr && vm_mem->vaddr)
1198 if (atomisp_get_css_frame_info(asd,
1199 atomisp_subdev_source_pad(vdev), &frame_info)) {
1204 ret = ia_css_frame_map(&handle, &frame_info,
1205 (void __user *)buf->m.userptr,
1208 dev_err(isp->dev, "Failed to map user buffer\n");
1212 if (vm_mem->vaddr) {
1213 mutex_lock(&pipe->capq.vb_lock);
1214 ia_css_frame_free(vm_mem->vaddr);
1215 vm_mem->vaddr = NULL;
1216 vb->state = VIDEOBUF_NEEDS_INIT;
1217 mutex_unlock(&pipe->capq.vb_lock);
1220 vm_mem->vaddr = handle;
1222 buf->flags &= ~V4L2_BUF_FLAG_MAPPED;
1223 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1224 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1225 } else if (buf->memory == V4L2_MEMORY_MMAP) {
1226 buf->flags |= V4L2_BUF_FLAG_MAPPED;
1227 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1228 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1231 * For mmap, frames were allocated at request buffers
1236 if (!((buf->flags & NOFLUSH_FLAGS) == NOFLUSH_FLAGS))
1239 if (!atomisp_is_vf_pipe(pipe) &&
1240 (buf->reserved2 & ATOMISP_BUFFER_HAS_PER_FRAME_SETTING)) {
1241 /* this buffer will have a per-frame parameter */
1242 pipe->frame_request_config_id[buf->index] = buf->reserved2 &
1243 ~ATOMISP_BUFFER_HAS_PER_FRAME_SETTING;
1245 "This buffer requires per_frame setting which has isp_config_id %d\n",
1246 pipe->frame_request_config_id[buf->index]);
1248 pipe->frame_request_config_id[buf->index] = 0;
1251 pipe->frame_params[buf->index] = NULL;
1253 rt_mutex_unlock(&isp->mutex);
1255 ret = videobuf_qbuf(&pipe->capq, buf);
1256 rt_mutex_lock(&isp->mutex);
1260 /* TODO: do this better, not best way to queue to css */
1261 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) {
1262 if (!list_empty(&pipe->buffers_waiting_for_param)) {
1263 atomisp_handle_parameter_and_buffer(pipe);
1265 atomisp_qbuffers_to_css(asd);
1268 if (!atomisp_is_wdt_running(asd) && atomisp_buffers_queued(asd))
1269 atomisp_wdt_start(asd);
1271 if (!atomisp_is_wdt_running(pipe) &&
1272 atomisp_buffers_queued_pipe(pipe))
1273 atomisp_wdt_start_pipe(pipe);
1278 /* Workaround: Due to the design of HALv3,
1279 * sometimes in ZSL or SDV mode HAL needs to
1280 * capture multiple images within one streaming cycle.
1281 * But the capture number cannot be determined by HAL.
1282 * So HAL only sets the capture number to be 1 and queue multiple
1283 * buffers. Atomisp driver needs to check this case and re-trigger
1284 * CSS to do capture when new buffer is queued. */
1285 if (asd->continuous_mode->val &&
1286 atomisp_subdev_source_pad(vdev)
1287 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE &&
1288 pipe->capq.streaming &&
1289 !asd->enable_raw_buffer_lock->val &&
1290 asd->params.offline_parm.num_captures == 1) {
1292 asd->pending_capture_request++;
1293 dev_dbg(isp->dev, "Add one pending capture request.\n");
1295 if (asd->re_trigger_capture) {
1296 ret = atomisp_css_offline_capture_configure(asd,
1297 asd->params.offline_parm.num_captures,
1298 asd->params.offline_parm.skip_frames,
1299 asd->params.offline_parm.offset);
1300 asd->re_trigger_capture = false;
1301 dev_dbg(isp->dev, "%s Trigger capture again ret=%d\n",
1305 asd->pending_capture_request++;
1306 asd->re_trigger_capture = false;
1307 dev_dbg(isp->dev, "Add one pending capture request.\n");
1311 rt_mutex_unlock(&isp->mutex);
1313 dev_dbg(isp->dev, "qbuf buffer %d (%s) for asd%d\n", buf->index,
1314 vdev->name, asd->index);
1319 rt_mutex_unlock(&isp->mutex);
1323 static int atomisp_qbuf_file(struct file *file, void *fh,
1324 struct v4l2_buffer *buf)
1326 struct video_device *vdev = video_devdata(file);
1327 struct atomisp_device *isp = video_get_drvdata(vdev);
1328 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1331 rt_mutex_lock(&isp->mutex);
1332 if (isp->isp_fatal_error) {
1337 if (!buf || buf->index >= VIDEO_MAX_FRAME ||
1338 !pipe->outq.bufs[buf->index]) {
1339 dev_err(isp->dev, "Invalid index for qbuf.\n");
1344 if (buf->memory != V4L2_MEMORY_MMAP) {
1345 dev_err(isp->dev, "Unsupported memory method\n");
1350 if (buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1351 dev_err(isp->dev, "Unsupported buffer type\n");
1355 rt_mutex_unlock(&isp->mutex);
1357 return videobuf_qbuf(&pipe->outq, buf);
1360 rt_mutex_unlock(&isp->mutex);
1365 static int __get_frame_exp_id(struct atomisp_video_pipe *pipe,
1366 struct v4l2_buffer *buf)
1368 struct videobuf_vmalloc_memory *vm_mem;
1369 struct ia_css_frame *handle;
1372 for (i = 0; pipe->capq.bufs[i]; i++) {
1373 vm_mem = pipe->capq.bufs[i]->priv;
1374 handle = vm_mem->vaddr;
1375 if (buf->index == pipe->capq.bufs[i]->i && handle)
1376 return handle->exp_id;
1382 * Applications call the VIDIOC_DQBUF ioctl to dequeue a filled (capturing) or
1383 * displayed (output buffer)from the driver's outgoing queue
1385 static int atomisp_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1387 struct video_device *vdev = video_devdata(file);
1388 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1389 struct atomisp_sub_device *asd = pipe->asd;
1390 struct atomisp_device *isp = video_get_drvdata(vdev);
1393 rt_mutex_lock(&isp->mutex);
1395 if (isp->isp_fatal_error) {
1396 rt_mutex_unlock(&isp->mutex);
1400 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) {
1401 rt_mutex_unlock(&isp->mutex);
1402 dev_err(isp->dev, "%s: reject, as ISP at stopping.\n",
1407 rt_mutex_unlock(&isp->mutex);
1409 ret = videobuf_dqbuf(&pipe->capq, buf, file->f_flags & O_NONBLOCK);
1412 dev_dbg(isp->dev, "<%s: %d\n", __func__, ret);
1415 rt_mutex_lock(&isp->mutex);
1416 buf->bytesused = pipe->pix.sizeimage;
1417 buf->reserved = asd->frame_status[buf->index];
1421 * Currently frame_status in the enum type which takes no more lower
1423 * use bit[31:16] for exp_id as it is only in the range of 1~255
1425 buf->reserved &= 0x0000ffff;
1426 if (!(buf->flags & V4L2_BUF_FLAG_ERROR))
1427 buf->reserved |= __get_frame_exp_id(pipe, buf) << 16;
1428 buf->reserved2 = pipe->frame_config_id[buf->index];
1429 rt_mutex_unlock(&isp->mutex);
1432 "dqbuf buffer %d (%s) for asd%d with exp_id %d, isp_config_id %d\n",
1433 buf->index, vdev->name, asd->index, buf->reserved >> 16,
1438 enum ia_css_pipe_id atomisp_get_css_pipe_id(struct atomisp_sub_device *asd)
1440 if (ATOMISP_USE_YUVPP(asd))
1441 return IA_CSS_PIPE_ID_YUVPP;
1443 if (asd->continuous_mode->val) {
1444 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
1445 return IA_CSS_PIPE_ID_VIDEO;
1447 return IA_CSS_PIPE_ID_PREVIEW;
1451 * Disable vf_pp and run CSS in video mode. This allows using ISP
1452 * scaling but it has one frame delay due to CSS internal buffering.
1454 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER)
1455 return IA_CSS_PIPE_ID_VIDEO;
1458 * Disable vf_pp and run CSS in still capture mode. In this mode
1459 * CSS does not cause extra latency with buffering, but scaling
1462 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT)
1463 return IA_CSS_PIPE_ID_CAPTURE;
1465 switch (asd->run_mode->val) {
1466 case ATOMISP_RUN_MODE_PREVIEW:
1467 return IA_CSS_PIPE_ID_PREVIEW;
1468 case ATOMISP_RUN_MODE_VIDEO:
1469 return IA_CSS_PIPE_ID_VIDEO;
1470 case ATOMISP_RUN_MODE_STILL_CAPTURE:
1473 return IA_CSS_PIPE_ID_CAPTURE;
1477 static unsigned int atomisp_sensor_start_stream(struct atomisp_sub_device *asd)
1479 struct atomisp_device *isp = asd->isp;
1481 if (isp->inputs[asd->input_curr].camera_caps->
1482 sensor[asd->sensor_curr].stream_num > 1) {
1483 if (asd->high_speed_mode)
1489 if (asd->vfpp->val != ATOMISP_VFPP_ENABLE ||
1493 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO ||
1494 (asd->run_mode->val == ATOMISP_RUN_MODE_STILL_CAPTURE &&
1495 !atomisp_is_mbuscode_raw(
1497 asd->capture_pad].fmt.code) &&
1498 !asd->continuous_mode->val))
1504 int atomisp_stream_on_master_slave_sensor(struct atomisp_device *isp,
1507 unsigned int master = -1, slave = -1, delay_slave = 0;
1511 * ISP only support 2 streams now so ignore multiple master/slave
1512 * case to reduce the delay between 2 stream_on calls.
1514 for (i = 0; i < isp->num_of_streams; i++) {
1515 int sensor_index = isp->asd[i].input_curr;
1517 if (isp->inputs[sensor_index].camera_caps->
1518 sensor[isp->asd[i].sensor_curr].is_slave)
1519 slave = sensor_index;
1521 master = sensor_index;
1524 if (master == -1 || slave == -1) {
1525 master = ATOMISP_DEPTH_DEFAULT_MASTER_SENSOR;
1526 slave = ATOMISP_DEPTH_DEFAULT_SLAVE_SENSOR;
1528 "depth mode use default master=%s.slave=%s.\n",
1529 isp->inputs[master].camera->name,
1530 isp->inputs[slave].camera->name);
1533 ret = v4l2_subdev_call(isp->inputs[master].camera, core,
1534 ioctl, ATOMISP_IOC_G_DEPTH_SYNC_COMP,
1538 "get depth sensor %s compensation delay failed.\n",
1539 isp->inputs[master].camera->name);
1541 ret = v4l2_subdev_call(isp->inputs[master].camera,
1542 video, s_stream, 1);
1544 dev_err(isp->dev, "depth mode master sensor %s stream-on failed.\n",
1545 isp->inputs[master].camera->name);
1549 if (delay_slave != 0)
1550 udelay(delay_slave);
1552 ret = v4l2_subdev_call(isp->inputs[slave].camera,
1553 video, s_stream, 1);
1555 dev_err(isp->dev, "depth mode slave sensor %s stream-on failed.\n",
1556 isp->inputs[slave].camera->name);
1557 v4l2_subdev_call(isp->inputs[master].camera, video, s_stream, 0);
1565 /* FIXME! ISP2400 */
1566 static void __wdt_on_master_slave_sensor(struct atomisp_device *isp,
1567 unsigned int wdt_duration)
1569 if (atomisp_buffers_queued(&isp->asd[0]))
1570 atomisp_wdt_refresh(&isp->asd[0], wdt_duration);
1571 if (atomisp_buffers_queued(&isp->asd[1]))
1572 atomisp_wdt_refresh(&isp->asd[1], wdt_duration);
1575 /* FIXME! ISP2401 */
1576 static void __wdt_on_master_slave_sensor_pipe(struct atomisp_video_pipe *pipe,
1577 unsigned int wdt_duration,
1580 static struct atomisp_video_pipe *pipe0;
1583 if (atomisp_buffers_queued_pipe(pipe0))
1584 atomisp_wdt_refresh_pipe(pipe0, wdt_duration);
1585 if (atomisp_buffers_queued_pipe(pipe))
1586 atomisp_wdt_refresh_pipe(pipe, wdt_duration);
1592 static void atomisp_pause_buffer_event(struct atomisp_device *isp)
1594 struct v4l2_event event = {0};
1597 event.type = V4L2_EVENT_ATOMISP_PAUSE_BUFFER;
1599 for (i = 0; i < isp->num_of_streams; i++) {
1600 int sensor_index = isp->asd[i].input_curr;
1602 if (isp->inputs[sensor_index].camera_caps->
1603 sensor[isp->asd[i].sensor_curr].is_slave) {
1604 v4l2_event_queue(isp->asd[i].subdev.devnode, &event);
1610 /* Input system HW workaround */
1611 /* Input system address translation corrupts burst during */
1612 /* invalidate. SW workaround for this is to set burst length */
1613 /* manually to 128 in case of 13MPx snapshot and to 1 otherwise. */
1614 static void atomisp_dma_burst_len_cfg(struct atomisp_sub_device *asd)
1616 struct v4l2_mbus_framefmt *sink;
1618 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
1619 V4L2_SUBDEV_FORMAT_ACTIVE,
1620 ATOMISP_SUBDEV_PAD_SINK);
1622 if (sink->width * sink->height >= 4096 * 3072)
1623 atomisp_css2_hw_store_32(DMA_BURST_SIZE_REG, 0x7F);
1625 atomisp_css2_hw_store_32(DMA_BURST_SIZE_REG, 0x00);
1629 * This ioctl start the capture during streaming I/O.
1631 static int atomisp_streamon(struct file *file, void *fh,
1632 enum v4l2_buf_type type)
1634 struct video_device *vdev = video_devdata(file);
1635 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1636 struct atomisp_sub_device *asd = pipe->asd;
1637 struct atomisp_device *isp = video_get_drvdata(vdev);
1638 enum ia_css_pipe_id css_pipe_id;
1639 unsigned int sensor_start_stream;
1640 unsigned int wdt_duration = ATOMISP_ISP_TIMEOUT_DURATION;
1642 unsigned long irqflags;
1644 dev_dbg(isp->dev, "Start stream on pad %d for asd%d\n",
1645 atomisp_subdev_source_pad(vdev), asd->index);
1647 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1648 dev_dbg(isp->dev, "unsupported v4l2 buf type\n");
1652 rt_mutex_lock(&isp->mutex);
1653 if (isp->isp_fatal_error) {
1658 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) {
1663 if (pipe->capq.streaming)
1666 /* Input system HW workaround */
1667 atomisp_dma_burst_len_cfg(asd);
1670 * The number of streaming video nodes is based on which
1671 * binary is going to be run.
1673 sensor_start_stream = atomisp_sensor_start_stream(asd);
1675 spin_lock_irqsave(&pipe->irq_lock, irqflags);
1676 if (list_empty(&pipe->capq.stream)) {
1677 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
1678 dev_dbg(isp->dev, "no buffer in the queue\n");
1682 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
1684 ret = videobuf_streamon(&pipe->capq);
1688 /* Reset pending capture request count. */
1689 asd->pending_capture_request = 0;
1691 asd->re_trigger_capture = false;
1693 if ((atomisp_subdev_streaming_count(asd) > sensor_start_stream) &&
1694 (!isp->inputs[asd->input_curr].camera_caps->multi_stream_ctrl)) {
1695 /* trigger still capture */
1696 if (asd->continuous_mode->val &&
1697 atomisp_subdev_source_pad(vdev)
1698 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE) {
1699 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
1700 dev_dbg(isp->dev, "SDV last video raw buffer id: %u\n",
1701 asd->latest_preview_exp_id);
1703 dev_dbg(isp->dev, "ZSL last preview raw buffer id: %u\n",
1704 asd->latest_preview_exp_id);
1706 if (asd->delayed_init == ATOMISP_DELAYED_INIT_QUEUED) {
1707 flush_work(&asd->delayed_init_work);
1708 rt_mutex_unlock(&isp->mutex);
1709 if (wait_for_completion_interruptible(
1710 &asd->init_done) != 0)
1711 return -ERESTARTSYS;
1712 rt_mutex_lock(&isp->mutex);
1715 /* handle per_frame_setting parameter and buffers */
1716 atomisp_handle_parameter_and_buffer(pipe);
1719 * only ZSL/SDV capture request will be here, raise
1720 * the ISP freq to the highest possible to minimize
1723 atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, false);
1725 * When asd->enable_raw_buffer_lock->val is true,
1726 * An extra IOCTL is needed to call
1727 * atomisp_css_exp_id_capture and trigger real capture
1729 if (!asd->enable_raw_buffer_lock->val) {
1730 ret = atomisp_css_offline_capture_configure(asd,
1731 asd->params.offline_parm.num_captures,
1732 asd->params.offline_parm.skip_frames,
1733 asd->params.offline_parm.offset);
1738 if (asd->depth_mode->val)
1739 atomisp_pause_buffer_event(isp);
1742 atomisp_qbuffers_to_css(asd);
1746 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) {
1747 atomisp_qbuffers_to_css(asd);
1751 css_pipe_id = atomisp_get_css_pipe_id(asd);
1753 ret = atomisp_acc_load_extensions(asd);
1755 dev_err(isp->dev, "acc extension failed to load\n");
1759 if (asd->params.css_update_params_needed) {
1760 atomisp_apply_css_parameters(asd, &asd->params.css_param);
1761 if (asd->params.css_param.update_flag.dz_config)
1762 asd->params.config.dz_config = &asd->params.css_param.dz_config;
1763 atomisp_css_update_isp_params(asd);
1764 asd->params.css_update_params_needed = false;
1765 memset(&asd->params.css_param.update_flag, 0,
1766 sizeof(struct atomisp_parameters));
1768 asd->params.dvs_6axis = NULL;
1770 ret = atomisp_css_start(asd, css_pipe_id, false);
1774 asd->streaming = ATOMISP_DEVICE_STREAMING_ENABLED;
1775 atomic_set(&asd->sof_count, -1);
1776 atomic_set(&asd->sequence, -1);
1777 atomic_set(&asd->sequence_temp, -1);
1778 if (isp->sw_contex.file_input)
1779 wdt_duration = ATOMISP_ISP_FILE_TIMEOUT_DURATION;
1781 asd->params.dis_proj_data_valid = false;
1782 asd->latest_preview_exp_id = 0;
1783 asd->postview_exp_id = 1;
1784 asd->preview_exp_id = 1;
1786 /* handle per_frame_setting parameter and buffers */
1787 atomisp_handle_parameter_and_buffer(pipe);
1789 atomisp_qbuffers_to_css(asd);
1791 /* Only start sensor when the last streaming instance started */
1792 if (atomisp_subdev_streaming_count(asd) < sensor_start_stream)
1797 asd->params.num_flash_frames = 0;
1798 asd->params.flash_state = ATOMISP_FLASH_IDLE;
1799 atomisp_setup_flash(asd);
1802 if (!isp->sw_contex.file_input) {
1803 atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
1804 atomisp_css_valid_sof(isp));
1805 atomisp_csi2_configure(asd);
1807 * set freq to max when streaming count > 1 which indicate
1808 * dual camera would run
1810 if (atomisp_streaming_count(isp) > 1) {
1811 if (atomisp_freq_scaling(isp,
1812 ATOMISP_DFS_MODE_MAX, false) < 0)
1813 dev_dbg(isp->dev, "DFS max mode failed!\n");
1815 if (atomisp_freq_scaling(isp,
1816 ATOMISP_DFS_MODE_AUTO, false) < 0)
1817 dev_dbg(isp->dev, "DFS auto mode failed!\n");
1820 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, false) < 0)
1821 dev_dbg(isp->dev, "DFS max mode failed!\n");
1824 if (asd->depth_mode->val && atomisp_streaming_count(isp) ==
1825 ATOMISP_DEPTH_SENSOR_STREAMON_COUNT) {
1826 ret = atomisp_stream_on_master_slave_sensor(isp, false);
1828 dev_err(isp->dev, "master slave sensor stream on failed!\n");
1832 __wdt_on_master_slave_sensor(isp, wdt_duration);
1834 __wdt_on_master_slave_sensor_pipe(pipe, wdt_duration, true);
1836 goto start_delay_wq;
1837 } else if (asd->depth_mode->val && (atomisp_streaming_count(isp) <
1838 ATOMISP_DEPTH_SENSOR_STREAMON_COUNT)) {
1840 __wdt_on_master_slave_sensor_pipe(pipe, wdt_duration, false);
1841 goto start_delay_wq;
1844 /* Enable the CSI interface on ANN B0/K0 */
1845 if (isp->media_dev.hw_revision >= ((ATOMISP_HW_REVISION_ISP2401 <<
1846 ATOMISP_HW_REVISION_SHIFT) | ATOMISP_HW_STEPPING_B0)) {
1847 pci_write_config_word(isp->pdev, MRFLD_PCI_CSI_CONTROL,
1848 isp->saved_regs.csi_control |
1849 MRFLD_PCI_CSI_CONTROL_CSI_READY);
1852 /* stream on the sensor */
1853 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1854 video, s_stream, 1);
1856 asd->streaming = ATOMISP_DEVICE_STREAMING_DISABLED;
1862 if (atomisp_buffers_queued(asd))
1863 atomisp_wdt_refresh(asd, wdt_duration);
1865 if (atomisp_buffers_queued_pipe(pipe))
1866 atomisp_wdt_refresh_pipe(pipe, wdt_duration);
1870 if (asd->continuous_mode->val) {
1871 struct v4l2_mbus_framefmt *sink;
1873 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
1874 V4L2_SUBDEV_FORMAT_ACTIVE,
1875 ATOMISP_SUBDEV_PAD_SINK);
1877 reinit_completion(&asd->init_done);
1878 asd->delayed_init = ATOMISP_DELAYED_INIT_QUEUED;
1879 queue_work(asd->delayed_init_workq, &asd->delayed_init_work);
1880 atomisp_css_set_cont_prev_start_time(isp,
1881 ATOMISP_CALC_CSS_PREV_OVERLAP(sink->height));
1883 asd->delayed_init = ATOMISP_DELAYED_INIT_NOT_QUEUED;
1886 rt_mutex_unlock(&isp->mutex);
1890 int __atomisp_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
1892 struct video_device *vdev = video_devdata(file);
1893 struct atomisp_device *isp = video_get_drvdata(vdev);
1894 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1895 struct atomisp_sub_device *asd = pipe->asd;
1896 struct atomisp_video_pipe *capture_pipe = NULL;
1897 struct atomisp_video_pipe *vf_pipe = NULL;
1898 struct atomisp_video_pipe *preview_pipe = NULL;
1899 struct atomisp_video_pipe *video_pipe = NULL;
1900 struct videobuf_buffer *vb, *_vb;
1901 enum ia_css_pipe_id css_pipe_id;
1903 unsigned long flags;
1904 bool first_streamoff = false;
1906 dev_dbg(isp->dev, "Stop stream on pad %d for asd%d\n",
1907 atomisp_subdev_source_pad(vdev), asd->index);
1909 BUG_ON(!rt_mutex_is_locked(&isp->mutex));
1910 BUG_ON(!mutex_is_locked(&isp->streamoff_mutex));
1912 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1913 dev_dbg(isp->dev, "unsupported v4l2 buf type\n");
1918 * do only videobuf_streamoff for capture & vf pipes in
1919 * case of continuous capture
1921 if ((asd->continuous_mode->val ||
1922 isp->inputs[asd->input_curr].camera_caps->multi_stream_ctrl) &&
1923 atomisp_subdev_source_pad(vdev) !=
1924 ATOMISP_SUBDEV_PAD_SOURCE_PREVIEW &&
1925 atomisp_subdev_source_pad(vdev) !=
1926 ATOMISP_SUBDEV_PAD_SOURCE_VIDEO) {
1927 if (isp->inputs[asd->input_curr].camera_caps->multi_stream_ctrl) {
1928 v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1929 video, s_stream, 0);
1930 } else if (atomisp_subdev_source_pad(vdev)
1931 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE) {
1932 /* stop continuous still capture if needed */
1933 if (asd->params.offline_parm.num_captures == -1)
1934 atomisp_css_offline_capture_configure(asd,
1936 atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_AUTO, false);
1939 * Currently there is no way to flush buffers queued to css.
1940 * When doing videobuf_streamoff, active buffers will be
1941 * marked as VIDEOBUF_NEEDS_INIT. HAL will be able to use
1942 * these buffers again, and these buffers might be queued to
1943 * css more than once! Warn here, if HAL has not dequeued all
1944 * buffers back before calling streamoff.
1946 if (pipe->buffers_in_css != 0) {
1947 WARN(1, "%s: buffers of vdev %s still in CSS!\n",
1948 __func__, pipe->vdev.name);
1951 * Buffers remained in css maybe dequeued out in the
1952 * next stream on, while this will causes serious
1953 * issues as buffers already get invalid after
1954 * previous stream off.
1956 * No way to flush buffers but to reset the whole css
1958 dev_warn(isp->dev, "Reset CSS to clean up css buffers.\n");
1959 atomisp_css_flush(isp);
1962 return videobuf_streamoff(&pipe->capq);
1965 if (!pipe->capq.streaming)
1968 spin_lock_irqsave(&isp->lock, flags);
1969 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) {
1970 asd->streaming = ATOMISP_DEVICE_STREAMING_STOPPING;
1971 first_streamoff = true;
1973 spin_unlock_irqrestore(&isp->lock, flags);
1975 if (first_streamoff) {
1976 /* if other streams are running, should not disable watch dog */
1977 rt_mutex_unlock(&isp->mutex);
1978 atomisp_wdt_stop(asd, true);
1981 * must stop sending pixels into GP_FIFO before stop
1984 if (isp->sw_contex.file_input)
1985 v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1986 video, s_stream, 0);
1988 rt_mutex_lock(&isp->mutex);
1989 atomisp_acc_unload_extensions(asd);
1992 spin_lock_irqsave(&isp->lock, flags);
1993 if (atomisp_subdev_streaming_count(asd) == 1)
1994 asd->streaming = ATOMISP_DEVICE_STREAMING_DISABLED;
1995 spin_unlock_irqrestore(&isp->lock, flags);
1997 if (!first_streamoff) {
1998 ret = videobuf_streamoff(&pipe->capq);
2004 atomisp_clear_css_buffer_counters(asd);
2006 if (!isp->sw_contex.file_input)
2007 atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
2010 if (asd->delayed_init == ATOMISP_DELAYED_INIT_QUEUED) {
2011 cancel_work_sync(&asd->delayed_init_work);
2012 asd->delayed_init = ATOMISP_DELAYED_INIT_NOT_QUEUED;
2014 if (first_streamoff) {
2015 css_pipe_id = atomisp_get_css_pipe_id(asd);
2016 ret = atomisp_css_stop(asd, css_pipe_id, false);
2018 /* cancel work queue*/
2019 if (asd->video_out_capture.users) {
2020 capture_pipe = &asd->video_out_capture;
2021 wake_up_interruptible(&capture_pipe->capq.wait);
2023 if (asd->video_out_vf.users) {
2024 vf_pipe = &asd->video_out_vf;
2025 wake_up_interruptible(&vf_pipe->capq.wait);
2027 if (asd->video_out_preview.users) {
2028 preview_pipe = &asd->video_out_preview;
2029 wake_up_interruptible(&preview_pipe->capq.wait);
2031 if (asd->video_out_video_capture.users) {
2032 video_pipe = &asd->video_out_video_capture;
2033 wake_up_interruptible(&video_pipe->capq.wait);
2035 ret = videobuf_streamoff(&pipe->capq);
2039 /* cleanup css here */
2040 /* no need for this, as ISP will be reset anyway */
2041 /*atomisp_flush_bufs_in_css(isp);*/
2043 spin_lock_irqsave(&pipe->irq_lock, flags);
2044 list_for_each_entry_safe(vb, _vb, &pipe->activeq, queue) {
2045 vb->state = VIDEOBUF_PREPARED;
2046 list_del(&vb->queue);
2048 list_for_each_entry_safe(vb, _vb, &pipe->buffers_waiting_for_param, queue) {
2049 vb->state = VIDEOBUF_PREPARED;
2050 list_del(&vb->queue);
2051 pipe->frame_request_config_id[vb->i] = 0;
2053 spin_unlock_irqrestore(&pipe->irq_lock, flags);
2055 atomisp_subdev_cleanup_pending_events(asd);
2057 if (atomisp_subdev_streaming_count(asd) + 1
2058 != atomisp_sensor_start_stream(asd))
2061 if (!isp->sw_contex.file_input)
2062 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2063 video, s_stream, 0);
2066 asd->params.num_flash_frames = 0;
2067 asd->params.flash_state = ATOMISP_FLASH_IDLE;
2070 /* if other streams are running, isp should not be powered off */
2071 if (atomisp_streaming_count(isp)) {
2072 atomisp_css_flush(isp);
2076 /* Disable the CSI interface on ANN B0/K0 */
2077 if (isp->media_dev.hw_revision >= ((ATOMISP_HW_REVISION_ISP2401 <<
2078 ATOMISP_HW_REVISION_SHIFT) | ATOMISP_HW_STEPPING_B0)) {
2079 pci_write_config_word(isp->pdev, MRFLD_PCI_CSI_CONTROL,
2080 isp->saved_regs.csi_control &
2081 ~MRFLD_PCI_CSI_CONTROL_CSI_READY);
2084 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_LOW, false))
2085 dev_warn(isp->dev, "DFS failed.\n");
2087 * ISP work around, need to reset isp
2088 * Is it correct time to reset ISP when first node does streamoff?
2090 if (isp->sw_contex.power_state == ATOM_ISP_POWER_UP) {
2092 bool recreate_streams[MAX_STREAM_NUM] = {0};
2094 if (isp->isp_timeout)
2095 dev_err(isp->dev, "%s: Resetting with WA activated",
2098 * It is possible that the other asd stream is in the stage
2099 * that v4l2_setfmt is just get called on it, which will
2100 * create css stream on that stream. But at this point, there
2101 * is no way to destroy the css stream created on that stream.
2103 * So force stream destroy here.
2105 for (i = 0; i < isp->num_of_streams; i++) {
2106 if (isp->asd[i].stream_prepared) {
2107 atomisp_destroy_pipes_stream_force(&isp->
2109 recreate_streams[i] = true;
2113 /* disable PUNIT/ISP acknowlede/handshake - SRSE=3 */
2114 pci_write_config_dword(isp->pdev, PCI_I_CONTROL, isp->saved_regs.i_control |
2115 MRFLD_PCI_I_CONTROL_SRSE_RESET_MASK);
2116 dev_err(isp->dev, "atomisp_reset");
2118 for (i = 0; i < isp->num_of_streams; i++) {
2119 if (recreate_streams[i])
2120 atomisp_create_pipes_stream(&isp->asd[i]);
2122 isp->isp_timeout = false;
2127 static int atomisp_streamoff(struct file *file, void *fh,
2128 enum v4l2_buf_type type)
2130 struct video_device *vdev = video_devdata(file);
2131 struct atomisp_device *isp = video_get_drvdata(vdev);
2134 mutex_lock(&isp->streamoff_mutex);
2135 rt_mutex_lock(&isp->mutex);
2136 rval = __atomisp_streamoff(file, fh, type);
2137 rt_mutex_unlock(&isp->mutex);
2138 mutex_unlock(&isp->streamoff_mutex);
2144 * To get the current value of a control.
2145 * applications initialize the id field of a struct v4l2_control and
2146 * call this ioctl with a pointer to this structure
2148 static int atomisp_g_ctrl(struct file *file, void *fh,
2149 struct v4l2_control *control)
2151 struct video_device *vdev = video_devdata(file);
2152 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2153 struct atomisp_device *isp = video_get_drvdata(vdev);
2154 int i, ret = -EINVAL;
2156 for (i = 0; i < ctrls_num; i++) {
2157 if (ci_v4l2_controls[i].id == control->id) {
2166 rt_mutex_lock(&isp->mutex);
2168 switch (control->id) {
2169 case V4L2_CID_IRIS_ABSOLUTE:
2170 case V4L2_CID_EXPOSURE_ABSOLUTE:
2171 case V4L2_CID_FNUMBER_ABSOLUTE:
2172 case V4L2_CID_2A_STATUS:
2173 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
2174 case V4L2_CID_EXPOSURE:
2175 case V4L2_CID_EXPOSURE_AUTO:
2176 case V4L2_CID_SCENE_MODE:
2177 case V4L2_CID_ISO_SENSITIVITY:
2178 case V4L2_CID_ISO_SENSITIVITY_AUTO:
2179 case V4L2_CID_CONTRAST:
2180 case V4L2_CID_SATURATION:
2181 case V4L2_CID_SHARPNESS:
2182 case V4L2_CID_3A_LOCK:
2183 case V4L2_CID_EXPOSURE_ZONE_NUM:
2184 case V4L2_CID_TEST_PATTERN:
2185 case V4L2_CID_TEST_PATTERN_COLOR_R:
2186 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2187 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2188 case V4L2_CID_TEST_PATTERN_COLOR_B:
2189 rt_mutex_unlock(&isp->mutex);
2190 return v4l2_g_ctrl(isp->inputs[asd->input_curr].camera->
2191 ctrl_handler, control);
2192 case V4L2_CID_COLORFX:
2193 ret = atomisp_color_effect(asd, 0, &control->value);
2195 case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION:
2196 ret = atomisp_bad_pixel(asd, 0, &control->value);
2198 case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC:
2199 ret = atomisp_gdc_cac(asd, 0, &control->value);
2201 case V4L2_CID_ATOMISP_VIDEO_STABLIZATION:
2202 ret = atomisp_video_stable(asd, 0, &control->value);
2204 case V4L2_CID_ATOMISP_FIXED_PATTERN_NR:
2205 ret = atomisp_fixed_pattern(asd, 0, &control->value);
2207 case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION:
2208 ret = atomisp_false_color(asd, 0, &control->value);
2210 case V4L2_CID_ATOMISP_LOW_LIGHT:
2211 ret = atomisp_low_light(asd, 0, &control->value);
2218 rt_mutex_unlock(&isp->mutex);
2223 * To change the value of a control.
2224 * applications initialize the id and value fields of a struct v4l2_control
2225 * and call this ioctl.
2227 static int atomisp_s_ctrl(struct file *file, void *fh,
2228 struct v4l2_control *control)
2230 struct video_device *vdev = video_devdata(file);
2231 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2232 struct atomisp_device *isp = video_get_drvdata(vdev);
2233 int i, ret = -EINVAL;
2235 for (i = 0; i < ctrls_num; i++) {
2236 if (ci_v4l2_controls[i].id == control->id) {
2245 rt_mutex_lock(&isp->mutex);
2246 switch (control->id) {
2247 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
2248 case V4L2_CID_EXPOSURE:
2249 case V4L2_CID_EXPOSURE_AUTO:
2250 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
2251 case V4L2_CID_SCENE_MODE:
2252 case V4L2_CID_ISO_SENSITIVITY:
2253 case V4L2_CID_ISO_SENSITIVITY_AUTO:
2254 case V4L2_CID_POWER_LINE_FREQUENCY:
2255 case V4L2_CID_EXPOSURE_METERING:
2256 case V4L2_CID_CONTRAST:
2257 case V4L2_CID_SATURATION:
2258 case V4L2_CID_SHARPNESS:
2259 case V4L2_CID_3A_LOCK:
2260 case V4L2_CID_COLORFX_CBCR:
2261 case V4L2_CID_TEST_PATTERN:
2262 case V4L2_CID_TEST_PATTERN_COLOR_R:
2263 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2264 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2265 case V4L2_CID_TEST_PATTERN_COLOR_B:
2266 rt_mutex_unlock(&isp->mutex);
2267 return v4l2_s_ctrl(NULL,
2268 isp->inputs[asd->input_curr].camera->
2269 ctrl_handler, control);
2270 case V4L2_CID_COLORFX:
2271 ret = atomisp_color_effect(asd, 1, &control->value);
2273 case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION:
2274 ret = atomisp_bad_pixel(asd, 1, &control->value);
2276 case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC:
2277 ret = atomisp_gdc_cac(asd, 1, &control->value);
2279 case V4L2_CID_ATOMISP_VIDEO_STABLIZATION:
2280 ret = atomisp_video_stable(asd, 1, &control->value);
2282 case V4L2_CID_ATOMISP_FIXED_PATTERN_NR:
2283 ret = atomisp_fixed_pattern(asd, 1, &control->value);
2285 case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION:
2286 ret = atomisp_false_color(asd, 1, &control->value);
2288 case V4L2_CID_REQUEST_FLASH:
2289 ret = atomisp_flash_enable(asd, control->value);
2291 case V4L2_CID_ATOMISP_LOW_LIGHT:
2292 ret = atomisp_low_light(asd, 1, &control->value);
2298 rt_mutex_unlock(&isp->mutex);
2303 * To query the attributes of a control.
2304 * applications set the id field of a struct v4l2_queryctrl and call the
2305 * this ioctl with a pointer to this structure. The driver fills
2306 * the rest of the structure.
2308 static int atomisp_queryctl(struct file *file, void *fh,
2309 struct v4l2_queryctrl *qc)
2311 int i, ret = -EINVAL;
2312 struct video_device *vdev = video_devdata(file);
2313 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2314 struct atomisp_device *isp = video_get_drvdata(vdev);
2317 case V4L2_CID_FOCUS_ABSOLUTE:
2318 case V4L2_CID_FOCUS_RELATIVE:
2319 case V4L2_CID_FOCUS_STATUS:
2321 return v4l2_queryctrl(isp->inputs[asd->input_curr].camera->
2326 return v4l2_queryctrl(isp->motor->ctrl_handler, qc);
2328 return v4l2_queryctrl(isp->inputs[asd->input_curr].
2329 camera->ctrl_handler, qc);
2332 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
2335 for (i = 0; i < ctrls_num; i++) {
2336 if (ci_v4l2_controls[i].id == qc->id) {
2337 memcpy(qc, &ci_v4l2_controls[i],
2338 sizeof(struct v4l2_queryctrl));
2339 qc->reserved[0] = 0;
2345 qc->flags = V4L2_CTRL_FLAG_DISABLED;
2350 static int atomisp_camera_g_ext_ctrls(struct file *file, void *fh,
2351 struct v4l2_ext_controls *c)
2353 struct video_device *vdev = video_devdata(file);
2354 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2355 struct atomisp_device *isp = video_get_drvdata(vdev);
2356 struct v4l2_subdev *motor;
2357 struct v4l2_control ctrl;
2362 motor = isp->inputs[asd->input_curr].motor;
2366 for (i = 0; i < c->count; i++) {
2367 ctrl.id = c->controls[i].id;
2368 ctrl.value = c->controls[i].value;
2370 case V4L2_CID_EXPOSURE_ABSOLUTE:
2371 case V4L2_CID_EXPOSURE_AUTO:
2372 case V4L2_CID_IRIS_ABSOLUTE:
2373 case V4L2_CID_FNUMBER_ABSOLUTE:
2374 case V4L2_CID_BIN_FACTOR_HORZ:
2375 case V4L2_CID_BIN_FACTOR_VERT:
2376 case V4L2_CID_3A_LOCK:
2377 case V4L2_CID_TEST_PATTERN:
2378 case V4L2_CID_TEST_PATTERN_COLOR_R:
2379 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2380 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2381 case V4L2_CID_TEST_PATTERN_COLOR_B:
2383 * Exposure related control will be handled by sensor
2387 v4l2_g_ctrl(isp->inputs[asd->input_curr].camera->
2388 ctrl_handler, &ctrl);
2390 case V4L2_CID_FOCUS_ABSOLUTE:
2391 case V4L2_CID_FOCUS_RELATIVE:
2392 case V4L2_CID_FOCUS_STATUS:
2393 case V4L2_CID_FOCUS_AUTO:
2395 ret = v4l2_g_ctrl(motor->ctrl_handler, &ctrl);
2397 case V4L2_CID_FLASH_STATUS:
2398 case V4L2_CID_FLASH_INTENSITY:
2399 case V4L2_CID_FLASH_TORCH_INTENSITY:
2400 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
2401 case V4L2_CID_FLASH_TIMEOUT:
2402 case V4L2_CID_FLASH_STROBE:
2403 case V4L2_CID_FLASH_MODE:
2404 case V4L2_CID_FLASH_STATUS_REGISTER:
2407 v4l2_g_ctrl(isp->flash->ctrl_handler,
2410 case V4L2_CID_ZOOM_ABSOLUTE:
2411 rt_mutex_lock(&isp->mutex);
2412 ret = atomisp_digital_zoom(asd, 0, &ctrl.value);
2413 rt_mutex_unlock(&isp->mutex);
2415 case V4L2_CID_G_SKIP_FRAMES:
2416 ret = v4l2_subdev_call(
2417 isp->inputs[asd->input_curr].camera,
2418 sensor, g_skip_frames, (u32 *)&ctrl.value);
2428 c->controls[i].value = ctrl.value;
2433 /* This ioctl allows the application to get multiple controls by class */
2434 static int atomisp_g_ext_ctrls(struct file *file, void *fh,
2435 struct v4l2_ext_controls *c)
2437 struct v4l2_control ctrl;
2440 /* input_lock is not need for the Camera related IOCTLs
2441 * The input_lock downgrade the FPS of 3A*/
2442 ret = atomisp_camera_g_ext_ctrls(file, fh, c);
2446 for (i = 0; i < c->count; i++) {
2447 ctrl.id = c->controls[i].id;
2448 ctrl.value = c->controls[i].value;
2449 ret = atomisp_g_ctrl(file, fh, &ctrl);
2450 c->controls[i].value = ctrl.value;
2459 static int atomisp_camera_s_ext_ctrls(struct file *file, void *fh,
2460 struct v4l2_ext_controls *c)
2462 struct video_device *vdev = video_devdata(file);
2463 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2464 struct atomisp_device *isp = video_get_drvdata(vdev);
2465 struct v4l2_subdev *motor;
2466 struct v4l2_control ctrl;
2471 motor = isp->inputs[asd->input_curr].motor;
2475 for (i = 0; i < c->count; i++) {
2476 struct v4l2_ctrl *ctr;
2478 ctrl.id = c->controls[i].id;
2479 ctrl.value = c->controls[i].value;
2481 case V4L2_CID_EXPOSURE_ABSOLUTE:
2482 case V4L2_CID_EXPOSURE_AUTO:
2483 case V4L2_CID_EXPOSURE_METERING:
2484 case V4L2_CID_IRIS_ABSOLUTE:
2485 case V4L2_CID_FNUMBER_ABSOLUTE:
2486 case V4L2_CID_VCM_TIMING:
2487 case V4L2_CID_VCM_SLEW:
2488 case V4L2_CID_3A_LOCK:
2489 case V4L2_CID_TEST_PATTERN:
2490 case V4L2_CID_TEST_PATTERN_COLOR_R:
2491 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2492 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2493 case V4L2_CID_TEST_PATTERN_COLOR_B:
2494 ret = v4l2_s_ctrl(NULL,
2495 isp->inputs[asd->input_curr].camera->
2496 ctrl_handler, &ctrl);
2498 case V4L2_CID_FOCUS_ABSOLUTE:
2499 case V4L2_CID_FOCUS_RELATIVE:
2500 case V4L2_CID_FOCUS_STATUS:
2501 case V4L2_CID_FOCUS_AUTO:
2503 ret = v4l2_s_ctrl(NULL, motor->ctrl_handler,
2506 ret = v4l2_s_ctrl(NULL,
2507 isp->inputs[asd->input_curr].
2508 camera->ctrl_handler, &ctrl);
2510 case V4L2_CID_FLASH_STATUS:
2511 case V4L2_CID_FLASH_INTENSITY:
2512 case V4L2_CID_FLASH_TORCH_INTENSITY:
2513 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
2514 case V4L2_CID_FLASH_TIMEOUT:
2515 case V4L2_CID_FLASH_STROBE:
2516 case V4L2_CID_FLASH_MODE:
2517 case V4L2_CID_FLASH_STATUS_REGISTER:
2518 rt_mutex_lock(&isp->mutex);
2521 v4l2_s_ctrl(NULL, isp->flash->ctrl_handler,
2523 /* When flash mode is changed we need to reset
2525 if (ctrl.id == V4L2_CID_FLASH_MODE) {
2526 asd->params.flash_state =
2528 asd->params.num_flash_frames = 0;
2531 rt_mutex_unlock(&isp->mutex);
2533 case V4L2_CID_ZOOM_ABSOLUTE:
2534 rt_mutex_lock(&isp->mutex);
2535 ret = atomisp_digital_zoom(asd, 1, &ctrl.value);
2536 rt_mutex_unlock(&isp->mutex);
2539 ctr = v4l2_ctrl_find(&asd->ctrl_handler, ctrl.id);
2541 ret = v4l2_ctrl_s_ctrl(ctr, ctrl.value);
2550 c->controls[i].value = ctrl.value;
2555 /* This ioctl allows the application to set multiple controls by class */
2556 static int atomisp_s_ext_ctrls(struct file *file, void *fh,
2557 struct v4l2_ext_controls *c)
2559 struct v4l2_control ctrl;
2562 /* input_lock is not need for the Camera related IOCTLs
2563 * The input_lock downgrade the FPS of 3A*/
2564 ret = atomisp_camera_s_ext_ctrls(file, fh, c);
2568 for (i = 0; i < c->count; i++) {
2569 ctrl.id = c->controls[i].id;
2570 ctrl.value = c->controls[i].value;
2571 ret = atomisp_s_ctrl(file, fh, &ctrl);
2572 c->controls[i].value = ctrl.value;
2582 * vidioc_g/s_param are used to switch isp running mode
2584 static int atomisp_g_parm(struct file *file, void *fh,
2585 struct v4l2_streamparm *parm)
2587 struct video_device *vdev = video_devdata(file);
2588 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2589 struct atomisp_device *isp = video_get_drvdata(vdev);
2591 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2592 dev_err(isp->dev, "unsupport v4l2 buf type\n");
2596 rt_mutex_lock(&isp->mutex);
2597 parm->parm.capture.capturemode = asd->run_mode->val;
2598 rt_mutex_unlock(&isp->mutex);
2603 static int atomisp_s_parm(struct file *file, void *fh,
2604 struct v4l2_streamparm *parm)
2606 struct video_device *vdev = video_devdata(file);
2607 struct atomisp_device *isp = video_get_drvdata(vdev);
2608 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2613 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2614 dev_err(isp->dev, "unsupport v4l2 buf type\n");
2618 rt_mutex_lock(&isp->mutex);
2620 asd->high_speed_mode = false;
2621 switch (parm->parm.capture.capturemode) {
2622 case CI_MODE_NONE: {
2623 struct v4l2_subdev_frame_interval fi = {0};
2625 fi.interval = parm->parm.capture.timeperframe;
2627 rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2628 video, s_frame_interval, &fi);
2630 parm->parm.capture.timeperframe = fi.interval;
2632 if (fi.interval.numerator != 0) {
2633 fps = fi.interval.denominator / fi.interval.numerator;
2635 asd->high_speed_mode = true;
2641 mode = ATOMISP_RUN_MODE_VIDEO;
2643 case CI_MODE_STILL_CAPTURE:
2644 mode = ATOMISP_RUN_MODE_STILL_CAPTURE;
2646 case CI_MODE_CONTINUOUS:
2647 mode = ATOMISP_RUN_MODE_CONTINUOUS_CAPTURE;
2649 case CI_MODE_PREVIEW:
2650 mode = ATOMISP_RUN_MODE_PREVIEW;
2657 rval = v4l2_ctrl_s_ctrl(asd->run_mode, mode);
2660 rt_mutex_unlock(&isp->mutex);
2662 return rval == -ENOIOCTLCMD ? 0 : rval;
2665 static int atomisp_s_parm_file(struct file *file, void *fh,
2666 struct v4l2_streamparm *parm)
2668 struct video_device *vdev = video_devdata(file);
2669 struct atomisp_device *isp = video_get_drvdata(vdev);
2671 if (parm->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2672 dev_err(isp->dev, "unsupport v4l2 buf type for output\n");
2676 rt_mutex_lock(&isp->mutex);
2677 isp->sw_contex.file_input = true;
2678 rt_mutex_unlock(&isp->mutex);
2683 static long atomisp_vidioc_default(struct file *file, void *fh,
2684 bool valid_prio, unsigned int cmd, void *arg)
2686 struct video_device *vdev = video_devdata(file);
2687 struct atomisp_device *isp = video_get_drvdata(vdev);
2688 struct atomisp_sub_device *asd;
2689 struct v4l2_subdev *motor;
2693 acc_node = !strcmp(vdev->name, "ATOMISP ISP ACC");
2695 asd = atomisp_to_acc_pipe(vdev)->asd;
2697 asd = atomisp_to_video_pipe(vdev)->asd;
2700 motor = isp->inputs[asd->input_curr].motor;
2705 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA:
2706 case ATOMISP_IOC_S_EXPOSURE:
2707 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP:
2708 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
2709 case ATOMISP_IOC_EXT_ISP_CTRL:
2710 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO:
2711 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE:
2712 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE:
2713 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT:
2714 case ATOMISP_IOC_S_SENSOR_EE_CONFIG:
2715 case ATOMISP_IOC_G_UPDATE_EXPOSURE:
2716 /* we do not need take isp->mutex for these IOCTLs */
2719 rt_mutex_lock(&isp->mutex);
2723 case ATOMISP_IOC_S_SENSOR_RUNMODE:
2725 err = atomisp_set_sensor_runmode(asd, arg);
2730 case ATOMISP_IOC_G_XNR:
2731 err = atomisp_xnr(asd, 0, arg);
2734 case ATOMISP_IOC_S_XNR:
2735 err = atomisp_xnr(asd, 1, arg);
2738 case ATOMISP_IOC_G_NR:
2739 err = atomisp_nr(asd, 0, arg);
2742 case ATOMISP_IOC_S_NR:
2743 err = atomisp_nr(asd, 1, arg);
2746 case ATOMISP_IOC_G_TNR:
2747 err = atomisp_tnr(asd, 0, arg);
2750 case ATOMISP_IOC_S_TNR:
2751 err = atomisp_tnr(asd, 1, arg);
2754 case ATOMISP_IOC_G_BLACK_LEVEL_COMP:
2755 err = atomisp_black_level(asd, 0, arg);
2758 case ATOMISP_IOC_S_BLACK_LEVEL_COMP:
2759 err = atomisp_black_level(asd, 1, arg);
2762 case ATOMISP_IOC_G_EE:
2763 err = atomisp_ee(asd, 0, arg);
2766 case ATOMISP_IOC_S_EE:
2767 err = atomisp_ee(asd, 1, arg);
2770 case ATOMISP_IOC_G_DIS_STAT:
2771 err = atomisp_get_dis_stat(asd, arg);
2774 case ATOMISP_IOC_G_DVS2_BQ_RESOLUTIONS:
2775 err = atomisp_get_dvs2_bq_resolutions(asd, arg);
2778 case ATOMISP_IOC_S_DIS_COEFS:
2779 err = atomisp_css_cp_dvs2_coefs(asd, arg,
2780 &asd->params.css_param, true);
2782 asd->params.css_update_params_needed = true;
2785 case ATOMISP_IOC_S_DIS_VECTOR:
2786 err = atomisp_cp_dvs_6axis_config(asd, arg,
2787 &asd->params.css_param, true);
2789 asd->params.css_update_params_needed = true;
2792 case ATOMISP_IOC_G_ISP_PARM:
2793 err = atomisp_param(asd, 0, arg);
2796 case ATOMISP_IOC_S_ISP_PARM:
2797 err = atomisp_param(asd, 1, arg);
2800 case ATOMISP_IOC_G_3A_STAT:
2801 err = atomisp_3a_stat(asd, 0, arg);
2804 case ATOMISP_IOC_G_ISP_GAMMA:
2805 err = atomisp_gamma(asd, 0, arg);
2808 case ATOMISP_IOC_S_ISP_GAMMA:
2809 err = atomisp_gamma(asd, 1, arg);
2812 case ATOMISP_IOC_G_ISP_GDC_TAB:
2813 err = atomisp_gdc_cac_table(asd, 0, arg);
2816 case ATOMISP_IOC_S_ISP_GDC_TAB:
2817 err = atomisp_gdc_cac_table(asd, 1, arg);
2820 case ATOMISP_IOC_G_ISP_MACC:
2821 err = atomisp_macc_table(asd, 0, arg);
2824 case ATOMISP_IOC_S_ISP_MACC:
2825 err = atomisp_macc_table(asd, 1, arg);
2828 case ATOMISP_IOC_G_ISP_BAD_PIXEL_DETECTION:
2829 err = atomisp_bad_pixel_param(asd, 0, arg);
2832 case ATOMISP_IOC_S_ISP_BAD_PIXEL_DETECTION:
2833 err = atomisp_bad_pixel_param(asd, 1, arg);
2836 case ATOMISP_IOC_G_ISP_FALSE_COLOR_CORRECTION:
2837 err = atomisp_false_color_param(asd, 0, arg);
2840 case ATOMISP_IOC_S_ISP_FALSE_COLOR_CORRECTION:
2841 err = atomisp_false_color_param(asd, 1, arg);
2844 case ATOMISP_IOC_G_ISP_CTC:
2845 err = atomisp_ctc(asd, 0, arg);
2848 case ATOMISP_IOC_S_ISP_CTC:
2849 err = atomisp_ctc(asd, 1, arg);
2852 case ATOMISP_IOC_G_ISP_WHITE_BALANCE:
2853 err = atomisp_white_balance_param(asd, 0, arg);
2856 case ATOMISP_IOC_S_ISP_WHITE_BALANCE:
2857 err = atomisp_white_balance_param(asd, 1, arg);
2860 case ATOMISP_IOC_G_3A_CONFIG:
2861 err = atomisp_3a_config_param(asd, 0, arg);
2864 case ATOMISP_IOC_S_3A_CONFIG:
2865 err = atomisp_3a_config_param(asd, 1, arg);
2868 case ATOMISP_IOC_S_ISP_FPN_TABLE:
2869 err = atomisp_fixed_pattern_table(asd, arg);
2872 case ATOMISP_IOC_ISP_MAKERNOTE:
2873 err = atomisp_exif_makernote(asd, arg);
2876 case ATOMISP_IOC_G_SENSOR_MODE_DATA:
2877 err = atomisp_get_sensor_mode_data(asd, arg);
2880 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA:
2882 err = v4l2_subdev_call(motor, core, ioctl, cmd, arg);
2884 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2885 core, ioctl, cmd, arg);
2888 case ATOMISP_IOC_S_EXPOSURE:
2889 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP:
2890 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
2891 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO:
2892 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE:
2893 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE:
2894 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT:
2895 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2896 core, ioctl, cmd, arg);
2898 case ATOMISP_IOC_G_UPDATE_EXPOSURE:
2900 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2901 core, ioctl, cmd, arg);
2906 case ATOMISP_IOC_ACC_LOAD:
2907 err = atomisp_acc_load(asd, arg);
2910 case ATOMISP_IOC_ACC_LOAD_TO_PIPE:
2911 err = atomisp_acc_load_to_pipe(asd, arg);
2914 case ATOMISP_IOC_ACC_UNLOAD:
2915 err = atomisp_acc_unload(asd, arg);
2918 case ATOMISP_IOC_ACC_START:
2919 err = atomisp_acc_start(asd, arg);
2922 case ATOMISP_IOC_ACC_WAIT:
2923 err = atomisp_acc_wait(asd, arg);
2926 case ATOMISP_IOC_ACC_MAP:
2927 err = atomisp_acc_map(asd, arg);
2930 case ATOMISP_IOC_ACC_UNMAP:
2931 err = atomisp_acc_unmap(asd, arg);
2934 case ATOMISP_IOC_ACC_S_MAPPED_ARG:
2935 err = atomisp_acc_s_mapped_arg(asd, arg);
2938 case ATOMISP_IOC_S_ISP_SHD_TAB:
2939 err = atomisp_set_shading_table(asd, arg);
2942 case ATOMISP_IOC_G_ISP_GAMMA_CORRECTION:
2943 err = atomisp_gamma_correction(asd, 0, arg);
2946 case ATOMISP_IOC_S_ISP_GAMMA_CORRECTION:
2947 err = atomisp_gamma_correction(asd, 1, arg);
2950 case ATOMISP_IOC_S_PARAMETERS:
2951 err = atomisp_set_parameters(vdev, arg);
2954 case ATOMISP_IOC_S_CONT_CAPTURE_CONFIG:
2955 err = atomisp_offline_capture_configure(asd, arg);
2957 case ATOMISP_IOC_G_METADATA:
2958 err = atomisp_get_metadata(asd, 0, arg);
2960 case ATOMISP_IOC_G_METADATA_BY_TYPE:
2961 err = atomisp_get_metadata_by_type(asd, 0, arg);
2963 case ATOMISP_IOC_EXT_ISP_CTRL:
2964 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2965 core, ioctl, cmd, arg);
2967 case ATOMISP_IOC_EXP_ID_UNLOCK:
2968 err = atomisp_exp_id_unlock(asd, arg);
2970 case ATOMISP_IOC_EXP_ID_CAPTURE:
2971 err = atomisp_exp_id_capture(asd, arg);
2973 case ATOMISP_IOC_S_ENABLE_DZ_CAPT_PIPE:
2974 err = atomisp_enable_dz_capt_pipe(asd, arg);
2976 case ATOMISP_IOC_G_FORMATS_CONFIG:
2977 err = atomisp_formats(asd, 0, arg);
2980 case ATOMISP_IOC_S_FORMATS_CONFIG:
2981 err = atomisp_formats(asd, 1, arg);
2983 case ATOMISP_IOC_S_EXPOSURE_WINDOW:
2984 err = atomisp_s_ae_window(asd, arg);
2986 case ATOMISP_IOC_S_ACC_STATE:
2987 err = atomisp_acc_set_state(asd, arg);
2989 case ATOMISP_IOC_G_ACC_STATE:
2990 err = atomisp_acc_get_state(asd, arg);
2992 case ATOMISP_IOC_INJECT_A_FAKE_EVENT:
2993 err = atomisp_inject_a_fake_event(asd, arg);
2995 case ATOMISP_IOC_G_INVALID_FRAME_NUM:
2996 err = atomisp_get_invalid_frame_num(vdev, arg);
2998 case ATOMISP_IOC_S_ARRAY_RESOLUTION:
2999 err = atomisp_set_array_res(asd, arg);
3007 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA:
3008 case ATOMISP_IOC_S_EXPOSURE:
3009 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP:
3010 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
3011 case ATOMISP_IOC_EXT_ISP_CTRL:
3012 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO:
3013 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE:
3014 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE:
3015 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT:
3016 case ATOMISP_IOC_G_UPDATE_EXPOSURE:
3019 rt_mutex_unlock(&isp->mutex);
3025 const struct v4l2_ioctl_ops atomisp_ioctl_ops = {
3026 .vidioc_querycap = atomisp_querycap,
3027 .vidioc_enum_input = atomisp_enum_input,
3028 .vidioc_g_input = atomisp_g_input,
3029 .vidioc_s_input = atomisp_s_input,
3030 .vidioc_queryctrl = atomisp_queryctl,
3031 .vidioc_s_ctrl = atomisp_s_ctrl,
3032 .vidioc_g_ctrl = atomisp_g_ctrl,
3033 .vidioc_s_ext_ctrls = atomisp_s_ext_ctrls,
3034 .vidioc_g_ext_ctrls = atomisp_g_ext_ctrls,
3035 .vidioc_enum_fmt_vid_cap = atomisp_enum_fmt_cap,
3036 .vidioc_try_fmt_vid_cap = atomisp_try_fmt_cap,
3037 .vidioc_g_fmt_vid_cap = atomisp_g_fmt_cap,
3038 .vidioc_s_fmt_vid_cap = atomisp_s_fmt_cap,
3039 .vidioc_reqbufs = atomisp_reqbufs,
3040 .vidioc_querybuf = atomisp_querybuf,
3041 .vidioc_qbuf = atomisp_qbuf,
3042 .vidioc_dqbuf = atomisp_dqbuf,
3043 .vidioc_streamon = atomisp_streamon,
3044 .vidioc_streamoff = atomisp_streamoff,
3045 .vidioc_default = atomisp_vidioc_default,
3046 .vidioc_s_parm = atomisp_s_parm,
3047 .vidioc_g_parm = atomisp_g_parm,
3050 const struct v4l2_ioctl_ops atomisp_file_ioctl_ops = {
3051 .vidioc_querycap = atomisp_querycap,
3052 .vidioc_g_fmt_vid_out = atomisp_g_fmt_file,
3053 .vidioc_s_fmt_vid_out = atomisp_s_fmt_file,
3054 .vidioc_s_parm = atomisp_s_parm_file,
3055 .vidioc_reqbufs = atomisp_reqbufs_file,
3056 .vidioc_querybuf = atomisp_querybuf_file,
3057 .vidioc_qbuf = atomisp_qbuf_file,