1 // SPDX-License-Identifier: GPL-2.0
2 /*
3 * Support for Medifield PNW Camera Imaging ISP subsystem.
4 *
5 * Copyright (c) 2010 Intel Corporation. All Rights Reserved.
6 *
7 * Copyright (c) 2010 Silicon Hive www.siliconhive.com.
8 *
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.
12 *
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.
17 *
18 *
19 */
20
21 #include <linux/delay.h>
22 #include <linux/pci.h>
23
24 #include <media/v4l2-ioctl.h>
25 #include <media/v4l2-event.h>
26 #include <media/videobuf-vmalloc.h>
27
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"
36
37 #include "sh_css_hrt.h"
38
39 #include "gp_device.h"
40 #include "device_access.h"
41 #include "irq.h"
42
43 static const char *DRIVER = "atomisp"; /* max size 15 */
44 static const char *CARD = "ATOM ISP"; /* max size 31 */
45
46 /*
47 * FIXME: ISP should not know beforehand all CIDs supported by sensor.
48 * Instead, it needs to propagate to sensor unkonwn CIDs.
49 */
50 static struct v4l2_queryctrl ci_v4l2_controls[] = {
51 {
52 .id = V4L2_CID_AUTO_WHITE_BALANCE,
53 .type = V4L2_CTRL_TYPE_BOOLEAN,
54 .name = "Automatic White Balance",
55 .minimum = 0,
56 .maximum = 1,
57 .step = 1,
58 .default_value = 0,
59 },
60 {
61 .id = V4L2_CID_RED_BALANCE,
62 .type = V4L2_CTRL_TYPE_INTEGER,
63 .name = "Red Balance",
64 .minimum = 0x00,
65 .maximum = 0xff,
66 .step = 1,
67 .default_value = 0x00,
68 },
69 {
70 .id = V4L2_CID_BLUE_BALANCE,
71 .type = V4L2_CTRL_TYPE_INTEGER,
72 .name = "Blue Balance",
73 .minimum = 0x00,
74 .maximum = 0xff,
75 .step = 1,
76 .default_value = 0x00,
77 },
78 {
79 .id = V4L2_CID_GAMMA,
80 .type = V4L2_CTRL_TYPE_INTEGER,
81 .name = "Gamma",
82 .minimum = 0x00,
83 .maximum = 0xff,
84 .step = 1,
85 .default_value = 0x00,
86 },
87 {
88 .id = V4L2_CID_POWER_LINE_FREQUENCY,
89 .type = V4L2_CTRL_TYPE_MENU,
90 .name = "Light frequency filter",
91 .minimum = 1,
92 .maximum = 2,
93 .step = 1,
94 .default_value = 1,
95 },
96 {
97 .id = V4L2_CID_COLORFX,
98 .type = V4L2_CTRL_TYPE_INTEGER,
99 .name = "Image Color Effect",
100 .minimum = 0,
101 .maximum = 9,
102 .step = 1,
103 .default_value = 0,
104 },
105 {
106 .id = V4L2_CID_COLORFX_CBCR,
107 .type = V4L2_CTRL_TYPE_INTEGER,
108 .name = "Image Color Effect CbCr",
109 .minimum = 0,
110 .maximum = 0xffff,
111 .step = 1,
112 .default_value = 0,
113 },
114 {
115 .id = V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION,
116 .type = V4L2_CTRL_TYPE_INTEGER,
117 .name = "Bad Pixel Correction",
118 .minimum = 0,
119 .maximum = 1,
120 .step = 1,
121 .default_value = 0,
122 },
123 {
124 .id = V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC,
125 .type = V4L2_CTRL_TYPE_INTEGER,
126 .name = "GDC/CAC",
127 .minimum = 0,
128 .maximum = 1,
129 .step = 1,
130 .default_value = 0,
131 },
132 {
133 .id = V4L2_CID_ATOMISP_VIDEO_STABLIZATION,
134 .type = V4L2_CTRL_TYPE_INTEGER,
135 .name = "Video Stablization",
136 .minimum = 0,
137 .maximum = 1,
138 .step = 1,
139 .default_value = 0,
140 },
141 {
142 .id = V4L2_CID_ATOMISP_FIXED_PATTERN_NR,
143 .type = V4L2_CTRL_TYPE_INTEGER,
144 .name = "Fixed Pattern Noise Reduction",
145 .minimum = 0,
146 .maximum = 1,
147 .step = 1,
148 .default_value = 0,
149 },
150 {
151 .id = V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION,
152 .type = V4L2_CTRL_TYPE_INTEGER,
153 .name = "False Color Correction",
154 .minimum = 0,
155 .maximum = 1,
156 .step = 1,
157 .default_value = 0,
158 },
159 {
160 .id = V4L2_CID_REQUEST_FLASH,
161 .type = V4L2_CTRL_TYPE_INTEGER,
162 .name = "Request flash frames",
163 .minimum = 0,
164 .maximum = 10,
165 .step = 1,
166 .default_value = 1,
167 },
168 {
169 .id = V4L2_CID_ATOMISP_LOW_LIGHT,
170 .type = V4L2_CTRL_TYPE_BOOLEAN,
171 .name = "Low light mode",
172 .minimum = 0,
173 .maximum = 1,
174 .step = 1,
175 .default_value = 1,
176 },
177 {
178 .id = V4L2_CID_BIN_FACTOR_HORZ,
179 .type = V4L2_CTRL_TYPE_INTEGER,
180 .name = "Horizontal binning factor",
181 .minimum = 0,
182 .maximum = 10,
183 .step = 1,
184 .default_value = 0,
185 },
186 {
187 .id = V4L2_CID_BIN_FACTOR_VERT,
188 .type = V4L2_CTRL_TYPE_INTEGER,
189 .name = "Vertical binning factor",
190 .minimum = 0,
191 .maximum = 10,
192 .step = 1,
193 .default_value = 0,
194 },
195 {
196 .id = V4L2_CID_2A_STATUS,
197 .type = V4L2_CTRL_TYPE_BITMASK,
198 .name = "AE and AWB status",
199 .minimum = 0,
200 .maximum = V4L2_2A_STATUS_AE_READY | V4L2_2A_STATUS_AWB_READY,
201 .step = 1,
202 .default_value = 0,
203 },
204 {
205 .id = V4L2_CID_EXPOSURE,
206 .type = V4L2_CTRL_TYPE_INTEGER,
207 .name = "exposure",
208 .minimum = -4,
209 .maximum = 4,
210 .step = 1,
211 .default_value = 0,
212 },
213 {
214 .id = V4L2_CID_EXPOSURE_ZONE_NUM,
215 .type = V4L2_CTRL_TYPE_INTEGER,
216 .name = "one-time exposure zone number",
217 .minimum = 0x0,
218 .maximum = 0xffff,
219 .step = 1,
220 .default_value = 0,
221 },
222 {
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,
228 .step = 1,
229 .default_value = V4L2_EXPOSURE_AUTO,
230 },
231 {
232 .id = V4L2_CID_SCENE_MODE,
233 .type = V4L2_CTRL_TYPE_INTEGER,
234 .name = "scene mode",
235 .minimum = 0,
236 .maximum = 13,
237 .step = 1,
238 .default_value = 0,
239 },
240 {
241 .id = V4L2_CID_ISO_SENSITIVITY,
242 .type = V4L2_CTRL_TYPE_INTEGER,
243 .name = "iso",
244 .minimum = -4,
245 .maximum = 4,
246 .step = 1,
247 .default_value = 0,
248 },
249 {
250 .id = V4L2_CID_ISO_SENSITIVITY_AUTO,
251 .type = V4L2_CTRL_TYPE_INTEGER,
252 .name = "iso mode",
253 .minimum = V4L2_ISO_SENSITIVITY_MANUAL,
254 .maximum = V4L2_ISO_SENSITIVITY_AUTO,
255 .step = 1,
256 .default_value = V4L2_ISO_SENSITIVITY_AUTO,
257 },
258 {
259 .id = V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
260 .type = V4L2_CTRL_TYPE_INTEGER,
261 .name = "white balance",
262 .minimum = 0,
263 .maximum = 9,
264 .step = 1,
265 .default_value = 0,
266 },
267 {
268 .id = V4L2_CID_EXPOSURE_METERING,
269 .type = V4L2_CTRL_TYPE_MENU,
270 .name = "metering",
271 .minimum = 0,
272 .maximum = 3,
273 .step = 1,
274 .default_value = 1,
275 },
276 {
277 .id = V4L2_CID_3A_LOCK,
278 .type = V4L2_CTRL_TYPE_BITMASK,
279 .name = "3a lock",
280 .minimum = 0,
281 .maximum = V4L2_LOCK_EXPOSURE | V4L2_LOCK_WHITE_BALANCE
282 | V4L2_LOCK_FOCUS,
283 .step = 1,
284 .default_value = 0,
285 },
286 {
287 .id = V4L2_CID_TEST_PATTERN,
288 .type = V4L2_CTRL_TYPE_INTEGER,
289 .name = "Test Pattern",
290 .minimum = 0,
291 .maximum = 0xffff,
292 .step = 1,
293 .default_value = 0,
294 },
295 {
296 .id = V4L2_CID_TEST_PATTERN_COLOR_R,
297 .type = V4L2_CTRL_TYPE_INTEGER,
298 .name = "Test Pattern Solid Color R",
299 .minimum = INT_MIN,
300 .maximum = INT_MAX,
301 .step = 1,
302 .default_value = 0,
303 },
304 {
305 .id = V4L2_CID_TEST_PATTERN_COLOR_GR,
306 .type = V4L2_CTRL_TYPE_INTEGER,
307 .name = "Test Pattern Solid Color GR",
308 .minimum = INT_MIN,
309 .maximum = INT_MAX,
310 .step = 1,
311 .default_value = 0,
312 },
313 {
314 .id = V4L2_CID_TEST_PATTERN_COLOR_GB,
315 .type = V4L2_CTRL_TYPE_INTEGER,
316 .name = "Test Pattern Solid Color GB",
317 .minimum = INT_MIN,
318 .maximum = INT_MAX,
319 .step = 1,
320 .default_value = 0,
321 },
322 {
323 .id = V4L2_CID_TEST_PATTERN_COLOR_B,
324 .type = V4L2_CTRL_TYPE_INTEGER,
325 .name = "Test Pattern Solid Color B",
326 .minimum = INT_MIN,
327 .maximum = INT_MAX,
328 .step = 1,
329 .default_value = 0,
330 },
331 };
332
333 static const u32 ctrls_num = ARRAY_SIZE(ci_v4l2_controls);
334
335 /*
336 * supported V4L2 fmts and resolutions
337 */
338 const struct atomisp_format_bridge atomisp_output_fmts[] = {
339 {
340 .pixelformat = V4L2_PIX_FMT_YUV420,
341 .depth = 12,
342 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV420,
343 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV420,
344 .description = "YUV420, planar",
345 .planar = true
346 }, {
347 .pixelformat = V4L2_PIX_FMT_YVU420,
348 .depth = 12,
349 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YVU420,
350 .sh_fmt = IA_CSS_FRAME_FORMAT_YV12,
351 .description = "YVU420, planar",
352 .planar = true
353 }, {
354 .pixelformat = V4L2_PIX_FMT_YUV422P,
355 .depth = 16,
356 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV422P,
357 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV422,
358 .description = "YUV422, planar",
359 .planar = true
360 }, {
361 .pixelformat = V4L2_PIX_FMT_YUV444,
362 .depth = 24,
363 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV444,
364 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV444,
365 .description = "YUV444"
366 }, {
367 .pixelformat = V4L2_PIX_FMT_NV12,
368 .depth = 12,
369 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV12,
370 .sh_fmt = IA_CSS_FRAME_FORMAT_NV12,
371 .description = "NV12, Y-plane, CbCr interleaved",
372 .planar = true
373 }, {
374 .pixelformat = V4L2_PIX_FMT_NV21,
375 .depth = 12,
376 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV21,
377 .sh_fmt = IA_CSS_FRAME_FORMAT_NV21,
378 .description = "NV21, Y-plane, CbCr interleaved",
379 .planar = true
380 }, {
381 .pixelformat = V4L2_PIX_FMT_NV16,
382 .depth = 16,
383 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV16,
384 .sh_fmt = IA_CSS_FRAME_FORMAT_NV16,
385 .description = "NV16, Y-plane, CbCr interleaved",
386 .planar = true
387 }, {
388 .pixelformat = V4L2_PIX_FMT_YUYV,
389 .depth = 16,
390 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUYV,
391 .sh_fmt = IA_CSS_FRAME_FORMAT_YUYV,
392 .description = "YUYV, interleaved"
393 }, {
394 .pixelformat = V4L2_PIX_FMT_UYVY,
395 .depth = 16,
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,
401 .depth = 16,
402 .mbus_code = MEDIA_BUS_FMT_UYVY8_2X8,
403 .sh_fmt = IA_CSS_FRAME_FORMAT_UYVY,
404 .description = "UYVY, interleaved"
405 }, {
406 .pixelformat = V4L2_PIX_FMT_SBGGR16,
407 .depth = 16,
408 .mbus_code = V4L2_MBUS_FMT_CUSTOM_SBGGR16,
409 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
410 .description = "Bayer 16"
411 }, {
412 .pixelformat = V4L2_PIX_FMT_SBGGR8,
413 .depth = 8,
414 .mbus_code = MEDIA_BUS_FMT_SBGGR8_1X8,
415 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
416 .description = "Bayer 8"
417 }, {
418 .pixelformat = V4L2_PIX_FMT_SGBRG8,
419 .depth = 8,
420 .mbus_code = MEDIA_BUS_FMT_SGBRG8_1X8,
421 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
422 .description = "Bayer 8"
423 }, {
424 .pixelformat = V4L2_PIX_FMT_SGRBG8,
425 .depth = 8,
426 .mbus_code = MEDIA_BUS_FMT_SGRBG8_1X8,
427 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
428 .description = "Bayer 8"
429 }, {
430 .pixelformat = V4L2_PIX_FMT_SRGGB8,
431 .depth = 8,
432 .mbus_code = MEDIA_BUS_FMT_SRGGB8_1X8,
433 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
434 .description = "Bayer 8"
435 }, {
436 .pixelformat = V4L2_PIX_FMT_SBGGR10,
437 .depth = 16,
438 .mbus_code = MEDIA_BUS_FMT_SBGGR10_1X10,
439 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
440 .description = "Bayer 10"
441 }, {
442 .pixelformat = V4L2_PIX_FMT_SGBRG10,
443 .depth = 16,
444 .mbus_code = MEDIA_BUS_FMT_SGBRG10_1X10,
445 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
446 .description = "Bayer 10"
447 }, {
448 .pixelformat = V4L2_PIX_FMT_SGRBG10,
449 .depth = 16,
450 .mbus_code = MEDIA_BUS_FMT_SGRBG10_1X10,
451 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
452 .description = "Bayer 10"
453 }, {
454 .pixelformat = V4L2_PIX_FMT_SRGGB10,
455 .depth = 16,
456 .mbus_code = MEDIA_BUS_FMT_SRGGB10_1X10,
457 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
458 .description = "Bayer 10"
459 }, {
460 .pixelformat = V4L2_PIX_FMT_SBGGR12,
461 .depth = 16,
462 .mbus_code = MEDIA_BUS_FMT_SBGGR12_1X12,
463 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
464 .description = "Bayer 12"
465 }, {
466 .pixelformat = V4L2_PIX_FMT_SGBRG12,
467 .depth = 16,
468 .mbus_code = MEDIA_BUS_FMT_SGBRG12_1X12,
469 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
470 .description = "Bayer 12"
471 }, {
472 .pixelformat = V4L2_PIX_FMT_SGRBG12,
473 .depth = 16,
474 .mbus_code = MEDIA_BUS_FMT_SGRBG12_1X12,
475 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
476 .description = "Bayer 12"
477 }, {
478 .pixelformat = V4L2_PIX_FMT_SRGGB12,
479 .depth = 16,
480 .mbus_code = MEDIA_BUS_FMT_SRGGB12_1X12,
481 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
482 .description = "Bayer 12"
483 }, {
484 .pixelformat = V4L2_PIX_FMT_RGB32,
485 .depth = 32,
486 .mbus_code = V4L2_MBUS_FMT_CUSTOM_RGB32,
487 .sh_fmt = IA_CSS_FRAME_FORMAT_RGBA888,
488 .description = "32 RGB 8-8-8-8"
489 }, {
490 .pixelformat = V4L2_PIX_FMT_RGB565,
491 .depth = 16,
492 .mbus_code = MEDIA_BUS_FMT_BGR565_2X8_LE,
493 .sh_fmt = IA_CSS_FRAME_FORMAT_RGB565,
494 .description = "16 RGB 5-6-5"
495 }, {
496 .pixelformat = V4L2_PIX_FMT_JPEG,
497 .depth = 8,
498 .mbus_code = MEDIA_BUS_FMT_JPEG_1X8,
499 .sh_fmt = IA_CSS_FRAME_FORMAT_BINARY_8,
500 .description = "JPEG"
501 },
502 #if 0
503 {
504 /* This is a custom format being used by M10MO to send the RAW data */
505 .pixelformat = V4L2_PIX_FMT_CUSTOM_M10MO_RAW,
506 .depth = 8,
507 .mbus_code = V4L2_MBUS_FMT_CUSTOM_M10MO_RAW,
508 .sh_fmt = IA_CSS_FRAME_FORMAT_BINARY_8,
509 .description = "Custom RAW for M10MO"
510 },
511 #endif
512 };
513
514 const struct atomisp_format_bridge *
atomisp_get_format_bridge(unsigned int pixelformat)515 atomisp_get_format_bridge(unsigned int pixelformat)
516 {
517 unsigned int i;
518
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];
522 }
523
524 return NULL;
525 }
526
527 const struct atomisp_format_bridge *
atomisp_get_format_bridge_from_mbus(u32 mbus_code)528 atomisp_get_format_bridge_from_mbus(u32 mbus_code)
529 {
530 unsigned int i;
531
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];
535 }
536
537 return NULL;
538 }
539
540 /*
541 * v4l2 ioctls
542 * return ISP capabilities
543 */
atomisp_querycap(struct file * file,void * fh,struct v4l2_capability * cap)544 static int atomisp_querycap(struct file *file, void *fh,
545 struct v4l2_capability *cap)
546 {
547 struct video_device *vdev = video_devdata(file);
548 struct atomisp_device *isp = video_get_drvdata(vdev);
549
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", dev_name(isp->dev));
553
554 return 0;
555 }
556
557 /*
558 * enum input are used to check primary/secondary camera
559 */
atomisp_enum_input(struct file * file,void * fh,struct v4l2_input * input)560 static int atomisp_enum_input(struct file *file, void *fh,
561 struct v4l2_input *input)
562 {
563 struct video_device *vdev = video_devdata(file);
564 struct atomisp_device *isp = video_get_drvdata(vdev);
565 int index = input->index;
566 struct v4l2_subdev *motor;
567
568 if (index >= isp->input_cnt)
569 return -EINVAL;
570
571 if (!isp->inputs[index].camera)
572 return -EINVAL;
573
574 memset(input, 0, sizeof(struct v4l2_input));
575 strscpy(input->name, isp->inputs[index].camera->name,
576 sizeof(input->name));
577
578 /*
579 * HACK: append actuator's name to sensor's
580 * As currently userspace can't talk directly to subdev nodes, this
581 * ioctl is the only way to enum inputs + possible external actuators
582 * for 3A tuning purpose.
583 */
584 if (!IS_ISP2401)
585 motor = isp->inputs[index].motor;
586 else
587 motor = isp->motor;
588
589 if (motor && strlen(motor->name) > 0) {
590 const int cur_len = strlen(input->name);
591 const int max_size = sizeof(input->name) - cur_len - 1;
592
593 if (max_size > 1) {
594 input->name[cur_len] = '+';
595 strscpy(&input->name[cur_len + 1],
596 motor->name, max_size);
597 }
598 }
599
600 input->type = V4L2_INPUT_TYPE_CAMERA;
601 input->index = index;
602 input->reserved[0] = isp->inputs[index].type;
603 input->reserved[1] = isp->inputs[index].port;
604
605 return 0;
606 }
607
608 static unsigned int
atomisp_subdev_streaming_count(struct atomisp_sub_device * asd)609 atomisp_subdev_streaming_count(struct atomisp_sub_device *asd)
610 {
611 return asd->video_out_preview.capq.streaming
612 + asd->video_out_capture.capq.streaming
613 + asd->video_out_video_capture.capq.streaming
614 + asd->video_out_vf.capq.streaming
615 + asd->video_in.capq.streaming;
616 }
617
atomisp_streaming_count(struct atomisp_device * isp)618 unsigned int atomisp_streaming_count(struct atomisp_device *isp)
619 {
620 unsigned int i, sum;
621
622 for (i = 0, sum = 0; i < isp->num_of_streams; i++)
623 sum += isp->asd[i].streaming ==
624 ATOMISP_DEVICE_STREAMING_ENABLED;
625
626 return sum;
627 }
628
atomisp_is_acc_enabled(struct atomisp_device * isp)629 unsigned int atomisp_is_acc_enabled(struct atomisp_device *isp)
630 {
631 unsigned int i;
632
633 for (i = 0; i < isp->num_of_streams; i++)
634 if (isp->asd[i].acc.pipeline)
635 return 1;
636
637 return 0;
638 }
639
640 /*
641 * get input are used to get current primary/secondary camera
642 */
atomisp_g_input(struct file * file,void * fh,unsigned int * input)643 static int atomisp_g_input(struct file *file, void *fh, unsigned int *input)
644 {
645 struct video_device *vdev = video_devdata(file);
646 struct atomisp_device *isp = video_get_drvdata(vdev);
647 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
648
649 rt_mutex_lock(&isp->mutex);
650 *input = asd->input_curr;
651 rt_mutex_unlock(&isp->mutex);
652
653 return 0;
654 }
655
656 /*
657 * set input are used to set current primary/secondary camera
658 */
atomisp_s_input(struct file * file,void * fh,unsigned int input)659 static int atomisp_s_input(struct file *file, void *fh, unsigned int input)
660 {
661 struct video_device *vdev = video_devdata(file);
662 struct atomisp_device *isp = video_get_drvdata(vdev);
663 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
664 struct v4l2_subdev *camera = NULL;
665 struct v4l2_subdev *motor;
666 int ret;
667
668 rt_mutex_lock(&isp->mutex);
669 if (input >= ATOM_ISP_MAX_INPUTS || input >= isp->input_cnt) {
670 dev_dbg(isp->dev, "input_cnt: %d\n", isp->input_cnt);
671 ret = -EINVAL;
672 goto error;
673 }
674
675 /*
676 * check whether the request camera:
677 * 1: already in use
678 * 2: if in use, whether it is used by other streams
679 */
680 if (isp->inputs[input].asd && isp->inputs[input].asd != asd) {
681 dev_err(isp->dev,
682 "%s, camera is already used by stream: %d\n", __func__,
683 isp->inputs[input].asd->index);
684 ret = -EBUSY;
685 goto error;
686 }
687
688 camera = isp->inputs[input].camera;
689 if (!camera) {
690 dev_err(isp->dev, "%s, no camera\n", __func__);
691 ret = -EINVAL;
692 goto error;
693 }
694
695 if (atomisp_subdev_streaming_count(asd)) {
696 dev_err(isp->dev,
697 "ISP is still streaming, stop first\n");
698 ret = -EINVAL;
699 goto error;
700 }
701
702 /* power off the current owned sensor, as it is not used this time */
703 if (isp->inputs[asd->input_curr].asd == asd &&
704 asd->input_curr != input) {
705 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
706 core, s_power, 0);
707 if (ret)
708 dev_warn(isp->dev,
709 "Failed to power-off sensor\n");
710 /* clear the asd field to show this camera is not used */
711 isp->inputs[asd->input_curr].asd = NULL;
712 }
713
714 /* powe on the new sensor */
715 ret = v4l2_subdev_call(isp->inputs[input].camera, core, s_power, 1);
716 if (ret) {
717 dev_err(isp->dev, "Failed to power-on sensor\n");
718 goto error;
719 }
720 /*
721 * Some sensor driver resets the run mode during power-on, thus force
722 * update the run mode to sensor after power-on.
723 */
724 atomisp_update_run_mode(asd);
725
726 /* select operating sensor */
727 ret = v4l2_subdev_call(isp->inputs[input].camera, video, s_routing,
728 0, isp->inputs[input].sensor_index, 0);
729 if (ret && (ret != -ENOIOCTLCMD)) {
730 dev_err(isp->dev, "Failed to select sensor\n");
731 goto error;
732 }
733
734 if (!IS_ISP2401) {
735 motor = isp->inputs[input].motor;
736 } else {
737 motor = isp->motor;
738 if (motor)
739 ret = v4l2_subdev_call(motor, core, s_power, 1);
740 }
741
742 if (!isp->sw_contex.file_input && motor)
743 ret = v4l2_subdev_call(motor, core, init, 1);
744
745 asd->input_curr = input;
746 /* mark this camera is used by the current stream */
747 isp->inputs[input].asd = asd;
748 rt_mutex_unlock(&isp->mutex);
749
750 return 0;
751
752 error:
753 rt_mutex_unlock(&isp->mutex);
754
755 return ret;
756 }
757
atomisp_enum_fmt_cap(struct file * file,void * fh,struct v4l2_fmtdesc * f)758 static int atomisp_enum_fmt_cap(struct file *file, void *fh,
759 struct v4l2_fmtdesc *f)
760 {
761 struct video_device *vdev = video_devdata(file);
762 struct atomisp_device *isp = video_get_drvdata(vdev);
763 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
764 struct v4l2_subdev_mbus_code_enum code = { 0 };
765 unsigned int i, fi = 0;
766 int rval;
767
768 rt_mutex_lock(&isp->mutex);
769 rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, pad,
770 enum_mbus_code, NULL, &code);
771 if (rval == -ENOIOCTLCMD) {
772 dev_warn(isp->dev,
773 "enum_mbus_code pad op not supported. Please fix your sensor driver!\n");
774 // rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
775 // video, enum_mbus_fmt, 0, &code.code);
776 }
777 rt_mutex_unlock(&isp->mutex);
778
779 if (rval)
780 return rval;
781
782 for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
783 const struct atomisp_format_bridge *format =
784 &atomisp_output_fmts[i];
785
786 /*
787 * Is the atomisp-supported format is valid for the
788 * sensor (configuration)? If not, skip it.
789 */
790 if (format->sh_fmt == IA_CSS_FRAME_FORMAT_RAW
791 && format->mbus_code != code.code)
792 continue;
793
794 /* Found a match. Now let's pick f->index'th one. */
795 if (fi < f->index) {
796 fi++;
797 continue;
798 }
799
800 strscpy(f->description, format->description,
801 sizeof(f->description));
802 f->pixelformat = format->pixelformat;
803 return 0;
804 }
805
806 return -EINVAL;
807 }
808
atomisp_g_fmt_cap(struct file * file,void * fh,struct v4l2_format * f)809 static int atomisp_g_fmt_cap(struct file *file, void *fh,
810 struct v4l2_format *f)
811 {
812 struct video_device *vdev = video_devdata(file);
813 struct atomisp_device *isp = video_get_drvdata(vdev);
814
815 int ret;
816
817 rt_mutex_lock(&isp->mutex);
818 ret = atomisp_get_fmt(vdev, f);
819 rt_mutex_unlock(&isp->mutex);
820 return ret;
821 }
822
atomisp_g_fmt_file(struct file * file,void * fh,struct v4l2_format * f)823 static int atomisp_g_fmt_file(struct file *file, void *fh,
824 struct v4l2_format *f)
825 {
826 struct video_device *vdev = video_devdata(file);
827 struct atomisp_device *isp = video_get_drvdata(vdev);
828 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
829
830 rt_mutex_lock(&isp->mutex);
831 f->fmt.pix = pipe->pix;
832 rt_mutex_unlock(&isp->mutex);
833
834 return 0;
835 }
836
837 /* This function looks up the closest available resolution. */
atomisp_try_fmt_cap(struct file * file,void * fh,struct v4l2_format * f)838 static int atomisp_try_fmt_cap(struct file *file, void *fh,
839 struct v4l2_format *f)
840 {
841 struct video_device *vdev = video_devdata(file);
842 struct atomisp_device *isp = video_get_drvdata(vdev);
843 int ret;
844
845 rt_mutex_lock(&isp->mutex);
846 ret = atomisp_try_fmt(vdev, f, NULL);
847 rt_mutex_unlock(&isp->mutex);
848 return ret;
849 }
850
atomisp_s_fmt_cap(struct file * file,void * fh,struct v4l2_format * f)851 static int atomisp_s_fmt_cap(struct file *file, void *fh,
852 struct v4l2_format *f)
853 {
854 struct video_device *vdev = video_devdata(file);
855 struct atomisp_device *isp = video_get_drvdata(vdev);
856 int ret;
857
858 rt_mutex_lock(&isp->mutex);
859 if (isp->isp_fatal_error) {
860 ret = -EIO;
861 rt_mutex_unlock(&isp->mutex);
862 return ret;
863 }
864 ret = atomisp_set_fmt(vdev, f);
865 rt_mutex_unlock(&isp->mutex);
866 return ret;
867 }
868
atomisp_s_fmt_file(struct file * file,void * fh,struct v4l2_format * f)869 static int atomisp_s_fmt_file(struct file *file, void *fh,
870 struct v4l2_format *f)
871 {
872 struct video_device *vdev = video_devdata(file);
873 struct atomisp_device *isp = video_get_drvdata(vdev);
874 int ret;
875
876 rt_mutex_lock(&isp->mutex);
877 ret = atomisp_set_fmt_file(vdev, f);
878 rt_mutex_unlock(&isp->mutex);
879 return ret;
880 }
881
882 /*
883 * Free videobuffer buffer priv data
884 */
atomisp_videobuf_free_buf(struct videobuf_buffer * vb)885 void atomisp_videobuf_free_buf(struct videobuf_buffer *vb)
886 {
887 struct videobuf_vmalloc_memory *vm_mem;
888
889 if (!vb)
890 return;
891
892 vm_mem = vb->priv;
893 if (vm_mem && vm_mem->vaddr) {
894 ia_css_frame_free(vm_mem->vaddr);
895 vm_mem->vaddr = NULL;
896 }
897 }
898
899 /*
900 * this function is used to free video buffer queue
901 */
atomisp_videobuf_free_queue(struct videobuf_queue * q)902 static void atomisp_videobuf_free_queue(struct videobuf_queue *q)
903 {
904 int i;
905
906 for (i = 0; i < VIDEO_MAX_FRAME; i++) {
907 atomisp_videobuf_free_buf(q->bufs[i]);
908 kfree(q->bufs[i]);
909 q->bufs[i] = NULL;
910 }
911 }
912
atomisp_alloc_css_stat_bufs(struct atomisp_sub_device * asd,uint16_t stream_id)913 int atomisp_alloc_css_stat_bufs(struct atomisp_sub_device *asd,
914 uint16_t stream_id)
915 {
916 struct atomisp_device *isp = asd->isp;
917 struct atomisp_s3a_buf *s3a_buf = NULL, *_s3a_buf;
918 struct atomisp_dis_buf *dis_buf = NULL, *_dis_buf;
919 struct atomisp_metadata_buf *md_buf = NULL, *_md_buf;
920 int count;
921 struct ia_css_dvs_grid_info *dvs_grid_info =
922 atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info);
923 unsigned int i;
924
925 if (list_empty(&asd->s3a_stats) &&
926 asd->params.curr_grid_info.s3a_grid.enable) {
927 count = ATOMISP_CSS_Q_DEPTH +
928 ATOMISP_S3A_BUF_QUEUE_DEPTH_FOR_HAL;
929 dev_dbg(isp->dev, "allocating %d 3a buffers\n", count);
930 while (count--) {
931 s3a_buf = kzalloc(sizeof(struct atomisp_s3a_buf), GFP_KERNEL);
932 if (!s3a_buf)
933 goto error;
934
935 if (atomisp_css_allocate_stat_buffers(
936 asd, stream_id, s3a_buf, NULL, NULL)) {
937 kfree(s3a_buf);
938 goto error;
939 }
940
941 list_add_tail(&s3a_buf->list, &asd->s3a_stats);
942 }
943 }
944
945 if (list_empty(&asd->dis_stats) && dvs_grid_info &&
946 dvs_grid_info->enable) {
947 count = ATOMISP_CSS_Q_DEPTH + 1;
948 dev_dbg(isp->dev, "allocating %d dis buffers\n", count);
949 while (count--) {
950 dis_buf = kzalloc(sizeof(struct atomisp_dis_buf), GFP_KERNEL);
951 if (!dis_buf) {
952 kfree(s3a_buf);
953 goto error;
954 }
955 if (atomisp_css_allocate_stat_buffers(
956 asd, stream_id, NULL, dis_buf, NULL)) {
957 kfree(dis_buf);
958 goto error;
959 }
960
961 list_add_tail(&dis_buf->list, &asd->dis_stats);
962 }
963 }
964
965 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
966 if (list_empty(&asd->metadata[i]) &&
967 list_empty(&asd->metadata_ready[i]) &&
968 list_empty(&asd->metadata_in_css[i])) {
969 count = ATOMISP_CSS_Q_DEPTH +
970 ATOMISP_METADATA_QUEUE_DEPTH_FOR_HAL;
971 dev_dbg(isp->dev, "allocating %d metadata buffers for type %d\n",
972 count, i);
973 while (count--) {
974 md_buf = kzalloc(sizeof(struct atomisp_metadata_buf),
975 GFP_KERNEL);
976 if (!md_buf)
977 goto error;
978
979 if (atomisp_css_allocate_stat_buffers(
980 asd, stream_id, NULL, NULL, md_buf)) {
981 kfree(md_buf);
982 goto error;
983 }
984 list_add_tail(&md_buf->list, &asd->metadata[i]);
985 }
986 }
987 }
988 return 0;
989
990 error:
991 dev_err(isp->dev, "failed to allocate statistics buffers\n");
992
993 list_for_each_entry_safe(dis_buf, _dis_buf, &asd->dis_stats, list) {
994 atomisp_css_free_dis_buffer(dis_buf);
995 list_del(&dis_buf->list);
996 kfree(dis_buf);
997 }
998
999 list_for_each_entry_safe(s3a_buf, _s3a_buf, &asd->s3a_stats, list) {
1000 atomisp_css_free_3a_buffer(s3a_buf);
1001 list_del(&s3a_buf->list);
1002 kfree(s3a_buf);
1003 }
1004
1005 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
1006 list_for_each_entry_safe(md_buf, _md_buf, &asd->metadata[i],
1007 list) {
1008 atomisp_css_free_metadata_buffer(md_buf);
1009 list_del(&md_buf->list);
1010 kfree(md_buf);
1011 }
1012 }
1013 return -ENOMEM;
1014 }
1015
1016 /*
1017 * Initiate Memory Mapping or User Pointer I/O
1018 */
__atomisp_reqbufs(struct file * file,void * fh,struct v4l2_requestbuffers * req)1019 int __atomisp_reqbufs(struct file *file, void *fh,
1020 struct v4l2_requestbuffers *req)
1021 {
1022 struct video_device *vdev = video_devdata(file);
1023 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1024 struct atomisp_sub_device *asd = pipe->asd;
1025 struct ia_css_frame_info frame_info;
1026 struct ia_css_frame *frame;
1027 struct videobuf_vmalloc_memory *vm_mem;
1028 u16 source_pad = atomisp_subdev_source_pad(vdev);
1029 u16 stream_id = atomisp_source_pad_to_stream_id(asd, source_pad);
1030 int ret = 0, i = 0;
1031
1032 if (req->count == 0) {
1033 mutex_lock(&pipe->capq.vb_lock);
1034 if (!list_empty(&pipe->capq.stream))
1035 videobuf_queue_cancel(&pipe->capq);
1036
1037 atomisp_videobuf_free_queue(&pipe->capq);
1038 mutex_unlock(&pipe->capq.vb_lock);
1039 /* clear request config id */
1040 memset(pipe->frame_request_config_id, 0,
1041 VIDEO_MAX_FRAME * sizeof(unsigned int));
1042 memset(pipe->frame_params, 0,
1043 VIDEO_MAX_FRAME *
1044 sizeof(struct atomisp_css_params_with_list *));
1045 return 0;
1046 }
1047
1048 ret = videobuf_reqbufs(&pipe->capq, req);
1049 if (ret)
1050 return ret;
1051
1052 atomisp_alloc_css_stat_bufs(asd, stream_id);
1053
1054 /*
1055 * for user pointer type, buffers are not really allocated here,
1056 * buffers are setup in QBUF operation through v4l2_buffer structure
1057 */
1058 if (req->memory == V4L2_MEMORY_USERPTR)
1059 return 0;
1060
1061 ret = atomisp_get_css_frame_info(asd, source_pad, &frame_info);
1062 if (ret)
1063 return ret;
1064
1065 /*
1066 * Allocate the real frame here for selected node using our
1067 * memory management function
1068 */
1069 for (i = 0; i < req->count; i++) {
1070 if (ia_css_frame_allocate_from_info(&frame, &frame_info))
1071 goto error;
1072 vm_mem = pipe->capq.bufs[i]->priv;
1073 vm_mem->vaddr = frame;
1074 }
1075
1076 return ret;
1077
1078 error:
1079 while (i--) {
1080 vm_mem = pipe->capq.bufs[i]->priv;
1081 ia_css_frame_free(vm_mem->vaddr);
1082 }
1083
1084 if (asd->vf_frame)
1085 ia_css_frame_free(asd->vf_frame);
1086
1087 return -ENOMEM;
1088 }
1089
atomisp_reqbufs(struct file * file,void * fh,struct v4l2_requestbuffers * req)1090 int atomisp_reqbufs(struct file *file, void *fh,
1091 struct v4l2_requestbuffers *req)
1092 {
1093 struct video_device *vdev = video_devdata(file);
1094 struct atomisp_device *isp = video_get_drvdata(vdev);
1095 int ret;
1096
1097 rt_mutex_lock(&isp->mutex);
1098 ret = __atomisp_reqbufs(file, fh, req);
1099 rt_mutex_unlock(&isp->mutex);
1100
1101 return ret;
1102 }
1103
atomisp_reqbufs_file(struct file * file,void * fh,struct v4l2_requestbuffers * req)1104 static int atomisp_reqbufs_file(struct file *file, void *fh,
1105 struct v4l2_requestbuffers *req)
1106 {
1107 struct video_device *vdev = video_devdata(file);
1108 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1109
1110 if (req->count == 0) {
1111 mutex_lock(&pipe->outq.vb_lock);
1112 atomisp_videobuf_free_queue(&pipe->outq);
1113 mutex_unlock(&pipe->outq.vb_lock);
1114 return 0;
1115 }
1116
1117 return videobuf_reqbufs(&pipe->outq, req);
1118 }
1119
1120 /* application query the status of a buffer */
atomisp_querybuf(struct file * file,void * fh,struct v4l2_buffer * buf)1121 static int atomisp_querybuf(struct file *file, void *fh,
1122 struct v4l2_buffer *buf)
1123 {
1124 struct video_device *vdev = video_devdata(file);
1125 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1126
1127 return videobuf_querybuf(&pipe->capq, buf);
1128 }
1129
atomisp_querybuf_file(struct file * file,void * fh,struct v4l2_buffer * buf)1130 static int atomisp_querybuf_file(struct file *file, void *fh,
1131 struct v4l2_buffer *buf)
1132 {
1133 struct video_device *vdev = video_devdata(file);
1134 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1135
1136 return videobuf_querybuf(&pipe->outq, buf);
1137 }
1138
1139 /*
1140 * Applications call the VIDIOC_QBUF ioctl to enqueue an empty (capturing) or
1141 * filled (output) buffer in the drivers incoming queue.
1142 */
atomisp_qbuf(struct file * file,void * fh,struct v4l2_buffer * buf)1143 static int atomisp_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1144 {
1145 static const int NOFLUSH_FLAGS = V4L2_BUF_FLAG_NO_CACHE_INVALIDATE |
1146 V4L2_BUF_FLAG_NO_CACHE_CLEAN;
1147 struct video_device *vdev = video_devdata(file);
1148 struct atomisp_device *isp = video_get_drvdata(vdev);
1149 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1150 struct atomisp_sub_device *asd = pipe->asd;
1151 struct videobuf_buffer *vb;
1152 struct videobuf_vmalloc_memory *vm_mem;
1153 struct ia_css_frame_info frame_info;
1154 struct ia_css_frame *handle = NULL;
1155 u32 length;
1156 u32 pgnr;
1157 int ret = 0;
1158
1159 rt_mutex_lock(&isp->mutex);
1160 if (isp->isp_fatal_error) {
1161 ret = -EIO;
1162 goto error;
1163 }
1164
1165 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) {
1166 dev_err(isp->dev, "%s: reject, as ISP at stopping.\n",
1167 __func__);
1168 ret = -EIO;
1169 goto error;
1170 }
1171
1172 if (!buf || buf->index >= VIDEO_MAX_FRAME ||
1173 !pipe->capq.bufs[buf->index]) {
1174 dev_err(isp->dev, "Invalid index for qbuf.\n");
1175 ret = -EINVAL;
1176 goto error;
1177 }
1178
1179 /*
1180 * For userptr type frame, we convert user space address to physic
1181 * address and reprograme out page table properly
1182 */
1183 if (buf->memory == V4L2_MEMORY_USERPTR) {
1184 vb = pipe->capq.bufs[buf->index];
1185 vm_mem = vb->priv;
1186 if (!vm_mem) {
1187 ret = -EINVAL;
1188 goto error;
1189 }
1190
1191 length = vb->bsize;
1192 pgnr = (length + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1193
1194 if (vb->baddr == buf->m.userptr && vm_mem->vaddr)
1195 goto done;
1196
1197 if (atomisp_get_css_frame_info(asd,
1198 atomisp_subdev_source_pad(vdev), &frame_info)) {
1199 ret = -EIO;
1200 goto error;
1201 }
1202
1203 ret = ia_css_frame_map(&handle, &frame_info,
1204 (void __user *)buf->m.userptr,
1205 0, pgnr);
1206 if (ret) {
1207 dev_err(isp->dev, "Failed to map user buffer\n");
1208 goto error;
1209 }
1210
1211 if (vm_mem->vaddr) {
1212 mutex_lock(&pipe->capq.vb_lock);
1213 ia_css_frame_free(vm_mem->vaddr);
1214 vm_mem->vaddr = NULL;
1215 vb->state = VIDEOBUF_NEEDS_INIT;
1216 mutex_unlock(&pipe->capq.vb_lock);
1217 }
1218
1219 vm_mem->vaddr = handle;
1220
1221 buf->flags &= ~V4L2_BUF_FLAG_MAPPED;
1222 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1223 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1224 } else if (buf->memory == V4L2_MEMORY_MMAP) {
1225 buf->flags |= V4L2_BUF_FLAG_MAPPED;
1226 buf->flags |= V4L2_BUF_FLAG_QUEUED;
1227 buf->flags &= ~V4L2_BUF_FLAG_DONE;
1228
1229 /*
1230 * For mmap, frames were allocated at request buffers
1231 */
1232 }
1233
1234 done:
1235 if (!((buf->flags & NOFLUSH_FLAGS) == NOFLUSH_FLAGS))
1236 wbinvd();
1237
1238 if (!atomisp_is_vf_pipe(pipe) &&
1239 (buf->reserved2 & ATOMISP_BUFFER_HAS_PER_FRAME_SETTING)) {
1240 /* this buffer will have a per-frame parameter */
1241 pipe->frame_request_config_id[buf->index] = buf->reserved2 &
1242 ~ATOMISP_BUFFER_HAS_PER_FRAME_SETTING;
1243 dev_dbg(isp->dev,
1244 "This buffer requires per_frame setting which has isp_config_id %d\n",
1245 pipe->frame_request_config_id[buf->index]);
1246 } else {
1247 pipe->frame_request_config_id[buf->index] = 0;
1248 }
1249
1250 pipe->frame_params[buf->index] = NULL;
1251
1252 rt_mutex_unlock(&isp->mutex);
1253
1254 ret = videobuf_qbuf(&pipe->capq, buf);
1255 rt_mutex_lock(&isp->mutex);
1256 if (ret)
1257 goto error;
1258
1259 /* TODO: do this better, not best way to queue to css */
1260 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) {
1261 if (!list_empty(&pipe->buffers_waiting_for_param)) {
1262 atomisp_handle_parameter_and_buffer(pipe);
1263 } else {
1264 atomisp_qbuffers_to_css(asd);
1265
1266 if (!IS_ISP2401) {
1267 if (!atomisp_is_wdt_running(asd) && atomisp_buffers_queued(asd))
1268 atomisp_wdt_start(asd);
1269 } else {
1270 if (!atomisp_is_wdt_running(pipe) &&
1271 atomisp_buffers_queued_pipe(pipe))
1272 atomisp_wdt_start_pipe(pipe);
1273 }
1274 }
1275 }
1276
1277 /*
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 */
1286 if (asd->continuous_mode->val &&
1287 atomisp_subdev_source_pad(vdev)
1288 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE &&
1289 pipe->capq.streaming &&
1290 !asd->enable_raw_buffer_lock->val &&
1291 asd->params.offline_parm.num_captures == 1) {
1292 if (!IS_ISP2401) {
1293 asd->pending_capture_request++;
1294 dev_dbg(isp->dev, "Add one pending capture request.\n");
1295 } else {
1296 if (asd->re_trigger_capture) {
1297 ret = atomisp_css_offline_capture_configure(asd,
1298 asd->params.offline_parm.num_captures,
1299 asd->params.offline_parm.skip_frames,
1300 asd->params.offline_parm.offset);
1301 asd->re_trigger_capture = false;
1302 dev_dbg(isp->dev, "%s Trigger capture again ret=%d\n",
1303 __func__, ret);
1304
1305 } else {
1306 asd->pending_capture_request++;
1307 asd->re_trigger_capture = false;
1308 dev_dbg(isp->dev, "Add one pending capture request.\n");
1309 }
1310 }
1311 }
1312 rt_mutex_unlock(&isp->mutex);
1313
1314 dev_dbg(isp->dev, "qbuf buffer %d (%s) for asd%d\n", buf->index,
1315 vdev->name, asd->index);
1316
1317 return ret;
1318
1319 error:
1320 rt_mutex_unlock(&isp->mutex);
1321 return ret;
1322 }
1323
atomisp_qbuf_file(struct file * file,void * fh,struct v4l2_buffer * buf)1324 static int atomisp_qbuf_file(struct file *file, void *fh,
1325 struct v4l2_buffer *buf)
1326 {
1327 struct video_device *vdev = video_devdata(file);
1328 struct atomisp_device *isp = video_get_drvdata(vdev);
1329 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1330 int ret;
1331
1332 rt_mutex_lock(&isp->mutex);
1333 if (isp->isp_fatal_error) {
1334 ret = -EIO;
1335 goto error;
1336 }
1337
1338 if (!buf || buf->index >= VIDEO_MAX_FRAME ||
1339 !pipe->outq.bufs[buf->index]) {
1340 dev_err(isp->dev, "Invalid index for qbuf.\n");
1341 ret = -EINVAL;
1342 goto error;
1343 }
1344
1345 if (buf->memory != V4L2_MEMORY_MMAP) {
1346 dev_err(isp->dev, "Unsupported memory method\n");
1347 ret = -EINVAL;
1348 goto error;
1349 }
1350
1351 if (buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
1352 dev_err(isp->dev, "Unsupported buffer type\n");
1353 ret = -EINVAL;
1354 goto error;
1355 }
1356 rt_mutex_unlock(&isp->mutex);
1357
1358 return videobuf_qbuf(&pipe->outq, buf);
1359
1360 error:
1361 rt_mutex_unlock(&isp->mutex);
1362
1363 return ret;
1364 }
1365
__get_frame_exp_id(struct atomisp_video_pipe * pipe,struct v4l2_buffer * buf)1366 static int __get_frame_exp_id(struct atomisp_video_pipe *pipe,
1367 struct v4l2_buffer *buf)
1368 {
1369 struct videobuf_vmalloc_memory *vm_mem;
1370 struct ia_css_frame *handle;
1371 int i;
1372
1373 for (i = 0; pipe->capq.bufs[i]; i++) {
1374 vm_mem = pipe->capq.bufs[i]->priv;
1375 handle = vm_mem->vaddr;
1376 if (buf->index == pipe->capq.bufs[i]->i && handle)
1377 return handle->exp_id;
1378 }
1379 return -EINVAL;
1380 }
1381
1382 /*
1383 * Applications call the VIDIOC_DQBUF ioctl to dequeue a filled (capturing) or
1384 * displayed (output buffer)from the driver's outgoing queue
1385 */
atomisp_dqbuf(struct file * file,void * fh,struct v4l2_buffer * buf)1386 static int atomisp_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf)
1387 {
1388 struct video_device *vdev = video_devdata(file);
1389 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1390 struct atomisp_sub_device *asd = pipe->asd;
1391 struct atomisp_device *isp = video_get_drvdata(vdev);
1392 int ret = 0;
1393
1394 rt_mutex_lock(&isp->mutex);
1395
1396 if (isp->isp_fatal_error) {
1397 rt_mutex_unlock(&isp->mutex);
1398 return -EIO;
1399 }
1400
1401 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) {
1402 rt_mutex_unlock(&isp->mutex);
1403 dev_err(isp->dev, "%s: reject, as ISP at stopping.\n",
1404 __func__);
1405 return -EIO;
1406 }
1407
1408 rt_mutex_unlock(&isp->mutex);
1409
1410 ret = videobuf_dqbuf(&pipe->capq, buf, file->f_flags & O_NONBLOCK);
1411 if (ret) {
1412 if (ret != -EAGAIN)
1413 dev_dbg(isp->dev, "<%s: %d\n", __func__, ret);
1414 return ret;
1415 }
1416 rt_mutex_lock(&isp->mutex);
1417 buf->bytesused = pipe->pix.sizeimage;
1418 buf->reserved = asd->frame_status[buf->index];
1419
1420 /*
1421 * Hack:
1422 * Currently frame_status in the enum type which takes no more lower
1423 * 8 bit.
1424 * use bit[31:16] for exp_id as it is only in the range of 1~255
1425 */
1426 buf->reserved &= 0x0000ffff;
1427 if (!(buf->flags & V4L2_BUF_FLAG_ERROR))
1428 buf->reserved |= __get_frame_exp_id(pipe, buf) << 16;
1429 buf->reserved2 = pipe->frame_config_id[buf->index];
1430 rt_mutex_unlock(&isp->mutex);
1431
1432 dev_dbg(isp->dev,
1433 "dqbuf buffer %d (%s) for asd%d with exp_id %d, isp_config_id %d\n",
1434 buf->index, vdev->name, asd->index, buf->reserved >> 16,
1435 buf->reserved2);
1436 return 0;
1437 }
1438
atomisp_get_css_pipe_id(struct atomisp_sub_device * asd)1439 enum ia_css_pipe_id atomisp_get_css_pipe_id(struct atomisp_sub_device *asd)
1440 {
1441 if (ATOMISP_USE_YUVPP(asd))
1442 return IA_CSS_PIPE_ID_YUVPP;
1443
1444 if (asd->continuous_mode->val) {
1445 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
1446 return IA_CSS_PIPE_ID_VIDEO;
1447 else
1448 return IA_CSS_PIPE_ID_PREVIEW;
1449 }
1450
1451 /*
1452 * Disable vf_pp and run CSS in video mode. This allows using ISP
1453 * scaling but it has one frame delay due to CSS internal buffering.
1454 */
1455 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER)
1456 return IA_CSS_PIPE_ID_VIDEO;
1457
1458 /*
1459 * Disable vf_pp and run CSS in still capture mode. In this mode
1460 * CSS does not cause extra latency with buffering, but scaling
1461 * is not available.
1462 */
1463 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT)
1464 return IA_CSS_PIPE_ID_CAPTURE;
1465
1466 switch (asd->run_mode->val) {
1467 case ATOMISP_RUN_MODE_PREVIEW:
1468 return IA_CSS_PIPE_ID_PREVIEW;
1469 case ATOMISP_RUN_MODE_VIDEO:
1470 return IA_CSS_PIPE_ID_VIDEO;
1471 case ATOMISP_RUN_MODE_STILL_CAPTURE:
1472 default:
1473 return IA_CSS_PIPE_ID_CAPTURE;
1474 }
1475 }
1476
atomisp_sensor_start_stream(struct atomisp_sub_device * asd)1477 static unsigned int atomisp_sensor_start_stream(struct atomisp_sub_device *asd)
1478 {
1479 struct atomisp_device *isp = asd->isp;
1480
1481 if (isp->inputs[asd->input_curr].camera_caps->
1482 sensor[asd->sensor_curr].stream_num > 1) {
1483 if (asd->high_speed_mode)
1484 return 1;
1485 else
1486 return 2;
1487 }
1488
1489 if (asd->vfpp->val != ATOMISP_VFPP_ENABLE ||
1490 asd->copy_mode)
1491 return 1;
1492
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(
1496 asd->fmt[
1497 asd->capture_pad].fmt.code) &&
1498 !asd->continuous_mode->val))
1499 return 2;
1500 else
1501 return 1;
1502 }
1503
atomisp_stream_on_master_slave_sensor(struct atomisp_device * isp,bool isp_timeout)1504 int atomisp_stream_on_master_slave_sensor(struct atomisp_device *isp,
1505 bool isp_timeout)
1506 {
1507 unsigned int master = -1, slave = -1, delay_slave = 0;
1508 int i, ret;
1509
1510 /*
1511 * ISP only support 2 streams now so ignore multiple master/slave
1512 * case to reduce the delay between 2 stream_on calls.
1513 */
1514 for (i = 0; i < isp->num_of_streams; i++) {
1515 int sensor_index = isp->asd[i].input_curr;
1516
1517 if (isp->inputs[sensor_index].camera_caps->
1518 sensor[isp->asd[i].sensor_curr].is_slave)
1519 slave = sensor_index;
1520 else
1521 master = sensor_index;
1522 }
1523
1524 if (master == -1 || slave == -1) {
1525 master = ATOMISP_DEPTH_DEFAULT_MASTER_SENSOR;
1526 slave = ATOMISP_DEPTH_DEFAULT_SLAVE_SENSOR;
1527 dev_warn(isp->dev,
1528 "depth mode use default master=%s.slave=%s.\n",
1529 isp->inputs[master].camera->name,
1530 isp->inputs[slave].camera->name);
1531 }
1532
1533 ret = v4l2_subdev_call(isp->inputs[master].camera, core,
1534 ioctl, ATOMISP_IOC_G_DEPTH_SYNC_COMP,
1535 &delay_slave);
1536 if (ret)
1537 dev_warn(isp->dev,
1538 "get depth sensor %s compensation delay failed.\n",
1539 isp->inputs[master].camera->name);
1540
1541 ret = v4l2_subdev_call(isp->inputs[master].camera,
1542 video, s_stream, 1);
1543 if (ret) {
1544 dev_err(isp->dev, "depth mode master sensor %s stream-on failed.\n",
1545 isp->inputs[master].camera->name);
1546 return -EINVAL;
1547 }
1548
1549 if (delay_slave != 0)
1550 udelay(delay_slave);
1551
1552 ret = v4l2_subdev_call(isp->inputs[slave].camera,
1553 video, s_stream, 1);
1554 if (ret) {
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);
1558
1559 return -EINVAL;
1560 }
1561
1562 return 0;
1563 }
1564
1565 /* FIXME! ISP2400 */
__wdt_on_master_slave_sensor(struct atomisp_device * isp,unsigned int wdt_duration)1566 static void __wdt_on_master_slave_sensor(struct atomisp_device *isp,
1567 unsigned int wdt_duration)
1568 {
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);
1573 }
1574
1575 /* FIXME! ISP2401 */
__wdt_on_master_slave_sensor_pipe(struct atomisp_video_pipe * pipe,unsigned int wdt_duration,bool enable)1576 static void __wdt_on_master_slave_sensor_pipe(struct atomisp_video_pipe *pipe,
1577 unsigned int wdt_duration,
1578 bool enable)
1579 {
1580 static struct atomisp_video_pipe *pipe0;
1581
1582 if (enable) {
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);
1587 } else {
1588 pipe0 = pipe;
1589 }
1590 }
1591
atomisp_pause_buffer_event(struct atomisp_device * isp)1592 static void atomisp_pause_buffer_event(struct atomisp_device *isp)
1593 {
1594 struct v4l2_event event = {0};
1595 int i;
1596
1597 event.type = V4L2_EVENT_ATOMISP_PAUSE_BUFFER;
1598
1599 for (i = 0; i < isp->num_of_streams; i++) {
1600 int sensor_index = isp->asd[i].input_curr;
1601
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);
1605 break;
1606 }
1607 }
1608 }
1609
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. */
atomisp_dma_burst_len_cfg(struct atomisp_sub_device * asd)1614 static void atomisp_dma_burst_len_cfg(struct atomisp_sub_device *asd)
1615 {
1616 struct v4l2_mbus_framefmt *sink;
1617
1618 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
1619 V4L2_SUBDEV_FORMAT_ACTIVE,
1620 ATOMISP_SUBDEV_PAD_SINK);
1621
1622 if (sink->width * sink->height >= 4096 * 3072)
1623 atomisp_css2_hw_store_32(DMA_BURST_SIZE_REG, 0x7F);
1624 else
1625 atomisp_css2_hw_store_32(DMA_BURST_SIZE_REG, 0x00);
1626 }
1627
1628 /*
1629 * This ioctl start the capture during streaming I/O.
1630 */
atomisp_streamon(struct file * file,void * fh,enum v4l2_buf_type type)1631 static int atomisp_streamon(struct file *file, void *fh,
1632 enum v4l2_buf_type type)
1633 {
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 struct pci_dev *pdev = to_pci_dev(isp->dev);
1639 enum ia_css_pipe_id css_pipe_id;
1640 unsigned int sensor_start_stream;
1641 unsigned int wdt_duration = ATOMISP_ISP_TIMEOUT_DURATION;
1642 int ret = 0;
1643 unsigned long irqflags;
1644
1645 dev_dbg(isp->dev, "Start stream on pad %d for asd%d\n",
1646 atomisp_subdev_source_pad(vdev), asd->index);
1647
1648 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1649 dev_dbg(isp->dev, "unsupported v4l2 buf type\n");
1650 return -EINVAL;
1651 }
1652
1653 rt_mutex_lock(&isp->mutex);
1654 if (isp->isp_fatal_error) {
1655 ret = -EIO;
1656 goto out;
1657 }
1658
1659 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) {
1660 ret = -EBUSY;
1661 goto out;
1662 }
1663
1664 if (pipe->capq.streaming)
1665 goto out;
1666
1667 /* Input system HW workaround */
1668 atomisp_dma_burst_len_cfg(asd);
1669
1670 /*
1671 * The number of streaming video nodes is based on which
1672 * binary is going to be run.
1673 */
1674 sensor_start_stream = atomisp_sensor_start_stream(asd);
1675
1676 spin_lock_irqsave(&pipe->irq_lock, irqflags);
1677 if (list_empty(&pipe->capq.stream)) {
1678 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
1679 dev_dbg(isp->dev, "no buffer in the queue\n");
1680 ret = -EINVAL;
1681 goto out;
1682 }
1683 spin_unlock_irqrestore(&pipe->irq_lock, irqflags);
1684
1685 ret = videobuf_streamon(&pipe->capq);
1686 if (ret)
1687 goto out;
1688
1689 /* Reset pending capture request count. */
1690 asd->pending_capture_request = 0;
1691 if (IS_ISP2401)
1692 asd->re_trigger_capture = false;
1693
1694 if ((atomisp_subdev_streaming_count(asd) > sensor_start_stream) &&
1695 (!isp->inputs[asd->input_curr].camera_caps->multi_stream_ctrl)) {
1696 /* trigger still capture */
1697 if (asd->continuous_mode->val &&
1698 atomisp_subdev_source_pad(vdev)
1699 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE) {
1700 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO)
1701 dev_dbg(isp->dev, "SDV last video raw buffer id: %u\n",
1702 asd->latest_preview_exp_id);
1703 else
1704 dev_dbg(isp->dev, "ZSL last preview raw buffer id: %u\n",
1705 asd->latest_preview_exp_id);
1706
1707 if (asd->delayed_init == ATOMISP_DELAYED_INIT_QUEUED) {
1708 flush_work(&asd->delayed_init_work);
1709 rt_mutex_unlock(&isp->mutex);
1710 if (wait_for_completion_interruptible(
1711 &asd->init_done) != 0)
1712 return -ERESTARTSYS;
1713 rt_mutex_lock(&isp->mutex);
1714 }
1715
1716 /* handle per_frame_setting parameter and buffers */
1717 atomisp_handle_parameter_and_buffer(pipe);
1718
1719 /*
1720 * only ZSL/SDV capture request will be here, raise
1721 * the ISP freq to the highest possible to minimize
1722 * the S2S latency.
1723 */
1724 atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, false);
1725 /*
1726 * When asd->enable_raw_buffer_lock->val is true,
1727 * An extra IOCTL is needed to call
1728 * atomisp_css_exp_id_capture and trigger real capture
1729 */
1730 if (!asd->enable_raw_buffer_lock->val) {
1731 ret = atomisp_css_offline_capture_configure(asd,
1732 asd->params.offline_parm.num_captures,
1733 asd->params.offline_parm.skip_frames,
1734 asd->params.offline_parm.offset);
1735 if (ret) {
1736 ret = -EINVAL;
1737 goto out;
1738 }
1739 if (asd->depth_mode->val)
1740 atomisp_pause_buffer_event(isp);
1741 }
1742 }
1743 atomisp_qbuffers_to_css(asd);
1744 goto out;
1745 }
1746
1747 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) {
1748 atomisp_qbuffers_to_css(asd);
1749 goto start_sensor;
1750 }
1751
1752 css_pipe_id = atomisp_get_css_pipe_id(asd);
1753
1754 ret = atomisp_acc_load_extensions(asd);
1755 if (ret < 0) {
1756 dev_err(isp->dev, "acc extension failed to load\n");
1757 goto out;
1758 }
1759
1760 if (asd->params.css_update_params_needed) {
1761 atomisp_apply_css_parameters(asd, &asd->params.css_param);
1762 if (asd->params.css_param.update_flag.dz_config)
1763 asd->params.config.dz_config = &asd->params.css_param.dz_config;
1764 atomisp_css_update_isp_params(asd);
1765 asd->params.css_update_params_needed = false;
1766 memset(&asd->params.css_param.update_flag, 0,
1767 sizeof(struct atomisp_parameters));
1768 }
1769 asd->params.dvs_6axis = NULL;
1770
1771 ret = atomisp_css_start(asd, css_pipe_id, false);
1772 if (ret)
1773 goto out;
1774
1775 asd->streaming = ATOMISP_DEVICE_STREAMING_ENABLED;
1776 atomic_set(&asd->sof_count, -1);
1777 atomic_set(&asd->sequence, -1);
1778 atomic_set(&asd->sequence_temp, -1);
1779 if (isp->sw_contex.file_input)
1780 wdt_duration = ATOMISP_ISP_FILE_TIMEOUT_DURATION;
1781
1782 asd->params.dis_proj_data_valid = false;
1783 asd->latest_preview_exp_id = 0;
1784 asd->postview_exp_id = 1;
1785 asd->preview_exp_id = 1;
1786
1787 /* handle per_frame_setting parameter and buffers */
1788 atomisp_handle_parameter_and_buffer(pipe);
1789
1790 atomisp_qbuffers_to_css(asd);
1791
1792 /* Only start sensor when the last streaming instance started */
1793 if (atomisp_subdev_streaming_count(asd) < sensor_start_stream)
1794 goto out;
1795
1796 start_sensor:
1797 if (isp->flash) {
1798 asd->params.num_flash_frames = 0;
1799 asd->params.flash_state = ATOMISP_FLASH_IDLE;
1800 atomisp_setup_flash(asd);
1801 }
1802
1803 if (!isp->sw_contex.file_input) {
1804 atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
1805 atomisp_css_valid_sof(isp));
1806 atomisp_csi2_configure(asd);
1807 /*
1808 * set freq to max when streaming count > 1 which indicate
1809 * dual camera would run
1810 */
1811 if (atomisp_streaming_count(isp) > 1) {
1812 if (atomisp_freq_scaling(isp,
1813 ATOMISP_DFS_MODE_MAX, false) < 0)
1814 dev_dbg(isp->dev, "DFS max mode failed!\n");
1815 } else {
1816 if (atomisp_freq_scaling(isp,
1817 ATOMISP_DFS_MODE_AUTO, false) < 0)
1818 dev_dbg(isp->dev, "DFS auto mode failed!\n");
1819 }
1820 } else {
1821 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, false) < 0)
1822 dev_dbg(isp->dev, "DFS max mode failed!\n");
1823 }
1824
1825 if (asd->depth_mode->val && atomisp_streaming_count(isp) ==
1826 ATOMISP_DEPTH_SENSOR_STREAMON_COUNT) {
1827 ret = atomisp_stream_on_master_slave_sensor(isp, false);
1828 if (ret) {
1829 dev_err(isp->dev, "master slave sensor stream on failed!\n");
1830 goto out;
1831 }
1832 if (!IS_ISP2401)
1833 __wdt_on_master_slave_sensor(isp, wdt_duration);
1834 else
1835 __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)) {
1839 if (IS_ISP2401)
1840 __wdt_on_master_slave_sensor_pipe(pipe, wdt_duration, false);
1841 goto start_delay_wq;
1842 }
1843
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(pdev, MRFLD_PCI_CSI_CONTROL,
1848 isp->saved_regs.csi_control | MRFLD_PCI_CSI_CONTROL_CSI_READY);
1849 }
1850
1851 /* stream on the sensor */
1852 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1853 video, s_stream, 1);
1854 if (ret) {
1855 asd->streaming = ATOMISP_DEVICE_STREAMING_DISABLED;
1856 ret = -EINVAL;
1857 goto out;
1858 }
1859
1860 if (!IS_ISP2401) {
1861 if (atomisp_buffers_queued(asd))
1862 atomisp_wdt_refresh(asd, wdt_duration);
1863 } else {
1864 if (atomisp_buffers_queued_pipe(pipe))
1865 atomisp_wdt_refresh_pipe(pipe, wdt_duration);
1866 }
1867
1868 start_delay_wq:
1869 if (asd->continuous_mode->val) {
1870 struct v4l2_mbus_framefmt *sink;
1871
1872 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
1873 V4L2_SUBDEV_FORMAT_ACTIVE,
1874 ATOMISP_SUBDEV_PAD_SINK);
1875
1876 reinit_completion(&asd->init_done);
1877 asd->delayed_init = ATOMISP_DELAYED_INIT_QUEUED;
1878 queue_work(asd->delayed_init_workq, &asd->delayed_init_work);
1879 atomisp_css_set_cont_prev_start_time(isp,
1880 ATOMISP_CALC_CSS_PREV_OVERLAP(sink->height));
1881 } else {
1882 asd->delayed_init = ATOMISP_DELAYED_INIT_NOT_QUEUED;
1883 }
1884 out:
1885 rt_mutex_unlock(&isp->mutex);
1886 return ret;
1887 }
1888
__atomisp_streamoff(struct file * file,void * fh,enum v4l2_buf_type type)1889 int __atomisp_streamoff(struct file *file, void *fh, enum v4l2_buf_type type)
1890 {
1891 struct video_device *vdev = video_devdata(file);
1892 struct atomisp_device *isp = video_get_drvdata(vdev);
1893 struct pci_dev *pdev = to_pci_dev(isp->dev);
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;
1902 int ret;
1903 unsigned long flags;
1904 bool first_streamoff = false;
1905
1906 dev_dbg(isp->dev, "Stop stream on pad %d for asd%d\n",
1907 atomisp_subdev_source_pad(vdev), asd->index);
1908
1909 BUG_ON(!rt_mutex_is_locked(&isp->mutex));
1910 BUG_ON(!mutex_is_locked(&isp->streamoff_mutex));
1911
1912 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1913 dev_dbg(isp->dev, "unsupported v4l2 buf type\n");
1914 return -EINVAL;
1915 }
1916
1917 /*
1918 * do only videobuf_streamoff for capture & vf pipes in
1919 * case of continuous capture
1920 */
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,
1935 0, 0, 0);
1936 atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_AUTO, false);
1937 }
1938 /*
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.
1945 */
1946 if (pipe->buffers_in_css != 0) {
1947 WARN(1, "%s: buffers of vdev %s still in CSS!\n",
1948 __func__, pipe->vdev.name);
1949
1950 /*
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.
1955 *
1956 * No way to flush buffers but to reset the whole css
1957 */
1958 dev_warn(isp->dev, "Reset CSS to clean up css buffers.\n");
1959 atomisp_css_flush(isp);
1960 }
1961
1962 return videobuf_streamoff(&pipe->capq);
1963 }
1964
1965 if (!pipe->capq.streaming)
1966 return 0;
1967
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;
1972 }
1973 spin_unlock_irqrestore(&isp->lock, flags);
1974
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);
1979
1980 /*
1981 * must stop sending pixels into GP_FIFO before stop
1982 * the pipeline.
1983 */
1984 if (isp->sw_contex.file_input)
1985 v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1986 video, s_stream, 0);
1987
1988 rt_mutex_lock(&isp->mutex);
1989 atomisp_acc_unload_extensions(asd);
1990 }
1991
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);
1996
1997 if (!first_streamoff) {
1998 ret = videobuf_streamoff(&pipe->capq);
1999 if (ret)
2000 return ret;
2001 goto stopsensor;
2002 }
2003
2004 atomisp_clear_css_buffer_counters(asd);
2005
2006 if (!isp->sw_contex.file_input)
2007 atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
2008 false);
2009
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;
2013 }
2014 if (first_streamoff) {
2015 css_pipe_id = atomisp_get_css_pipe_id(asd);
2016 ret = atomisp_css_stop(asd, css_pipe_id, false);
2017 }
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);
2022 }
2023 if (asd->video_out_vf.users) {
2024 vf_pipe = &asd->video_out_vf;
2025 wake_up_interruptible(&vf_pipe->capq.wait);
2026 }
2027 if (asd->video_out_preview.users) {
2028 preview_pipe = &asd->video_out_preview;
2029 wake_up_interruptible(&preview_pipe->capq.wait);
2030 }
2031 if (asd->video_out_video_capture.users) {
2032 video_pipe = &asd->video_out_video_capture;
2033 wake_up_interruptible(&video_pipe->capq.wait);
2034 }
2035 ret = videobuf_streamoff(&pipe->capq);
2036 if (ret)
2037 return ret;
2038
2039 /* cleanup css here */
2040 /* no need for this, as ISP will be reset anyway */
2041 /*atomisp_flush_bufs_in_css(isp);*/
2042
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);
2047 }
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;
2052 }
2053 spin_unlock_irqrestore(&pipe->irq_lock, flags);
2054
2055 atomisp_subdev_cleanup_pending_events(asd);
2056 stopsensor:
2057 if (atomisp_subdev_streaming_count(asd) + 1
2058 != atomisp_sensor_start_stream(asd))
2059 return 0;
2060
2061 if (!isp->sw_contex.file_input)
2062 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2063 video, s_stream, 0);
2064
2065 if (isp->flash) {
2066 asd->params.num_flash_frames = 0;
2067 asd->params.flash_state = ATOMISP_FLASH_IDLE;
2068 }
2069
2070 /* if other streams are running, isp should not be powered off */
2071 if (atomisp_streaming_count(isp)) {
2072 atomisp_css_flush(isp);
2073 return 0;
2074 }
2075
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(pdev, MRFLD_PCI_CSI_CONTROL,
2080 isp->saved_regs.csi_control & ~MRFLD_PCI_CSI_CONTROL_CSI_READY);
2081 }
2082
2083 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_LOW, false))
2084 dev_warn(isp->dev, "DFS failed.\n");
2085 /*
2086 * ISP work around, need to reset isp
2087 * Is it correct time to reset ISP when first node does streamoff?
2088 */
2089 if (isp->sw_contex.power_state == ATOM_ISP_POWER_UP) {
2090 unsigned int i;
2091 bool recreate_streams[MAX_STREAM_NUM] = {0};
2092
2093 if (isp->isp_timeout)
2094 dev_err(isp->dev, "%s: Resetting with WA activated",
2095 __func__);
2096 /*
2097 * It is possible that the other asd stream is in the stage
2098 * that v4l2_setfmt is just get called on it, which will
2099 * create css stream on that stream. But at this point, there
2100 * is no way to destroy the css stream created on that stream.
2101 *
2102 * So force stream destroy here.
2103 */
2104 for (i = 0; i < isp->num_of_streams; i++) {
2105 if (isp->asd[i].stream_prepared) {
2106 atomisp_destroy_pipes_stream_force(&isp->
2107 asd[i]);
2108 recreate_streams[i] = true;
2109 }
2110 }
2111
2112 /* disable PUNIT/ISP acknowlede/handshake - SRSE=3 */
2113 pci_write_config_dword(pdev, PCI_I_CONTROL,
2114 isp->saved_regs.i_control | MRFLD_PCI_I_CONTROL_SRSE_RESET_MASK);
2115 dev_err(isp->dev, "atomisp_reset");
2116 atomisp_reset(isp);
2117 for (i = 0; i < isp->num_of_streams; i++) {
2118 if (recreate_streams[i])
2119 atomisp_create_pipes_stream(&isp->asd[i]);
2120 }
2121 isp->isp_timeout = false;
2122 }
2123 return ret;
2124 }
2125
atomisp_streamoff(struct file * file,void * fh,enum v4l2_buf_type type)2126 static int atomisp_streamoff(struct file *file, void *fh,
2127 enum v4l2_buf_type type)
2128 {
2129 struct video_device *vdev = video_devdata(file);
2130 struct atomisp_device *isp = video_get_drvdata(vdev);
2131 int rval;
2132
2133 mutex_lock(&isp->streamoff_mutex);
2134 rt_mutex_lock(&isp->mutex);
2135 rval = __atomisp_streamoff(file, fh, type);
2136 rt_mutex_unlock(&isp->mutex);
2137 mutex_unlock(&isp->streamoff_mutex);
2138
2139 return rval;
2140 }
2141
2142 /*
2143 * To get the current value of a control.
2144 * applications initialize the id field of a struct v4l2_control and
2145 * call this ioctl with a pointer to this structure
2146 */
atomisp_g_ctrl(struct file * file,void * fh,struct v4l2_control * control)2147 static int atomisp_g_ctrl(struct file *file, void *fh,
2148 struct v4l2_control *control)
2149 {
2150 struct video_device *vdev = video_devdata(file);
2151 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2152 struct atomisp_device *isp = video_get_drvdata(vdev);
2153 int i, ret = -EINVAL;
2154
2155 for (i = 0; i < ctrls_num; i++) {
2156 if (ci_v4l2_controls[i].id == control->id) {
2157 ret = 0;
2158 break;
2159 }
2160 }
2161
2162 if (ret)
2163 return ret;
2164
2165 rt_mutex_lock(&isp->mutex);
2166
2167 switch (control->id) {
2168 case V4L2_CID_IRIS_ABSOLUTE:
2169 case V4L2_CID_EXPOSURE_ABSOLUTE:
2170 case V4L2_CID_FNUMBER_ABSOLUTE:
2171 case V4L2_CID_2A_STATUS:
2172 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
2173 case V4L2_CID_EXPOSURE:
2174 case V4L2_CID_EXPOSURE_AUTO:
2175 case V4L2_CID_SCENE_MODE:
2176 case V4L2_CID_ISO_SENSITIVITY:
2177 case V4L2_CID_ISO_SENSITIVITY_AUTO:
2178 case V4L2_CID_CONTRAST:
2179 case V4L2_CID_SATURATION:
2180 case V4L2_CID_SHARPNESS:
2181 case V4L2_CID_3A_LOCK:
2182 case V4L2_CID_EXPOSURE_ZONE_NUM:
2183 case V4L2_CID_TEST_PATTERN:
2184 case V4L2_CID_TEST_PATTERN_COLOR_R:
2185 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2186 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2187 case V4L2_CID_TEST_PATTERN_COLOR_B:
2188 rt_mutex_unlock(&isp->mutex);
2189 return v4l2_g_ctrl(isp->inputs[asd->input_curr].camera->
2190 ctrl_handler, control);
2191 case V4L2_CID_COLORFX:
2192 ret = atomisp_color_effect(asd, 0, &control->value);
2193 break;
2194 case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION:
2195 ret = atomisp_bad_pixel(asd, 0, &control->value);
2196 break;
2197 case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC:
2198 ret = atomisp_gdc_cac(asd, 0, &control->value);
2199 break;
2200 case V4L2_CID_ATOMISP_VIDEO_STABLIZATION:
2201 ret = atomisp_video_stable(asd, 0, &control->value);
2202 break;
2203 case V4L2_CID_ATOMISP_FIXED_PATTERN_NR:
2204 ret = atomisp_fixed_pattern(asd, 0, &control->value);
2205 break;
2206 case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION:
2207 ret = atomisp_false_color(asd, 0, &control->value);
2208 break;
2209 case V4L2_CID_ATOMISP_LOW_LIGHT:
2210 ret = atomisp_low_light(asd, 0, &control->value);
2211 break;
2212 default:
2213 ret = -EINVAL;
2214 break;
2215 }
2216
2217 rt_mutex_unlock(&isp->mutex);
2218 return ret;
2219 }
2220
2221 /*
2222 * To change the value of a control.
2223 * applications initialize the id and value fields of a struct v4l2_control
2224 * and call this ioctl.
2225 */
atomisp_s_ctrl(struct file * file,void * fh,struct v4l2_control * control)2226 static int atomisp_s_ctrl(struct file *file, void *fh,
2227 struct v4l2_control *control)
2228 {
2229 struct video_device *vdev = video_devdata(file);
2230 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2231 struct atomisp_device *isp = video_get_drvdata(vdev);
2232 int i, ret = -EINVAL;
2233
2234 for (i = 0; i < ctrls_num; i++) {
2235 if (ci_v4l2_controls[i].id == control->id) {
2236 ret = 0;
2237 break;
2238 }
2239 }
2240
2241 if (ret)
2242 return ret;
2243
2244 rt_mutex_lock(&isp->mutex);
2245 switch (control->id) {
2246 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
2247 case V4L2_CID_EXPOSURE:
2248 case V4L2_CID_EXPOSURE_AUTO:
2249 case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
2250 case V4L2_CID_SCENE_MODE:
2251 case V4L2_CID_ISO_SENSITIVITY:
2252 case V4L2_CID_ISO_SENSITIVITY_AUTO:
2253 case V4L2_CID_POWER_LINE_FREQUENCY:
2254 case V4L2_CID_EXPOSURE_METERING:
2255 case V4L2_CID_CONTRAST:
2256 case V4L2_CID_SATURATION:
2257 case V4L2_CID_SHARPNESS:
2258 case V4L2_CID_3A_LOCK:
2259 case V4L2_CID_COLORFX_CBCR:
2260 case V4L2_CID_TEST_PATTERN:
2261 case V4L2_CID_TEST_PATTERN_COLOR_R:
2262 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2263 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2264 case V4L2_CID_TEST_PATTERN_COLOR_B:
2265 rt_mutex_unlock(&isp->mutex);
2266 return v4l2_s_ctrl(NULL,
2267 isp->inputs[asd->input_curr].camera->
2268 ctrl_handler, control);
2269 case V4L2_CID_COLORFX:
2270 ret = atomisp_color_effect(asd, 1, &control->value);
2271 break;
2272 case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION:
2273 ret = atomisp_bad_pixel(asd, 1, &control->value);
2274 break;
2275 case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC:
2276 ret = atomisp_gdc_cac(asd, 1, &control->value);
2277 break;
2278 case V4L2_CID_ATOMISP_VIDEO_STABLIZATION:
2279 ret = atomisp_video_stable(asd, 1, &control->value);
2280 break;
2281 case V4L2_CID_ATOMISP_FIXED_PATTERN_NR:
2282 ret = atomisp_fixed_pattern(asd, 1, &control->value);
2283 break;
2284 case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION:
2285 ret = atomisp_false_color(asd, 1, &control->value);
2286 break;
2287 case V4L2_CID_REQUEST_FLASH:
2288 ret = atomisp_flash_enable(asd, control->value);
2289 break;
2290 case V4L2_CID_ATOMISP_LOW_LIGHT:
2291 ret = atomisp_low_light(asd, 1, &control->value);
2292 break;
2293 default:
2294 ret = -EINVAL;
2295 break;
2296 }
2297 rt_mutex_unlock(&isp->mutex);
2298 return ret;
2299 }
2300
2301 /*
2302 * To query the attributes of a control.
2303 * applications set the id field of a struct v4l2_queryctrl and call the
2304 * this ioctl with a pointer to this structure. The driver fills
2305 * the rest of the structure.
2306 */
atomisp_queryctl(struct file * file,void * fh,struct v4l2_queryctrl * qc)2307 static int atomisp_queryctl(struct file *file, void *fh,
2308 struct v4l2_queryctrl *qc)
2309 {
2310 int i, ret = -EINVAL;
2311 struct video_device *vdev = video_devdata(file);
2312 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2313 struct atomisp_device *isp = video_get_drvdata(vdev);
2314
2315 switch (qc->id) {
2316 case V4L2_CID_FOCUS_ABSOLUTE:
2317 case V4L2_CID_FOCUS_RELATIVE:
2318 case V4L2_CID_FOCUS_STATUS:
2319 if (!IS_ISP2401) {
2320 return v4l2_queryctrl(isp->inputs[asd->input_curr].camera->
2321 ctrl_handler, qc);
2322 }
2323 /* ISP2401 */
2324 if (isp->motor)
2325 return v4l2_queryctrl(isp->motor->ctrl_handler, qc);
2326 else
2327 return v4l2_queryctrl(isp->inputs[asd->input_curr].
2328 camera->ctrl_handler, qc);
2329 }
2330
2331 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
2332 return ret;
2333
2334 for (i = 0; i < ctrls_num; i++) {
2335 if (ci_v4l2_controls[i].id == qc->id) {
2336 memcpy(qc, &ci_v4l2_controls[i],
2337 sizeof(struct v4l2_queryctrl));
2338 qc->reserved[0] = 0;
2339 ret = 0;
2340 break;
2341 }
2342 }
2343 if (ret != 0)
2344 qc->flags = V4L2_CTRL_FLAG_DISABLED;
2345
2346 return ret;
2347 }
2348
atomisp_camera_g_ext_ctrls(struct file * file,void * fh,struct v4l2_ext_controls * c)2349 static int atomisp_camera_g_ext_ctrls(struct file *file, void *fh,
2350 struct v4l2_ext_controls *c)
2351 {
2352 struct video_device *vdev = video_devdata(file);
2353 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2354 struct atomisp_device *isp = video_get_drvdata(vdev);
2355 struct v4l2_subdev *motor;
2356 struct v4l2_control ctrl;
2357 int i;
2358 int ret = 0;
2359
2360 if (!IS_ISP2401)
2361 motor = isp->inputs[asd->input_curr].motor;
2362 else
2363 motor = isp->motor;
2364
2365 for (i = 0; i < c->count; i++) {
2366 ctrl.id = c->controls[i].id;
2367 ctrl.value = c->controls[i].value;
2368 switch (ctrl.id) {
2369 case V4L2_CID_EXPOSURE_ABSOLUTE:
2370 case V4L2_CID_EXPOSURE_AUTO:
2371 case V4L2_CID_IRIS_ABSOLUTE:
2372 case V4L2_CID_FNUMBER_ABSOLUTE:
2373 case V4L2_CID_BIN_FACTOR_HORZ:
2374 case V4L2_CID_BIN_FACTOR_VERT:
2375 case V4L2_CID_3A_LOCK:
2376 case V4L2_CID_TEST_PATTERN:
2377 case V4L2_CID_TEST_PATTERN_COLOR_R:
2378 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2379 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2380 case V4L2_CID_TEST_PATTERN_COLOR_B:
2381 /*
2382 * Exposure related control will be handled by sensor
2383 * driver
2384 */
2385 ret =
2386 v4l2_g_ctrl(isp->inputs[asd->input_curr].camera->
2387 ctrl_handler, &ctrl);
2388 break;
2389 case V4L2_CID_FOCUS_ABSOLUTE:
2390 case V4L2_CID_FOCUS_RELATIVE:
2391 case V4L2_CID_FOCUS_STATUS:
2392 case V4L2_CID_FOCUS_AUTO:
2393 if (motor)
2394 ret = v4l2_g_ctrl(motor->ctrl_handler, &ctrl);
2395 break;
2396 case V4L2_CID_FLASH_STATUS:
2397 case V4L2_CID_FLASH_INTENSITY:
2398 case V4L2_CID_FLASH_TORCH_INTENSITY:
2399 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
2400 case V4L2_CID_FLASH_TIMEOUT:
2401 case V4L2_CID_FLASH_STROBE:
2402 case V4L2_CID_FLASH_MODE:
2403 case V4L2_CID_FLASH_STATUS_REGISTER:
2404 if (isp->flash)
2405 ret =
2406 v4l2_g_ctrl(isp->flash->ctrl_handler,
2407 &ctrl);
2408 break;
2409 case V4L2_CID_ZOOM_ABSOLUTE:
2410 rt_mutex_lock(&isp->mutex);
2411 ret = atomisp_digital_zoom(asd, 0, &ctrl.value);
2412 rt_mutex_unlock(&isp->mutex);
2413 break;
2414 case V4L2_CID_G_SKIP_FRAMES:
2415 ret = v4l2_subdev_call(
2416 isp->inputs[asd->input_curr].camera,
2417 sensor, g_skip_frames, (u32 *)&ctrl.value);
2418 break;
2419 default:
2420 ret = -EINVAL;
2421 }
2422
2423 if (ret) {
2424 c->error_idx = i;
2425 break;
2426 }
2427 c->controls[i].value = ctrl.value;
2428 }
2429 return ret;
2430 }
2431
2432 /* This ioctl allows the application to get multiple controls by class */
atomisp_g_ext_ctrls(struct file * file,void * fh,struct v4l2_ext_controls * c)2433 static int atomisp_g_ext_ctrls(struct file *file, void *fh,
2434 struct v4l2_ext_controls *c)
2435 {
2436 struct v4l2_control ctrl;
2437 int i, ret = 0;
2438
2439 /*
2440 * input_lock is not need for the Camera related IOCTLs
2441 * The input_lock downgrade the FPS of 3A
2442 */
2443 ret = atomisp_camera_g_ext_ctrls(file, fh, c);
2444 if (ret != -EINVAL)
2445 return ret;
2446
2447 for (i = 0; i < c->count; i++) {
2448 ctrl.id = c->controls[i].id;
2449 ctrl.value = c->controls[i].value;
2450 ret = atomisp_g_ctrl(file, fh, &ctrl);
2451 c->controls[i].value = ctrl.value;
2452 if (ret) {
2453 c->error_idx = i;
2454 break;
2455 }
2456 }
2457 return ret;
2458 }
2459
atomisp_camera_s_ext_ctrls(struct file * file,void * fh,struct v4l2_ext_controls * c)2460 static int atomisp_camera_s_ext_ctrls(struct file *file, void *fh,
2461 struct v4l2_ext_controls *c)
2462 {
2463 struct video_device *vdev = video_devdata(file);
2464 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2465 struct atomisp_device *isp = video_get_drvdata(vdev);
2466 struct v4l2_subdev *motor;
2467 struct v4l2_control ctrl;
2468 int i;
2469 int ret = 0;
2470
2471 if (!IS_ISP2401)
2472 motor = isp->inputs[asd->input_curr].motor;
2473 else
2474 motor = isp->motor;
2475
2476 for (i = 0; i < c->count; i++) {
2477 struct v4l2_ctrl *ctr;
2478
2479 ctrl.id = c->controls[i].id;
2480 ctrl.value = c->controls[i].value;
2481 switch (ctrl.id) {
2482 case V4L2_CID_EXPOSURE_ABSOLUTE:
2483 case V4L2_CID_EXPOSURE_AUTO:
2484 case V4L2_CID_EXPOSURE_METERING:
2485 case V4L2_CID_IRIS_ABSOLUTE:
2486 case V4L2_CID_FNUMBER_ABSOLUTE:
2487 case V4L2_CID_VCM_TIMING:
2488 case V4L2_CID_VCM_SLEW:
2489 case V4L2_CID_3A_LOCK:
2490 case V4L2_CID_TEST_PATTERN:
2491 case V4L2_CID_TEST_PATTERN_COLOR_R:
2492 case V4L2_CID_TEST_PATTERN_COLOR_GR:
2493 case V4L2_CID_TEST_PATTERN_COLOR_GB:
2494 case V4L2_CID_TEST_PATTERN_COLOR_B:
2495 ret = v4l2_s_ctrl(NULL,
2496 isp->inputs[asd->input_curr].camera->
2497 ctrl_handler, &ctrl);
2498 break;
2499 case V4L2_CID_FOCUS_ABSOLUTE:
2500 case V4L2_CID_FOCUS_RELATIVE:
2501 case V4L2_CID_FOCUS_STATUS:
2502 case V4L2_CID_FOCUS_AUTO:
2503 if (motor)
2504 ret = v4l2_s_ctrl(NULL, motor->ctrl_handler,
2505 &ctrl);
2506 else
2507 ret = v4l2_s_ctrl(NULL,
2508 isp->inputs[asd->input_curr].
2509 camera->ctrl_handler, &ctrl);
2510 break;
2511 case V4L2_CID_FLASH_STATUS:
2512 case V4L2_CID_FLASH_INTENSITY:
2513 case V4L2_CID_FLASH_TORCH_INTENSITY:
2514 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
2515 case V4L2_CID_FLASH_TIMEOUT:
2516 case V4L2_CID_FLASH_STROBE:
2517 case V4L2_CID_FLASH_MODE:
2518 case V4L2_CID_FLASH_STATUS_REGISTER:
2519 rt_mutex_lock(&isp->mutex);
2520 if (isp->flash) {
2521 ret =
2522 v4l2_s_ctrl(NULL, isp->flash->ctrl_handler,
2523 &ctrl);
2524 /*
2525 * When flash mode is changed we need to reset
2526 * flash state
2527 */
2528 if (ctrl.id == V4L2_CID_FLASH_MODE) {
2529 asd->params.flash_state =
2530 ATOMISP_FLASH_IDLE;
2531 asd->params.num_flash_frames = 0;
2532 }
2533 }
2534 rt_mutex_unlock(&isp->mutex);
2535 break;
2536 case V4L2_CID_ZOOM_ABSOLUTE:
2537 rt_mutex_lock(&isp->mutex);
2538 ret = atomisp_digital_zoom(asd, 1, &ctrl.value);
2539 rt_mutex_unlock(&isp->mutex);
2540 break;
2541 default:
2542 ctr = v4l2_ctrl_find(&asd->ctrl_handler, ctrl.id);
2543 if (ctr)
2544 ret = v4l2_ctrl_s_ctrl(ctr, ctrl.value);
2545 else
2546 ret = -EINVAL;
2547 }
2548
2549 if (ret) {
2550 c->error_idx = i;
2551 break;
2552 }
2553 c->controls[i].value = ctrl.value;
2554 }
2555 return ret;
2556 }
2557
2558 /* This ioctl allows the application to set multiple controls by class */
atomisp_s_ext_ctrls(struct file * file,void * fh,struct v4l2_ext_controls * c)2559 static int atomisp_s_ext_ctrls(struct file *file, void *fh,
2560 struct v4l2_ext_controls *c)
2561 {
2562 struct v4l2_control ctrl;
2563 int i, ret = 0;
2564
2565 /*
2566 * input_lock is not need for the Camera related IOCTLs
2567 * The input_lock downgrade the FPS of 3A
2568 */
2569 ret = atomisp_camera_s_ext_ctrls(file, fh, c);
2570 if (ret != -EINVAL)
2571 return ret;
2572
2573 for (i = 0; i < c->count; i++) {
2574 ctrl.id = c->controls[i].id;
2575 ctrl.value = c->controls[i].value;
2576 ret = atomisp_s_ctrl(file, fh, &ctrl);
2577 c->controls[i].value = ctrl.value;
2578 if (ret) {
2579 c->error_idx = i;
2580 break;
2581 }
2582 }
2583 return ret;
2584 }
2585
2586 /*
2587 * vidioc_g/s_param are used to switch isp running mode
2588 */
atomisp_g_parm(struct file * file,void * fh,struct v4l2_streamparm * parm)2589 static int atomisp_g_parm(struct file *file, void *fh,
2590 struct v4l2_streamparm *parm)
2591 {
2592 struct video_device *vdev = video_devdata(file);
2593 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2594 struct atomisp_device *isp = video_get_drvdata(vdev);
2595
2596 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2597 dev_err(isp->dev, "unsupported v4l2 buf type\n");
2598 return -EINVAL;
2599 }
2600
2601 rt_mutex_lock(&isp->mutex);
2602 parm->parm.capture.capturemode = asd->run_mode->val;
2603 rt_mutex_unlock(&isp->mutex);
2604
2605 return 0;
2606 }
2607
atomisp_s_parm(struct file * file,void * fh,struct v4l2_streamparm * parm)2608 static int atomisp_s_parm(struct file *file, void *fh,
2609 struct v4l2_streamparm *parm)
2610 {
2611 struct video_device *vdev = video_devdata(file);
2612 struct atomisp_device *isp = video_get_drvdata(vdev);
2613 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
2614 int mode;
2615 int rval;
2616 int fps;
2617
2618 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
2619 dev_err(isp->dev, "unsupported v4l2 buf type\n");
2620 return -EINVAL;
2621 }
2622
2623 rt_mutex_lock(&isp->mutex);
2624
2625 asd->high_speed_mode = false;
2626 switch (parm->parm.capture.capturemode) {
2627 case CI_MODE_NONE: {
2628 struct v4l2_subdev_frame_interval fi = {0};
2629
2630 fi.interval = parm->parm.capture.timeperframe;
2631
2632 rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2633 video, s_frame_interval, &fi);
2634 if (!rval)
2635 parm->parm.capture.timeperframe = fi.interval;
2636
2637 if (fi.interval.numerator != 0) {
2638 fps = fi.interval.denominator / fi.interval.numerator;
2639 if (fps > 30)
2640 asd->high_speed_mode = true;
2641 }
2642
2643 goto out;
2644 }
2645 case CI_MODE_VIDEO:
2646 mode = ATOMISP_RUN_MODE_VIDEO;
2647 break;
2648 case CI_MODE_STILL_CAPTURE:
2649 mode = ATOMISP_RUN_MODE_STILL_CAPTURE;
2650 break;
2651 case CI_MODE_CONTINUOUS:
2652 mode = ATOMISP_RUN_MODE_CONTINUOUS_CAPTURE;
2653 break;
2654 case CI_MODE_PREVIEW:
2655 mode = ATOMISP_RUN_MODE_PREVIEW;
2656 break;
2657 default:
2658 rval = -EINVAL;
2659 goto out;
2660 }
2661
2662 rval = v4l2_ctrl_s_ctrl(asd->run_mode, mode);
2663
2664 out:
2665 rt_mutex_unlock(&isp->mutex);
2666
2667 return rval == -ENOIOCTLCMD ? 0 : rval;
2668 }
2669
atomisp_s_parm_file(struct file * file,void * fh,struct v4l2_streamparm * parm)2670 static int atomisp_s_parm_file(struct file *file, void *fh,
2671 struct v4l2_streamparm *parm)
2672 {
2673 struct video_device *vdev = video_devdata(file);
2674 struct atomisp_device *isp = video_get_drvdata(vdev);
2675
2676 if (parm->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) {
2677 dev_err(isp->dev, "unsupported v4l2 buf type for output\n");
2678 return -EINVAL;
2679 }
2680
2681 rt_mutex_lock(&isp->mutex);
2682 isp->sw_contex.file_input = true;
2683 rt_mutex_unlock(&isp->mutex);
2684
2685 return 0;
2686 }
2687
atomisp_vidioc_default(struct file * file,void * fh,bool valid_prio,unsigned int cmd,void * arg)2688 static long atomisp_vidioc_default(struct file *file, void *fh,
2689 bool valid_prio, unsigned int cmd, void *arg)
2690 {
2691 struct video_device *vdev = video_devdata(file);
2692 struct atomisp_device *isp = video_get_drvdata(vdev);
2693 struct atomisp_sub_device *asd;
2694 struct v4l2_subdev *motor;
2695 bool acc_node;
2696 int err;
2697
2698 acc_node = !strcmp(vdev->name, "ATOMISP ISP ACC");
2699 if (acc_node)
2700 asd = atomisp_to_acc_pipe(vdev)->asd;
2701 else
2702 asd = atomisp_to_video_pipe(vdev)->asd;
2703
2704 if (!IS_ISP2401)
2705 motor = isp->inputs[asd->input_curr].motor;
2706 else
2707 motor = isp->motor;
2708
2709 switch (cmd) {
2710 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA:
2711 case ATOMISP_IOC_S_EXPOSURE:
2712 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP:
2713 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
2714 case ATOMISP_IOC_EXT_ISP_CTRL:
2715 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO:
2716 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE:
2717 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE:
2718 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT:
2719 case ATOMISP_IOC_S_SENSOR_EE_CONFIG:
2720 case ATOMISP_IOC_G_UPDATE_EXPOSURE:
2721 /* we do not need take isp->mutex for these IOCTLs */
2722 break;
2723 default:
2724 rt_mutex_lock(&isp->mutex);
2725 break;
2726 }
2727 switch (cmd) {
2728 case ATOMISP_IOC_S_SENSOR_RUNMODE:
2729 if (IS_ISP2401)
2730 err = atomisp_set_sensor_runmode(asd, arg);
2731 else
2732 err = -EINVAL;
2733 break;
2734
2735 case ATOMISP_IOC_G_XNR:
2736 err = atomisp_xnr(asd, 0, arg);
2737 break;
2738
2739 case ATOMISP_IOC_S_XNR:
2740 err = atomisp_xnr(asd, 1, arg);
2741 break;
2742
2743 case ATOMISP_IOC_G_NR:
2744 err = atomisp_nr(asd, 0, arg);
2745 break;
2746
2747 case ATOMISP_IOC_S_NR:
2748 err = atomisp_nr(asd, 1, arg);
2749 break;
2750
2751 case ATOMISP_IOC_G_TNR:
2752 err = atomisp_tnr(asd, 0, arg);
2753 break;
2754
2755 case ATOMISP_IOC_S_TNR:
2756 err = atomisp_tnr(asd, 1, arg);
2757 break;
2758
2759 case ATOMISP_IOC_G_BLACK_LEVEL_COMP:
2760 err = atomisp_black_level(asd, 0, arg);
2761 break;
2762
2763 case ATOMISP_IOC_S_BLACK_LEVEL_COMP:
2764 err = atomisp_black_level(asd, 1, arg);
2765 break;
2766
2767 case ATOMISP_IOC_G_EE:
2768 err = atomisp_ee(asd, 0, arg);
2769 break;
2770
2771 case ATOMISP_IOC_S_EE:
2772 err = atomisp_ee(asd, 1, arg);
2773 break;
2774
2775 case ATOMISP_IOC_G_DIS_STAT:
2776 err = atomisp_get_dis_stat(asd, arg);
2777 break;
2778
2779 case ATOMISP_IOC_G_DVS2_BQ_RESOLUTIONS:
2780 err = atomisp_get_dvs2_bq_resolutions(asd, arg);
2781 break;
2782
2783 case ATOMISP_IOC_S_DIS_COEFS:
2784 err = atomisp_css_cp_dvs2_coefs(asd, arg,
2785 &asd->params.css_param, true);
2786 if (!err && arg)
2787 asd->params.css_update_params_needed = true;
2788 break;
2789
2790 case ATOMISP_IOC_S_DIS_VECTOR:
2791 err = atomisp_cp_dvs_6axis_config(asd, arg,
2792 &asd->params.css_param, true);
2793 if (!err && arg)
2794 asd->params.css_update_params_needed = true;
2795 break;
2796
2797 case ATOMISP_IOC_G_ISP_PARM:
2798 err = atomisp_param(asd, 0, arg);
2799 break;
2800
2801 case ATOMISP_IOC_S_ISP_PARM:
2802 err = atomisp_param(asd, 1, arg);
2803 break;
2804
2805 case ATOMISP_IOC_G_3A_STAT:
2806 err = atomisp_3a_stat(asd, 0, arg);
2807 break;
2808
2809 case ATOMISP_IOC_G_ISP_GAMMA:
2810 err = atomisp_gamma(asd, 0, arg);
2811 break;
2812
2813 case ATOMISP_IOC_S_ISP_GAMMA:
2814 err = atomisp_gamma(asd, 1, arg);
2815 break;
2816
2817 case ATOMISP_IOC_G_ISP_GDC_TAB:
2818 err = atomisp_gdc_cac_table(asd, 0, arg);
2819 break;
2820
2821 case ATOMISP_IOC_S_ISP_GDC_TAB:
2822 err = atomisp_gdc_cac_table(asd, 1, arg);
2823 break;
2824
2825 case ATOMISP_IOC_G_ISP_MACC:
2826 err = atomisp_macc_table(asd, 0, arg);
2827 break;
2828
2829 case ATOMISP_IOC_S_ISP_MACC:
2830 err = atomisp_macc_table(asd, 1, arg);
2831 break;
2832
2833 case ATOMISP_IOC_G_ISP_BAD_PIXEL_DETECTION:
2834 err = atomisp_bad_pixel_param(asd, 0, arg);
2835 break;
2836
2837 case ATOMISP_IOC_S_ISP_BAD_PIXEL_DETECTION:
2838 err = atomisp_bad_pixel_param(asd, 1, arg);
2839 break;
2840
2841 case ATOMISP_IOC_G_ISP_FALSE_COLOR_CORRECTION:
2842 err = atomisp_false_color_param(asd, 0, arg);
2843 break;
2844
2845 case ATOMISP_IOC_S_ISP_FALSE_COLOR_CORRECTION:
2846 err = atomisp_false_color_param(asd, 1, arg);
2847 break;
2848
2849 case ATOMISP_IOC_G_ISP_CTC:
2850 err = atomisp_ctc(asd, 0, arg);
2851 break;
2852
2853 case ATOMISP_IOC_S_ISP_CTC:
2854 err = atomisp_ctc(asd, 1, arg);
2855 break;
2856
2857 case ATOMISP_IOC_G_ISP_WHITE_BALANCE:
2858 err = atomisp_white_balance_param(asd, 0, arg);
2859 break;
2860
2861 case ATOMISP_IOC_S_ISP_WHITE_BALANCE:
2862 err = atomisp_white_balance_param(asd, 1, arg);
2863 break;
2864
2865 case ATOMISP_IOC_G_3A_CONFIG:
2866 err = atomisp_3a_config_param(asd, 0, arg);
2867 break;
2868
2869 case ATOMISP_IOC_S_3A_CONFIG:
2870 err = atomisp_3a_config_param(asd, 1, arg);
2871 break;
2872
2873 case ATOMISP_IOC_S_ISP_FPN_TABLE:
2874 err = atomisp_fixed_pattern_table(asd, arg);
2875 break;
2876
2877 case ATOMISP_IOC_ISP_MAKERNOTE:
2878 err = atomisp_exif_makernote(asd, arg);
2879 break;
2880
2881 case ATOMISP_IOC_G_SENSOR_MODE_DATA:
2882 err = atomisp_get_sensor_mode_data(asd, arg);
2883 break;
2884
2885 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA:
2886 if (motor)
2887 err = v4l2_subdev_call(motor, core, ioctl, cmd, arg);
2888 else
2889 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2890 core, ioctl, cmd, arg);
2891 break;
2892
2893 case ATOMISP_IOC_S_EXPOSURE:
2894 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP:
2895 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
2896 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO:
2897 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE:
2898 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE:
2899 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT:
2900 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2901 core, ioctl, cmd, arg);
2902 break;
2903 case ATOMISP_IOC_G_UPDATE_EXPOSURE:
2904 if (IS_ISP2401)
2905 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2906 core, ioctl, cmd, arg);
2907 else
2908 err = -EINVAL;
2909 break;
2910
2911 case ATOMISP_IOC_ACC_LOAD:
2912 err = atomisp_acc_load(asd, arg);
2913 break;
2914
2915 case ATOMISP_IOC_ACC_LOAD_TO_PIPE:
2916 err = atomisp_acc_load_to_pipe(asd, arg);
2917 break;
2918
2919 case ATOMISP_IOC_ACC_UNLOAD:
2920 err = atomisp_acc_unload(asd, arg);
2921 break;
2922
2923 case ATOMISP_IOC_ACC_START:
2924 err = atomisp_acc_start(asd, arg);
2925 break;
2926
2927 case ATOMISP_IOC_ACC_WAIT:
2928 err = atomisp_acc_wait(asd, arg);
2929 break;
2930
2931 case ATOMISP_IOC_ACC_MAP:
2932 err = atomisp_acc_map(asd, arg);
2933 break;
2934
2935 case ATOMISP_IOC_ACC_UNMAP:
2936 err = atomisp_acc_unmap(asd, arg);
2937 break;
2938
2939 case ATOMISP_IOC_ACC_S_MAPPED_ARG:
2940 err = atomisp_acc_s_mapped_arg(asd, arg);
2941 break;
2942
2943 case ATOMISP_IOC_S_ISP_SHD_TAB:
2944 err = atomisp_set_shading_table(asd, arg);
2945 break;
2946
2947 case ATOMISP_IOC_G_ISP_GAMMA_CORRECTION:
2948 err = atomisp_gamma_correction(asd, 0, arg);
2949 break;
2950
2951 case ATOMISP_IOC_S_ISP_GAMMA_CORRECTION:
2952 err = atomisp_gamma_correction(asd, 1, arg);
2953 break;
2954
2955 case ATOMISP_IOC_S_PARAMETERS:
2956 err = atomisp_set_parameters(vdev, arg);
2957 break;
2958
2959 case ATOMISP_IOC_S_CONT_CAPTURE_CONFIG:
2960 err = atomisp_offline_capture_configure(asd, arg);
2961 break;
2962 case ATOMISP_IOC_G_METADATA:
2963 err = atomisp_get_metadata(asd, 0, arg);
2964 break;
2965 case ATOMISP_IOC_G_METADATA_BY_TYPE:
2966 err = atomisp_get_metadata_by_type(asd, 0, arg);
2967 break;
2968 case ATOMISP_IOC_EXT_ISP_CTRL:
2969 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
2970 core, ioctl, cmd, arg);
2971 break;
2972 case ATOMISP_IOC_EXP_ID_UNLOCK:
2973 err = atomisp_exp_id_unlock(asd, arg);
2974 break;
2975 case ATOMISP_IOC_EXP_ID_CAPTURE:
2976 err = atomisp_exp_id_capture(asd, arg);
2977 break;
2978 case ATOMISP_IOC_S_ENABLE_DZ_CAPT_PIPE:
2979 err = atomisp_enable_dz_capt_pipe(asd, arg);
2980 break;
2981 case ATOMISP_IOC_G_FORMATS_CONFIG:
2982 err = atomisp_formats(asd, 0, arg);
2983 break;
2984
2985 case ATOMISP_IOC_S_FORMATS_CONFIG:
2986 err = atomisp_formats(asd, 1, arg);
2987 break;
2988 case ATOMISP_IOC_S_EXPOSURE_WINDOW:
2989 err = atomisp_s_ae_window(asd, arg);
2990 break;
2991 case ATOMISP_IOC_S_ACC_STATE:
2992 err = atomisp_acc_set_state(asd, arg);
2993 break;
2994 case ATOMISP_IOC_G_ACC_STATE:
2995 err = atomisp_acc_get_state(asd, arg);
2996 break;
2997 case ATOMISP_IOC_INJECT_A_FAKE_EVENT:
2998 err = atomisp_inject_a_fake_event(asd, arg);
2999 break;
3000 case ATOMISP_IOC_G_INVALID_FRAME_NUM:
3001 err = atomisp_get_invalid_frame_num(vdev, arg);
3002 break;
3003 case ATOMISP_IOC_S_ARRAY_RESOLUTION:
3004 err = atomisp_set_array_res(asd, arg);
3005 break;
3006 default:
3007 err = -EINVAL;
3008 break;
3009 }
3010
3011 switch (cmd) {
3012 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA:
3013 case ATOMISP_IOC_S_EXPOSURE:
3014 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP:
3015 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA:
3016 case ATOMISP_IOC_EXT_ISP_CTRL:
3017 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO:
3018 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE:
3019 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE:
3020 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT:
3021 case ATOMISP_IOC_G_UPDATE_EXPOSURE:
3022 break;
3023 default:
3024 rt_mutex_unlock(&isp->mutex);
3025 break;
3026 }
3027 return err;
3028 }
3029
3030 const struct v4l2_ioctl_ops atomisp_ioctl_ops = {
3031 .vidioc_querycap = atomisp_querycap,
3032 .vidioc_enum_input = atomisp_enum_input,
3033 .vidioc_g_input = atomisp_g_input,
3034 .vidioc_s_input = atomisp_s_input,
3035 .vidioc_queryctrl = atomisp_queryctl,
3036 .vidioc_s_ctrl = atomisp_s_ctrl,
3037 .vidioc_g_ctrl = atomisp_g_ctrl,
3038 .vidioc_s_ext_ctrls = atomisp_s_ext_ctrls,
3039 .vidioc_g_ext_ctrls = atomisp_g_ext_ctrls,
3040 .vidioc_enum_fmt_vid_cap = atomisp_enum_fmt_cap,
3041 .vidioc_try_fmt_vid_cap = atomisp_try_fmt_cap,
3042 .vidioc_g_fmt_vid_cap = atomisp_g_fmt_cap,
3043 .vidioc_s_fmt_vid_cap = atomisp_s_fmt_cap,
3044 .vidioc_reqbufs = atomisp_reqbufs,
3045 .vidioc_querybuf = atomisp_querybuf,
3046 .vidioc_qbuf = atomisp_qbuf,
3047 .vidioc_dqbuf = atomisp_dqbuf,
3048 .vidioc_streamon = atomisp_streamon,
3049 .vidioc_streamoff = atomisp_streamoff,
3050 .vidioc_default = atomisp_vidioc_default,
3051 .vidioc_s_parm = atomisp_s_parm,
3052 .vidioc_g_parm = atomisp_g_parm,
3053 };
3054
3055 const struct v4l2_ioctl_ops atomisp_file_ioctl_ops = {
3056 .vidioc_querycap = atomisp_querycap,
3057 .vidioc_g_fmt_vid_out = atomisp_g_fmt_file,
3058 .vidioc_s_fmt_vid_out = atomisp_s_fmt_file,
3059 .vidioc_s_parm = atomisp_s_parm_file,
3060 .vidioc_reqbufs = atomisp_reqbufs_file,
3061 .vidioc_querybuf = atomisp_querybuf_file,
3062 .vidioc_qbuf = atomisp_qbuf_file,
3063 };
3064