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( 515 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( 528 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 */ 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) - 1); 551 strscpy(cap->card, CARD, sizeof(cap->card) - 1); 552 snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", 553 pci_name(isp->pdev)); 554 555 return 0; 556 } 557 558 /* 559 * enum input are used to check primary/secondary camera 560 */ 561 static int atomisp_enum_input(struct file *file, void *fh, 562 struct v4l2_input *input) 563 { 564 struct video_device *vdev = video_devdata(file); 565 struct atomisp_device *isp = video_get_drvdata(vdev); 566 int index = input->index; 567 struct v4l2_subdev *motor; 568 569 if (index >= isp->input_cnt) 570 return -EINVAL; 571 572 if (!isp->inputs[index].camera) 573 return -EINVAL; 574 575 memset(input, 0, sizeof(struct v4l2_input)); 576 strncpy(input->name, isp->inputs[index].camera->name, 577 sizeof(input->name) - 1); 578 579 /* 580 * HACK: append actuator's name to sensor's 581 * As currently userspace can't talk directly to subdev nodes, this 582 * ioctl is the only way to enum inputs + possible external actuators 583 * for 3A tuning purpose. 584 */ 585 if (!atomisp_hw_is_isp2401) 586 motor = isp->inputs[index].motor; 587 else 588 motor = isp->motor; 589 590 if (motor && strlen(motor->name) > 0) { 591 const int cur_len = strlen(input->name); 592 const int max_size = sizeof(input->name) - cur_len - 1; 593 594 if (max_size > 1) { 595 input->name[cur_len] = '+'; 596 strncpy(&input->name[cur_len + 1], 597 motor->name, max_size - 1); 598 } 599 } 600 601 input->type = V4L2_INPUT_TYPE_CAMERA; 602 input->index = index; 603 input->reserved[0] = isp->inputs[index].type; 604 input->reserved[1] = isp->inputs[index].port; 605 606 return 0; 607 } 608 609 static unsigned int atomisp_subdev_streaming_count( 610 struct atomisp_sub_device *asd) 611 { 612 return asd->video_out_preview.capq.streaming 613 + asd->video_out_capture.capq.streaming 614 + asd->video_out_video_capture.capq.streaming 615 + asd->video_out_vf.capq.streaming 616 + asd->video_in.capq.streaming; 617 } 618 619 unsigned int atomisp_streaming_count(struct atomisp_device *isp) 620 { 621 unsigned int i, sum; 622 623 for (i = 0, sum = 0; i < isp->num_of_streams; i++) 624 sum += isp->asd[i].streaming == 625 ATOMISP_DEVICE_STREAMING_ENABLED; 626 627 return sum; 628 } 629 630 unsigned int atomisp_is_acc_enabled(struct atomisp_device *isp) 631 { 632 unsigned int i; 633 634 for (i = 0; i < isp->num_of_streams; i++) 635 if (isp->asd[i].acc.pipeline) 636 return 1; 637 638 return 0; 639 } 640 641 /* 642 * get input are used to get current primary/secondary camera 643 */ 644 static int atomisp_g_input(struct file *file, void *fh, unsigned int *input) 645 { 646 struct video_device *vdev = video_devdata(file); 647 struct atomisp_device *isp = video_get_drvdata(vdev); 648 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 649 650 rt_mutex_lock(&isp->mutex); 651 *input = asd->input_curr; 652 rt_mutex_unlock(&isp->mutex); 653 654 return 0; 655 } 656 657 /* 658 * set input are used to set current primary/secondary camera 659 */ 660 static int atomisp_s_input(struct file *file, void *fh, unsigned int input) 661 { 662 struct video_device *vdev = video_devdata(file); 663 struct atomisp_device *isp = video_get_drvdata(vdev); 664 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 665 struct v4l2_subdev *camera = NULL; 666 struct v4l2_subdev *motor; 667 int ret; 668 669 rt_mutex_lock(&isp->mutex); 670 if (input >= ATOM_ISP_MAX_INPUTS || input >= isp->input_cnt) { 671 dev_dbg(isp->dev, "input_cnt: %d\n", isp->input_cnt); 672 ret = -EINVAL; 673 goto error; 674 } 675 676 /* 677 * check whether the request camera: 678 * 1: already in use 679 * 2: if in use, whether it is used by other streams 680 */ 681 if (isp->inputs[input].asd && isp->inputs[input].asd != asd) { 682 dev_err(isp->dev, 683 "%s, camera is already used by stream: %d\n", __func__, 684 isp->inputs[input].asd->index); 685 ret = -EBUSY; 686 goto error; 687 } 688 689 camera = isp->inputs[input].camera; 690 if (!camera) { 691 dev_err(isp->dev, "%s, no camera\n", __func__); 692 ret = -EINVAL; 693 goto error; 694 } 695 696 if (atomisp_subdev_streaming_count(asd)) { 697 dev_err(isp->dev, 698 "ISP is still streaming, stop first\n"); 699 ret = -EINVAL; 700 goto error; 701 } 702 703 /* power off the current owned sensor, as it is not used this time */ 704 if (isp->inputs[asd->input_curr].asd == asd && 705 asd->input_curr != input) { 706 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 707 core, s_power, 0); 708 if (ret) 709 dev_warn(isp->dev, 710 "Failed to power-off sensor\n"); 711 /* clear the asd field to show this camera is not used */ 712 isp->inputs[asd->input_curr].asd = NULL; 713 } 714 715 /* powe on the new sensor */ 716 ret = v4l2_subdev_call(isp->inputs[input].camera, core, s_power, 1); 717 if (ret) { 718 dev_err(isp->dev, "Failed to power-on sensor\n"); 719 goto error; 720 } 721 /* 722 * Some sensor driver resets the run mode during power-on, thus force 723 * update the run mode to sensor after power-on. 724 */ 725 atomisp_update_run_mode(asd); 726 727 /* select operating sensor */ 728 ret = v4l2_subdev_call(isp->inputs[input].camera, video, s_routing, 729 0, isp->inputs[input].sensor_index, 0); 730 if (ret && (ret != -ENOIOCTLCMD)) { 731 dev_err(isp->dev, "Failed to select sensor\n"); 732 goto error; 733 } 734 735 if (!atomisp_hw_is_isp2401) { 736 motor = isp->inputs[input].motor; 737 } else { 738 motor = isp->motor; 739 if (motor) 740 ret = v4l2_subdev_call(motor, core, s_power, 1); 741 } 742 743 if (!isp->sw_contex.file_input && motor) 744 ret = v4l2_subdev_call(motor, core, init, 1); 745 746 asd->input_curr = input; 747 /* mark this camera is used by the current stream */ 748 isp->inputs[input].asd = asd; 749 rt_mutex_unlock(&isp->mutex); 750 751 return 0; 752 753 error: 754 rt_mutex_unlock(&isp->mutex); 755 756 return ret; 757 } 758 759 static int atomisp_enum_fmt_cap(struct file *file, void *fh, 760 struct v4l2_fmtdesc *f) 761 { 762 struct video_device *vdev = video_devdata(file); 763 struct atomisp_device *isp = video_get_drvdata(vdev); 764 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 765 struct v4l2_subdev_mbus_code_enum code = { 0 }; 766 unsigned int i, fi = 0; 767 int rval; 768 769 rt_mutex_lock(&isp->mutex); 770 rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, pad, 771 enum_mbus_code, NULL, &code); 772 if (rval == -ENOIOCTLCMD) { 773 dev_warn(isp->dev, 774 "enum_mbus_code pad op not supported. Please fix your sensor driver!\n"); 775 // rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 776 // video, enum_mbus_fmt, 0, &code.code); 777 } 778 rt_mutex_unlock(&isp->mutex); 779 780 if (rval) 781 return rval; 782 783 for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) { 784 const struct atomisp_format_bridge *format = 785 &atomisp_output_fmts[i]; 786 787 /* 788 * Is the atomisp-supported format is valid for the 789 * sensor (configuration)? If not, skip it. 790 */ 791 if (format->sh_fmt == IA_CSS_FRAME_FORMAT_RAW 792 && format->mbus_code != code.code) 793 continue; 794 795 /* Found a match. Now let's pick f->index'th one. */ 796 if (fi < f->index) { 797 fi++; 798 continue; 799 } 800 801 strlcpy(f->description, format->description, 802 sizeof(f->description)); 803 f->pixelformat = format->pixelformat; 804 return 0; 805 } 806 807 return -EINVAL; 808 } 809 810 static int atomisp_g_fmt_cap(struct file *file, void *fh, 811 struct v4l2_format *f) 812 { 813 struct video_device *vdev = video_devdata(file); 814 struct atomisp_device *isp = video_get_drvdata(vdev); 815 816 int ret; 817 818 rt_mutex_lock(&isp->mutex); 819 ret = atomisp_get_fmt(vdev, f); 820 rt_mutex_unlock(&isp->mutex); 821 return ret; 822 } 823 824 static int atomisp_g_fmt_file(struct file *file, void *fh, 825 struct v4l2_format *f) 826 { 827 struct video_device *vdev = video_devdata(file); 828 struct atomisp_device *isp = video_get_drvdata(vdev); 829 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 830 831 rt_mutex_lock(&isp->mutex); 832 f->fmt.pix = pipe->pix; 833 rt_mutex_unlock(&isp->mutex); 834 835 return 0; 836 } 837 838 /* This function looks up the closest available resolution. */ 839 static int atomisp_try_fmt_cap(struct file *file, void *fh, 840 struct v4l2_format *f) 841 { 842 struct video_device *vdev = video_devdata(file); 843 struct atomisp_device *isp = video_get_drvdata(vdev); 844 int ret; 845 846 rt_mutex_lock(&isp->mutex); 847 ret = atomisp_try_fmt(vdev, f, NULL); 848 rt_mutex_unlock(&isp->mutex); 849 return ret; 850 } 851 852 static int atomisp_s_fmt_cap(struct file *file, void *fh, 853 struct v4l2_format *f) 854 { 855 struct video_device *vdev = video_devdata(file); 856 struct atomisp_device *isp = video_get_drvdata(vdev); 857 int ret; 858 859 rt_mutex_lock(&isp->mutex); 860 if (isp->isp_fatal_error) { 861 ret = -EIO; 862 rt_mutex_unlock(&isp->mutex); 863 return ret; 864 } 865 ret = atomisp_set_fmt(vdev, f); 866 rt_mutex_unlock(&isp->mutex); 867 return ret; 868 } 869 870 static int atomisp_s_fmt_file(struct file *file, void *fh, 871 struct v4l2_format *f) 872 { 873 struct video_device *vdev = video_devdata(file); 874 struct atomisp_device *isp = video_get_drvdata(vdev); 875 int ret; 876 877 rt_mutex_lock(&isp->mutex); 878 ret = atomisp_set_fmt_file(vdev, f); 879 rt_mutex_unlock(&isp->mutex); 880 return ret; 881 } 882 883 /* 884 * Free videobuffer buffer priv data 885 */ 886 void atomisp_videobuf_free_buf(struct videobuf_buffer *vb) 887 { 888 struct videobuf_vmalloc_memory *vm_mem; 889 890 if (!vb) 891 return; 892 893 vm_mem = vb->priv; 894 if (vm_mem && vm_mem->vaddr) { 895 ia_css_frame_free(vm_mem->vaddr); 896 vm_mem->vaddr = NULL; 897 } 898 } 899 900 /* 901 * this function is used to free video buffer queue 902 */ 903 static void atomisp_videobuf_free_queue(struct videobuf_queue *q) 904 { 905 int i; 906 907 for (i = 0; i < VIDEO_MAX_FRAME; i++) { 908 atomisp_videobuf_free_buf(q->bufs[i]); 909 kfree(q->bufs[i]); 910 q->bufs[i] = NULL; 911 } 912 } 913 914 int atomisp_alloc_css_stat_bufs(struct atomisp_sub_device *asd, 915 uint16_t stream_id) 916 { 917 struct atomisp_device *isp = asd->isp; 918 struct atomisp_s3a_buf *s3a_buf = NULL, *_s3a_buf; 919 struct atomisp_dis_buf *dis_buf = NULL, *_dis_buf; 920 struct atomisp_metadata_buf *md_buf = NULL, *_md_buf; 921 int count; 922 struct ia_css_dvs_grid_info *dvs_grid_info = 923 atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info); 924 unsigned int i; 925 926 if (list_empty(&asd->s3a_stats) && 927 asd->params.curr_grid_info.s3a_grid.enable) { 928 count = ATOMISP_CSS_Q_DEPTH + 929 ATOMISP_S3A_BUF_QUEUE_DEPTH_FOR_HAL; 930 dev_dbg(isp->dev, "allocating %d 3a buffers\n", count); 931 while (count--) { 932 s3a_buf = kzalloc(sizeof(struct atomisp_s3a_buf), GFP_KERNEL); 933 if (!s3a_buf) 934 goto error; 935 936 if (atomisp_css_allocate_stat_buffers( 937 asd, stream_id, s3a_buf, NULL, NULL)) { 938 kfree(s3a_buf); 939 goto error; 940 } 941 942 list_add_tail(&s3a_buf->list, &asd->s3a_stats); 943 } 944 } 945 946 if (list_empty(&asd->dis_stats) && dvs_grid_info && 947 dvs_grid_info->enable) { 948 count = ATOMISP_CSS_Q_DEPTH + 1; 949 dev_dbg(isp->dev, "allocating %d dis buffers\n", count); 950 while (count--) { 951 dis_buf = kzalloc(sizeof(struct atomisp_dis_buf), GFP_KERNEL); 952 if (!dis_buf) { 953 kfree(s3a_buf); 954 goto error; 955 } 956 if (atomisp_css_allocate_stat_buffers( 957 asd, stream_id, NULL, dis_buf, NULL)) { 958 kfree(dis_buf); 959 goto error; 960 } 961 962 list_add_tail(&dis_buf->list, &asd->dis_stats); 963 } 964 } 965 966 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) { 967 if (list_empty(&asd->metadata[i]) && 968 list_empty(&asd->metadata_ready[i]) && 969 list_empty(&asd->metadata_in_css[i])) { 970 count = ATOMISP_CSS_Q_DEPTH + 971 ATOMISP_METADATA_QUEUE_DEPTH_FOR_HAL; 972 dev_dbg(isp->dev, "allocating %d metadata buffers for type %d\n", 973 count, i); 974 while (count--) { 975 md_buf = kzalloc(sizeof(struct atomisp_metadata_buf), 976 GFP_KERNEL); 977 if (!md_buf) 978 goto error; 979 980 if (atomisp_css_allocate_stat_buffers( 981 asd, stream_id, NULL, NULL, md_buf)) { 982 kfree(md_buf); 983 goto error; 984 } 985 list_add_tail(&md_buf->list, &asd->metadata[i]); 986 } 987 } 988 } 989 return 0; 990 991 error: 992 dev_err(isp->dev, "failed to allocate statistics buffers\n"); 993 994 list_for_each_entry_safe(dis_buf, _dis_buf, &asd->dis_stats, list) { 995 atomisp_css_free_dis_buffer(dis_buf); 996 list_del(&dis_buf->list); 997 kfree(dis_buf); 998 } 999 1000 list_for_each_entry_safe(s3a_buf, _s3a_buf, &asd->s3a_stats, list) { 1001 atomisp_css_free_3a_buffer(s3a_buf); 1002 list_del(&s3a_buf->list); 1003 kfree(s3a_buf); 1004 } 1005 1006 for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) { 1007 list_for_each_entry_safe(md_buf, _md_buf, &asd->metadata[i], 1008 list) { 1009 atomisp_css_free_metadata_buffer(md_buf); 1010 list_del(&md_buf->list); 1011 kfree(md_buf); 1012 } 1013 } 1014 return -ENOMEM; 1015 } 1016 1017 /* 1018 * Initiate Memory Mapping or User Pointer I/O 1019 */ 1020 int __atomisp_reqbufs(struct file *file, void *fh, 1021 struct v4l2_requestbuffers *req) 1022 { 1023 struct video_device *vdev = video_devdata(file); 1024 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1025 struct atomisp_sub_device *asd = pipe->asd; 1026 struct ia_css_frame_info frame_info; 1027 struct ia_css_frame *frame; 1028 struct videobuf_vmalloc_memory *vm_mem; 1029 u16 source_pad = atomisp_subdev_source_pad(vdev); 1030 u16 stream_id = atomisp_source_pad_to_stream_id(asd, source_pad); 1031 int ret = 0, i = 0; 1032 1033 if (req->count == 0) { 1034 mutex_lock(&pipe->capq.vb_lock); 1035 if (!list_empty(&pipe->capq.stream)) 1036 videobuf_queue_cancel(&pipe->capq); 1037 1038 atomisp_videobuf_free_queue(&pipe->capq); 1039 mutex_unlock(&pipe->capq.vb_lock); 1040 /* clear request config id */ 1041 memset(pipe->frame_request_config_id, 0, 1042 VIDEO_MAX_FRAME * sizeof(unsigned int)); 1043 memset(pipe->frame_params, 0, 1044 VIDEO_MAX_FRAME * 1045 sizeof(struct atomisp_css_params_with_list *)); 1046 return 0; 1047 } 1048 1049 ret = videobuf_reqbufs(&pipe->capq, req); 1050 if (ret) 1051 return ret; 1052 1053 atomisp_alloc_css_stat_bufs(asd, stream_id); 1054 1055 /* 1056 * for user pointer type, buffers are not really allocated here, 1057 * buffers are setup in QBUF operation through v4l2_buffer structure 1058 */ 1059 if (req->memory == V4L2_MEMORY_USERPTR) 1060 return 0; 1061 1062 ret = atomisp_get_css_frame_info(asd, source_pad, &frame_info); 1063 if (ret) 1064 return ret; 1065 1066 /* 1067 * Allocate the real frame here for selected node using our 1068 * memory management function 1069 */ 1070 for (i = 0; i < req->count; i++) { 1071 if (ia_css_frame_allocate_from_info(&frame, &frame_info)) 1072 goto error; 1073 vm_mem = pipe->capq.bufs[i]->priv; 1074 vm_mem->vaddr = frame; 1075 } 1076 1077 return ret; 1078 1079 error: 1080 while (i--) { 1081 vm_mem = pipe->capq.bufs[i]->priv; 1082 ia_css_frame_free(vm_mem->vaddr); 1083 } 1084 1085 if (asd->vf_frame) 1086 ia_css_frame_free(asd->vf_frame); 1087 1088 return -ENOMEM; 1089 } 1090 1091 int atomisp_reqbufs(struct file *file, void *fh, 1092 struct v4l2_requestbuffers *req) 1093 { 1094 struct video_device *vdev = video_devdata(file); 1095 struct atomisp_device *isp = video_get_drvdata(vdev); 1096 int ret; 1097 1098 rt_mutex_lock(&isp->mutex); 1099 ret = __atomisp_reqbufs(file, fh, req); 1100 rt_mutex_unlock(&isp->mutex); 1101 1102 return ret; 1103 } 1104 1105 static int atomisp_reqbufs_file(struct file *file, void *fh, 1106 struct v4l2_requestbuffers *req) 1107 { 1108 struct video_device *vdev = video_devdata(file); 1109 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1110 1111 if (req->count == 0) { 1112 mutex_lock(&pipe->outq.vb_lock); 1113 atomisp_videobuf_free_queue(&pipe->outq); 1114 mutex_unlock(&pipe->outq.vb_lock); 1115 return 0; 1116 } 1117 1118 return videobuf_reqbufs(&pipe->outq, req); 1119 } 1120 1121 /* application query the status of a buffer */ 1122 static int atomisp_querybuf(struct file *file, void *fh, 1123 struct v4l2_buffer *buf) 1124 { 1125 struct video_device *vdev = video_devdata(file); 1126 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1127 1128 return videobuf_querybuf(&pipe->capq, buf); 1129 } 1130 1131 static int atomisp_querybuf_file(struct file *file, void *fh, 1132 struct v4l2_buffer *buf) 1133 { 1134 struct video_device *vdev = video_devdata(file); 1135 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1136 1137 return videobuf_querybuf(&pipe->outq, buf); 1138 } 1139 1140 /* 1141 * Applications call the VIDIOC_QBUF ioctl to enqueue an empty (capturing) or 1142 * filled (output) buffer in the drivers incoming queue. 1143 */ 1144 static int atomisp_qbuf(struct file *file, void *fh, struct v4l2_buffer *buf) 1145 { 1146 static const int NOFLUSH_FLAGS = V4L2_BUF_FLAG_NO_CACHE_INVALIDATE | 1147 V4L2_BUF_FLAG_NO_CACHE_CLEAN; 1148 struct video_device *vdev = video_devdata(file); 1149 struct atomisp_device *isp = video_get_drvdata(vdev); 1150 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1151 struct atomisp_sub_device *asd = pipe->asd; 1152 struct videobuf_buffer *vb; 1153 struct videobuf_vmalloc_memory *vm_mem; 1154 struct ia_css_frame_info frame_info; 1155 struct ia_css_frame *handle = NULL; 1156 u32 length; 1157 u32 pgnr; 1158 int ret = 0; 1159 1160 rt_mutex_lock(&isp->mutex); 1161 if (isp->isp_fatal_error) { 1162 ret = -EIO; 1163 goto error; 1164 } 1165 1166 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) { 1167 dev_err(isp->dev, "%s: reject, as ISP at stopping.\n", 1168 __func__); 1169 ret = -EIO; 1170 goto error; 1171 } 1172 1173 if (!buf || buf->index >= VIDEO_MAX_FRAME || 1174 !pipe->capq.bufs[buf->index]) { 1175 dev_err(isp->dev, "Invalid index for qbuf.\n"); 1176 ret = -EINVAL; 1177 goto error; 1178 } 1179 1180 /* 1181 * For userptr type frame, we convert user space address to physic 1182 * address and reprograme out page table properly 1183 */ 1184 if (buf->memory == V4L2_MEMORY_USERPTR) { 1185 vb = pipe->capq.bufs[buf->index]; 1186 vm_mem = vb->priv; 1187 if (!vm_mem) { 1188 ret = -EINVAL; 1189 goto error; 1190 } 1191 1192 length = vb->bsize; 1193 pgnr = (length + (PAGE_SIZE - 1)) >> PAGE_SHIFT; 1194 1195 if (vb->baddr == buf->m.userptr && vm_mem->vaddr) 1196 goto done; 1197 1198 if (atomisp_get_css_frame_info(asd, 1199 atomisp_subdev_source_pad(vdev), &frame_info)) { 1200 ret = -EIO; 1201 goto error; 1202 } 1203 1204 ret = ia_css_frame_map(&handle, &frame_info, 1205 (void __user *)buf->m.userptr, 1206 0, pgnr); 1207 if (ret) { 1208 dev_err(isp->dev, "Failed to map user buffer\n"); 1209 goto error; 1210 } 1211 1212 if (vm_mem->vaddr) { 1213 mutex_lock(&pipe->capq.vb_lock); 1214 ia_css_frame_free(vm_mem->vaddr); 1215 vm_mem->vaddr = NULL; 1216 vb->state = VIDEOBUF_NEEDS_INIT; 1217 mutex_unlock(&pipe->capq.vb_lock); 1218 } 1219 1220 vm_mem->vaddr = handle; 1221 1222 buf->flags &= ~V4L2_BUF_FLAG_MAPPED; 1223 buf->flags |= V4L2_BUF_FLAG_QUEUED; 1224 buf->flags &= ~V4L2_BUF_FLAG_DONE; 1225 } else if (buf->memory == V4L2_MEMORY_MMAP) { 1226 buf->flags |= V4L2_BUF_FLAG_MAPPED; 1227 buf->flags |= V4L2_BUF_FLAG_QUEUED; 1228 buf->flags &= ~V4L2_BUF_FLAG_DONE; 1229 1230 /* 1231 * For mmap, frames were allocated at request buffers 1232 */ 1233 } 1234 1235 done: 1236 if (!((buf->flags & NOFLUSH_FLAGS) == NOFLUSH_FLAGS)) 1237 wbinvd(); 1238 1239 if (!atomisp_is_vf_pipe(pipe) && 1240 (buf->reserved2 & ATOMISP_BUFFER_HAS_PER_FRAME_SETTING)) { 1241 /* this buffer will have a per-frame parameter */ 1242 pipe->frame_request_config_id[buf->index] = buf->reserved2 & 1243 ~ATOMISP_BUFFER_HAS_PER_FRAME_SETTING; 1244 dev_dbg(isp->dev, 1245 "This buffer requires per_frame setting which has isp_config_id %d\n", 1246 pipe->frame_request_config_id[buf->index]); 1247 } else { 1248 pipe->frame_request_config_id[buf->index] = 0; 1249 } 1250 1251 pipe->frame_params[buf->index] = NULL; 1252 1253 rt_mutex_unlock(&isp->mutex); 1254 1255 ret = videobuf_qbuf(&pipe->capq, buf); 1256 rt_mutex_lock(&isp->mutex); 1257 if (ret) 1258 goto error; 1259 1260 /* TODO: do this better, not best way to queue to css */ 1261 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) { 1262 if (!list_empty(&pipe->buffers_waiting_for_param)) { 1263 atomisp_handle_parameter_and_buffer(pipe); 1264 } else { 1265 atomisp_qbuffers_to_css(asd); 1266 1267 if (!atomisp_hw_is_isp2401) { 1268 if (!atomisp_is_wdt_running(asd) && atomisp_buffers_queued(asd)) 1269 atomisp_wdt_start(asd); 1270 } else { 1271 if (!atomisp_is_wdt_running(pipe) && 1272 atomisp_buffers_queued_pipe(pipe)) 1273 atomisp_wdt_start_pipe(pipe); 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 if (asd->continuous_mode->val && 1286 atomisp_subdev_source_pad(vdev) 1287 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE && 1288 pipe->capq.streaming && 1289 !asd->enable_raw_buffer_lock->val && 1290 asd->params.offline_parm.num_captures == 1) { 1291 if (!atomisp_hw_is_isp2401) { 1292 asd->pending_capture_request++; 1293 dev_dbg(isp->dev, "Add one pending capture request.\n"); 1294 } else { 1295 if (asd->re_trigger_capture) { 1296 ret = atomisp_css_offline_capture_configure(asd, 1297 asd->params.offline_parm.num_captures, 1298 asd->params.offline_parm.skip_frames, 1299 asd->params.offline_parm.offset); 1300 asd->re_trigger_capture = false; 1301 dev_dbg(isp->dev, "%s Trigger capture again ret=%d\n", 1302 __func__, ret); 1303 1304 } else { 1305 asd->pending_capture_request++; 1306 asd->re_trigger_capture = false; 1307 dev_dbg(isp->dev, "Add one pending capture request.\n"); 1308 } 1309 } 1310 } 1311 rt_mutex_unlock(&isp->mutex); 1312 1313 dev_dbg(isp->dev, "qbuf buffer %d (%s) for asd%d\n", buf->index, 1314 vdev->name, asd->index); 1315 1316 return ret; 1317 1318 error: 1319 rt_mutex_unlock(&isp->mutex); 1320 return ret; 1321 } 1322 1323 static int atomisp_qbuf_file(struct file *file, void *fh, 1324 struct v4l2_buffer *buf) 1325 { 1326 struct video_device *vdev = video_devdata(file); 1327 struct atomisp_device *isp = video_get_drvdata(vdev); 1328 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1329 int ret; 1330 1331 rt_mutex_lock(&isp->mutex); 1332 if (isp->isp_fatal_error) { 1333 ret = -EIO; 1334 goto error; 1335 } 1336 1337 if (!buf || buf->index >= VIDEO_MAX_FRAME || 1338 !pipe->outq.bufs[buf->index]) { 1339 dev_err(isp->dev, "Invalid index for qbuf.\n"); 1340 ret = -EINVAL; 1341 goto error; 1342 } 1343 1344 if (buf->memory != V4L2_MEMORY_MMAP) { 1345 dev_err(isp->dev, "Unsupported memory method\n"); 1346 ret = -EINVAL; 1347 goto error; 1348 } 1349 1350 if (buf->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) { 1351 dev_err(isp->dev, "Unsupported buffer type\n"); 1352 ret = -EINVAL; 1353 goto error; 1354 } 1355 rt_mutex_unlock(&isp->mutex); 1356 1357 return videobuf_qbuf(&pipe->outq, buf); 1358 1359 error: 1360 rt_mutex_unlock(&isp->mutex); 1361 1362 return ret; 1363 } 1364 1365 static int __get_frame_exp_id(struct atomisp_video_pipe *pipe, 1366 struct v4l2_buffer *buf) 1367 { 1368 struct videobuf_vmalloc_memory *vm_mem; 1369 struct ia_css_frame *handle; 1370 int i; 1371 1372 for (i = 0; pipe->capq.bufs[i]; i++) { 1373 vm_mem = pipe->capq.bufs[i]->priv; 1374 handle = vm_mem->vaddr; 1375 if (buf->index == pipe->capq.bufs[i]->i && handle) 1376 return handle->exp_id; 1377 } 1378 return -EINVAL; 1379 } 1380 1381 /* 1382 * Applications call the VIDIOC_DQBUF ioctl to dequeue a filled (capturing) or 1383 * displayed (output buffer)from the driver's outgoing queue 1384 */ 1385 static int atomisp_dqbuf(struct file *file, void *fh, struct v4l2_buffer *buf) 1386 { 1387 struct video_device *vdev = video_devdata(file); 1388 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1389 struct atomisp_sub_device *asd = pipe->asd; 1390 struct atomisp_device *isp = video_get_drvdata(vdev); 1391 int ret = 0; 1392 1393 rt_mutex_lock(&isp->mutex); 1394 1395 if (isp->isp_fatal_error) { 1396 rt_mutex_unlock(&isp->mutex); 1397 return -EIO; 1398 } 1399 1400 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) { 1401 rt_mutex_unlock(&isp->mutex); 1402 dev_err(isp->dev, "%s: reject, as ISP at stopping.\n", 1403 __func__); 1404 return -EIO; 1405 } 1406 1407 rt_mutex_unlock(&isp->mutex); 1408 1409 ret = videobuf_dqbuf(&pipe->capq, buf, file->f_flags & O_NONBLOCK); 1410 if (ret) { 1411 if (ret != -EAGAIN) 1412 dev_dbg(isp->dev, "<%s: %d\n", __func__, ret); 1413 return ret; 1414 } 1415 rt_mutex_lock(&isp->mutex); 1416 buf->bytesused = pipe->pix.sizeimage; 1417 buf->reserved = asd->frame_status[buf->index]; 1418 1419 /* 1420 * Hack: 1421 * Currently frame_status in the enum type which takes no more lower 1422 * 8 bit. 1423 * use bit[31:16] for exp_id as it is only in the range of 1~255 1424 */ 1425 buf->reserved &= 0x0000ffff; 1426 if (!(buf->flags & V4L2_BUF_FLAG_ERROR)) 1427 buf->reserved |= __get_frame_exp_id(pipe, buf) << 16; 1428 buf->reserved2 = pipe->frame_config_id[buf->index]; 1429 rt_mutex_unlock(&isp->mutex); 1430 1431 dev_dbg(isp->dev, 1432 "dqbuf buffer %d (%s) for asd%d with exp_id %d, isp_config_id %d\n", 1433 buf->index, vdev->name, asd->index, buf->reserved >> 16, 1434 buf->reserved2); 1435 return 0; 1436 } 1437 1438 enum ia_css_pipe_id atomisp_get_css_pipe_id(struct atomisp_sub_device *asd) 1439 { 1440 if (ATOMISP_USE_YUVPP(asd)) 1441 return IA_CSS_PIPE_ID_YUVPP; 1442 1443 if (asd->continuous_mode->val) { 1444 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) 1445 return IA_CSS_PIPE_ID_VIDEO; 1446 else 1447 return IA_CSS_PIPE_ID_PREVIEW; 1448 } 1449 1450 /* 1451 * Disable vf_pp and run CSS in video mode. This allows using ISP 1452 * scaling but it has one frame delay due to CSS internal buffering. 1453 */ 1454 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_SCALER) 1455 return IA_CSS_PIPE_ID_VIDEO; 1456 1457 /* 1458 * Disable vf_pp and run CSS in still capture mode. In this mode 1459 * CSS does not cause extra latency with buffering, but scaling 1460 * is not available. 1461 */ 1462 if (asd->vfpp->val == ATOMISP_VFPP_DISABLE_LOWLAT) 1463 return IA_CSS_PIPE_ID_CAPTURE; 1464 1465 switch (asd->run_mode->val) { 1466 case ATOMISP_RUN_MODE_PREVIEW: 1467 return IA_CSS_PIPE_ID_PREVIEW; 1468 case ATOMISP_RUN_MODE_VIDEO: 1469 return IA_CSS_PIPE_ID_VIDEO; 1470 case ATOMISP_RUN_MODE_STILL_CAPTURE: 1471 /* fall through */ 1472 default: 1473 return IA_CSS_PIPE_ID_CAPTURE; 1474 } 1475 } 1476 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 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 */ 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 */ 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 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. */ 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 */ 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 enum ia_css_pipe_id css_pipe_id; 1639 unsigned int sensor_start_stream; 1640 unsigned int wdt_duration = ATOMISP_ISP_TIMEOUT_DURATION; 1641 int ret = 0; 1642 unsigned long irqflags; 1643 1644 dev_dbg(isp->dev, "Start stream on pad %d for asd%d\n", 1645 atomisp_subdev_source_pad(vdev), asd->index); 1646 1647 if (type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 1648 dev_dbg(isp->dev, "unsupported v4l2 buf type\n"); 1649 return -EINVAL; 1650 } 1651 1652 rt_mutex_lock(&isp->mutex); 1653 if (isp->isp_fatal_error) { 1654 ret = -EIO; 1655 goto out; 1656 } 1657 1658 if (asd->streaming == ATOMISP_DEVICE_STREAMING_STOPPING) { 1659 ret = -EBUSY; 1660 goto out; 1661 } 1662 1663 if (pipe->capq.streaming) 1664 goto out; 1665 1666 /* Input system HW workaround */ 1667 atomisp_dma_burst_len_cfg(asd); 1668 1669 /* 1670 * The number of streaming video nodes is based on which 1671 * binary is going to be run. 1672 */ 1673 sensor_start_stream = atomisp_sensor_start_stream(asd); 1674 1675 spin_lock_irqsave(&pipe->irq_lock, irqflags); 1676 if (list_empty(&pipe->capq.stream)) { 1677 spin_unlock_irqrestore(&pipe->irq_lock, irqflags); 1678 dev_dbg(isp->dev, "no buffer in the queue\n"); 1679 ret = -EINVAL; 1680 goto out; 1681 } 1682 spin_unlock_irqrestore(&pipe->irq_lock, irqflags); 1683 1684 ret = videobuf_streamon(&pipe->capq); 1685 if (ret) 1686 goto out; 1687 1688 /* Reset pending capture request count. */ 1689 asd->pending_capture_request = 0; 1690 if (atomisp_hw_is_isp2401) 1691 asd->re_trigger_capture = false; 1692 1693 if ((atomisp_subdev_streaming_count(asd) > sensor_start_stream) && 1694 (!isp->inputs[asd->input_curr].camera_caps->multi_stream_ctrl)) { 1695 /* trigger still capture */ 1696 if (asd->continuous_mode->val && 1697 atomisp_subdev_source_pad(vdev) 1698 == ATOMISP_SUBDEV_PAD_SOURCE_CAPTURE) { 1699 if (asd->run_mode->val == ATOMISP_RUN_MODE_VIDEO) 1700 dev_dbg(isp->dev, "SDV last video raw buffer id: %u\n", 1701 asd->latest_preview_exp_id); 1702 else 1703 dev_dbg(isp->dev, "ZSL last preview raw buffer id: %u\n", 1704 asd->latest_preview_exp_id); 1705 1706 if (asd->delayed_init == ATOMISP_DELAYED_INIT_QUEUED) { 1707 flush_work(&asd->delayed_init_work); 1708 rt_mutex_unlock(&isp->mutex); 1709 if (wait_for_completion_interruptible( 1710 &asd->init_done) != 0) 1711 return -ERESTARTSYS; 1712 rt_mutex_lock(&isp->mutex); 1713 } 1714 1715 /* handle per_frame_setting parameter and buffers */ 1716 atomisp_handle_parameter_and_buffer(pipe); 1717 1718 /* 1719 * only ZSL/SDV capture request will be here, raise 1720 * the ISP freq to the highest possible to minimize 1721 * the S2S latency. 1722 */ 1723 atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, false); 1724 /* 1725 * When asd->enable_raw_buffer_lock->val is true, 1726 * An extra IOCTL is needed to call 1727 * atomisp_css_exp_id_capture and trigger real capture 1728 */ 1729 if (!asd->enable_raw_buffer_lock->val) { 1730 ret = atomisp_css_offline_capture_configure(asd, 1731 asd->params.offline_parm.num_captures, 1732 asd->params.offline_parm.skip_frames, 1733 asd->params.offline_parm.offset); 1734 if (ret) { 1735 ret = -EINVAL; 1736 goto out; 1737 } 1738 if (asd->depth_mode->val) 1739 atomisp_pause_buffer_event(isp); 1740 } 1741 } 1742 atomisp_qbuffers_to_css(asd); 1743 goto out; 1744 } 1745 1746 if (asd->streaming == ATOMISP_DEVICE_STREAMING_ENABLED) { 1747 atomisp_qbuffers_to_css(asd); 1748 goto start_sensor; 1749 } 1750 1751 css_pipe_id = atomisp_get_css_pipe_id(asd); 1752 1753 ret = atomisp_acc_load_extensions(asd); 1754 if (ret < 0) { 1755 dev_err(isp->dev, "acc extension failed to load\n"); 1756 goto out; 1757 } 1758 1759 if (asd->params.css_update_params_needed) { 1760 atomisp_apply_css_parameters(asd, &asd->params.css_param); 1761 if (asd->params.css_param.update_flag.dz_config) 1762 asd->params.config.dz_config = &asd->params.css_param.dz_config; 1763 atomisp_css_update_isp_params(asd); 1764 asd->params.css_update_params_needed = false; 1765 memset(&asd->params.css_param.update_flag, 0, 1766 sizeof(struct atomisp_parameters)); 1767 } 1768 asd->params.dvs_6axis = NULL; 1769 1770 ret = atomisp_css_start(asd, css_pipe_id, false); 1771 if (ret) 1772 goto out; 1773 1774 asd->streaming = ATOMISP_DEVICE_STREAMING_ENABLED; 1775 atomic_set(&asd->sof_count, -1); 1776 atomic_set(&asd->sequence, -1); 1777 atomic_set(&asd->sequence_temp, -1); 1778 if (isp->sw_contex.file_input) 1779 wdt_duration = ATOMISP_ISP_FILE_TIMEOUT_DURATION; 1780 1781 asd->params.dis_proj_data_valid = false; 1782 asd->latest_preview_exp_id = 0; 1783 asd->postview_exp_id = 1; 1784 asd->preview_exp_id = 1; 1785 1786 /* handle per_frame_setting parameter and buffers */ 1787 atomisp_handle_parameter_and_buffer(pipe); 1788 1789 atomisp_qbuffers_to_css(asd); 1790 1791 /* Only start sensor when the last streaming instance started */ 1792 if (atomisp_subdev_streaming_count(asd) < sensor_start_stream) 1793 goto out; 1794 1795 start_sensor: 1796 if (isp->flash) { 1797 asd->params.num_flash_frames = 0; 1798 asd->params.flash_state = ATOMISP_FLASH_IDLE; 1799 atomisp_setup_flash(asd); 1800 } 1801 1802 if (!isp->sw_contex.file_input) { 1803 atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF, 1804 atomisp_css_valid_sof(isp)); 1805 atomisp_csi2_configure(asd); 1806 /* 1807 * set freq to max when streaming count > 1 which indicate 1808 * dual camera would run 1809 */ 1810 if (atomisp_streaming_count(isp) > 1) { 1811 if (atomisp_freq_scaling(isp, 1812 ATOMISP_DFS_MODE_MAX, false) < 0) 1813 dev_dbg(isp->dev, "dfs failed!\n"); 1814 } else { 1815 if (atomisp_freq_scaling(isp, 1816 ATOMISP_DFS_MODE_AUTO, false) < 0) 1817 dev_dbg(isp->dev, "dfs failed!\n"); 1818 } 1819 } else { 1820 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_MAX, false) < 0) 1821 dev_dbg(isp->dev, "dfs failed!\n"); 1822 } 1823 1824 if (asd->depth_mode->val && atomisp_streaming_count(isp) == 1825 ATOMISP_DEPTH_SENSOR_STREAMON_COUNT) { 1826 ret = atomisp_stream_on_master_slave_sensor(isp, false); 1827 if (ret) { 1828 dev_err(isp->dev, "master slave sensor stream on failed!\n"); 1829 goto out; 1830 } 1831 if (!atomisp_hw_is_isp2401) { 1832 __wdt_on_master_slave_sensor(isp, wdt_duration); 1833 } else { 1834 __wdt_on_master_slave_sensor_pipe(pipe, wdt_duration, true); 1835 } 1836 goto start_delay_wq; 1837 } else if (asd->depth_mode->val && (atomisp_streaming_count(isp) < 1838 ATOMISP_DEPTH_SENSOR_STREAMON_COUNT)) { 1839 if (atomisp_hw_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(isp->pdev, MRFLD_PCI_CSI_CONTROL, 1848 isp->saved_regs.csi_control | 1849 MRFLD_PCI_CSI_CONTROL_CSI_READY); 1850 } 1851 1852 /* stream on the sensor */ 1853 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 1854 video, s_stream, 1); 1855 if (ret) { 1856 asd->streaming = ATOMISP_DEVICE_STREAMING_DISABLED; 1857 ret = -EINVAL; 1858 goto out; 1859 } 1860 1861 if (!atomisp_hw_is_isp2401) { 1862 if (atomisp_buffers_queued(asd)) 1863 atomisp_wdt_refresh(asd, wdt_duration); 1864 } else { 1865 if (atomisp_buffers_queued_pipe(pipe)) 1866 atomisp_wdt_refresh_pipe(pipe, wdt_duration); 1867 } 1868 1869 start_delay_wq: 1870 if (asd->continuous_mode->val) { 1871 struct v4l2_mbus_framefmt *sink; 1872 1873 sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL, 1874 V4L2_SUBDEV_FORMAT_ACTIVE, 1875 ATOMISP_SUBDEV_PAD_SINK); 1876 1877 reinit_completion(&asd->init_done); 1878 asd->delayed_init = ATOMISP_DELAYED_INIT_QUEUED; 1879 queue_work(asd->delayed_init_workq, &asd->delayed_init_work); 1880 atomisp_css_set_cont_prev_start_time(isp, 1881 ATOMISP_CALC_CSS_PREV_OVERLAP(sink->height)); 1882 } else { 1883 asd->delayed_init = ATOMISP_DELAYED_INIT_NOT_QUEUED; 1884 } 1885 out: 1886 rt_mutex_unlock(&isp->mutex); 1887 return ret; 1888 } 1889 1890 int __atomisp_streamoff(struct file *file, void *fh, enum v4l2_buf_type type) 1891 { 1892 struct video_device *vdev = video_devdata(file); 1893 struct atomisp_device *isp = video_get_drvdata(vdev); 1894 struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev); 1895 struct atomisp_sub_device *asd = pipe->asd; 1896 struct atomisp_video_pipe *capture_pipe = NULL; 1897 struct atomisp_video_pipe *vf_pipe = NULL; 1898 struct atomisp_video_pipe *preview_pipe = NULL; 1899 struct atomisp_video_pipe *video_pipe = NULL; 1900 struct videobuf_buffer *vb, *_vb; 1901 enum ia_css_pipe_id css_pipe_id; 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(isp->pdev, MRFLD_PCI_CSI_CONTROL, 2080 isp->saved_regs.csi_control & 2081 ~MRFLD_PCI_CSI_CONTROL_CSI_READY); 2082 } 2083 2084 if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_LOW, false)) 2085 dev_warn(isp->dev, "DFS failed.\n"); 2086 /* 2087 * ISP work around, need to reset isp 2088 * Is it correct time to reset ISP when first node does streamoff? 2089 */ 2090 if (isp->sw_contex.power_state == ATOM_ISP_POWER_UP) { 2091 unsigned int i; 2092 bool recreate_streams[MAX_STREAM_NUM] = {0}; 2093 2094 if (isp->isp_timeout) 2095 dev_err(isp->dev, "%s: Resetting with WA activated", 2096 __func__); 2097 /* 2098 * It is possible that the other asd stream is in the stage 2099 * that v4l2_setfmt is just get called on it, which will 2100 * create css stream on that stream. But at this point, there 2101 * is no way to destroy the css stream created on that stream. 2102 * 2103 * So force stream destroy here. 2104 */ 2105 for (i = 0; i < isp->num_of_streams; i++) { 2106 if (isp->asd[i].stream_prepared) { 2107 atomisp_destroy_pipes_stream_force(&isp-> 2108 asd[i]); 2109 recreate_streams[i] = true; 2110 } 2111 } 2112 2113 /* disable PUNIT/ISP acknowlede/handshake - SRSE=3 */ 2114 pci_write_config_dword(isp->pdev, PCI_I_CONTROL, isp->saved_regs.i_control | 2115 MRFLD_PCI_I_CONTROL_SRSE_RESET_MASK); 2116 dev_err(isp->dev, "atomisp_reset"); 2117 atomisp_reset(isp); 2118 for (i = 0; i < isp->num_of_streams; i++) { 2119 if (recreate_streams[i]) 2120 atomisp_create_pipes_stream(&isp->asd[i]); 2121 } 2122 isp->isp_timeout = false; 2123 } 2124 return ret; 2125 } 2126 2127 static int atomisp_streamoff(struct file *file, void *fh, 2128 enum v4l2_buf_type type) 2129 { 2130 struct video_device *vdev = video_devdata(file); 2131 struct atomisp_device *isp = video_get_drvdata(vdev); 2132 int rval; 2133 2134 mutex_lock(&isp->streamoff_mutex); 2135 rt_mutex_lock(&isp->mutex); 2136 rval = __atomisp_streamoff(file, fh, type); 2137 rt_mutex_unlock(&isp->mutex); 2138 mutex_unlock(&isp->streamoff_mutex); 2139 2140 return rval; 2141 } 2142 2143 /* 2144 * To get the current value of a control. 2145 * applications initialize the id field of a struct v4l2_control and 2146 * call this ioctl with a pointer to this structure 2147 */ 2148 static int atomisp_g_ctrl(struct file *file, void *fh, 2149 struct v4l2_control *control) 2150 { 2151 struct video_device *vdev = video_devdata(file); 2152 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2153 struct atomisp_device *isp = video_get_drvdata(vdev); 2154 int i, ret = -EINVAL; 2155 2156 for (i = 0; i < ctrls_num; i++) { 2157 if (ci_v4l2_controls[i].id == control->id) { 2158 ret = 0; 2159 break; 2160 } 2161 } 2162 2163 if (ret) 2164 return ret; 2165 2166 rt_mutex_lock(&isp->mutex); 2167 2168 switch (control->id) { 2169 case V4L2_CID_IRIS_ABSOLUTE: 2170 case V4L2_CID_EXPOSURE_ABSOLUTE: 2171 case V4L2_CID_FNUMBER_ABSOLUTE: 2172 case V4L2_CID_2A_STATUS: 2173 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: 2174 case V4L2_CID_EXPOSURE: 2175 case V4L2_CID_EXPOSURE_AUTO: 2176 case V4L2_CID_SCENE_MODE: 2177 case V4L2_CID_ISO_SENSITIVITY: 2178 case V4L2_CID_ISO_SENSITIVITY_AUTO: 2179 case V4L2_CID_CONTRAST: 2180 case V4L2_CID_SATURATION: 2181 case V4L2_CID_SHARPNESS: 2182 case V4L2_CID_3A_LOCK: 2183 case V4L2_CID_EXPOSURE_ZONE_NUM: 2184 case V4L2_CID_TEST_PATTERN: 2185 case V4L2_CID_TEST_PATTERN_COLOR_R: 2186 case V4L2_CID_TEST_PATTERN_COLOR_GR: 2187 case V4L2_CID_TEST_PATTERN_COLOR_GB: 2188 case V4L2_CID_TEST_PATTERN_COLOR_B: 2189 rt_mutex_unlock(&isp->mutex); 2190 return v4l2_g_ctrl(isp->inputs[asd->input_curr].camera-> 2191 ctrl_handler, control); 2192 case V4L2_CID_COLORFX: 2193 ret = atomisp_color_effect(asd, 0, &control->value); 2194 break; 2195 case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION: 2196 ret = atomisp_bad_pixel(asd, 0, &control->value); 2197 break; 2198 case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC: 2199 ret = atomisp_gdc_cac(asd, 0, &control->value); 2200 break; 2201 case V4L2_CID_ATOMISP_VIDEO_STABLIZATION: 2202 ret = atomisp_video_stable(asd, 0, &control->value); 2203 break; 2204 case V4L2_CID_ATOMISP_FIXED_PATTERN_NR: 2205 ret = atomisp_fixed_pattern(asd, 0, &control->value); 2206 break; 2207 case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION: 2208 ret = atomisp_false_color(asd, 0, &control->value); 2209 break; 2210 case V4L2_CID_ATOMISP_LOW_LIGHT: 2211 ret = atomisp_low_light(asd, 0, &control->value); 2212 break; 2213 default: 2214 ret = -EINVAL; 2215 break; 2216 } 2217 2218 rt_mutex_unlock(&isp->mutex); 2219 return ret; 2220 } 2221 2222 /* 2223 * To change the value of a control. 2224 * applications initialize the id and value fields of a struct v4l2_control 2225 * and call this ioctl. 2226 */ 2227 static int atomisp_s_ctrl(struct file *file, void *fh, 2228 struct v4l2_control *control) 2229 { 2230 struct video_device *vdev = video_devdata(file); 2231 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2232 struct atomisp_device *isp = video_get_drvdata(vdev); 2233 int i, ret = -EINVAL; 2234 2235 for (i = 0; i < ctrls_num; i++) { 2236 if (ci_v4l2_controls[i].id == control->id) { 2237 ret = 0; 2238 break; 2239 } 2240 } 2241 2242 if (ret) 2243 return ret; 2244 2245 rt_mutex_lock(&isp->mutex); 2246 switch (control->id) { 2247 case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE: 2248 case V4L2_CID_EXPOSURE: 2249 case V4L2_CID_EXPOSURE_AUTO: 2250 case V4L2_CID_EXPOSURE_AUTO_PRIORITY: 2251 case V4L2_CID_SCENE_MODE: 2252 case V4L2_CID_ISO_SENSITIVITY: 2253 case V4L2_CID_ISO_SENSITIVITY_AUTO: 2254 case V4L2_CID_POWER_LINE_FREQUENCY: 2255 case V4L2_CID_EXPOSURE_METERING: 2256 case V4L2_CID_CONTRAST: 2257 case V4L2_CID_SATURATION: 2258 case V4L2_CID_SHARPNESS: 2259 case V4L2_CID_3A_LOCK: 2260 case V4L2_CID_COLORFX_CBCR: 2261 case V4L2_CID_TEST_PATTERN: 2262 case V4L2_CID_TEST_PATTERN_COLOR_R: 2263 case V4L2_CID_TEST_PATTERN_COLOR_GR: 2264 case V4L2_CID_TEST_PATTERN_COLOR_GB: 2265 case V4L2_CID_TEST_PATTERN_COLOR_B: 2266 rt_mutex_unlock(&isp->mutex); 2267 return v4l2_s_ctrl(NULL, 2268 isp->inputs[asd->input_curr].camera-> 2269 ctrl_handler, control); 2270 case V4L2_CID_COLORFX: 2271 ret = atomisp_color_effect(asd, 1, &control->value); 2272 break; 2273 case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION: 2274 ret = atomisp_bad_pixel(asd, 1, &control->value); 2275 break; 2276 case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC: 2277 ret = atomisp_gdc_cac(asd, 1, &control->value); 2278 break; 2279 case V4L2_CID_ATOMISP_VIDEO_STABLIZATION: 2280 ret = atomisp_video_stable(asd, 1, &control->value); 2281 break; 2282 case V4L2_CID_ATOMISP_FIXED_PATTERN_NR: 2283 ret = atomisp_fixed_pattern(asd, 1, &control->value); 2284 break; 2285 case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION: 2286 ret = atomisp_false_color(asd, 1, &control->value); 2287 break; 2288 case V4L2_CID_REQUEST_FLASH: 2289 ret = atomisp_flash_enable(asd, control->value); 2290 break; 2291 case V4L2_CID_ATOMISP_LOW_LIGHT: 2292 ret = atomisp_low_light(asd, 1, &control->value); 2293 break; 2294 default: 2295 ret = -EINVAL; 2296 break; 2297 } 2298 rt_mutex_unlock(&isp->mutex); 2299 return ret; 2300 } 2301 2302 /* 2303 * To query the attributes of a control. 2304 * applications set the id field of a struct v4l2_queryctrl and call the 2305 * this ioctl with a pointer to this structure. The driver fills 2306 * the rest of the structure. 2307 */ 2308 static int atomisp_queryctl(struct file *file, void *fh, 2309 struct v4l2_queryctrl *qc) 2310 { 2311 int i, ret = -EINVAL; 2312 struct video_device *vdev = video_devdata(file); 2313 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2314 struct atomisp_device *isp = video_get_drvdata(vdev); 2315 2316 switch (qc->id) { 2317 case V4L2_CID_FOCUS_ABSOLUTE: 2318 case V4L2_CID_FOCUS_RELATIVE: 2319 case V4L2_CID_FOCUS_STATUS: 2320 if (!atomisp_hw_is_isp2401) { 2321 return v4l2_queryctrl(isp->inputs[asd->input_curr].camera-> 2322 ctrl_handler, qc); 2323 } 2324 /* ISP2401 */ 2325 if (isp->motor) 2326 return v4l2_queryctrl(isp->motor->ctrl_handler, qc); 2327 else 2328 return v4l2_queryctrl(isp->inputs[asd->input_curr]. 2329 camera->ctrl_handler, qc); 2330 } 2331 2332 if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL) 2333 return ret; 2334 2335 for (i = 0; i < ctrls_num; i++) { 2336 if (ci_v4l2_controls[i].id == qc->id) { 2337 memcpy(qc, &ci_v4l2_controls[i], 2338 sizeof(struct v4l2_queryctrl)); 2339 qc->reserved[0] = 0; 2340 ret = 0; 2341 break; 2342 } 2343 } 2344 if (ret != 0) 2345 qc->flags = V4L2_CTRL_FLAG_DISABLED; 2346 2347 return ret; 2348 } 2349 2350 static int atomisp_camera_g_ext_ctrls(struct file *file, void *fh, 2351 struct v4l2_ext_controls *c) 2352 { 2353 struct video_device *vdev = video_devdata(file); 2354 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2355 struct atomisp_device *isp = video_get_drvdata(vdev); 2356 struct v4l2_subdev *motor; 2357 struct v4l2_control ctrl; 2358 int i; 2359 int ret = 0; 2360 2361 if (!atomisp_hw_is_isp2401) 2362 motor = isp->inputs[asd->input_curr].motor; 2363 else 2364 motor = isp->motor; 2365 2366 for (i = 0; i < c->count; i++) { 2367 ctrl.id = c->controls[i].id; 2368 ctrl.value = c->controls[i].value; 2369 switch (ctrl.id) { 2370 case V4L2_CID_EXPOSURE_ABSOLUTE: 2371 case V4L2_CID_EXPOSURE_AUTO: 2372 case V4L2_CID_IRIS_ABSOLUTE: 2373 case V4L2_CID_FNUMBER_ABSOLUTE: 2374 case V4L2_CID_BIN_FACTOR_HORZ: 2375 case V4L2_CID_BIN_FACTOR_VERT: 2376 case V4L2_CID_3A_LOCK: 2377 case V4L2_CID_TEST_PATTERN: 2378 case V4L2_CID_TEST_PATTERN_COLOR_R: 2379 case V4L2_CID_TEST_PATTERN_COLOR_GR: 2380 case V4L2_CID_TEST_PATTERN_COLOR_GB: 2381 case V4L2_CID_TEST_PATTERN_COLOR_B: 2382 /* 2383 * Exposure related control will be handled by sensor 2384 * driver 2385 */ 2386 ret = 2387 v4l2_g_ctrl(isp->inputs[asd->input_curr].camera-> 2388 ctrl_handler, &ctrl); 2389 break; 2390 case V4L2_CID_FOCUS_ABSOLUTE: 2391 case V4L2_CID_FOCUS_RELATIVE: 2392 case V4L2_CID_FOCUS_STATUS: 2393 case V4L2_CID_FOCUS_AUTO: 2394 if (motor) 2395 ret = v4l2_g_ctrl(motor->ctrl_handler, &ctrl); 2396 break; 2397 case V4L2_CID_FLASH_STATUS: 2398 case V4L2_CID_FLASH_INTENSITY: 2399 case V4L2_CID_FLASH_TORCH_INTENSITY: 2400 case V4L2_CID_FLASH_INDICATOR_INTENSITY: 2401 case V4L2_CID_FLASH_TIMEOUT: 2402 case V4L2_CID_FLASH_STROBE: 2403 case V4L2_CID_FLASH_MODE: 2404 case V4L2_CID_FLASH_STATUS_REGISTER: 2405 if (isp->flash) 2406 ret = 2407 v4l2_g_ctrl(isp->flash->ctrl_handler, 2408 &ctrl); 2409 break; 2410 case V4L2_CID_ZOOM_ABSOLUTE: 2411 rt_mutex_lock(&isp->mutex); 2412 ret = atomisp_digital_zoom(asd, 0, &ctrl.value); 2413 rt_mutex_unlock(&isp->mutex); 2414 break; 2415 case V4L2_CID_G_SKIP_FRAMES: 2416 ret = v4l2_subdev_call( 2417 isp->inputs[asd->input_curr].camera, 2418 sensor, g_skip_frames, (u32 *)&ctrl.value); 2419 break; 2420 default: 2421 ret = -EINVAL; 2422 } 2423 2424 if (ret) { 2425 c->error_idx = i; 2426 break; 2427 } 2428 c->controls[i].value = ctrl.value; 2429 } 2430 return ret; 2431 } 2432 2433 /* This ioctl allows the application to get multiple controls by class */ 2434 static int atomisp_g_ext_ctrls(struct file *file, void *fh, 2435 struct v4l2_ext_controls *c) 2436 { 2437 struct v4l2_control ctrl; 2438 int i, ret = 0; 2439 2440 /* input_lock is not need for the Camera related IOCTLs 2441 * The input_lock downgrade the FPS of 3A*/ 2442 ret = atomisp_camera_g_ext_ctrls(file, fh, c); 2443 if (ret != -EINVAL) 2444 return ret; 2445 2446 for (i = 0; i < c->count; i++) { 2447 ctrl.id = c->controls[i].id; 2448 ctrl.value = c->controls[i].value; 2449 ret = atomisp_g_ctrl(file, fh, &ctrl); 2450 c->controls[i].value = ctrl.value; 2451 if (ret) { 2452 c->error_idx = i; 2453 break; 2454 } 2455 } 2456 return ret; 2457 } 2458 2459 static int atomisp_camera_s_ext_ctrls(struct file *file, void *fh, 2460 struct v4l2_ext_controls *c) 2461 { 2462 struct video_device *vdev = video_devdata(file); 2463 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2464 struct atomisp_device *isp = video_get_drvdata(vdev); 2465 struct v4l2_subdev *motor; 2466 struct v4l2_control ctrl; 2467 int i; 2468 int ret = 0; 2469 2470 if (!atomisp_hw_is_isp2401) 2471 motor = isp->inputs[asd->input_curr].motor; 2472 else 2473 motor = isp->motor; 2474 2475 for (i = 0; i < c->count; i++) { 2476 struct v4l2_ctrl *ctr; 2477 2478 ctrl.id = c->controls[i].id; 2479 ctrl.value = c->controls[i].value; 2480 switch (ctrl.id) { 2481 case V4L2_CID_EXPOSURE_ABSOLUTE: 2482 case V4L2_CID_EXPOSURE_AUTO: 2483 case V4L2_CID_EXPOSURE_METERING: 2484 case V4L2_CID_IRIS_ABSOLUTE: 2485 case V4L2_CID_FNUMBER_ABSOLUTE: 2486 case V4L2_CID_VCM_TIMING: 2487 case V4L2_CID_VCM_SLEW: 2488 case V4L2_CID_3A_LOCK: 2489 case V4L2_CID_TEST_PATTERN: 2490 case V4L2_CID_TEST_PATTERN_COLOR_R: 2491 case V4L2_CID_TEST_PATTERN_COLOR_GR: 2492 case V4L2_CID_TEST_PATTERN_COLOR_GB: 2493 case V4L2_CID_TEST_PATTERN_COLOR_B: 2494 ret = v4l2_s_ctrl(NULL, 2495 isp->inputs[asd->input_curr].camera-> 2496 ctrl_handler, &ctrl); 2497 break; 2498 case V4L2_CID_FOCUS_ABSOLUTE: 2499 case V4L2_CID_FOCUS_RELATIVE: 2500 case V4L2_CID_FOCUS_STATUS: 2501 case V4L2_CID_FOCUS_AUTO: 2502 if (motor) 2503 ret = v4l2_s_ctrl(NULL, motor->ctrl_handler, 2504 &ctrl); 2505 else 2506 ret = v4l2_s_ctrl(NULL, 2507 isp->inputs[asd->input_curr]. 2508 camera->ctrl_handler, &ctrl); 2509 break; 2510 case V4L2_CID_FLASH_STATUS: 2511 case V4L2_CID_FLASH_INTENSITY: 2512 case V4L2_CID_FLASH_TORCH_INTENSITY: 2513 case V4L2_CID_FLASH_INDICATOR_INTENSITY: 2514 case V4L2_CID_FLASH_TIMEOUT: 2515 case V4L2_CID_FLASH_STROBE: 2516 case V4L2_CID_FLASH_MODE: 2517 case V4L2_CID_FLASH_STATUS_REGISTER: 2518 rt_mutex_lock(&isp->mutex); 2519 if (isp->flash) { 2520 ret = 2521 v4l2_s_ctrl(NULL, isp->flash->ctrl_handler, 2522 &ctrl); 2523 /* When flash mode is changed we need to reset 2524 * flash state */ 2525 if (ctrl.id == V4L2_CID_FLASH_MODE) { 2526 asd->params.flash_state = 2527 ATOMISP_FLASH_IDLE; 2528 asd->params.num_flash_frames = 0; 2529 } 2530 } 2531 rt_mutex_unlock(&isp->mutex); 2532 break; 2533 case V4L2_CID_ZOOM_ABSOLUTE: 2534 rt_mutex_lock(&isp->mutex); 2535 ret = atomisp_digital_zoom(asd, 1, &ctrl.value); 2536 rt_mutex_unlock(&isp->mutex); 2537 break; 2538 default: 2539 ctr = v4l2_ctrl_find(&asd->ctrl_handler, ctrl.id); 2540 if (ctr) 2541 ret = v4l2_ctrl_s_ctrl(ctr, ctrl.value); 2542 else 2543 ret = -EINVAL; 2544 } 2545 2546 if (ret) { 2547 c->error_idx = i; 2548 break; 2549 } 2550 c->controls[i].value = ctrl.value; 2551 } 2552 return ret; 2553 } 2554 2555 /* This ioctl allows the application to set multiple controls by class */ 2556 static int atomisp_s_ext_ctrls(struct file *file, void *fh, 2557 struct v4l2_ext_controls *c) 2558 { 2559 struct v4l2_control ctrl; 2560 int i, ret = 0; 2561 2562 /* input_lock is not need for the Camera related IOCTLs 2563 * The input_lock downgrade the FPS of 3A*/ 2564 ret = atomisp_camera_s_ext_ctrls(file, fh, c); 2565 if (ret != -EINVAL) 2566 return ret; 2567 2568 for (i = 0; i < c->count; i++) { 2569 ctrl.id = c->controls[i].id; 2570 ctrl.value = c->controls[i].value; 2571 ret = atomisp_s_ctrl(file, fh, &ctrl); 2572 c->controls[i].value = ctrl.value; 2573 if (ret) { 2574 c->error_idx = i; 2575 break; 2576 } 2577 } 2578 return ret; 2579 } 2580 2581 /* 2582 * vidioc_g/s_param are used to switch isp running mode 2583 */ 2584 static int atomisp_g_parm(struct file *file, void *fh, 2585 struct v4l2_streamparm *parm) 2586 { 2587 struct video_device *vdev = video_devdata(file); 2588 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2589 struct atomisp_device *isp = video_get_drvdata(vdev); 2590 2591 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2592 dev_err(isp->dev, "unsupport v4l2 buf type\n"); 2593 return -EINVAL; 2594 } 2595 2596 rt_mutex_lock(&isp->mutex); 2597 parm->parm.capture.capturemode = asd->run_mode->val; 2598 rt_mutex_unlock(&isp->mutex); 2599 2600 return 0; 2601 } 2602 2603 static int atomisp_s_parm(struct file *file, void *fh, 2604 struct v4l2_streamparm *parm) 2605 { 2606 struct video_device *vdev = video_devdata(file); 2607 struct atomisp_device *isp = video_get_drvdata(vdev); 2608 struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd; 2609 int mode; 2610 int rval; 2611 int fps; 2612 2613 if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) { 2614 dev_err(isp->dev, "unsupport v4l2 buf type\n"); 2615 return -EINVAL; 2616 } 2617 2618 rt_mutex_lock(&isp->mutex); 2619 2620 asd->high_speed_mode = false; 2621 switch (parm->parm.capture.capturemode) { 2622 case CI_MODE_NONE: { 2623 struct v4l2_subdev_frame_interval fi = {0}; 2624 2625 fi.interval = parm->parm.capture.timeperframe; 2626 2627 rval = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 2628 video, s_frame_interval, &fi); 2629 if (!rval) 2630 parm->parm.capture.timeperframe = fi.interval; 2631 2632 if (fi.interval.numerator != 0) { 2633 fps = fi.interval.denominator / fi.interval.numerator; 2634 if (fps > 30) 2635 asd->high_speed_mode = true; 2636 } 2637 2638 goto out; 2639 } 2640 case CI_MODE_VIDEO: 2641 mode = ATOMISP_RUN_MODE_VIDEO; 2642 break; 2643 case CI_MODE_STILL_CAPTURE: 2644 mode = ATOMISP_RUN_MODE_STILL_CAPTURE; 2645 break; 2646 case CI_MODE_CONTINUOUS: 2647 mode = ATOMISP_RUN_MODE_CONTINUOUS_CAPTURE; 2648 break; 2649 case CI_MODE_PREVIEW: 2650 mode = ATOMISP_RUN_MODE_PREVIEW; 2651 break; 2652 default: 2653 rval = -EINVAL; 2654 goto out; 2655 } 2656 2657 rval = v4l2_ctrl_s_ctrl(asd->run_mode, mode); 2658 2659 out: 2660 rt_mutex_unlock(&isp->mutex); 2661 2662 return rval == -ENOIOCTLCMD ? 0 : rval; 2663 } 2664 2665 static int atomisp_s_parm_file(struct file *file, void *fh, 2666 struct v4l2_streamparm *parm) 2667 { 2668 struct video_device *vdev = video_devdata(file); 2669 struct atomisp_device *isp = video_get_drvdata(vdev); 2670 2671 if (parm->type != V4L2_BUF_TYPE_VIDEO_OUTPUT) { 2672 dev_err(isp->dev, "unsupport v4l2 buf type for output\n"); 2673 return -EINVAL; 2674 } 2675 2676 rt_mutex_lock(&isp->mutex); 2677 isp->sw_contex.file_input = true; 2678 rt_mutex_unlock(&isp->mutex); 2679 2680 return 0; 2681 } 2682 2683 static long atomisp_vidioc_default(struct file *file, void *fh, 2684 bool valid_prio, unsigned int cmd, void *arg) 2685 { 2686 struct video_device *vdev = video_devdata(file); 2687 struct atomisp_device *isp = video_get_drvdata(vdev); 2688 struct atomisp_sub_device *asd; 2689 struct v4l2_subdev *motor; 2690 bool acc_node; 2691 int err; 2692 2693 acc_node = !strcmp(vdev->name, "ATOMISP ISP ACC"); 2694 if (acc_node) 2695 asd = atomisp_to_acc_pipe(vdev)->asd; 2696 else 2697 asd = atomisp_to_video_pipe(vdev)->asd; 2698 2699 if (!atomisp_hw_is_isp2401) 2700 motor = isp->inputs[asd->input_curr].motor; 2701 else 2702 motor = isp->motor; 2703 2704 switch (cmd) { 2705 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA: 2706 case ATOMISP_IOC_S_EXPOSURE: 2707 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP: 2708 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA: 2709 case ATOMISP_IOC_EXT_ISP_CTRL: 2710 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO: 2711 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE: 2712 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE: 2713 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT: 2714 case ATOMISP_IOC_S_SENSOR_EE_CONFIG: 2715 case ATOMISP_IOC_G_UPDATE_EXPOSURE: 2716 /* we do not need take isp->mutex for these IOCTLs */ 2717 break; 2718 default: 2719 rt_mutex_lock(&isp->mutex); 2720 break; 2721 } 2722 switch (cmd) { 2723 case ATOMISP_IOC_S_SENSOR_RUNMODE: 2724 if (atomisp_hw_is_isp2401) 2725 err = atomisp_set_sensor_runmode(asd, arg); 2726 else 2727 err = -EINVAL; 2728 break; 2729 2730 case ATOMISP_IOC_G_XNR: 2731 err = atomisp_xnr(asd, 0, arg); 2732 break; 2733 2734 case ATOMISP_IOC_S_XNR: 2735 err = atomisp_xnr(asd, 1, arg); 2736 break; 2737 2738 case ATOMISP_IOC_G_NR: 2739 err = atomisp_nr(asd, 0, arg); 2740 break; 2741 2742 case ATOMISP_IOC_S_NR: 2743 err = atomisp_nr(asd, 1, arg); 2744 break; 2745 2746 case ATOMISP_IOC_G_TNR: 2747 err = atomisp_tnr(asd, 0, arg); 2748 break; 2749 2750 case ATOMISP_IOC_S_TNR: 2751 err = atomisp_tnr(asd, 1, arg); 2752 break; 2753 2754 case ATOMISP_IOC_G_BLACK_LEVEL_COMP: 2755 err = atomisp_black_level(asd, 0, arg); 2756 break; 2757 2758 case ATOMISP_IOC_S_BLACK_LEVEL_COMP: 2759 err = atomisp_black_level(asd, 1, arg); 2760 break; 2761 2762 case ATOMISP_IOC_G_EE: 2763 err = atomisp_ee(asd, 0, arg); 2764 break; 2765 2766 case ATOMISP_IOC_S_EE: 2767 err = atomisp_ee(asd, 1, arg); 2768 break; 2769 2770 case ATOMISP_IOC_G_DIS_STAT: 2771 err = atomisp_get_dis_stat(asd, arg); 2772 break; 2773 2774 case ATOMISP_IOC_G_DVS2_BQ_RESOLUTIONS: 2775 err = atomisp_get_dvs2_bq_resolutions(asd, arg); 2776 break; 2777 2778 case ATOMISP_IOC_S_DIS_COEFS: 2779 err = atomisp_css_cp_dvs2_coefs(asd, arg, 2780 &asd->params.css_param, true); 2781 if (!err && arg) 2782 asd->params.css_update_params_needed = true; 2783 break; 2784 2785 case ATOMISP_IOC_S_DIS_VECTOR: 2786 err = atomisp_cp_dvs_6axis_config(asd, arg, 2787 &asd->params.css_param, true); 2788 if (!err && arg) 2789 asd->params.css_update_params_needed = true; 2790 break; 2791 2792 case ATOMISP_IOC_G_ISP_PARM: 2793 err = atomisp_param(asd, 0, arg); 2794 break; 2795 2796 case ATOMISP_IOC_S_ISP_PARM: 2797 err = atomisp_param(asd, 1, arg); 2798 break; 2799 2800 case ATOMISP_IOC_G_3A_STAT: 2801 err = atomisp_3a_stat(asd, 0, arg); 2802 break; 2803 2804 case ATOMISP_IOC_G_ISP_GAMMA: 2805 err = atomisp_gamma(asd, 0, arg); 2806 break; 2807 2808 case ATOMISP_IOC_S_ISP_GAMMA: 2809 err = atomisp_gamma(asd, 1, arg); 2810 break; 2811 2812 case ATOMISP_IOC_G_ISP_GDC_TAB: 2813 err = atomisp_gdc_cac_table(asd, 0, arg); 2814 break; 2815 2816 case ATOMISP_IOC_S_ISP_GDC_TAB: 2817 err = atomisp_gdc_cac_table(asd, 1, arg); 2818 break; 2819 2820 case ATOMISP_IOC_G_ISP_MACC: 2821 err = atomisp_macc_table(asd, 0, arg); 2822 break; 2823 2824 case ATOMISP_IOC_S_ISP_MACC: 2825 err = atomisp_macc_table(asd, 1, arg); 2826 break; 2827 2828 case ATOMISP_IOC_G_ISP_BAD_PIXEL_DETECTION: 2829 err = atomisp_bad_pixel_param(asd, 0, arg); 2830 break; 2831 2832 case ATOMISP_IOC_S_ISP_BAD_PIXEL_DETECTION: 2833 err = atomisp_bad_pixel_param(asd, 1, arg); 2834 break; 2835 2836 case ATOMISP_IOC_G_ISP_FALSE_COLOR_CORRECTION: 2837 err = atomisp_false_color_param(asd, 0, arg); 2838 break; 2839 2840 case ATOMISP_IOC_S_ISP_FALSE_COLOR_CORRECTION: 2841 err = atomisp_false_color_param(asd, 1, arg); 2842 break; 2843 2844 case ATOMISP_IOC_G_ISP_CTC: 2845 err = atomisp_ctc(asd, 0, arg); 2846 break; 2847 2848 case ATOMISP_IOC_S_ISP_CTC: 2849 err = atomisp_ctc(asd, 1, arg); 2850 break; 2851 2852 case ATOMISP_IOC_G_ISP_WHITE_BALANCE: 2853 err = atomisp_white_balance_param(asd, 0, arg); 2854 break; 2855 2856 case ATOMISP_IOC_S_ISP_WHITE_BALANCE: 2857 err = atomisp_white_balance_param(asd, 1, arg); 2858 break; 2859 2860 case ATOMISP_IOC_G_3A_CONFIG: 2861 err = atomisp_3a_config_param(asd, 0, arg); 2862 break; 2863 2864 case ATOMISP_IOC_S_3A_CONFIG: 2865 err = atomisp_3a_config_param(asd, 1, arg); 2866 break; 2867 2868 case ATOMISP_IOC_S_ISP_FPN_TABLE: 2869 err = atomisp_fixed_pattern_table(asd, arg); 2870 break; 2871 2872 case ATOMISP_IOC_ISP_MAKERNOTE: 2873 err = atomisp_exif_makernote(asd, arg); 2874 break; 2875 2876 case ATOMISP_IOC_G_SENSOR_MODE_DATA: 2877 err = atomisp_get_sensor_mode_data(asd, arg); 2878 break; 2879 2880 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA: 2881 if (motor) 2882 err = v4l2_subdev_call(motor, core, ioctl, cmd, arg); 2883 else 2884 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 2885 core, ioctl, cmd, arg); 2886 break; 2887 2888 case ATOMISP_IOC_S_EXPOSURE: 2889 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP: 2890 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA: 2891 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO: 2892 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE: 2893 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE: 2894 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT: 2895 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 2896 core, ioctl, cmd, arg); 2897 break; 2898 case ATOMISP_IOC_G_UPDATE_EXPOSURE: 2899 if (atomisp_hw_is_isp2401) 2900 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 2901 core, ioctl, cmd, arg); 2902 else 2903 err = -EINVAL; 2904 break; 2905 2906 case ATOMISP_IOC_ACC_LOAD: 2907 err = atomisp_acc_load(asd, arg); 2908 break; 2909 2910 case ATOMISP_IOC_ACC_LOAD_TO_PIPE: 2911 err = atomisp_acc_load_to_pipe(asd, arg); 2912 break; 2913 2914 case ATOMISP_IOC_ACC_UNLOAD: 2915 err = atomisp_acc_unload(asd, arg); 2916 break; 2917 2918 case ATOMISP_IOC_ACC_START: 2919 err = atomisp_acc_start(asd, arg); 2920 break; 2921 2922 case ATOMISP_IOC_ACC_WAIT: 2923 err = atomisp_acc_wait(asd, arg); 2924 break; 2925 2926 case ATOMISP_IOC_ACC_MAP: 2927 err = atomisp_acc_map(asd, arg); 2928 break; 2929 2930 case ATOMISP_IOC_ACC_UNMAP: 2931 err = atomisp_acc_unmap(asd, arg); 2932 break; 2933 2934 case ATOMISP_IOC_ACC_S_MAPPED_ARG: 2935 err = atomisp_acc_s_mapped_arg(asd, arg); 2936 break; 2937 2938 case ATOMISP_IOC_S_ISP_SHD_TAB: 2939 err = atomisp_set_shading_table(asd, arg); 2940 break; 2941 2942 case ATOMISP_IOC_G_ISP_GAMMA_CORRECTION: 2943 err = atomisp_gamma_correction(asd, 0, arg); 2944 break; 2945 2946 case ATOMISP_IOC_S_ISP_GAMMA_CORRECTION: 2947 err = atomisp_gamma_correction(asd, 1, arg); 2948 break; 2949 2950 case ATOMISP_IOC_S_PARAMETERS: 2951 err = atomisp_set_parameters(vdev, arg); 2952 break; 2953 2954 case ATOMISP_IOC_S_CONT_CAPTURE_CONFIG: 2955 err = atomisp_offline_capture_configure(asd, arg); 2956 break; 2957 case ATOMISP_IOC_G_METADATA: 2958 err = atomisp_get_metadata(asd, 0, arg); 2959 break; 2960 case ATOMISP_IOC_G_METADATA_BY_TYPE: 2961 err = atomisp_get_metadata_by_type(asd, 0, arg); 2962 break; 2963 case ATOMISP_IOC_EXT_ISP_CTRL: 2964 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera, 2965 core, ioctl, cmd, arg); 2966 break; 2967 case ATOMISP_IOC_EXP_ID_UNLOCK: 2968 err = atomisp_exp_id_unlock(asd, arg); 2969 break; 2970 case ATOMISP_IOC_EXP_ID_CAPTURE: 2971 err = atomisp_exp_id_capture(asd, arg); 2972 break; 2973 case ATOMISP_IOC_S_ENABLE_DZ_CAPT_PIPE: 2974 err = atomisp_enable_dz_capt_pipe(asd, arg); 2975 break; 2976 case ATOMISP_IOC_G_FORMATS_CONFIG: 2977 err = atomisp_formats(asd, 0, arg); 2978 break; 2979 2980 case ATOMISP_IOC_S_FORMATS_CONFIG: 2981 err = atomisp_formats(asd, 1, arg); 2982 break; 2983 case ATOMISP_IOC_S_EXPOSURE_WINDOW: 2984 err = atomisp_s_ae_window(asd, arg); 2985 break; 2986 case ATOMISP_IOC_S_ACC_STATE: 2987 err = atomisp_acc_set_state(asd, arg); 2988 break; 2989 case ATOMISP_IOC_G_ACC_STATE: 2990 err = atomisp_acc_get_state(asd, arg); 2991 break; 2992 case ATOMISP_IOC_INJECT_A_FAKE_EVENT: 2993 err = atomisp_inject_a_fake_event(asd, arg); 2994 break; 2995 case ATOMISP_IOC_G_INVALID_FRAME_NUM: 2996 err = atomisp_get_invalid_frame_num(vdev, arg); 2997 break; 2998 case ATOMISP_IOC_S_ARRAY_RESOLUTION: 2999 err = atomisp_set_array_res(asd, arg); 3000 break; 3001 default: 3002 err = -EINVAL; 3003 break; 3004 } 3005 3006 switch (cmd) { 3007 case ATOMISP_IOC_G_MOTOR_PRIV_INT_DATA: 3008 case ATOMISP_IOC_S_EXPOSURE: 3009 case ATOMISP_IOC_G_SENSOR_CALIBRATION_GROUP: 3010 case ATOMISP_IOC_G_SENSOR_PRIV_INT_DATA: 3011 case ATOMISP_IOC_EXT_ISP_CTRL: 3012 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_INFO: 3013 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_MODE: 3014 case ATOMISP_IOC_G_SENSOR_AE_BRACKETING_MODE: 3015 case ATOMISP_IOC_S_SENSOR_AE_BRACKETING_LUT: 3016 case ATOMISP_IOC_G_UPDATE_EXPOSURE: 3017 break; 3018 default: 3019 rt_mutex_unlock(&isp->mutex); 3020 break; 3021 } 3022 return err; 3023 } 3024 3025 const struct v4l2_ioctl_ops atomisp_ioctl_ops = { 3026 .vidioc_querycap = atomisp_querycap, 3027 .vidioc_enum_input = atomisp_enum_input, 3028 .vidioc_g_input = atomisp_g_input, 3029 .vidioc_s_input = atomisp_s_input, 3030 .vidioc_queryctrl = atomisp_queryctl, 3031 .vidioc_s_ctrl = atomisp_s_ctrl, 3032 .vidioc_g_ctrl = atomisp_g_ctrl, 3033 .vidioc_s_ext_ctrls = atomisp_s_ext_ctrls, 3034 .vidioc_g_ext_ctrls = atomisp_g_ext_ctrls, 3035 .vidioc_enum_fmt_vid_cap = atomisp_enum_fmt_cap, 3036 .vidioc_try_fmt_vid_cap = atomisp_try_fmt_cap, 3037 .vidioc_g_fmt_vid_cap = atomisp_g_fmt_cap, 3038 .vidioc_s_fmt_vid_cap = atomisp_s_fmt_cap, 3039 .vidioc_reqbufs = atomisp_reqbufs, 3040 .vidioc_querybuf = atomisp_querybuf, 3041 .vidioc_qbuf = atomisp_qbuf, 3042 .vidioc_dqbuf = atomisp_dqbuf, 3043 .vidioc_streamon = atomisp_streamon, 3044 .vidioc_streamoff = atomisp_streamoff, 3045 .vidioc_default = atomisp_vidioc_default, 3046 .vidioc_s_parm = atomisp_s_parm, 3047 .vidioc_g_parm = atomisp_g_parm, 3048 }; 3049 3050 const struct v4l2_ioctl_ops atomisp_file_ioctl_ops = { 3051 .vidioc_querycap = atomisp_querycap, 3052 .vidioc_g_fmt_vid_out = atomisp_g_fmt_file, 3053 .vidioc_s_fmt_vid_out = atomisp_s_fmt_file, 3054 .vidioc_s_parm = atomisp_s_parm_file, 3055 .vidioc_reqbufs = atomisp_reqbufs_file, 3056 .vidioc_querybuf = atomisp_querybuf_file, 3057 .vidioc_qbuf = atomisp_qbuf_file, 3058 }; 3059