drivers/staging/media/atomisp/pci/atomisp_ioctl.c

   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
  27 #include "atomisp_cmd.h"
  28 #include "atomisp_common.h"
  29 #include "atomisp_fops.h"
  30 #include "atomisp_internal.h"
  31 #include "atomisp_ioctl.h"
  32 #include "atomisp-regs.h"
  33 #include "atomisp_compat.h"
  34
  35 #include "sh_css_hrt.h"
  36
  37 #include "gp_device.h"
  38 #include "device_access.h"
  39 #include "irq.h"
  40
  41 static const char *DRIVER = "atomisp";  /* max size 15 */
  42 static const char *CARD = "ATOM ISP";   /* max size 31 */
  43
  44 /*
  45  * FIXME: ISP should not know beforehand all CIDs supported by sensor.
  46  * Instead, it needs to propagate to sensor unkonwn CIDs.
  47  */
  48 static struct v4l2_queryctrl ci_v4l2_controls[] = {
  49         {
  50                 .id = V4L2_CID_AUTO_WHITE_BALANCE,
  51                 .type = V4L2_CTRL_TYPE_BOOLEAN,
  52                 .name = "Automatic White Balance",
  53                 .minimum = 0,
  54                 .maximum = 1,
  55                 .step = 1,
  56                 .default_value = 0,
  57         },
  58         {
  59                 .id = V4L2_CID_RED_BALANCE,
  60                 .type = V4L2_CTRL_TYPE_INTEGER,
  61                 .name = "Red Balance",
  62                 .minimum = 0x00,
  63                 .maximum = 0xff,
  64                 .step = 1,
  65                 .default_value = 0x00,
  66         },
  67         {
  68                 .id = V4L2_CID_BLUE_BALANCE,
  69                 .type = V4L2_CTRL_TYPE_INTEGER,
  70                 .name = "Blue Balance",
  71                 .minimum = 0x00,
  72                 .maximum = 0xff,
  73                 .step = 1,
  74                 .default_value = 0x00,
  75         },
  76         {
  77                 .id = V4L2_CID_GAMMA,
  78                 .type = V4L2_CTRL_TYPE_INTEGER,
  79                 .name = "Gamma",
  80                 .minimum = 0x00,
  81                 .maximum = 0xff,
  82                 .step = 1,
  83                 .default_value = 0x00,
  84         },
  85         {
  86                 .id = V4L2_CID_POWER_LINE_FREQUENCY,
  87                 .type = V4L2_CTRL_TYPE_MENU,
  88                 .name = "Light frequency filter",
  89                 .minimum = 1,
  90                 .maximum = 2,
  91                 .step = 1,
  92                 .default_value = 1,
  93         },
  94         {
  95                 .id = V4L2_CID_COLORFX,
  96                 .type = V4L2_CTRL_TYPE_INTEGER,
  97                 .name = "Image Color Effect",
  98                 .minimum = 0,
  99                 .maximum = 9,
 100                 .step = 1,
 101                 .default_value = 0,
 102         },
 103         {
 104                 .id = V4L2_CID_COLORFX_CBCR,
 105                 .type = V4L2_CTRL_TYPE_INTEGER,
 106                 .name = "Image Color Effect CbCr",
 107                 .minimum = 0,
 108                 .maximum = 0xffff,
 109                 .step = 1,
 110                 .default_value = 0,
 111         },
 112         {
 113                 .id = V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION,
 114                 .type = V4L2_CTRL_TYPE_INTEGER,
 115                 .name = "Bad Pixel Correction",
 116                 .minimum = 0,
 117                 .maximum = 1,
 118                 .step = 1,
 119                 .default_value = 0,
 120         },
 121         {
 122                 .id = V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC,
 123                 .type = V4L2_CTRL_TYPE_INTEGER,
 124                 .name = "GDC/CAC",
 125                 .minimum = 0,
 126                 .maximum = 1,
 127                 .step = 1,
 128                 .default_value = 0,
 129         },
 130         {
 131                 .id = V4L2_CID_ATOMISP_VIDEO_STABLIZATION,
 132                 .type = V4L2_CTRL_TYPE_INTEGER,
 133                 .name = "Video Stablization",
 134                 .minimum = 0,
 135                 .maximum = 1,
 136                 .step = 1,
 137                 .default_value = 0,
 138         },
 139         {
 140                 .id = V4L2_CID_ATOMISP_FIXED_PATTERN_NR,
 141                 .type = V4L2_CTRL_TYPE_INTEGER,
 142                 .name = "Fixed Pattern Noise Reduction",
 143                 .minimum = 0,
 144                 .maximum = 1,
 145                 .step = 1,
 146                 .default_value = 0,
 147         },
 148         {
 149                 .id = V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION,
 150                 .type = V4L2_CTRL_TYPE_INTEGER,
 151                 .name = "False Color Correction",
 152                 .minimum = 0,
 153                 .maximum = 1,
 154                 .step = 1,
 155                 .default_value = 0,
 156         },
 157         {
 158                 .id = V4L2_CID_REQUEST_FLASH,
 159                 .type = V4L2_CTRL_TYPE_INTEGER,
 160                 .name = "Request flash frames",
 161                 .minimum = 0,
 162                 .maximum = 10,
 163                 .step = 1,
 164                 .default_value = 1,
 165         },
 166         {
 167                 .id = V4L2_CID_ATOMISP_LOW_LIGHT,
 168                 .type = V4L2_CTRL_TYPE_BOOLEAN,
 169                 .name = "Low light mode",
 170                 .minimum = 0,
 171                 .maximum = 1,
 172                 .step = 1,
 173                 .default_value = 1,
 174         },
 175         {
 176                 .id = V4L2_CID_2A_STATUS,
 177                 .type = V4L2_CTRL_TYPE_BITMASK,
 178                 .name = "AE and AWB status",
 179                 .minimum = 0,
 180                 .maximum = V4L2_2A_STATUS_AE_READY | V4L2_2A_STATUS_AWB_READY,
 181                 .step = 1,
 182                 .default_value = 0,
 183         },
 184         {
 185                 .id = V4L2_CID_EXPOSURE,
 186                 .type = V4L2_CTRL_TYPE_INTEGER,
 187                 .name = "exposure",
 188                 .minimum = -4,
 189                 .maximum = 4,
 190                 .step = 1,
 191                 .default_value = 0,
 192         },
 193         {
 194                 .id = V4L2_CID_EXPOSURE_ZONE_NUM,
 195                 .type = V4L2_CTRL_TYPE_INTEGER,
 196                 .name = "one-time exposure zone number",
 197                 .minimum = 0x0,
 198                 .maximum = 0xffff,
 199                 .step = 1,
 200                 .default_value = 0,
 201         },
 202         {
 203                 .id = V4L2_CID_EXPOSURE_AUTO_PRIORITY,
 204                 .type = V4L2_CTRL_TYPE_INTEGER,
 205                 .name = "Exposure auto priority",
 206                 .minimum = V4L2_EXPOSURE_AUTO,
 207                 .maximum = V4L2_EXPOSURE_APERTURE_PRIORITY,
 208                 .step = 1,
 209                 .default_value = V4L2_EXPOSURE_AUTO,
 210         },
 211         {
 212                 .id = V4L2_CID_SCENE_MODE,
 213                 .type = V4L2_CTRL_TYPE_INTEGER,
 214                 .name = "scene mode",
 215                 .minimum = 0,
 216                 .maximum = 13,
 217                 .step = 1,
 218                 .default_value = 0,
 219         },
 220         {
 221                 .id = V4L2_CID_ISO_SENSITIVITY,
 222                 .type = V4L2_CTRL_TYPE_INTEGER,
 223                 .name = "iso",
 224                 .minimum = -4,
 225                 .maximum = 4,
 226                 .step = 1,
 227                 .default_value = 0,
 228         },
 229         {
 230                 .id = V4L2_CID_ISO_SENSITIVITY_AUTO,
 231                 .type = V4L2_CTRL_TYPE_INTEGER,
 232                 .name = "iso mode",
 233                 .minimum = V4L2_ISO_SENSITIVITY_MANUAL,
 234                 .maximum = V4L2_ISO_SENSITIVITY_AUTO,
 235                 .step = 1,
 236                 .default_value = V4L2_ISO_SENSITIVITY_AUTO,
 237         },
 238         {
 239                 .id = V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE,
 240                 .type = V4L2_CTRL_TYPE_INTEGER,
 241                 .name = "white balance",
 242                 .minimum = 0,
 243                 .maximum = 9,
 244                 .step = 1,
 245                 .default_value = 0,
 246         },
 247         {
 248                 .id = V4L2_CID_EXPOSURE_METERING,
 249                 .type = V4L2_CTRL_TYPE_MENU,
 250                 .name = "metering",
 251                 .minimum = 0,
 252                 .maximum = 3,
 253                 .step = 1,
 254                 .default_value = 1,
 255         },
 256         {
 257                 .id = V4L2_CID_3A_LOCK,
 258                 .type = V4L2_CTRL_TYPE_BITMASK,
 259                 .name = "3a lock",
 260                 .minimum = 0,
 261                 .maximum = V4L2_LOCK_EXPOSURE | V4L2_LOCK_WHITE_BALANCE
 262                 | V4L2_LOCK_FOCUS,
 263                 .step = 1,
 264                 .default_value = 0,
 265         },
 266         {
 267                 .id = V4L2_CID_TEST_PATTERN,
 268                 .type = V4L2_CTRL_TYPE_INTEGER,
 269                 .name = "Test Pattern",
 270                 .minimum = 0,
 271                 .maximum = 0xffff,
 272                 .step = 1,
 273                 .default_value = 0,
 274         },
 275         {
 276                 .id = V4L2_CID_TEST_PATTERN_COLOR_R,
 277                 .type = V4L2_CTRL_TYPE_INTEGER,
 278                 .name = "Test Pattern Solid Color R",
 279                 .minimum = INT_MIN,
 280                 .maximum = INT_MAX,
 281                 .step = 1,
 282                 .default_value = 0,
 283         },
 284         {
 285                 .id = V4L2_CID_TEST_PATTERN_COLOR_GR,
 286                 .type = V4L2_CTRL_TYPE_INTEGER,
 287                 .name = "Test Pattern Solid Color GR",
 288                 .minimum = INT_MIN,
 289                 .maximum = INT_MAX,
 290                 .step = 1,
 291                 .default_value = 0,
 292         },
 293         {
 294                 .id = V4L2_CID_TEST_PATTERN_COLOR_GB,
 295                 .type = V4L2_CTRL_TYPE_INTEGER,
 296                 .name = "Test Pattern Solid Color GB",
 297                 .minimum = INT_MIN,
 298                 .maximum = INT_MAX,
 299                 .step = 1,
 300                 .default_value = 0,
 301         },
 302         {
 303                 .id = V4L2_CID_TEST_PATTERN_COLOR_B,
 304                 .type = V4L2_CTRL_TYPE_INTEGER,
 305                 .name = "Test Pattern Solid Color B",
 306                 .minimum = INT_MIN,
 307                 .maximum = INT_MAX,
 308                 .step = 1,
 309                 .default_value = 0,
 310         },
 311 };
 312
 313 static const u32 ctrls_num = ARRAY_SIZE(ci_v4l2_controls);
 314
 315 /*
 316  * supported V4L2 fmts and resolutions
 317  */
 318 const struct atomisp_format_bridge atomisp_output_fmts[] = {
 319         {
 320                 .pixelformat = V4L2_PIX_FMT_YUV420,
 321                 .depth = 12,
 322                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV420,
 323                 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV420,
 324                 .description = "YUV420, planar",
 325                 .planar = true
 326         }, {
 327                 .pixelformat = V4L2_PIX_FMT_YVU420,
 328                 .depth = 12,
 329                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YVU420,
 330                 .sh_fmt = IA_CSS_FRAME_FORMAT_YV12,
 331                 .description = "YVU420, planar",
 332                 .planar = true
 333         }, {
 334                 .pixelformat = V4L2_PIX_FMT_YUV422P,
 335                 .depth = 16,
 336                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV422P,
 337                 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV422,
 338                 .description = "YUV422, planar",
 339                 .planar = true
 340         }, {
 341                 .pixelformat = V4L2_PIX_FMT_YUV444,
 342                 .depth = 24,
 343                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUV444,
 344                 .sh_fmt = IA_CSS_FRAME_FORMAT_YUV444,
 345                 .description = "YUV444"
 346         }, {
 347                 .pixelformat = V4L2_PIX_FMT_NV12,
 348                 .depth = 12,
 349                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV12,
 350                 .sh_fmt = IA_CSS_FRAME_FORMAT_NV12,
 351                 .description = "NV12, Y-plane, CbCr interleaved",
 352                 .planar = true
 353         }, {
 354                 .pixelformat = V4L2_PIX_FMT_NV21,
 355                 .depth = 12,
 356                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV21,
 357                 .sh_fmt = IA_CSS_FRAME_FORMAT_NV21,
 358                 .description = "NV21, Y-plane, CbCr interleaved",
 359                 .planar = true
 360         }, {
 361                 .pixelformat = V4L2_PIX_FMT_NV16,
 362                 .depth = 16,
 363                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_NV16,
 364                 .sh_fmt = IA_CSS_FRAME_FORMAT_NV16,
 365                 .description = "NV16, Y-plane, CbCr interleaved",
 366                 .planar = true
 367         }, {
 368                 .pixelformat = V4L2_PIX_FMT_YUYV,
 369                 .depth = 16,
 370                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_YUYV,
 371                 .sh_fmt = IA_CSS_FRAME_FORMAT_YUYV,
 372                 .description = "YUYV, interleaved"
 373         }, {
 374                 .pixelformat = V4L2_PIX_FMT_UYVY,
 375                 .depth = 16,
 376                 .mbus_code = MEDIA_BUS_FMT_UYVY8_1X16,
 377                 .sh_fmt = IA_CSS_FRAME_FORMAT_UYVY,
 378                 .description = "UYVY, interleaved"
 379         }, { /* This one is for parallel sensors! DO NOT USE! */
 380                 .pixelformat = V4L2_PIX_FMT_UYVY,
 381                 .depth = 16,
 382                 .mbus_code = MEDIA_BUS_FMT_UYVY8_2X8,
 383                 .sh_fmt = IA_CSS_FRAME_FORMAT_UYVY,
 384                 .description = "UYVY, interleaved"
 385         }, {
 386                 .pixelformat = V4L2_PIX_FMT_SBGGR16,
 387                 .depth = 16,
 388                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_SBGGR16,
 389                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 390                 .description = "Bayer 16"
 391         }, {
 392                 .pixelformat = V4L2_PIX_FMT_SBGGR8,
 393                 .depth = 8,
 394                 .mbus_code = MEDIA_BUS_FMT_SBGGR8_1X8,
 395                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 396                 .description = "Bayer 8"
 397         }, {
 398                 .pixelformat = V4L2_PIX_FMT_SGBRG8,
 399                 .depth = 8,
 400                 .mbus_code = MEDIA_BUS_FMT_SGBRG8_1X8,
 401                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 402                 .description = "Bayer 8"
 403         }, {
 404                 .pixelformat = V4L2_PIX_FMT_SGRBG8,
 405                 .depth = 8,
 406                 .mbus_code = MEDIA_BUS_FMT_SGRBG8_1X8,
 407                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 408                 .description = "Bayer 8"
 409         }, {
 410                 .pixelformat = V4L2_PIX_FMT_SRGGB8,
 411                 .depth = 8,
 412                 .mbus_code = MEDIA_BUS_FMT_SRGGB8_1X8,
 413                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 414                 .description = "Bayer 8"
 415         }, {
 416                 .pixelformat = V4L2_PIX_FMT_SBGGR10,
 417                 .depth = 16,
 418                 .mbus_code = MEDIA_BUS_FMT_SBGGR10_1X10,
 419                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 420                 .description = "Bayer 10"
 421         }, {
 422                 .pixelformat = V4L2_PIX_FMT_SGBRG10,
 423                 .depth = 16,
 424                 .mbus_code = MEDIA_BUS_FMT_SGBRG10_1X10,
 425                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 426                 .description = "Bayer 10"
 427         }, {
 428                 .pixelformat = V4L2_PIX_FMT_SGRBG10,
 429                 .depth = 16,
 430                 .mbus_code = MEDIA_BUS_FMT_SGRBG10_1X10,
 431                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 432                 .description = "Bayer 10"
 433         }, {
 434                 .pixelformat = V4L2_PIX_FMT_SRGGB10,
 435                 .depth = 16,
 436                 .mbus_code = MEDIA_BUS_FMT_SRGGB10_1X10,
 437                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 438                 .description = "Bayer 10"
 439         }, {
 440                 .pixelformat = V4L2_PIX_FMT_SBGGR12,
 441                 .depth = 16,
 442                 .mbus_code = MEDIA_BUS_FMT_SBGGR12_1X12,
 443                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 444                 .description = "Bayer 12"
 445         }, {
 446                 .pixelformat = V4L2_PIX_FMT_SGBRG12,
 447                 .depth = 16,
 448                 .mbus_code = MEDIA_BUS_FMT_SGBRG12_1X12,
 449                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 450                 .description = "Bayer 12"
 451         }, {
 452                 .pixelformat = V4L2_PIX_FMT_SGRBG12,
 453                 .depth = 16,
 454                 .mbus_code = MEDIA_BUS_FMT_SGRBG12_1X12,
 455                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 456                 .description = "Bayer 12"
 457         }, {
 458                 .pixelformat = V4L2_PIX_FMT_SRGGB12,
 459                 .depth = 16,
 460                 .mbus_code = MEDIA_BUS_FMT_SRGGB12_1X12,
 461                 .sh_fmt = IA_CSS_FRAME_FORMAT_RAW,
 462                 .description = "Bayer 12"
 463         }, {
 464                 .pixelformat = V4L2_PIX_FMT_RGB32,
 465                 .depth = 32,
 466                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_RGB32,
 467                 .sh_fmt = IA_CSS_FRAME_FORMAT_RGBA888,
 468                 .description = "32 RGB 8-8-8-8"
 469         }, {
 470                 .pixelformat = V4L2_PIX_FMT_RGB565,
 471                 .depth = 16,
 472                 .mbus_code = MEDIA_BUS_FMT_BGR565_2X8_LE,
 473                 .sh_fmt = IA_CSS_FRAME_FORMAT_RGB565,
 474                 .description = "16 RGB 5-6-5"
 475 #if 0
 476         }, {
 477                 .pixelformat = V4L2_PIX_FMT_JPEG,
 478                 .depth = 8,
 479                 .mbus_code = MEDIA_BUS_FMT_JPEG_1X8,
 480                 .sh_fmt = IA_CSS_FRAME_FORMAT_BINARY_8,
 481                 .description = "JPEG"
 482         }, {
 483                 /* This is a custom format being used by M10MO to send the RAW data */
 484                 .pixelformat = V4L2_PIX_FMT_CUSTOM_M10MO_RAW,
 485                 .depth = 8,
 486                 .mbus_code = V4L2_MBUS_FMT_CUSTOM_M10MO_RAW,
 487                 .sh_fmt = IA_CSS_FRAME_FORMAT_BINARY_8,
 488                 .description = "Custom RAW for M10MO"
 489 #endif
 490         },
 491 };
 492
 493 const struct atomisp_format_bridge *
 494 atomisp_get_format_bridge(unsigned int pixelformat)
 495 {
 496         unsigned int i;
 497
 498         for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
 499                 if (atomisp_output_fmts[i].pixelformat == pixelformat)
 500                         return &atomisp_output_fmts[i];
 501         }
 502
 503         return NULL;
 504 }
 505
 506 const struct atomisp_format_bridge *
 507 atomisp_get_format_bridge_from_mbus(u32 mbus_code)
 508 {
 509         unsigned int i;
 510
 511         for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
 512                 if (mbus_code == atomisp_output_fmts[i].mbus_code)
 513                         return &atomisp_output_fmts[i];
 514         }
 515
 516         return NULL;
 517 }
 518
 519 int atomisp_pipe_check(struct atomisp_video_pipe *pipe, bool settings_change)
 520 {
 521         lockdep_assert_held(&pipe->isp->mutex);
 522
 523         if (pipe->isp->isp_fatal_error)
 524                 return -EIO;
 525
 526         if (settings_change && vb2_is_busy(&pipe->vb_queue)) {
 527                 dev_err(pipe->isp->dev, "Set fmt/input IOCTL while streaming\n");
 528                 return -EBUSY;
 529         }
 530
 531         return 0;
 532 }
 533
 534 /*
 535  * v4l2 ioctls
 536  * return ISP capabilities
 537  */
 538 static int atomisp_querycap(struct file *file, void *fh,
 539                             struct v4l2_capability *cap)
 540 {
 541         struct video_device *vdev = video_devdata(file);
 542         struct atomisp_device *isp = video_get_drvdata(vdev);
 543
 544         strscpy(cap->driver, DRIVER, sizeof(cap->driver));
 545         strscpy(cap->card, CARD, sizeof(cap->card));
 546         snprintf(cap->bus_info, sizeof(cap->bus_info), "PCI:%s", dev_name(isp->dev));
 547
 548         return 0;
 549 }
 550
 551 /*
 552  * enum input are used to check primary/secondary camera
 553  */
 554 static int atomisp_enum_input(struct file *file, void *fh,
 555                               struct v4l2_input *input)
 556 {
 557         struct video_device *vdev = video_devdata(file);
 558         struct atomisp_device *isp = video_get_drvdata(vdev);
 559         int index = input->index;
 560         struct v4l2_subdev *motor;
 561
 562         if (index >= isp->input_cnt)
 563                 return -EINVAL;
 564
 565         if (!isp->inputs[index].camera)
 566                 return -EINVAL;
 567
 568         memset(input, 0, sizeof(struct v4l2_input));
 569         strscpy(input->name, isp->inputs[index].camera->name,
 570                 sizeof(input->name));
 571
 572         /*
 573          * HACK: append actuator's name to sensor's
 574          * As currently userspace can't talk directly to subdev nodes, this
 575          * ioctl is the only way to enum inputs + possible external actuators
 576          * for 3A tuning purpose.
 577          */
 578         if (!IS_ISP2401)
 579                 motor = isp->inputs[index].motor;
 580         else
 581                 motor = isp->motor;
 582
 583         if (motor && strlen(motor->name) > 0) {
 584                 const int cur_len = strlen(input->name);
 585                 const int max_size = sizeof(input->name) - cur_len - 1;
 586
 587                 if (max_size > 1) {
 588                         input->name[cur_len] = '+';
 589                         strscpy(&input->name[cur_len + 1],
 590                                 motor->name, max_size);
 591                 }
 592         }
 593
 594         input->type = V4L2_INPUT_TYPE_CAMERA;
 595         input->index = index;
 596         input->reserved[0] = isp->inputs[index].type;
 597         input->reserved[1] = isp->inputs[index].port;
 598
 599         return 0;
 600 }
 601
 602 /*
 603  * get input are used to get current primary/secondary camera
 604  */
 605 static int atomisp_g_input(struct file *file, void *fh, unsigned int *input)
 606 {
 607         struct video_device *vdev = video_devdata(file);
 608         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
 609
 610         *input = asd->input_curr;
 611         return 0;
 612 }
 613
 614 static int atomisp_s_fmt_cap(struct file *file, void *fh,
 615                              struct v4l2_format *f)
 616 {
 617         struct video_device *vdev = video_devdata(file);
 618
 619         return atomisp_set_fmt(vdev, f);
 620 }
 621
 622 /*
 623  * set input are used to set current primary/secondary camera
 624  */
 625 static int atomisp_s_input(struct file *file, void *fh, unsigned int input)
 626 {
 627         struct video_device *vdev = video_devdata(file);
 628         struct atomisp_device *isp = video_get_drvdata(vdev);
 629         struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
 630         struct atomisp_sub_device *asd = pipe->asd;
 631         struct v4l2_subdev *camera = NULL;
 632         struct v4l2_subdev *motor;
 633         int ret;
 634
 635         ret = atomisp_pipe_check(pipe, true);
 636         if (ret)
 637                 return ret;
 638
 639         if (input >= ATOM_ISP_MAX_INPUTS || input >= isp->input_cnt) {
 640                 dev_dbg(isp->dev, "input_cnt: %d\n", isp->input_cnt);
 641                 return -EINVAL;
 642         }
 643
 644         camera = isp->inputs[input].camera;
 645         if (!camera) {
 646                 dev_err(isp->dev, "%s, no camera\n", __func__);
 647                 return -EINVAL;
 648         }
 649
 650         /* power off the current owned sensor, as it is not used this time */
 651         if (isp->inputs[asd->input_curr].asd == asd &&
 652             asd->input_curr != input) {
 653                 ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
 654                                        core, s_power, 0);
 655                 if (ret && ret != -ENOIOCTLCMD)
 656                         dev_warn(isp->dev,
 657                                  "Failed to power-off sensor\n");
 658                 /* clear the asd field to show this camera is not used */
 659                 isp->inputs[asd->input_curr].asd = NULL;
 660         }
 661
 662         /* powe on the new sensor */
 663         ret = v4l2_subdev_call(isp->inputs[input].camera, core, s_power, 1);
 664         if (ret && ret != -ENOIOCTLCMD) {
 665                 dev_err(isp->dev, "Failed to power-on sensor\n");
 666                 return ret;
 667         }
 668
 669         /* select operating sensor */
 670         ret = v4l2_subdev_call(isp->inputs[input].camera, video, s_routing,
 671                                0, 0, 0);
 672         if (ret && (ret != -ENOIOCTLCMD)) {
 673                 dev_err(isp->dev, "Failed to select sensor\n");
 674                 return ret;
 675         }
 676
 677         if (!IS_ISP2401) {
 678                 motor = isp->inputs[input].motor;
 679         } else {
 680                 motor = isp->motor;
 681                 if (motor)
 682                         ret = v4l2_subdev_call(motor, core, s_power, 1);
 683         }
 684
 685         if (motor)
 686                 ret = v4l2_subdev_call(motor, core, init, 1);
 687
 688         asd->input_curr = input;
 689         /* mark this camera is used by the current stream */
 690         isp->inputs[input].asd = asd;
 691
 692         return 0;
 693 }
 694
 695 /*
 696  * With crop any framesize <= sensor-size can be made, give
 697  * userspace a list of sizes to choice from.
 698  */
 699 static int atomisp_enum_framesizes_crop_inner(struct atomisp_device *isp,
 700                                               struct v4l2_frmsizeenum *fsize,
 701                                               const struct v4l2_rect *active,
 702                                               const struct v4l2_rect *native,
 703                                               int *valid_sizes)
 704 {
 705         static const struct v4l2_frmsize_discrete frame_sizes[] = {
 706                 { 1920, 1440 },
 707                 { 1920, 1200 },
 708                 { 1920, 1080 },
 709                 { 1600, 1200 },
 710                 { 1600, 1080 },
 711                 { 1600,  900 },
 712                 { 1440, 1080 },
 713                 { 1280,  960 },
 714                 { 1280,  720 },
 715                 {  800,  600 },
 716                 {  640,  480 },
 717         };
 718         u32 padding_w, padding_h;
 719         int i;
 720
 721         for (i = 0; i < ARRAY_SIZE(frame_sizes); i++) {
 722                 atomisp_get_padding(isp, frame_sizes[i].width, frame_sizes[i].height,
 723                                     &padding_w, &padding_h);
 724
 725                 if ((frame_sizes[i].width + padding_w) > native->width ||
 726                     (frame_sizes[i].height + padding_h) > native->height)
 727                         continue;
 728
 729                 /*
 730                  * Skip sizes where width and height are less then 5/8th of the
 731                  * sensor size to avoid sizes with a too small field of view.
 732                  */
 733                 if (frame_sizes[i].width < (active->width * 5 / 8) &&
 734                     frame_sizes[i].height < (active->height * 5 / 8))
 735                         continue;
 736
 737                 if (*valid_sizes == fsize->index) {
 738                         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 739                         fsize->discrete = frame_sizes[i];
 740                         return 0;
 741                 }
 742
 743                 (*valid_sizes)++;
 744         }
 745
 746         return -EINVAL;
 747 }
 748
 749 static int atomisp_enum_framesizes_crop(struct atomisp_device *isp,
 750                                         struct v4l2_frmsizeenum *fsize)
 751 {
 752         struct atomisp_input_subdev *input = &isp->inputs[isp->asd.input_curr];
 753         struct v4l2_rect active = input->active_rect;
 754         struct v4l2_rect native = input->native_rect;
 755         int ret, valid_sizes = 0;
 756
 757         ret = atomisp_enum_framesizes_crop_inner(isp, fsize, &active, &native, &valid_sizes);
 758         if (ret == 0)
 759                 return 0;
 760
 761         if (!input->binning_support)
 762                 return -EINVAL;
 763
 764         active.width /= 2;
 765         active.height /= 2;
 766         native.width /= 2;
 767         native.height /= 2;
 768
 769         return atomisp_enum_framesizes_crop_inner(isp, fsize, &active, &native, &valid_sizes);
 770 }
 771
 772 static int atomisp_enum_framesizes(struct file *file, void *priv,
 773                                    struct v4l2_frmsizeenum *fsize)
 774 {
 775         struct video_device *vdev = video_devdata(file);
 776         struct atomisp_device *isp = video_get_drvdata(vdev);
 777         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
 778         struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
 779         struct v4l2_subdev_frame_size_enum fse = {
 780                 .index = fsize->index,
 781                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 782                 .code = input->code,
 783         };
 784         struct v4l2_subdev_state *act_sd_state;
 785         int ret;
 786
 787         if (!input->camera)
 788                 return -EINVAL;
 789
 790         if (input->crop_support)
 791                 return atomisp_enum_framesizes_crop(isp, fsize);
 792
 793         act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
 794         ret = v4l2_subdev_call(input->camera, pad, enum_frame_size,
 795                                act_sd_state, &fse);
 796         if (act_sd_state)
 797                 v4l2_subdev_unlock_state(act_sd_state);
 798         if (ret)
 799                 return ret;
 800
 801         fsize->type = V4L2_FRMSIZE_TYPE_DISCRETE;
 802         fsize->discrete.width = fse.max_width - pad_w;
 803         fsize->discrete.height = fse.max_height - pad_h;
 804
 805         return 0;
 806 }
 807
 808 static int atomisp_enum_frameintervals(struct file *file, void *priv,
 809                                        struct v4l2_frmivalenum *fival)
 810 {
 811         struct video_device *vdev = video_devdata(file);
 812         struct atomisp_device *isp = video_get_drvdata(vdev);
 813         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
 814         struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
 815         struct v4l2_subdev_frame_interval_enum fie = {
 816                 .code = atomisp_in_fmt_conv[0].code,
 817                 .index = fival->index,
 818                 .width = fival->width,
 819                 .height = fival->height,
 820                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 821         };
 822         struct v4l2_subdev_state *act_sd_state;
 823         int ret;
 824
 825         if (!input->camera)
 826                 return -EINVAL;
 827
 828         act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
 829         ret = v4l2_subdev_call(input->camera, pad, enum_frame_interval,
 830                                act_sd_state, &fie);
 831         if (act_sd_state)
 832                 v4l2_subdev_unlock_state(act_sd_state);
 833         if (ret)
 834                 return ret;
 835
 836         fival->type = V4L2_FRMIVAL_TYPE_DISCRETE;
 837         fival->discrete = fie.interval;
 838
 839         return ret;
 840 }
 841
 842 static int atomisp_enum_fmt_cap(struct file *file, void *fh,
 843                                 struct v4l2_fmtdesc *f)
 844 {
 845         struct video_device *vdev = video_devdata(file);
 846         struct atomisp_device *isp = video_get_drvdata(vdev);
 847         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
 848         struct atomisp_input_subdev *input = &isp->inputs[asd->input_curr];
 849         struct v4l2_subdev_mbus_code_enum code = {
 850                 .which = V4L2_SUBDEV_FORMAT_ACTIVE,
 851         };
 852         const struct atomisp_format_bridge *format;
 853         struct v4l2_subdev_state *act_sd_state;
 854         unsigned int i, fi = 0;
 855         int ret;
 856
 857         if (!input->camera)
 858                 return -EINVAL;
 859
 860         act_sd_state = v4l2_subdev_lock_and_get_active_state(input->camera);
 861         ret = v4l2_subdev_call(input->camera, pad, enum_mbus_code,
 862                                act_sd_state, &code);
 863         if (act_sd_state)
 864                 v4l2_subdev_unlock_state(act_sd_state);
 865         if (ret)
 866                 return ret;
 867
 868         for (i = 0; i < ARRAY_SIZE(atomisp_output_fmts); i++) {
 869                 format = &atomisp_output_fmts[i];
 870
 871                 /*
 872                  * Is the atomisp-supported format is valid for the
 873                  * sensor (configuration)? If not, skip it.
 874                  *
 875                  * FIXME: fix the pipeline to allow sensor format too.
 876                  */
 877                 if (format->sh_fmt == IA_CSS_FRAME_FORMAT_RAW)
 878                         continue;
 879
 880                 /* Found a match. Now let's pick f->index'th one. */
 881                 if (fi < f->index) {
 882                         fi++;
 883                         continue;
 884                 }
 885
 886                 strscpy(f->description, format->description,
 887                         sizeof(f->description));
 888                 f->pixelformat = format->pixelformat;
 889                 return 0;
 890         }
 891
 892         return -EINVAL;
 893 }
 894
 895 /* This function looks up the closest available resolution. */
 896 static int atomisp_try_fmt_cap(struct file *file, void *fh,
 897                                struct v4l2_format *f)
 898 {
 899         struct video_device *vdev = video_devdata(file);
 900         struct atomisp_device *isp = video_get_drvdata(vdev);
 901
 902         return atomisp_try_fmt(isp, &f->fmt.pix, NULL, NULL);
 903 }
 904
 905 static int atomisp_g_fmt_cap(struct file *file, void *fh,
 906                              struct v4l2_format *f)
 907 {
 908         struct video_device *vdev = video_devdata(file);
 909         struct atomisp_video_pipe *pipe;
 910
 911         pipe = atomisp_to_video_pipe(vdev);
 912
 913         f->fmt.pix = pipe->pix;
 914
 915         /* If s_fmt was issued, just return whatever is was previouly set */
 916         if (f->fmt.pix.sizeimage)
 917                 return 0;
 918
 919         f->fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
 920         f->fmt.pix.width = 10000;
 921         f->fmt.pix.height = 10000;
 922
 923         return atomisp_try_fmt_cap(file, fh, f);
 924 }
 925
 926 int atomisp_alloc_css_stat_bufs(struct atomisp_sub_device *asd,
 927                                 uint16_t stream_id)
 928 {
 929         struct atomisp_device *isp = asd->isp;
 930         struct atomisp_s3a_buf *s3a_buf = NULL, *_s3a_buf;
 931         struct atomisp_dis_buf *dis_buf = NULL, *_dis_buf;
 932         struct atomisp_metadata_buf *md_buf = NULL, *_md_buf;
 933         int count;
 934         struct ia_css_dvs_grid_info *dvs_grid_info =
 935             atomisp_css_get_dvs_grid_info(&asd->params.curr_grid_info);
 936         unsigned int i;
 937
 938         if (list_empty(&asd->s3a_stats) &&
 939             asd->params.curr_grid_info.s3a_grid.enable) {
 940                 count = ATOMISP_CSS_Q_DEPTH +
 941                         ATOMISP_S3A_BUF_QUEUE_DEPTH_FOR_HAL;
 942                 dev_dbg(isp->dev, "allocating %d 3a buffers\n", count);
 943                 while (count--) {
 944                         s3a_buf = kzalloc(sizeof(struct atomisp_s3a_buf), GFP_KERNEL);
 945                         if (!s3a_buf)
 946                                 goto error;
 947
 948                         if (atomisp_css_allocate_stat_buffers(
 949                                 asd, stream_id, s3a_buf, NULL, NULL)) {
 950                                 kfree(s3a_buf);
 951                                 goto error;
 952                         }
 953
 954                         list_add_tail(&s3a_buf->list, &asd->s3a_stats);
 955                 }
 956         }
 957
 958         if (list_empty(&asd->dis_stats) && dvs_grid_info &&
 959             dvs_grid_info->enable) {
 960                 count = ATOMISP_CSS_Q_DEPTH + 1;
 961                 dev_dbg(isp->dev, "allocating %d dis buffers\n", count);
 962                 while (count--) {
 963                         dis_buf = kzalloc(sizeof(struct atomisp_dis_buf), GFP_KERNEL);
 964                         if (!dis_buf)
 965                                 goto error;
 966                         if (atomisp_css_allocate_stat_buffers(
 967                                 asd, stream_id, NULL, dis_buf, NULL)) {
 968                                 kfree(dis_buf);
 969                                 goto error;
 970                         }
 971
 972                         list_add_tail(&dis_buf->list, &asd->dis_stats);
 973                 }
 974         }
 975
 976         for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
 977                 if (list_empty(&asd->metadata[i]) &&
 978                     list_empty(&asd->metadata_ready[i]) &&
 979                     list_empty(&asd->metadata_in_css[i])) {
 980                         count = ATOMISP_CSS_Q_DEPTH +
 981                                 ATOMISP_METADATA_QUEUE_DEPTH_FOR_HAL;
 982                         dev_dbg(isp->dev, "allocating %d metadata buffers for type %d\n",
 983                                 count, i);
 984                         while (count--) {
 985                                 md_buf = kzalloc(sizeof(struct atomisp_metadata_buf),
 986                                                  GFP_KERNEL);
 987                                 if (!md_buf)
 988                                         goto error;
 989
 990                                 if (atomisp_css_allocate_stat_buffers(
 991                                         asd, stream_id, NULL, NULL, md_buf)) {
 992                                         kfree(md_buf);
 993                                         goto error;
 994                                 }
 995                                 list_add_tail(&md_buf->list, &asd->metadata[i]);
 996                         }
 997                 }
 998         }
 999         return 0;
1000
1001 error:
1002         dev_err(isp->dev, "failed to allocate statistics buffers\n");
1003
1004         list_for_each_entry_safe(dis_buf, _dis_buf, &asd->dis_stats, list) {
1005                 atomisp_css_free_dis_buffer(dis_buf);
1006                 list_del(&dis_buf->list);
1007                 kfree(dis_buf);
1008         }
1009
1010         list_for_each_entry_safe(s3a_buf, _s3a_buf, &asd->s3a_stats, list) {
1011                 atomisp_css_free_3a_buffer(s3a_buf);
1012                 list_del(&s3a_buf->list);
1013                 kfree(s3a_buf);
1014         }
1015
1016         for (i = 0; i < ATOMISP_METADATA_TYPE_NUM; i++) {
1017                 list_for_each_entry_safe(md_buf, _md_buf, &asd->metadata[i],
1018                                          list) {
1019                         atomisp_css_free_metadata_buffer(md_buf);
1020                         list_del(&md_buf->list);
1021                         kfree(md_buf);
1022                 }
1023         }
1024         return -ENOMEM;
1025 }
1026
1027 /*
1028  * FIXME the abuse of buf->reserved2 in the qbuf and dqbuf wrappers comes from
1029  * the original atomisp buffer handling and should be replaced with proper V4L2
1030  * per frame parameters use.
1031  *
1032  * Once this is fixed these wrappers can be removed, replacing them with direct
1033  * calls to vb2_ioctl_[d]qbuf().
1034  */
1035 static int atomisp_qbuf_wrapper(struct file *file, void *fh, struct v4l2_buffer *buf)
1036 {
1037         struct video_device *vdev = video_devdata(file);
1038         struct atomisp_device *isp = video_get_drvdata(vdev);
1039         struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1040
1041         if (buf->index >= vb2_get_num_buffers(vdev->queue))
1042                 return -EINVAL;
1043
1044         if (buf->reserved2 & ATOMISP_BUFFER_HAS_PER_FRAME_SETTING) {
1045                 /* this buffer will have a per-frame parameter */
1046                 pipe->frame_request_config_id[buf->index] = buf->reserved2 &
1047                         ~ATOMISP_BUFFER_HAS_PER_FRAME_SETTING;
1048                 dev_dbg(isp->dev,
1049                         "This buffer requires per_frame setting which has isp_config_id %d\n",
1050                         pipe->frame_request_config_id[buf->index]);
1051         } else {
1052                 pipe->frame_request_config_id[buf->index] = 0;
1053         }
1054
1055         return vb2_ioctl_qbuf(file, fh, buf);
1056 }
1057
1058 static int atomisp_dqbuf_wrapper(struct file *file, void *fh, struct v4l2_buffer *buf)
1059 {
1060         struct video_device *vdev = video_devdata(file);
1061         struct atomisp_video_pipe *pipe = atomisp_to_video_pipe(vdev);
1062         struct atomisp_sub_device *asd = pipe->asd;
1063         struct atomisp_device *isp = video_get_drvdata(vdev);
1064         struct ia_css_frame *frame;
1065         struct vb2_buffer *vb;
1066         int ret;
1067
1068         ret = vb2_ioctl_dqbuf(file, fh, buf);
1069         if (ret)
1070                 return ret;
1071
1072         vb = vb2_get_buffer(&pipe->vb_queue, buf->index);
1073         frame = vb_to_frame(vb);
1074
1075         buf->reserved = asd->frame_status[buf->index];
1076
1077         /*
1078          * Hack:
1079          * Currently frame_status in the enum type which takes no more lower
1080          * 8 bit.
1081          * use bit[31:16] for exp_id as it is only in the range of 1~255
1082          */
1083         buf->reserved &= 0x0000ffff;
1084         if (!(buf->flags & V4L2_BUF_FLAG_ERROR))
1085                 buf->reserved |= frame->exp_id;
1086         buf->reserved2 = pipe->frame_config_id[buf->index];
1087
1088         dev_dbg(isp->dev,
1089                 "dqbuf buffer %d (%s) with exp_id %d, isp_config_id %d\n",
1090                 buf->index, vdev->name, buf->reserved >> 16, buf->reserved2);
1091         return 0;
1092 }
1093
1094 /* Input system HW workaround */
1095 /* Input system address translation corrupts burst during */
1096 /* invalidate. SW workaround for this is to set burst length */
1097 /* manually to 128 in case of 13MPx snapshot and to 1 otherwise. */
1098 static void atomisp_dma_burst_len_cfg(struct atomisp_sub_device *asd)
1099 {
1100         struct v4l2_mbus_framefmt *sink;
1101
1102         sink = atomisp_subdev_get_ffmt(&asd->subdev, NULL,
1103                                        V4L2_SUBDEV_FORMAT_ACTIVE,
1104                                        ATOMISP_SUBDEV_PAD_SINK);
1105
1106         if (sink->width * sink->height >= 4096 * 3072)
1107                 atomisp_css2_hw_store_32(DMA_BURST_SIZE_REG, 0x7F);
1108         else
1109                 atomisp_css2_hw_store_32(DMA_BURST_SIZE_REG, 0x00);
1110 }
1111
1112 int atomisp_start_streaming(struct vb2_queue *vq, unsigned int count)
1113 {
1114         struct atomisp_video_pipe *pipe = vq_to_pipe(vq);
1115         struct atomisp_sub_device *asd = pipe->asd;
1116         struct atomisp_device *isp = asd->isp;
1117         struct pci_dev *pdev = to_pci_dev(isp->dev);
1118         unsigned long irqflags;
1119         int ret;
1120
1121         dev_dbg(isp->dev, "Start stream\n");
1122
1123         mutex_lock(&isp->mutex);
1124
1125         ret = atomisp_pipe_check(pipe, false);
1126         if (ret)
1127                 goto out_unlock;
1128
1129         /* Input system HW workaround */
1130         atomisp_dma_burst_len_cfg(asd);
1131
1132         /* Invalidate caches. FIXME: should flush only necessary buffers */
1133         wbinvd();
1134
1135         if (asd->params.css_update_params_needed) {
1136                 atomisp_apply_css_parameters(asd, &asd->params.css_param);
1137                 if (asd->params.css_param.update_flag.dz_config)
1138                         asd->params.config.dz_config = &asd->params.css_param.dz_config;
1139                 atomisp_css_update_isp_params(asd);
1140                 asd->params.css_update_params_needed = false;
1141                 memset(&asd->params.css_param.update_flag, 0,
1142                        sizeof(struct atomisp_parameters));
1143         }
1144         asd->params.dvs_6axis = NULL;
1145
1146         ret = atomisp_css_start(asd);
1147         if (ret) {
1148                 atomisp_flush_video_pipe(pipe, VB2_BUF_STATE_QUEUED, true);
1149                 goto out_unlock;
1150         }
1151
1152         spin_lock_irqsave(&isp->lock, irqflags);
1153         asd->streaming = true;
1154         spin_unlock_irqrestore(&isp->lock, irqflags);
1155         atomic_set(&asd->sof_count, -1);
1156         atomic_set(&asd->sequence, -1);
1157         atomic_set(&asd->sequence_temp, -1);
1158
1159         asd->params.dis_proj_data_valid = false;
1160         asd->latest_preview_exp_id = 0;
1161         asd->postview_exp_id = 1;
1162         asd->preview_exp_id = 1;
1163
1164         /* handle per_frame_setting parameter and buffers */
1165         atomisp_handle_parameter_and_buffer(pipe);
1166
1167         atomisp_qbuffers_to_css(asd);
1168
1169         if (isp->flash) {
1170                 asd->params.num_flash_frames = 0;
1171                 asd->params.flash_state = ATOMISP_FLASH_IDLE;
1172                 atomisp_setup_flash(asd);
1173         }
1174
1175         atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF,
1176                                atomisp_css_valid_sof(isp));
1177         atomisp_csi2_configure(asd);
1178
1179         if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_AUTO, false) < 0)
1180                 dev_dbg(isp->dev, "DFS auto mode failed!\n");
1181
1182         /* Enable the CSI interface on ANN B0/K0 */
1183         if (isp->media_dev.hw_revision >= ((ATOMISP_HW_REVISION_ISP2401 <<
1184                                             ATOMISP_HW_REVISION_SHIFT) | ATOMISP_HW_STEPPING_B0)) {
1185                 pci_write_config_word(pdev, MRFLD_PCI_CSI_CONTROL,
1186                                       isp->saved_regs.csi_control | MRFLD_PCI_CSI_CONTROL_CSI_READY);
1187         }
1188
1189         /* stream on the sensor */
1190         ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1191                                video, s_stream, 1);
1192         if (ret) {
1193                 dev_err(isp->dev, "Starting sensor stream failed: %d\n", ret);
1194                 spin_lock_irqsave(&isp->lock, irqflags);
1195                 asd->streaming = false;
1196                 spin_unlock_irqrestore(&isp->lock, irqflags);
1197                 ret = -EINVAL;
1198                 goto out_unlock;
1199         }
1200
1201 out_unlock:
1202         mutex_unlock(&isp->mutex);
1203         return ret;
1204 }
1205
1206 void atomisp_stop_streaming(struct vb2_queue *vq)
1207 {
1208         struct atomisp_video_pipe *pipe = vq_to_pipe(vq);
1209         struct atomisp_sub_device *asd = pipe->asd;
1210         struct atomisp_device *isp = asd->isp;
1211         struct pci_dev *pdev = to_pci_dev(isp->dev);
1212         unsigned long flags;
1213         int ret;
1214
1215         dev_dbg(isp->dev, "Stop stream\n");
1216
1217         mutex_lock(&isp->mutex);
1218         /*
1219          * There is no guarantee that the buffers queued to / owned by the ISP
1220          * will properly be returned to the queue when stopping. Set a flag to
1221          * avoid new buffers getting queued and then wait for all the current
1222          * buffers to finish.
1223          */
1224         pipe->stopping = true;
1225         mutex_unlock(&isp->mutex);
1226         /* wait max 1 second */
1227         ret = wait_event_timeout(pipe->vb_queue.done_wq,
1228                                  atomisp_buffers_in_css(pipe) == 0, HZ);
1229         mutex_lock(&isp->mutex);
1230         pipe->stopping = false;
1231         if (ret == 0)
1232                 dev_warn(isp->dev, "Warning timeout waiting for CSS to return buffers\n");
1233
1234         spin_lock_irqsave(&isp->lock, flags);
1235         asd->streaming = false;
1236         spin_unlock_irqrestore(&isp->lock, flags);
1237
1238         atomisp_clear_css_buffer_counters(asd);
1239         atomisp_css_irq_enable(isp, IA_CSS_IRQ_INFO_CSS_RECEIVER_SOF, false);
1240
1241         atomisp_css_stop(asd, false);
1242
1243         atomisp_flush_video_pipe(pipe, VB2_BUF_STATE_ERROR, true);
1244
1245         atomisp_subdev_cleanup_pending_events(asd);
1246
1247         ret = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1248                                video, s_stream, 0);
1249         if (ret)
1250                 dev_warn(isp->dev, "Stopping sensor stream failed: %d\n", ret);
1251
1252         if (isp->flash) {
1253                 asd->params.num_flash_frames = 0;
1254                 asd->params.flash_state = ATOMISP_FLASH_IDLE;
1255         }
1256
1257         /* Disable the CSI interface on ANN B0/K0 */
1258         if (isp->media_dev.hw_revision >= ((ATOMISP_HW_REVISION_ISP2401 <<
1259                                             ATOMISP_HW_REVISION_SHIFT) | ATOMISP_HW_STEPPING_B0)) {
1260                 pci_write_config_word(pdev, MRFLD_PCI_CSI_CONTROL,
1261                                       isp->saved_regs.csi_control & ~MRFLD_PCI_CSI_CONTROL_CSI_READY);
1262         }
1263
1264         if (atomisp_freq_scaling(isp, ATOMISP_DFS_MODE_LOW, false))
1265                 dev_warn(isp->dev, "DFS failed.\n");
1266
1267         /*
1268          * ISP work around, need to reset ISP to allow next stream on to work.
1269          * Streams have already been destroyed by atomisp_css_stop().
1270          * Disable PUNIT/ISP acknowlede/handshake - SRSE=3 and then reset.
1271          */
1272         pci_write_config_dword(pdev, PCI_I_CONTROL,
1273                                isp->saved_regs.i_control | MRFLD_PCI_I_CONTROL_SRSE_RESET_MASK);
1274         atomisp_reset(isp);
1275
1276         /* Streams were destroyed by atomisp_css_stop(), recreate them. */
1277         ret = atomisp_create_pipes_stream(&isp->asd);
1278         if (ret)
1279                 dev_warn(isp->dev, "Recreating streams failed: %d\n", ret);
1280
1281         mutex_unlock(&isp->mutex);
1282 }
1283
1284 /*
1285  * To get the current value of a control.
1286  * applications initialize the id field of a struct v4l2_control and
1287  * call this ioctl with a pointer to this structure
1288  */
1289 static int atomisp_g_ctrl(struct file *file, void *fh,
1290                           struct v4l2_control *control)
1291 {
1292         struct video_device *vdev = video_devdata(file);
1293         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1294         struct atomisp_device *isp = video_get_drvdata(vdev);
1295         int i, ret = -EINVAL;
1296
1297         for (i = 0; i < ctrls_num; i++) {
1298                 if (ci_v4l2_controls[i].id == control->id) {
1299                         ret = 0;
1300                         break;
1301                 }
1302         }
1303
1304         if (ret)
1305                 return ret;
1306
1307         switch (control->id) {
1308         case V4L2_CID_IRIS_ABSOLUTE:
1309         case V4L2_CID_EXPOSURE_ABSOLUTE:
1310         case V4L2_CID_2A_STATUS:
1311         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1312         case V4L2_CID_EXPOSURE:
1313         case V4L2_CID_EXPOSURE_AUTO:
1314         case V4L2_CID_SCENE_MODE:
1315         case V4L2_CID_ISO_SENSITIVITY:
1316         case V4L2_CID_ISO_SENSITIVITY_AUTO:
1317         case V4L2_CID_CONTRAST:
1318         case V4L2_CID_SATURATION:
1319         case V4L2_CID_SHARPNESS:
1320         case V4L2_CID_3A_LOCK:
1321         case V4L2_CID_EXPOSURE_ZONE_NUM:
1322         case V4L2_CID_TEST_PATTERN:
1323         case V4L2_CID_TEST_PATTERN_COLOR_R:
1324         case V4L2_CID_TEST_PATTERN_COLOR_GR:
1325         case V4L2_CID_TEST_PATTERN_COLOR_GB:
1326         case V4L2_CID_TEST_PATTERN_COLOR_B:
1327                 return v4l2_g_ctrl(isp->inputs[asd->input_curr].camera->
1328                                    ctrl_handler, control);
1329         case V4L2_CID_COLORFX:
1330                 ret = atomisp_color_effect(asd, 0, &control->value);
1331                 break;
1332         case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION:
1333                 ret = atomisp_bad_pixel(asd, 0, &control->value);
1334                 break;
1335         case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC:
1336                 ret = atomisp_gdc_cac(asd, 0, &control->value);
1337                 break;
1338         case V4L2_CID_ATOMISP_VIDEO_STABLIZATION:
1339                 ret = atomisp_video_stable(asd, 0, &control->value);
1340                 break;
1341         case V4L2_CID_ATOMISP_FIXED_PATTERN_NR:
1342                 ret = atomisp_fixed_pattern(asd, 0, &control->value);
1343                 break;
1344         case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION:
1345                 ret = atomisp_false_color(asd, 0, &control->value);
1346                 break;
1347         case V4L2_CID_ATOMISP_LOW_LIGHT:
1348                 ret = atomisp_low_light(asd, 0, &control->value);
1349                 break;
1350         default:
1351                 ret = -EINVAL;
1352                 break;
1353         }
1354
1355         return ret;
1356 }
1357
1358 /*
1359  * To change the value of a control.
1360  * applications initialize the id and value fields of a struct v4l2_control
1361  * and call this ioctl.
1362  */
1363 static int atomisp_s_ctrl(struct file *file, void *fh,
1364                           struct v4l2_control *control)
1365 {
1366         struct video_device *vdev = video_devdata(file);
1367         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1368         struct atomisp_device *isp = video_get_drvdata(vdev);
1369         int i, ret = -EINVAL;
1370
1371         for (i = 0; i < ctrls_num; i++) {
1372                 if (ci_v4l2_controls[i].id == control->id) {
1373                         ret = 0;
1374                         break;
1375                 }
1376         }
1377
1378         if (ret)
1379                 return ret;
1380
1381         switch (control->id) {
1382         case V4L2_CID_AUTO_N_PRESET_WHITE_BALANCE:
1383         case V4L2_CID_EXPOSURE:
1384         case V4L2_CID_EXPOSURE_AUTO:
1385         case V4L2_CID_EXPOSURE_AUTO_PRIORITY:
1386         case V4L2_CID_SCENE_MODE:
1387         case V4L2_CID_ISO_SENSITIVITY:
1388         case V4L2_CID_ISO_SENSITIVITY_AUTO:
1389         case V4L2_CID_POWER_LINE_FREQUENCY:
1390         case V4L2_CID_EXPOSURE_METERING:
1391         case V4L2_CID_CONTRAST:
1392         case V4L2_CID_SATURATION:
1393         case V4L2_CID_SHARPNESS:
1394         case V4L2_CID_3A_LOCK:
1395         case V4L2_CID_COLORFX_CBCR:
1396         case V4L2_CID_TEST_PATTERN:
1397         case V4L2_CID_TEST_PATTERN_COLOR_R:
1398         case V4L2_CID_TEST_PATTERN_COLOR_GR:
1399         case V4L2_CID_TEST_PATTERN_COLOR_GB:
1400         case V4L2_CID_TEST_PATTERN_COLOR_B:
1401                 return v4l2_s_ctrl(NULL,
1402                                    isp->inputs[asd->input_curr].camera->
1403                                    ctrl_handler, control);
1404         case V4L2_CID_COLORFX:
1405                 ret = atomisp_color_effect(asd, 1, &control->value);
1406                 break;
1407         case V4L2_CID_ATOMISP_BAD_PIXEL_DETECTION:
1408                 ret = atomisp_bad_pixel(asd, 1, &control->value);
1409                 break;
1410         case V4L2_CID_ATOMISP_POSTPROCESS_GDC_CAC:
1411                 ret = atomisp_gdc_cac(asd, 1, &control->value);
1412                 break;
1413         case V4L2_CID_ATOMISP_VIDEO_STABLIZATION:
1414                 ret = atomisp_video_stable(asd, 1, &control->value);
1415                 break;
1416         case V4L2_CID_ATOMISP_FIXED_PATTERN_NR:
1417                 ret = atomisp_fixed_pattern(asd, 1, &control->value);
1418                 break;
1419         case V4L2_CID_ATOMISP_FALSE_COLOR_CORRECTION:
1420                 ret = atomisp_false_color(asd, 1, &control->value);
1421                 break;
1422         case V4L2_CID_REQUEST_FLASH:
1423                 ret = atomisp_flash_enable(asd, control->value);
1424                 break;
1425         case V4L2_CID_ATOMISP_LOW_LIGHT:
1426                 ret = atomisp_low_light(asd, 1, &control->value);
1427                 break;
1428         default:
1429                 ret = -EINVAL;
1430                 break;
1431         }
1432         return ret;
1433 }
1434
1435 /*
1436  * To query the attributes of a control.
1437  * applications set the id field of a struct v4l2_queryctrl and call the
1438  * this ioctl with a pointer to this structure. The driver fills
1439  * the rest of the structure.
1440  */
1441 static int atomisp_queryctl(struct file *file, void *fh,
1442                             struct v4l2_queryctrl *qc)
1443 {
1444         int i, ret = -EINVAL;
1445         struct video_device *vdev = video_devdata(file);
1446         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1447         struct atomisp_device *isp = video_get_drvdata(vdev);
1448
1449         switch (qc->id) {
1450         case V4L2_CID_FOCUS_ABSOLUTE:
1451         case V4L2_CID_FOCUS_RELATIVE:
1452         case V4L2_CID_FOCUS_STATUS:
1453                 if (!IS_ISP2401) {
1454                         return v4l2_queryctrl(isp->inputs[asd->input_curr].camera->
1455                                             ctrl_handler, qc);
1456                 }
1457                 /* ISP2401 */
1458                 if (isp->motor)
1459                         return v4l2_queryctrl(isp->motor->ctrl_handler, qc);
1460                 else
1461                         return v4l2_queryctrl(isp->inputs[asd->input_curr].
1462                                               camera->ctrl_handler, qc);
1463         }
1464
1465         if (qc->id & V4L2_CTRL_FLAG_NEXT_CTRL)
1466                 return ret;
1467
1468         for (i = 0; i < ctrls_num; i++) {
1469                 if (ci_v4l2_controls[i].id == qc->id) {
1470                         memcpy(qc, &ci_v4l2_controls[i],
1471                                sizeof(struct v4l2_queryctrl));
1472                         qc->reserved[0] = 0;
1473                         ret = 0;
1474                         break;
1475                 }
1476         }
1477         if (ret != 0)
1478                 qc->flags = V4L2_CTRL_FLAG_DISABLED;
1479
1480         return ret;
1481 }
1482
1483 static int atomisp_camera_g_ext_ctrls(struct file *file, void *fh,
1484                                       struct v4l2_ext_controls *c)
1485 {
1486         struct video_device *vdev = video_devdata(file);
1487         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1488         struct atomisp_device *isp = video_get_drvdata(vdev);
1489         struct v4l2_subdev *motor;
1490         struct v4l2_control ctrl;
1491         int i;
1492         int ret = 0;
1493
1494         if (!IS_ISP2401)
1495                 motor = isp->inputs[asd->input_curr].motor;
1496         else
1497                 motor = isp->motor;
1498
1499         for (i = 0; i < c->count; i++) {
1500                 ctrl.id = c->controls[i].id;
1501                 ctrl.value = c->controls[i].value;
1502                 switch (ctrl.id) {
1503                 case V4L2_CID_EXPOSURE_ABSOLUTE:
1504                 case V4L2_CID_EXPOSURE_AUTO:
1505                 case V4L2_CID_IRIS_ABSOLUTE:
1506                 case V4L2_CID_3A_LOCK:
1507                 case V4L2_CID_TEST_PATTERN:
1508                 case V4L2_CID_TEST_PATTERN_COLOR_R:
1509                 case V4L2_CID_TEST_PATTERN_COLOR_GR:
1510                 case V4L2_CID_TEST_PATTERN_COLOR_GB:
1511                 case V4L2_CID_TEST_PATTERN_COLOR_B:
1512                         /*
1513                          * Exposure related control will be handled by sensor
1514                          * driver
1515                          */
1516                         ret =
1517                             v4l2_g_ctrl(isp->inputs[asd->input_curr].camera->
1518                                         ctrl_handler, &ctrl);
1519                         break;
1520                 case V4L2_CID_FOCUS_ABSOLUTE:
1521                 case V4L2_CID_FOCUS_RELATIVE:
1522                 case V4L2_CID_FOCUS_STATUS:
1523                 case V4L2_CID_FOCUS_AUTO:
1524                         if (motor)
1525                                 ret = v4l2_g_ctrl(motor->ctrl_handler, &ctrl);
1526                         break;
1527                 case V4L2_CID_FLASH_STATUS:
1528                 case V4L2_CID_FLASH_INTENSITY:
1529                 case V4L2_CID_FLASH_TORCH_INTENSITY:
1530                 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
1531                 case V4L2_CID_FLASH_TIMEOUT:
1532                 case V4L2_CID_FLASH_STROBE:
1533                 case V4L2_CID_FLASH_MODE:
1534                 case V4L2_CID_FLASH_STATUS_REGISTER:
1535                         if (isp->flash)
1536                                 ret =
1537                                     v4l2_g_ctrl(isp->flash->ctrl_handler,
1538                                                 &ctrl);
1539                         break;
1540                 case V4L2_CID_ZOOM_ABSOLUTE:
1541                         ret = atomisp_digital_zoom(asd, 0, &ctrl.value);
1542                         break;
1543                 case V4L2_CID_G_SKIP_FRAMES:
1544                         ret = v4l2_subdev_call(
1545                                   isp->inputs[asd->input_curr].camera,
1546                                   sensor, g_skip_frames, (u32 *)&ctrl.value);
1547                         break;
1548                 default:
1549                         ret = -EINVAL;
1550                 }
1551
1552                 if (ret) {
1553                         c->error_idx = i;
1554                         break;
1555                 }
1556                 c->controls[i].value = ctrl.value;
1557         }
1558         return ret;
1559 }
1560
1561 /* This ioctl allows the application to get multiple controls by class */
1562 static int atomisp_g_ext_ctrls(struct file *file, void *fh,
1563                                struct v4l2_ext_controls *c)
1564 {
1565         struct v4l2_control ctrl;
1566         int i, ret = 0;
1567
1568         /*
1569          * input_lock is not need for the Camera related IOCTLs
1570          * The input_lock downgrade the FPS of 3A
1571          */
1572         ret = atomisp_camera_g_ext_ctrls(file, fh, c);
1573         if (ret != -EINVAL)
1574                 return ret;
1575
1576         for (i = 0; i < c->count; i++) {
1577                 ctrl.id = c->controls[i].id;
1578                 ctrl.value = c->controls[i].value;
1579                 ret = atomisp_g_ctrl(file, fh, &ctrl);
1580                 c->controls[i].value = ctrl.value;
1581                 if (ret) {
1582                         c->error_idx = i;
1583                         break;
1584                 }
1585         }
1586         return ret;
1587 }
1588
1589 static int atomisp_camera_s_ext_ctrls(struct file *file, void *fh,
1590                                       struct v4l2_ext_controls *c)
1591 {
1592         struct video_device *vdev = video_devdata(file);
1593         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1594         struct atomisp_device *isp = video_get_drvdata(vdev);
1595         struct v4l2_subdev *motor;
1596         struct v4l2_control ctrl;
1597         int i;
1598         int ret = 0;
1599
1600         if (!IS_ISP2401)
1601                 motor = isp->inputs[asd->input_curr].motor;
1602         else
1603                 motor = isp->motor;
1604
1605         for (i = 0; i < c->count; i++) {
1606                 struct v4l2_ctrl *ctr;
1607
1608                 ctrl.id = c->controls[i].id;
1609                 ctrl.value = c->controls[i].value;
1610                 switch (ctrl.id) {
1611                 case V4L2_CID_EXPOSURE_ABSOLUTE:
1612                 case V4L2_CID_EXPOSURE_AUTO:
1613                 case V4L2_CID_EXPOSURE_METERING:
1614                 case V4L2_CID_IRIS_ABSOLUTE:
1615                 case V4L2_CID_VCM_TIMING:
1616                 case V4L2_CID_VCM_SLEW:
1617                 case V4L2_CID_3A_LOCK:
1618                 case V4L2_CID_TEST_PATTERN:
1619                 case V4L2_CID_TEST_PATTERN_COLOR_R:
1620                 case V4L2_CID_TEST_PATTERN_COLOR_GR:
1621                 case V4L2_CID_TEST_PATTERN_COLOR_GB:
1622                 case V4L2_CID_TEST_PATTERN_COLOR_B:
1623                         ret = v4l2_s_ctrl(NULL,
1624                                           isp->inputs[asd->input_curr].camera->
1625                                           ctrl_handler, &ctrl);
1626                         break;
1627                 case V4L2_CID_FOCUS_ABSOLUTE:
1628                 case V4L2_CID_FOCUS_RELATIVE:
1629                 case V4L2_CID_FOCUS_STATUS:
1630                 case V4L2_CID_FOCUS_AUTO:
1631                         if (motor)
1632                                 ret = v4l2_s_ctrl(NULL, motor->ctrl_handler,
1633                                                   &ctrl);
1634                         else
1635                                 ret = v4l2_s_ctrl(NULL,
1636                                                   isp->inputs[asd->input_curr].
1637                                                   camera->ctrl_handler, &ctrl);
1638                         break;
1639                 case V4L2_CID_FLASH_STATUS:
1640                 case V4L2_CID_FLASH_INTENSITY:
1641                 case V4L2_CID_FLASH_TORCH_INTENSITY:
1642                 case V4L2_CID_FLASH_INDICATOR_INTENSITY:
1643                 case V4L2_CID_FLASH_TIMEOUT:
1644                 case V4L2_CID_FLASH_STROBE:
1645                 case V4L2_CID_FLASH_MODE:
1646                 case V4L2_CID_FLASH_STATUS_REGISTER:
1647                         if (isp->flash) {
1648                                 ret =
1649                                     v4l2_s_ctrl(NULL, isp->flash->ctrl_handler,
1650                                                 &ctrl);
1651                                 /*
1652                                  * When flash mode is changed we need to reset
1653                                  * flash state
1654                                  */
1655                                 if (ctrl.id == V4L2_CID_FLASH_MODE) {
1656                                         asd->params.flash_state =
1657                                             ATOMISP_FLASH_IDLE;
1658                                         asd->params.num_flash_frames = 0;
1659                                 }
1660                         }
1661                         break;
1662                 case V4L2_CID_ZOOM_ABSOLUTE:
1663                         ret = atomisp_digital_zoom(asd, 1, &ctrl.value);
1664                         break;
1665                 default:
1666                         ctr = v4l2_ctrl_find(&asd->ctrl_handler, ctrl.id);
1667                         if (ctr)
1668                                 ret = v4l2_ctrl_s_ctrl(ctr, ctrl.value);
1669                         else
1670                                 ret = -EINVAL;
1671                 }
1672
1673                 if (ret) {
1674                         c->error_idx = i;
1675                         break;
1676                 }
1677                 c->controls[i].value = ctrl.value;
1678         }
1679         return ret;
1680 }
1681
1682 /* This ioctl allows the application to set multiple controls by class */
1683 static int atomisp_s_ext_ctrls(struct file *file, void *fh,
1684                                struct v4l2_ext_controls *c)
1685 {
1686         struct v4l2_control ctrl;
1687         int i, ret = 0;
1688
1689         /*
1690          * input_lock is not need for the Camera related IOCTLs
1691          * The input_lock downgrade the FPS of 3A
1692          */
1693         ret = atomisp_camera_s_ext_ctrls(file, fh, c);
1694         if (ret != -EINVAL)
1695                 return ret;
1696
1697         for (i = 0; i < c->count; i++) {
1698                 ctrl.id = c->controls[i].id;
1699                 ctrl.value = c->controls[i].value;
1700                 ret = atomisp_s_ctrl(file, fh, &ctrl);
1701                 c->controls[i].value = ctrl.value;
1702                 if (ret) {
1703                         c->error_idx = i;
1704                         break;
1705                 }
1706         }
1707         return ret;
1708 }
1709
1710 /*
1711  * vidioc_g/s_param are used to switch isp running mode
1712  */
1713 static int atomisp_g_parm(struct file *file, void *fh,
1714                           struct v4l2_streamparm *parm)
1715 {
1716         struct video_device *vdev = video_devdata(file);
1717         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1718         struct atomisp_device *isp = video_get_drvdata(vdev);
1719
1720         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1721                 dev_err(isp->dev, "unsupported v4l2 buf type\n");
1722                 return -EINVAL;
1723         }
1724
1725         parm->parm.capture.capturemode = asd->run_mode->val;
1726
1727         return 0;
1728 }
1729
1730 static int atomisp_s_parm(struct file *file, void *fh,
1731                           struct v4l2_streamparm *parm)
1732 {
1733         struct video_device *vdev = video_devdata(file);
1734         struct atomisp_device *isp = video_get_drvdata(vdev);
1735         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1736         int mode;
1737         int rval;
1738         int fps;
1739
1740         if (parm->type != V4L2_BUF_TYPE_VIDEO_CAPTURE) {
1741                 dev_err(isp->dev, "unsupported v4l2 buf type\n");
1742                 return -EINVAL;
1743         }
1744
1745         asd->high_speed_mode = false;
1746         switch (parm->parm.capture.capturemode) {
1747         case CI_MODE_NONE: {
1748                 struct v4l2_subdev_frame_interval fi = {0};
1749
1750                 fi.interval = parm->parm.capture.timeperframe;
1751
1752                 rval = v4l2_subdev_call_state_active(isp->inputs[asd->input_curr].camera,
1753                                                      pad, set_frame_interval, &fi);
1754                 if (!rval)
1755                         parm->parm.capture.timeperframe = fi.interval;
1756
1757                 if (fi.interval.numerator != 0) {
1758                         fps = fi.interval.denominator / fi.interval.numerator;
1759                         if (fps > 30)
1760                                 asd->high_speed_mode = true;
1761                 }
1762
1763                 return rval == -ENOIOCTLCMD ? 0 : rval;
1764         }
1765         case CI_MODE_VIDEO:
1766                 mode = ATOMISP_RUN_MODE_VIDEO;
1767                 break;
1768         case CI_MODE_STILL_CAPTURE:
1769                 mode = ATOMISP_RUN_MODE_STILL_CAPTURE;
1770                 break;
1771         case CI_MODE_PREVIEW:
1772                 mode = ATOMISP_RUN_MODE_PREVIEW;
1773                 break;
1774         default:
1775                 return -EINVAL;
1776         }
1777
1778         rval = v4l2_ctrl_s_ctrl(asd->run_mode, mode);
1779
1780         return rval == -ENOIOCTLCMD ? 0 : rval;
1781 }
1782
1783 static long atomisp_vidioc_default(struct file *file, void *fh,
1784                                    bool valid_prio, unsigned int cmd, void *arg)
1785 {
1786         struct video_device *vdev = video_devdata(file);
1787         struct atomisp_device *isp = video_get_drvdata(vdev);
1788         struct atomisp_sub_device *asd = atomisp_to_video_pipe(vdev)->asd;
1789         int err;
1790
1791         switch (cmd) {
1792         case ATOMISP_IOC_G_XNR:
1793                 err = atomisp_xnr(asd, 0, arg);
1794                 break;
1795
1796         case ATOMISP_IOC_S_XNR:
1797                 err = atomisp_xnr(asd, 1, arg);
1798                 break;
1799
1800         case ATOMISP_IOC_G_NR:
1801                 err = atomisp_nr(asd, 0, arg);
1802                 break;
1803
1804         case ATOMISP_IOC_S_NR:
1805                 err = atomisp_nr(asd, 1, arg);
1806                 break;
1807
1808         case ATOMISP_IOC_G_TNR:
1809                 err = atomisp_tnr(asd, 0, arg);
1810                 break;
1811
1812         case ATOMISP_IOC_S_TNR:
1813                 err = atomisp_tnr(asd, 1, arg);
1814                 break;
1815
1816         case ATOMISP_IOC_G_BLACK_LEVEL_COMP:
1817                 err = atomisp_black_level(asd, 0, arg);
1818                 break;
1819
1820         case ATOMISP_IOC_S_BLACK_LEVEL_COMP:
1821                 err = atomisp_black_level(asd, 1, arg);
1822                 break;
1823
1824         case ATOMISP_IOC_G_EE:
1825                 err = atomisp_ee(asd, 0, arg);
1826                 break;
1827
1828         case ATOMISP_IOC_S_EE:
1829                 err = atomisp_ee(asd, 1, arg);
1830                 break;
1831
1832         case ATOMISP_IOC_G_DIS_STAT:
1833                 err = atomisp_get_dis_stat(asd, arg);
1834                 break;
1835
1836         case ATOMISP_IOC_G_DVS2_BQ_RESOLUTIONS:
1837                 err = atomisp_get_dvs2_bq_resolutions(asd, arg);
1838                 break;
1839
1840         case ATOMISP_IOC_S_DIS_COEFS:
1841                 err = atomisp_css_cp_dvs2_coefs(asd, arg,
1842                                                 &asd->params.css_param, true);
1843                 if (!err && arg)
1844                         asd->params.css_update_params_needed = true;
1845                 break;
1846
1847         case ATOMISP_IOC_S_DIS_VECTOR:
1848                 err = atomisp_cp_dvs_6axis_config(asd, arg,
1849                                                   &asd->params.css_param, true);
1850                 if (!err && arg)
1851                         asd->params.css_update_params_needed = true;
1852                 break;
1853
1854         case ATOMISP_IOC_G_ISP_PARM:
1855                 err = atomisp_param(asd, 0, arg);
1856                 break;
1857
1858         case ATOMISP_IOC_S_ISP_PARM:
1859                 err = atomisp_param(asd, 1, arg);
1860                 break;
1861
1862         case ATOMISP_IOC_G_3A_STAT:
1863                 err = atomisp_3a_stat(asd, 0, arg);
1864                 break;
1865
1866         case ATOMISP_IOC_G_ISP_GAMMA:
1867                 err = atomisp_gamma(asd, 0, arg);
1868                 break;
1869
1870         case ATOMISP_IOC_S_ISP_GAMMA:
1871                 err = atomisp_gamma(asd, 1, arg);
1872                 break;
1873
1874         case ATOMISP_IOC_G_ISP_GDC_TAB:
1875                 err = atomisp_gdc_cac_table(asd, 0, arg);
1876                 break;
1877
1878         case ATOMISP_IOC_S_ISP_GDC_TAB:
1879                 err = atomisp_gdc_cac_table(asd, 1, arg);
1880                 break;
1881
1882         case ATOMISP_IOC_G_ISP_MACC:
1883                 err = atomisp_macc_table(asd, 0, arg);
1884                 break;
1885
1886         case ATOMISP_IOC_S_ISP_MACC:
1887                 err = atomisp_macc_table(asd, 1, arg);
1888                 break;
1889
1890         case ATOMISP_IOC_G_ISP_BAD_PIXEL_DETECTION:
1891                 err = atomisp_bad_pixel_param(asd, 0, arg);
1892                 break;
1893
1894         case ATOMISP_IOC_S_ISP_BAD_PIXEL_DETECTION:
1895                 err = atomisp_bad_pixel_param(asd, 1, arg);
1896                 break;
1897
1898         case ATOMISP_IOC_G_ISP_FALSE_COLOR_CORRECTION:
1899                 err = atomisp_false_color_param(asd, 0, arg);
1900                 break;
1901
1902         case ATOMISP_IOC_S_ISP_FALSE_COLOR_CORRECTION:
1903                 err = atomisp_false_color_param(asd, 1, arg);
1904                 break;
1905
1906         case ATOMISP_IOC_G_ISP_CTC:
1907                 err = atomisp_ctc(asd, 0, arg);
1908                 break;
1909
1910         case ATOMISP_IOC_S_ISP_CTC:
1911                 err = atomisp_ctc(asd, 1, arg);
1912                 break;
1913
1914         case ATOMISP_IOC_G_ISP_WHITE_BALANCE:
1915                 err = atomisp_white_balance_param(asd, 0, arg);
1916                 break;
1917
1918         case ATOMISP_IOC_S_ISP_WHITE_BALANCE:
1919                 err = atomisp_white_balance_param(asd, 1, arg);
1920                 break;
1921
1922         case ATOMISP_IOC_G_3A_CONFIG:
1923                 err = atomisp_3a_config_param(asd, 0, arg);
1924                 break;
1925
1926         case ATOMISP_IOC_S_3A_CONFIG:
1927                 err = atomisp_3a_config_param(asd, 1, arg);
1928                 break;
1929
1930         case ATOMISP_IOC_S_ISP_FPN_TABLE:
1931                 err = atomisp_fixed_pattern_table(asd, arg);
1932                 break;
1933
1934         case ATOMISP_IOC_S_EXPOSURE:
1935                 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1936                                        core, ioctl, cmd, arg);
1937                 break;
1938
1939         case ATOMISP_IOC_S_ISP_SHD_TAB:
1940                 err = atomisp_set_shading_table(asd, arg);
1941                 break;
1942
1943         case ATOMISP_IOC_G_ISP_GAMMA_CORRECTION:
1944                 err = atomisp_gamma_correction(asd, 0, arg);
1945                 break;
1946
1947         case ATOMISP_IOC_S_ISP_GAMMA_CORRECTION:
1948                 err = atomisp_gamma_correction(asd, 1, arg);
1949                 break;
1950
1951         case ATOMISP_IOC_S_PARAMETERS:
1952                 err = atomisp_set_parameters(vdev, arg);
1953                 break;
1954
1955         case ATOMISP_IOC_EXT_ISP_CTRL:
1956                 err = v4l2_subdev_call(isp->inputs[asd->input_curr].camera,
1957                                        core, ioctl, cmd, arg);
1958                 break;
1959         case ATOMISP_IOC_EXP_ID_UNLOCK:
1960                 err = atomisp_exp_id_unlock(asd, arg);
1961                 break;
1962         case ATOMISP_IOC_EXP_ID_CAPTURE:
1963                 err = atomisp_exp_id_capture(asd, arg);
1964                 break;
1965         case ATOMISP_IOC_S_ENABLE_DZ_CAPT_PIPE:
1966                 err = atomisp_enable_dz_capt_pipe(asd, arg);
1967                 break;
1968         case ATOMISP_IOC_G_FORMATS_CONFIG:
1969                 err = atomisp_formats(asd, 0, arg);
1970                 break;
1971
1972         case ATOMISP_IOC_S_FORMATS_CONFIG:
1973                 err = atomisp_formats(asd, 1, arg);
1974                 break;
1975         case ATOMISP_IOC_INJECT_A_FAKE_EVENT:
1976                 err = atomisp_inject_a_fake_event(asd, arg);
1977                 break;
1978         case ATOMISP_IOC_S_ARRAY_RESOLUTION:
1979                 err = atomisp_set_array_res(asd, arg);
1980                 break;
1981         default:
1982                 err = -EINVAL;
1983                 break;
1984         }
1985
1986         return err;
1987 }
1988
1989 const struct v4l2_ioctl_ops atomisp_ioctl_ops = {
1990         .vidioc_querycap = atomisp_querycap,
1991         .vidioc_enum_input = atomisp_enum_input,
1992         .vidioc_g_input = atomisp_g_input,
1993         .vidioc_s_input = atomisp_s_input,
1994         .vidioc_queryctrl = atomisp_queryctl,
1995         .vidioc_s_ctrl = atomisp_s_ctrl,
1996         .vidioc_g_ctrl = atomisp_g_ctrl,
1997         .vidioc_s_ext_ctrls = atomisp_s_ext_ctrls,
1998         .vidioc_g_ext_ctrls = atomisp_g_ext_ctrls,
1999         .vidioc_enum_framesizes   = atomisp_enum_framesizes,
2000         .vidioc_enum_frameintervals = atomisp_enum_frameintervals,
2001         .vidioc_enum_fmt_vid_cap = atomisp_enum_fmt_cap,
2002         .vidioc_try_fmt_vid_cap = atomisp_try_fmt_cap,
2003         .vidioc_g_fmt_vid_cap = atomisp_g_fmt_cap,
2004         .vidioc_s_fmt_vid_cap = atomisp_s_fmt_cap,
2005         .vidioc_reqbufs = vb2_ioctl_reqbufs,
2006         .vidioc_querybuf = vb2_ioctl_querybuf,
2007         .vidioc_qbuf = atomisp_qbuf_wrapper,
2008         .vidioc_dqbuf = atomisp_dqbuf_wrapper,
2009         .vidioc_streamon = vb2_ioctl_streamon,
2010         .vidioc_streamoff = vb2_ioctl_streamoff,
2011         .vidioc_default = atomisp_vidioc_default,
2012         .vidioc_s_parm = atomisp_s_parm,
2013         .vidioc_g_parm = atomisp_g_parm,
2014 };