drivers/media/usb/gspca/cpia1.c

   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * cpia CPiA (1) gspca driver
   4  *
   5  * Copyright (C) 2010-2011 Hans de Goede <[email protected]>
   6  *
   7  * This module is adapted from the in kernel v4l1 cpia driver which is :
   8  *
   9  * (C) Copyright 1999-2000 Peter Pregler
  10  * (C) Copyright 1999-2000 Scott J. Bertin
  11  * (C) Copyright 1999-2000 Johannes Erdfelt <[email protected]>
  12  * (C) Copyright 2000 STMicroelectronics
  13  */
  14
  15 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  16
  17 #define MODULE_NAME "cpia1"
  18
  19 #include <linux/input.h>
  20 #include <linux/sched/signal.h>
  21 #include <linux/bitops.h>
  22
  23 #include "gspca.h"
  24
  25 MODULE_AUTHOR("Hans de Goede <[email protected]>");
  26 MODULE_DESCRIPTION("Vision CPiA");
  27 MODULE_LICENSE("GPL");
  28
  29 /* constant value's */
  30 #define MAGIC_0         0x19
  31 #define MAGIC_1         0x68
  32 #define DATA_IN         0xc0
  33 #define DATA_OUT        0x40
  34 #define VIDEOSIZE_QCIF  0       /* 176x144 */
  35 #define VIDEOSIZE_CIF   1       /* 352x288 */
  36 #define SUBSAMPLE_420   0
  37 #define SUBSAMPLE_422   1
  38 #define YUVORDER_YUYV   0
  39 #define YUVORDER_UYVY   1
  40 #define NOT_COMPRESSED  0
  41 #define COMPRESSED      1
  42 #define NO_DECIMATION   0
  43 #define DECIMATION_ENAB 1
  44 #define EOI             0xff    /* End Of Image */
  45 #define EOL             0xfd    /* End Of Line */
  46 #define FRAME_HEADER_SIZE       64
  47
  48 /* Image grab modes */
  49 #define CPIA_GRAB_SINGLE        0
  50 #define CPIA_GRAB_CONTINEOUS    1
  51
  52 /* Compression parameters */
  53 #define CPIA_COMPRESSION_NONE   0
  54 #define CPIA_COMPRESSION_AUTO   1
  55 #define CPIA_COMPRESSION_MANUAL 2
  56 #define CPIA_COMPRESSION_TARGET_QUALITY         0
  57 #define CPIA_COMPRESSION_TARGET_FRAMERATE       1
  58
  59 /* Return offsets for GetCameraState */
  60 #define SYSTEMSTATE     0
  61 #define GRABSTATE       1
  62 #define STREAMSTATE     2
  63 #define FATALERROR      3
  64 #define CMDERROR        4
  65 #define DEBUGFLAGS      5
  66 #define VPSTATUS        6
  67 #define ERRORCODE       7
  68
  69 /* SystemState */
  70 #define UNINITIALISED_STATE     0
  71 #define PASS_THROUGH_STATE      1
  72 #define LO_POWER_STATE          2
  73 #define HI_POWER_STATE          3
  74 #define WARM_BOOT_STATE         4
  75
  76 /* GrabState */
  77 #define GRAB_IDLE               0
  78 #define GRAB_ACTIVE             1
  79 #define GRAB_DONE               2
  80
  81 /* StreamState */
  82 #define STREAM_NOT_READY        0
  83 #define STREAM_READY            1
  84 #define STREAM_OPEN             2
  85 #define STREAM_PAUSED           3
  86 #define STREAM_FINISHED         4
  87
  88 /* Fatal Error, CmdError, and DebugFlags */
  89 #define CPIA_FLAG         1
  90 #define SYSTEM_FLAG       2
  91 #define INT_CTRL_FLAG     4
  92 #define PROCESS_FLAG      8
  93 #define COM_FLAG         16
  94 #define VP_CTRL_FLAG     32
  95 #define CAPTURE_FLAG     64
  96 #define DEBUG_FLAG      128
  97
  98 /* VPStatus */
  99 #define VP_STATE_OK                     0x00
 100
 101 #define VP_STATE_FAILED_VIDEOINIT       0x01
 102 #define VP_STATE_FAILED_AECACBINIT      0x02
 103 #define VP_STATE_AEC_MAX                0x04
 104 #define VP_STATE_ACB_BMAX               0x08
 105
 106 #define VP_STATE_ACB_RMIN               0x10
 107 #define VP_STATE_ACB_GMIN               0x20
 108 #define VP_STATE_ACB_RMAX               0x40
 109 #define VP_STATE_ACB_GMAX               0x80
 110
 111 /* default (minimum) compensation values */
 112 #define COMP_RED        220
 113 #define COMP_GREEN1     214
 114 #define COMP_GREEN2     COMP_GREEN1
 115 #define COMP_BLUE       230
 116
 117 /* exposure status */
 118 #define EXPOSURE_VERY_LIGHT 0
 119 #define EXPOSURE_LIGHT      1
 120 #define EXPOSURE_NORMAL     2
 121 #define EXPOSURE_DARK       3
 122 #define EXPOSURE_VERY_DARK  4
 123
 124 #define CPIA_MODULE_CPIA                        (0 << 5)
 125 #define CPIA_MODULE_SYSTEM                      (1 << 5)
 126 #define CPIA_MODULE_VP_CTRL                     (5 << 5)
 127 #define CPIA_MODULE_CAPTURE                     (6 << 5)
 128 #define CPIA_MODULE_DEBUG                       (7 << 5)
 129
 130 #define INPUT (DATA_IN << 8)
 131 #define OUTPUT (DATA_OUT << 8)
 132
 133 #define CPIA_COMMAND_GetCPIAVersion     (INPUT | CPIA_MODULE_CPIA | 1)
 134 #define CPIA_COMMAND_GetPnPID           (INPUT | CPIA_MODULE_CPIA | 2)
 135 #define CPIA_COMMAND_GetCameraStatus    (INPUT | CPIA_MODULE_CPIA | 3)
 136 #define CPIA_COMMAND_GotoHiPower        (OUTPUT | CPIA_MODULE_CPIA | 4)
 137 #define CPIA_COMMAND_GotoLoPower        (OUTPUT | CPIA_MODULE_CPIA | 5)
 138 #define CPIA_COMMAND_GotoSuspend        (OUTPUT | CPIA_MODULE_CPIA | 7)
 139 #define CPIA_COMMAND_GotoPassThrough    (OUTPUT | CPIA_MODULE_CPIA | 8)
 140 #define CPIA_COMMAND_ModifyCameraStatus (OUTPUT | CPIA_MODULE_CPIA | 10)
 141
 142 #define CPIA_COMMAND_ReadVCRegs         (INPUT | CPIA_MODULE_SYSTEM | 1)
 143 #define CPIA_COMMAND_WriteVCReg         (OUTPUT | CPIA_MODULE_SYSTEM | 2)
 144 #define CPIA_COMMAND_ReadMCPorts        (INPUT | CPIA_MODULE_SYSTEM | 3)
 145 #define CPIA_COMMAND_WriteMCPort        (OUTPUT | CPIA_MODULE_SYSTEM | 4)
 146 #define CPIA_COMMAND_SetBaudRate        (OUTPUT | CPIA_MODULE_SYSTEM | 5)
 147 #define CPIA_COMMAND_SetECPTiming       (OUTPUT | CPIA_MODULE_SYSTEM | 6)
 148 #define CPIA_COMMAND_ReadIDATA          (INPUT | CPIA_MODULE_SYSTEM | 7)
 149 #define CPIA_COMMAND_WriteIDATA         (OUTPUT | CPIA_MODULE_SYSTEM | 8)
 150 #define CPIA_COMMAND_GenericCall        (OUTPUT | CPIA_MODULE_SYSTEM | 9)
 151 #define CPIA_COMMAND_I2CStart           (OUTPUT | CPIA_MODULE_SYSTEM | 10)
 152 #define CPIA_COMMAND_I2CStop            (OUTPUT | CPIA_MODULE_SYSTEM | 11)
 153 #define CPIA_COMMAND_I2CWrite           (OUTPUT | CPIA_MODULE_SYSTEM | 12)
 154 #define CPIA_COMMAND_I2CRead            (INPUT | CPIA_MODULE_SYSTEM | 13)
 155
 156 #define CPIA_COMMAND_GetVPVersion       (INPUT | CPIA_MODULE_VP_CTRL | 1)
 157 #define CPIA_COMMAND_ResetFrameCounter  (INPUT | CPIA_MODULE_VP_CTRL | 2)
 158 #define CPIA_COMMAND_SetColourParams    (OUTPUT | CPIA_MODULE_VP_CTRL | 3)
 159 #define CPIA_COMMAND_SetExposure        (OUTPUT | CPIA_MODULE_VP_CTRL | 4)
 160 #define CPIA_COMMAND_SetColourBalance   (OUTPUT | CPIA_MODULE_VP_CTRL | 6)
 161 #define CPIA_COMMAND_SetSensorFPS       (OUTPUT | CPIA_MODULE_VP_CTRL | 7)
 162 #define CPIA_COMMAND_SetVPDefaults      (OUTPUT | CPIA_MODULE_VP_CTRL | 8)
 163 #define CPIA_COMMAND_SetApcor           (OUTPUT | CPIA_MODULE_VP_CTRL | 9)
 164 #define CPIA_COMMAND_SetFlickerCtrl     (OUTPUT | CPIA_MODULE_VP_CTRL | 10)
 165 #define CPIA_COMMAND_SetVLOffset        (OUTPUT | CPIA_MODULE_VP_CTRL | 11)
 166 #define CPIA_COMMAND_GetColourParams    (INPUT | CPIA_MODULE_VP_CTRL | 16)
 167 #define CPIA_COMMAND_GetColourBalance   (INPUT | CPIA_MODULE_VP_CTRL | 17)
 168 #define CPIA_COMMAND_GetExposure        (INPUT | CPIA_MODULE_VP_CTRL | 18)
 169 #define CPIA_COMMAND_SetSensorMatrix    (OUTPUT | CPIA_MODULE_VP_CTRL | 19)
 170 #define CPIA_COMMAND_ColourBars         (OUTPUT | CPIA_MODULE_VP_CTRL | 25)
 171 #define CPIA_COMMAND_ReadVPRegs         (INPUT | CPIA_MODULE_VP_CTRL | 30)
 172 #define CPIA_COMMAND_WriteVPReg         (OUTPUT | CPIA_MODULE_VP_CTRL | 31)
 173
 174 #define CPIA_COMMAND_GrabFrame          (OUTPUT | CPIA_MODULE_CAPTURE | 1)
 175 #define CPIA_COMMAND_UploadFrame        (OUTPUT | CPIA_MODULE_CAPTURE | 2)
 176 #define CPIA_COMMAND_SetGrabMode        (OUTPUT | CPIA_MODULE_CAPTURE | 3)
 177 #define CPIA_COMMAND_InitStreamCap      (OUTPUT | CPIA_MODULE_CAPTURE | 4)
 178 #define CPIA_COMMAND_FiniStreamCap      (OUTPUT | CPIA_MODULE_CAPTURE | 5)
 179 #define CPIA_COMMAND_StartStreamCap     (OUTPUT | CPIA_MODULE_CAPTURE | 6)
 180 #define CPIA_COMMAND_EndStreamCap       (OUTPUT | CPIA_MODULE_CAPTURE | 7)
 181 #define CPIA_COMMAND_SetFormat          (OUTPUT | CPIA_MODULE_CAPTURE | 8)
 182 #define CPIA_COMMAND_SetROI             (OUTPUT | CPIA_MODULE_CAPTURE | 9)
 183 #define CPIA_COMMAND_SetCompression     (OUTPUT | CPIA_MODULE_CAPTURE | 10)
 184 #define CPIA_COMMAND_SetCompressionTarget (OUTPUT | CPIA_MODULE_CAPTURE | 11)
 185 #define CPIA_COMMAND_SetYUVThresh       (OUTPUT | CPIA_MODULE_CAPTURE | 12)
 186 #define CPIA_COMMAND_SetCompressionParams (OUTPUT | CPIA_MODULE_CAPTURE | 13)
 187 #define CPIA_COMMAND_DiscardFrame       (OUTPUT | CPIA_MODULE_CAPTURE | 14)
 188 #define CPIA_COMMAND_GrabReset          (OUTPUT | CPIA_MODULE_CAPTURE | 15)
 189
 190 #define CPIA_COMMAND_OutputRS232        (OUTPUT | CPIA_MODULE_DEBUG | 1)
 191 #define CPIA_COMMAND_AbortProcess       (OUTPUT | CPIA_MODULE_DEBUG | 4)
 192 #define CPIA_COMMAND_SetDramPage        (OUTPUT | CPIA_MODULE_DEBUG | 5)
 193 #define CPIA_COMMAND_StartDramUpload    (OUTPUT | CPIA_MODULE_DEBUG | 6)
 194 #define CPIA_COMMAND_StartDummyDtream   (OUTPUT | CPIA_MODULE_DEBUG | 8)
 195 #define CPIA_COMMAND_AbortStream        (OUTPUT | CPIA_MODULE_DEBUG | 9)
 196 #define CPIA_COMMAND_DownloadDRAM       (OUTPUT | CPIA_MODULE_DEBUG | 10)
 197 #define CPIA_COMMAND_Null               (OUTPUT | CPIA_MODULE_DEBUG | 11)
 198
 199 #define ROUND_UP_EXP_FOR_FLICKER 15
 200
 201 /* Constants for automatic frame rate adjustment */
 202 #define MAX_EXP       302
 203 #define MAX_EXP_102   255
 204 #define LOW_EXP       140
 205 #define VERY_LOW_EXP   70
 206 #define TC             94
 207 #define EXP_ACC_DARK   50
 208 #define EXP_ACC_LIGHT  90
 209 #define HIGH_COMP_102 160
 210 #define MAX_COMP      239
 211 #define DARK_TIME       3
 212 #define LIGHT_TIME      3
 213
 214 #define FIRMWARE_VERSION(x, y) (sd->params.version.firmwareVersion == (x) && \
 215                                 sd->params.version.firmwareRevision == (y))
 216
 217 #define CPIA1_CID_COMP_TARGET (V4L2_CTRL_CLASS_USER + 0x1000)
 218 #define BRIGHTNESS_DEF 50
 219 #define CONTRAST_DEF 48
 220 #define SATURATION_DEF 50
 221 #define FREQ_DEF V4L2_CID_POWER_LINE_FREQUENCY_50HZ
 222 #define ILLUMINATORS_1_DEF 0
 223 #define ILLUMINATORS_2_DEF 0
 224 #define COMP_TARGET_DEF CPIA_COMPRESSION_TARGET_QUALITY
 225
 226 /* Developer's Guide Table 5 p 3-34
 227  * indexed by [mains][sensorFps.baserate][sensorFps.divisor]*/
 228 static u8 flicker_jumps[2][2][4] =
 229 { { { 76, 38, 19, 9 }, { 92, 46, 23, 11 } },
 230   { { 64, 32, 16, 8 }, { 76, 38, 19, 9} }
 231 };
 232
 233 struct cam_params {
 234         struct {
 235                 u8 firmwareVersion;
 236                 u8 firmwareRevision;
 237                 u8 vcVersion;
 238                 u8 vcRevision;
 239         } version;
 240         struct {
 241                 u16 vendor;
 242                 u16 product;
 243                 u16 deviceRevision;
 244         } pnpID;
 245         struct {
 246                 u8 vpVersion;
 247                 u8 vpRevision;
 248                 u16 cameraHeadID;
 249         } vpVersion;
 250         struct {
 251                 u8 systemState;
 252                 u8 grabState;
 253                 u8 streamState;
 254                 u8 fatalError;
 255                 u8 cmdError;
 256                 u8 debugFlags;
 257                 u8 vpStatus;
 258                 u8 errorCode;
 259         } status;
 260         struct {
 261                 u8 brightness;
 262                 u8 contrast;
 263                 u8 saturation;
 264         } colourParams;
 265         struct {
 266                 u8 gainMode;
 267                 u8 expMode;
 268                 u8 compMode;
 269                 u8 centreWeight;
 270                 u8 gain;
 271                 u8 fineExp;
 272                 u8 coarseExpLo;
 273                 u8 coarseExpHi;
 274                 u8 redComp;
 275                 u8 green1Comp;
 276                 u8 green2Comp;
 277                 u8 blueComp;
 278         } exposure;
 279         struct {
 280                 u8 balanceMode;
 281                 u8 redGain;
 282                 u8 greenGain;
 283                 u8 blueGain;
 284         } colourBalance;
 285         struct {
 286                 u8 divisor;
 287                 u8 baserate;
 288         } sensorFps;
 289         struct {
 290                 u8 gain1;
 291                 u8 gain2;
 292                 u8 gain4;
 293                 u8 gain8;
 294         } apcor;
 295         struct {
 296                 u8 disabled;
 297                 u8 flickerMode;
 298                 u8 coarseJump;
 299                 u8 allowableOverExposure;
 300         } flickerControl;
 301         struct {
 302                 u8 gain1;
 303                 u8 gain2;
 304                 u8 gain4;
 305                 u8 gain8;
 306         } vlOffset;
 307         struct {
 308                 u8 mode;
 309                 u8 decimation;
 310         } compression;
 311         struct {
 312                 u8 frTargeting;
 313                 u8 targetFR;
 314                 u8 targetQ;
 315         } compressionTarget;
 316         struct {
 317                 u8 yThreshold;
 318                 u8 uvThreshold;
 319         } yuvThreshold;
 320         struct {
 321                 u8 hysteresis;
 322                 u8 threshMax;
 323                 u8 smallStep;
 324                 u8 largeStep;
 325                 u8 decimationHysteresis;
 326                 u8 frDiffStepThresh;
 327                 u8 qDiffStepThresh;
 328                 u8 decimationThreshMod;
 329         } compressionParams;
 330         struct {
 331                 u8 videoSize;           /* CIF/QCIF */
 332                 u8 subSample;
 333                 u8 yuvOrder;
 334         } format;
 335         struct {                        /* Intel QX3 specific data */
 336                 u8 qx3_detected;        /* a QX3 is present */
 337                 u8 toplight;            /* top light lit , R/W */
 338                 u8 bottomlight;         /* bottom light lit, R/W */
 339                 u8 button;              /* snapshot button pressed (R/O) */
 340                 u8 cradled;             /* microscope is in cradle (R/O) */
 341         } qx3;
 342         struct {
 343                 u8 colStart;            /* skip first 8*colStart pixels */
 344                 u8 colEnd;              /* finish at 8*colEnd pixels */
 345                 u8 rowStart;            /* skip first 4*rowStart lines */
 346                 u8 rowEnd;              /* finish at 4*rowEnd lines */
 347         } roi;
 348         u8 ecpTiming;
 349         u8 streamStartLine;
 350 };
 351
 352 /* specific webcam descriptor */
 353 struct sd {
 354         struct gspca_dev gspca_dev;             /* !! must be the first item */
 355         struct cam_params params;               /* camera settings */
 356
 357         atomic_t cam_exposure;
 358         atomic_t fps;
 359         int exposure_count;
 360         u8 exposure_status;
 361         struct v4l2_ctrl *freq;
 362         u8 mainsFreq;                           /* 0 = 50hz, 1 = 60hz */
 363         u8 first_frame;
 364 };
 365
 366 static const struct v4l2_pix_format mode[] = {
 367         {160, 120, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
 368                 /* The sizeimage is trial and error, as with low framerates
 369                  *  the camera will pad out usb frames, making the image
 370                  *  data larger than strictly necessary
 371                  */
 372                 .bytesperline = 160,
 373                 .sizeimage = 65536,
 374                 .colorspace = V4L2_COLORSPACE_SRGB,
 375                 .priv = 3},
 376         {176, 144, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
 377                 .bytesperline = 172,
 378                 .sizeimage = 65536,
 379                 .colorspace = V4L2_COLORSPACE_SRGB,
 380                 .priv = 2},
 381         {320, 240, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
 382                 .bytesperline = 320,
 383                 .sizeimage = 262144,
 384                 .colorspace = V4L2_COLORSPACE_SRGB,
 385                 .priv = 1},
 386         {352, 288, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
 387                 .bytesperline = 352,
 388                 .sizeimage = 262144,
 389                 .colorspace = V4L2_COLORSPACE_SRGB,
 390                 .priv = 0},
 391 };
 392
 393 /**********************************************************************
 394  *
 395  * General functions
 396  *
 397  **********************************************************************/
 398
 399 static int cpia_usb_transferCmd(struct gspca_dev *gspca_dev, u8 *command)
 400 {
 401         u8 requesttype;
 402         unsigned int pipe;
 403         int ret, databytes = command[6] | (command[7] << 8);
 404         /* Sometimes we see spurious EPIPE errors */
 405         int retries = 3;
 406
 407         if (command[0] == DATA_IN) {
 408                 pipe = usb_rcvctrlpipe(gspca_dev->dev, 0);
 409                 requesttype = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
 410         } else if (command[0] == DATA_OUT) {
 411                 pipe = usb_sndctrlpipe(gspca_dev->dev, 0);
 412                 requesttype = USB_TYPE_VENDOR | USB_RECIP_DEVICE;
 413         } else {
 414                 gspca_err(gspca_dev, "Unexpected first byte of command: %x\n",
 415                           command[0]);
 416                 return -EINVAL;
 417         }
 418
 419 retry:
 420         ret = usb_control_msg(gspca_dev->dev, pipe,
 421                               command[1],
 422                               requesttype,
 423                               command[2] | (command[3] << 8),
 424                               command[4] | (command[5] << 8),
 425                               gspca_dev->usb_buf, databytes, 1000);
 426
 427         if (ret < 0)
 428                 pr_err("usb_control_msg %02x, error %d\n", command[1], ret);
 429
 430         if (ret == -EPIPE && retries > 0) {
 431                 retries--;
 432                 goto retry;
 433         }
 434
 435         return (ret < 0) ? ret : 0;
 436 }
 437
 438 /* send an arbitrary command to the camera */
 439 static int do_command(struct gspca_dev *gspca_dev, u16 command,
 440                       u8 a, u8 b, u8 c, u8 d)
 441 {
 442         struct sd *sd = (struct sd *) gspca_dev;
 443         int ret, datasize;
 444         u8 cmd[8];
 445
 446         switch (command) {
 447         case CPIA_COMMAND_GetCPIAVersion:
 448         case CPIA_COMMAND_GetPnPID:
 449         case CPIA_COMMAND_GetCameraStatus:
 450         case CPIA_COMMAND_GetVPVersion:
 451         case CPIA_COMMAND_GetColourParams:
 452         case CPIA_COMMAND_GetColourBalance:
 453         case CPIA_COMMAND_GetExposure:
 454                 datasize = 8;
 455                 break;
 456         case CPIA_COMMAND_ReadMCPorts:
 457         case CPIA_COMMAND_ReadVCRegs:
 458                 datasize = 4;
 459                 break;
 460         default:
 461                 datasize = 0;
 462                 break;
 463         }
 464
 465         cmd[0] = command >> 8;
 466         cmd[1] = command & 0xff;
 467         cmd[2] = a;
 468         cmd[3] = b;
 469         cmd[4] = c;
 470         cmd[5] = d;
 471         cmd[6] = datasize;
 472         cmd[7] = 0;
 473
 474         ret = cpia_usb_transferCmd(gspca_dev, cmd);
 475         if (ret)
 476                 return ret;
 477
 478         switch (command) {
 479         case CPIA_COMMAND_GetCPIAVersion:
 480                 sd->params.version.firmwareVersion = gspca_dev->usb_buf[0];
 481                 sd->params.version.firmwareRevision = gspca_dev->usb_buf[1];
 482                 sd->params.version.vcVersion = gspca_dev->usb_buf[2];
 483                 sd->params.version.vcRevision = gspca_dev->usb_buf[3];
 484                 break;
 485         case CPIA_COMMAND_GetPnPID:
 486                 sd->params.pnpID.vendor =
 487                         gspca_dev->usb_buf[0] | (gspca_dev->usb_buf[1] << 8);
 488                 sd->params.pnpID.product =
 489                         gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
 490                 sd->params.pnpID.deviceRevision =
 491                         gspca_dev->usb_buf[4] | (gspca_dev->usb_buf[5] << 8);
 492                 break;
 493         case CPIA_COMMAND_GetCameraStatus:
 494                 sd->params.status.systemState = gspca_dev->usb_buf[0];
 495                 sd->params.status.grabState = gspca_dev->usb_buf[1];
 496                 sd->params.status.streamState = gspca_dev->usb_buf[2];
 497                 sd->params.status.fatalError = gspca_dev->usb_buf[3];
 498                 sd->params.status.cmdError = gspca_dev->usb_buf[4];
 499                 sd->params.status.debugFlags = gspca_dev->usb_buf[5];
 500                 sd->params.status.vpStatus = gspca_dev->usb_buf[6];
 501                 sd->params.status.errorCode = gspca_dev->usb_buf[7];
 502                 break;
 503         case CPIA_COMMAND_GetVPVersion:
 504                 sd->params.vpVersion.vpVersion = gspca_dev->usb_buf[0];
 505                 sd->params.vpVersion.vpRevision = gspca_dev->usb_buf[1];
 506                 sd->params.vpVersion.cameraHeadID =
 507                         gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
 508                 break;
 509         case CPIA_COMMAND_GetColourParams:
 510                 sd->params.colourParams.brightness = gspca_dev->usb_buf[0];
 511                 sd->params.colourParams.contrast = gspca_dev->usb_buf[1];
 512                 sd->params.colourParams.saturation = gspca_dev->usb_buf[2];
 513                 break;
 514         case CPIA_COMMAND_GetColourBalance:
 515                 sd->params.colourBalance.redGain = gspca_dev->usb_buf[0];
 516                 sd->params.colourBalance.greenGain = gspca_dev->usb_buf[1];
 517                 sd->params.colourBalance.blueGain = gspca_dev->usb_buf[2];
 518                 break;
 519         case CPIA_COMMAND_GetExposure:
 520                 sd->params.exposure.gain = gspca_dev->usb_buf[0];
 521                 sd->params.exposure.fineExp = gspca_dev->usb_buf[1];
 522                 sd->params.exposure.coarseExpLo = gspca_dev->usb_buf[2];
 523                 sd->params.exposure.coarseExpHi = gspca_dev->usb_buf[3];
 524                 sd->params.exposure.redComp = gspca_dev->usb_buf[4];
 525                 sd->params.exposure.green1Comp = gspca_dev->usb_buf[5];
 526                 sd->params.exposure.green2Comp = gspca_dev->usb_buf[6];
 527                 sd->params.exposure.blueComp = gspca_dev->usb_buf[7];
 528                 break;
 529
 530         case CPIA_COMMAND_ReadMCPorts:
 531                 /* test button press */
 532                 a = ((gspca_dev->usb_buf[1] & 0x02) == 0);
 533                 if (a != sd->params.qx3.button) {
 534 #if IS_ENABLED(CONFIG_INPUT)
 535                         input_report_key(gspca_dev->input_dev, KEY_CAMERA, a);
 536                         input_sync(gspca_dev->input_dev);
 537 #endif
 538                         sd->params.qx3.button = a;
 539                 }
 540                 if (sd->params.qx3.button) {
 541                         /* button pressed - unlock the latch */
 542                         ret = do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
 543                                    3, 0xdf, 0xdf, 0);
 544                         if (ret)
 545                                 return ret;
 546                         ret = do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
 547                                    3, 0xff, 0xff, 0);
 548                         if (ret)
 549                                 return ret;
 550                 }
 551
 552                 /* test whether microscope is cradled */
 553                 sd->params.qx3.cradled = ((gspca_dev->usb_buf[2] & 0x40) == 0);
 554                 break;
 555         }
 556
 557         return 0;
 558 }
 559
 560 /* send a command to the camera with an additional data transaction */
 561 static int do_command_extended(struct gspca_dev *gspca_dev, u16 command,
 562                                u8 a, u8 b, u8 c, u8 d,
 563                                u8 e, u8 f, u8 g, u8 h,
 564                                u8 i, u8 j, u8 k, u8 l)
 565 {
 566         u8 cmd[8];
 567
 568         cmd[0] = command >> 8;
 569         cmd[1] = command & 0xff;
 570         cmd[2] = a;
 571         cmd[3] = b;
 572         cmd[4] = c;
 573         cmd[5] = d;
 574         cmd[6] = 8;
 575         cmd[7] = 0;
 576         gspca_dev->usb_buf[0] = e;
 577         gspca_dev->usb_buf[1] = f;
 578         gspca_dev->usb_buf[2] = g;
 579         gspca_dev->usb_buf[3] = h;
 580         gspca_dev->usb_buf[4] = i;
 581         gspca_dev->usb_buf[5] = j;
 582         gspca_dev->usb_buf[6] = k;
 583         gspca_dev->usb_buf[7] = l;
 584
 585         return cpia_usb_transferCmd(gspca_dev, cmd);
 586 }
 587
 588 /*  find_over_exposure
 589  *  Finds a suitable value of OverExposure for use with SetFlickerCtrl
 590  *  Some calculation is required because this value changes with the brightness
 591  *  set with SetColourParameters
 592  *
 593  *  Parameters: Brightness - last brightness value set with SetColourParameters
 594  *
 595  *  Returns: OverExposure value to use with SetFlickerCtrl
 596  */
 597 #define FLICKER_MAX_EXPOSURE                    250
 598 #define FLICKER_ALLOWABLE_OVER_EXPOSURE         146
 599 #define FLICKER_BRIGHTNESS_CONSTANT             59
 600 static int find_over_exposure(int brightness)
 601 {
 602         int MaxAllowableOverExposure, OverExposure;
 603
 604         MaxAllowableOverExposure = FLICKER_MAX_EXPOSURE - brightness -
 605                                    FLICKER_BRIGHTNESS_CONSTANT;
 606
 607         OverExposure = min(MaxAllowableOverExposure,
 608                            FLICKER_ALLOWABLE_OVER_EXPOSURE);
 609
 610         return OverExposure;
 611 }
 612 #undef FLICKER_MAX_EXPOSURE
 613 #undef FLICKER_ALLOWABLE_OVER_EXPOSURE
 614 #undef FLICKER_BRIGHTNESS_CONSTANT
 615
 616 /* initialise cam_data structure  */
 617 static void reset_camera_params(struct gspca_dev *gspca_dev)
 618 {
 619         struct sd *sd = (struct sd *) gspca_dev;
 620         struct cam_params *params = &sd->params;
 621
 622         /* The following parameter values are the defaults from
 623          * "Software Developer's Guide for CPiA Cameras".  Any changes
 624          * to the defaults are noted in comments. */
 625         params->colourParams.brightness = BRIGHTNESS_DEF;
 626         params->colourParams.contrast = CONTRAST_DEF;
 627         params->colourParams.saturation = SATURATION_DEF;
 628         params->exposure.gainMode = 4;
 629         params->exposure.expMode = 2;           /* AEC */
 630         params->exposure.compMode = 1;
 631         params->exposure.centreWeight = 1;
 632         params->exposure.gain = 0;
 633         params->exposure.fineExp = 0;
 634         params->exposure.coarseExpLo = 185;
 635         params->exposure.coarseExpHi = 0;
 636         params->exposure.redComp = COMP_RED;
 637         params->exposure.green1Comp = COMP_GREEN1;
 638         params->exposure.green2Comp = COMP_GREEN2;
 639         params->exposure.blueComp = COMP_BLUE;
 640         params->colourBalance.balanceMode = 2;  /* ACB */
 641         params->colourBalance.redGain = 32;
 642         params->colourBalance.greenGain = 6;
 643         params->colourBalance.blueGain = 92;
 644         params->apcor.gain1 = 0x18;
 645         params->apcor.gain2 = 0x16;
 646         params->apcor.gain4 = 0x24;
 647         params->apcor.gain8 = 0x34;
 648         params->vlOffset.gain1 = 20;
 649         params->vlOffset.gain2 = 24;
 650         params->vlOffset.gain4 = 26;
 651         params->vlOffset.gain8 = 26;
 652         params->compressionParams.hysteresis = 3;
 653         params->compressionParams.threshMax = 11;
 654         params->compressionParams.smallStep = 1;
 655         params->compressionParams.largeStep = 3;
 656         params->compressionParams.decimationHysteresis = 2;
 657         params->compressionParams.frDiffStepThresh = 5;
 658         params->compressionParams.qDiffStepThresh = 3;
 659         params->compressionParams.decimationThreshMod = 2;
 660         /* End of default values from Software Developer's Guide */
 661
 662         /* Set Sensor FPS to 15fps. This seems better than 30fps
 663          * for indoor lighting. */
 664         params->sensorFps.divisor = 1;
 665         params->sensorFps.baserate = 1;
 666
 667         params->flickerControl.flickerMode = 0;
 668         params->flickerControl.disabled = 1;
 669         params->flickerControl.coarseJump =
 670                 flicker_jumps[sd->mainsFreq]
 671                              [params->sensorFps.baserate]
 672                              [params->sensorFps.divisor];
 673         params->flickerControl.allowableOverExposure =
 674                 find_over_exposure(params->colourParams.brightness);
 675
 676         params->yuvThreshold.yThreshold = 6; /* From windows driver */
 677         params->yuvThreshold.uvThreshold = 6; /* From windows driver */
 678
 679         params->format.subSample = SUBSAMPLE_420;
 680         params->format.yuvOrder = YUVORDER_YUYV;
 681
 682         params->compression.mode = CPIA_COMPRESSION_AUTO;
 683         params->compression.decimation = NO_DECIMATION;
 684
 685         params->compressionTarget.frTargeting = COMP_TARGET_DEF;
 686         params->compressionTarget.targetFR = 15; /* From windows driver */
 687         params->compressionTarget.targetQ = 5; /* From windows driver */
 688
 689         params->qx3.qx3_detected = 0;
 690         params->qx3.toplight = 0;
 691         params->qx3.bottomlight = 0;
 692         params->qx3.button = 0;
 693         params->qx3.cradled = 0;
 694 }
 695
 696 static void printstatus(struct gspca_dev *gspca_dev, struct cam_params *params)
 697 {
 698         gspca_dbg(gspca_dev, D_PROBE, "status: %02x %02x %02x %02x %02x %02x %02x %02x\n",
 699                   params->status.systemState, params->status.grabState,
 700                   params->status.streamState, params->status.fatalError,
 701                   params->status.cmdError, params->status.debugFlags,
 702                   params->status.vpStatus, params->status.errorCode);
 703 }
 704
 705 static int goto_low_power(struct gspca_dev *gspca_dev)
 706 {
 707         struct sd *sd = (struct sd *) gspca_dev;
 708         int ret;
 709
 710         ret = do_command(gspca_dev, CPIA_COMMAND_GotoLoPower, 0, 0, 0, 0);
 711         if (ret)
 712                 return ret;
 713
 714         ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
 715         if (ret)
 716                 return ret;
 717
 718         if (sd->params.status.systemState != LO_POWER_STATE) {
 719                 if (sd->params.status.systemState != WARM_BOOT_STATE) {
 720                         gspca_err(gspca_dev, "unexpected state after lo power cmd: %02x\n",
 721                                   sd->params.status.systemState);
 722                         printstatus(gspca_dev, &sd->params);
 723                 }
 724                 return -EIO;
 725         }
 726
 727         gspca_dbg(gspca_dev, D_CONF, "camera now in LOW power state\n");
 728         return 0;
 729 }
 730
 731 static int goto_high_power(struct gspca_dev *gspca_dev)
 732 {
 733         struct sd *sd = (struct sd *) gspca_dev;
 734         int ret;
 735
 736         ret = do_command(gspca_dev, CPIA_COMMAND_GotoHiPower, 0, 0, 0, 0);
 737         if (ret)
 738                 return ret;
 739
 740         msleep_interruptible(40);       /* windows driver does it too */
 741
 742         if (signal_pending(current))
 743                 return -EINTR;
 744
 745         ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
 746         if (ret)
 747                 return ret;
 748
 749         if (sd->params.status.systemState != HI_POWER_STATE) {
 750                 gspca_err(gspca_dev, "unexpected state after hi power cmd: %02x\n",
 751                           sd->params.status.systemState);
 752                 printstatus(gspca_dev, &sd->params);
 753                 return -EIO;
 754         }
 755
 756         gspca_dbg(gspca_dev, D_CONF, "camera now in HIGH power state\n");
 757         return 0;
 758 }
 759
 760 static int get_version_information(struct gspca_dev *gspca_dev)
 761 {
 762         int ret;
 763
 764         /* GetCPIAVersion */
 765         ret = do_command(gspca_dev, CPIA_COMMAND_GetCPIAVersion, 0, 0, 0, 0);
 766         if (ret)
 767                 return ret;
 768
 769         /* GetPnPID */
 770         return do_command(gspca_dev, CPIA_COMMAND_GetPnPID, 0, 0, 0, 0);
 771 }
 772
 773 static int save_camera_state(struct gspca_dev *gspca_dev)
 774 {
 775         int ret;
 776
 777         ret = do_command(gspca_dev, CPIA_COMMAND_GetColourBalance, 0, 0, 0, 0);
 778         if (ret)
 779                 return ret;
 780
 781         return do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
 782 }
 783
 784 static int command_setformat(struct gspca_dev *gspca_dev)
 785 {
 786         struct sd *sd = (struct sd *) gspca_dev;
 787         int ret;
 788
 789         ret = do_command(gspca_dev, CPIA_COMMAND_SetFormat,
 790                          sd->params.format.videoSize,
 791                          sd->params.format.subSample,
 792                          sd->params.format.yuvOrder, 0);
 793         if (ret)
 794                 return ret;
 795
 796         return do_command(gspca_dev, CPIA_COMMAND_SetROI,
 797                           sd->params.roi.colStart, sd->params.roi.colEnd,
 798                           sd->params.roi.rowStart, sd->params.roi.rowEnd);
 799 }
 800
 801 static int command_setcolourparams(struct gspca_dev *gspca_dev)
 802 {
 803         struct sd *sd = (struct sd *) gspca_dev;
 804         return do_command(gspca_dev, CPIA_COMMAND_SetColourParams,
 805                           sd->params.colourParams.brightness,
 806                           sd->params.colourParams.contrast,
 807                           sd->params.colourParams.saturation, 0);
 808 }
 809
 810 static int command_setapcor(struct gspca_dev *gspca_dev)
 811 {
 812         struct sd *sd = (struct sd *) gspca_dev;
 813         return do_command(gspca_dev, CPIA_COMMAND_SetApcor,
 814                           sd->params.apcor.gain1,
 815                           sd->params.apcor.gain2,
 816                           sd->params.apcor.gain4,
 817                           sd->params.apcor.gain8);
 818 }
 819
 820 static int command_setvloffset(struct gspca_dev *gspca_dev)
 821 {
 822         struct sd *sd = (struct sd *) gspca_dev;
 823         return do_command(gspca_dev, CPIA_COMMAND_SetVLOffset,
 824                           sd->params.vlOffset.gain1,
 825                           sd->params.vlOffset.gain2,
 826                           sd->params.vlOffset.gain4,
 827                           sd->params.vlOffset.gain8);
 828 }
 829
 830 static int command_setexposure(struct gspca_dev *gspca_dev)
 831 {
 832         struct sd *sd = (struct sd *) gspca_dev;
 833         int ret;
 834
 835         ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
 836                                   sd->params.exposure.gainMode,
 837                                   1,
 838                                   sd->params.exposure.compMode,
 839                                   sd->params.exposure.centreWeight,
 840                                   sd->params.exposure.gain,
 841                                   sd->params.exposure.fineExp,
 842                                   sd->params.exposure.coarseExpLo,
 843                                   sd->params.exposure.coarseExpHi,
 844                                   sd->params.exposure.redComp,
 845                                   sd->params.exposure.green1Comp,
 846                                   sd->params.exposure.green2Comp,
 847                                   sd->params.exposure.blueComp);
 848         if (ret)
 849                 return ret;
 850
 851         if (sd->params.exposure.expMode != 1) {
 852                 ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
 853                                           0,
 854                                           sd->params.exposure.expMode,
 855                                           0, 0,
 856                                           sd->params.exposure.gain,
 857                                           sd->params.exposure.fineExp,
 858                                           sd->params.exposure.coarseExpLo,
 859                                           sd->params.exposure.coarseExpHi,
 860                                           0, 0, 0, 0);
 861         }
 862
 863         return ret;
 864 }
 865
 866 static int command_setcolourbalance(struct gspca_dev *gspca_dev)
 867 {
 868         struct sd *sd = (struct sd *) gspca_dev;
 869
 870         if (sd->params.colourBalance.balanceMode == 1) {
 871                 int ret;
 872
 873                 ret = do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
 874                                  1,
 875                                  sd->params.colourBalance.redGain,
 876                                  sd->params.colourBalance.greenGain,
 877                                  sd->params.colourBalance.blueGain);
 878                 if (ret)
 879                         return ret;
 880
 881                 return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
 882                                   3, 0, 0, 0);
 883         }
 884         if (sd->params.colourBalance.balanceMode == 2) {
 885                 return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
 886                                   2, 0, 0, 0);
 887         }
 888         if (sd->params.colourBalance.balanceMode == 3) {
 889                 return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
 890                                   3, 0, 0, 0);
 891         }
 892
 893         return -EINVAL;
 894 }
 895
 896 static int command_setcompressiontarget(struct gspca_dev *gspca_dev)
 897 {
 898         struct sd *sd = (struct sd *) gspca_dev;
 899
 900         return do_command(gspca_dev, CPIA_COMMAND_SetCompressionTarget,
 901                           sd->params.compressionTarget.frTargeting,
 902                           sd->params.compressionTarget.targetFR,
 903                           sd->params.compressionTarget.targetQ, 0);
 904 }
 905
 906 static int command_setyuvtresh(struct gspca_dev *gspca_dev)
 907 {
 908         struct sd *sd = (struct sd *) gspca_dev;
 909
 910         return do_command(gspca_dev, CPIA_COMMAND_SetYUVThresh,
 911                           sd->params.yuvThreshold.yThreshold,
 912                           sd->params.yuvThreshold.uvThreshold, 0, 0);
 913 }
 914
 915 static int command_setcompressionparams(struct gspca_dev *gspca_dev)
 916 {
 917         struct sd *sd = (struct sd *) gspca_dev;
 918
 919         return do_command_extended(gspca_dev,
 920                             CPIA_COMMAND_SetCompressionParams,
 921                             0, 0, 0, 0,
 922                             sd->params.compressionParams.hysteresis,
 923                             sd->params.compressionParams.threshMax,
 924                             sd->params.compressionParams.smallStep,
 925                             sd->params.compressionParams.largeStep,
 926                             sd->params.compressionParams.decimationHysteresis,
 927                             sd->params.compressionParams.frDiffStepThresh,
 928                             sd->params.compressionParams.qDiffStepThresh,
 929                             sd->params.compressionParams.decimationThreshMod);
 930 }
 931
 932 static int command_setcompression(struct gspca_dev *gspca_dev)
 933 {
 934         struct sd *sd = (struct sd *) gspca_dev;
 935
 936         return do_command(gspca_dev, CPIA_COMMAND_SetCompression,
 937                           sd->params.compression.mode,
 938                           sd->params.compression.decimation, 0, 0);
 939 }
 940
 941 static int command_setsensorfps(struct gspca_dev *gspca_dev)
 942 {
 943         struct sd *sd = (struct sd *) gspca_dev;
 944
 945         return do_command(gspca_dev, CPIA_COMMAND_SetSensorFPS,
 946                           sd->params.sensorFps.divisor,
 947                           sd->params.sensorFps.baserate, 0, 0);
 948 }
 949
 950 static int command_setflickerctrl(struct gspca_dev *gspca_dev)
 951 {
 952         struct sd *sd = (struct sd *) gspca_dev;
 953
 954         return do_command(gspca_dev, CPIA_COMMAND_SetFlickerCtrl,
 955                           sd->params.flickerControl.flickerMode,
 956                           sd->params.flickerControl.coarseJump,
 957                           sd->params.flickerControl.allowableOverExposure,
 958                           0);
 959 }
 960
 961 static int command_setecptiming(struct gspca_dev *gspca_dev)
 962 {
 963         struct sd *sd = (struct sd *) gspca_dev;
 964
 965         return do_command(gspca_dev, CPIA_COMMAND_SetECPTiming,
 966                           sd->params.ecpTiming, 0, 0, 0);
 967 }
 968
 969 static int command_pause(struct gspca_dev *gspca_dev)
 970 {
 971         return do_command(gspca_dev, CPIA_COMMAND_EndStreamCap, 0, 0, 0, 0);
 972 }
 973
 974 static int command_resume(struct gspca_dev *gspca_dev)
 975 {
 976         struct sd *sd = (struct sd *) gspca_dev;
 977
 978         return do_command(gspca_dev, CPIA_COMMAND_InitStreamCap,
 979                           0, sd->params.streamStartLine, 0, 0);
 980 }
 981
 982 static int command_setlights(struct gspca_dev *gspca_dev)
 983 {
 984         struct sd *sd = (struct sd *) gspca_dev;
 985         int ret, p1, p2;
 986
 987         p1 = (sd->params.qx3.bottomlight == 0) << 1;
 988         p2 = (sd->params.qx3.toplight == 0) << 3;
 989
 990         ret = do_command(gspca_dev, CPIA_COMMAND_WriteVCReg,
 991                          0x90, 0x8f, 0x50, 0);
 992         if (ret)
 993                 return ret;
 994
 995         return do_command(gspca_dev, CPIA_COMMAND_WriteMCPort, 2, 0,
 996                           p1 | p2 | 0xe0, 0);
 997 }
 998
 999 static int set_flicker(struct gspca_dev *gspca_dev, int on, int apply)
1000 {
1001         /* Everything in here is from the Windows driver */
1002 /* define for compgain calculation */
1003 #if 0
1004 #define COMPGAIN(base, curexp, newexp) \
1005     (u8) ((((float) base - 128.0) * ((float) curexp / (float) newexp)) + 128.5)
1006 #define EXP_FROM_COMP(basecomp, curcomp, curexp) \
1007     (u16)((float)curexp * (float)(u8)(curcomp + 128) / \
1008     (float)(u8)(basecomp - 128))
1009 #else
1010   /* equivalent functions without floating point math */
1011 #define COMPGAIN(base, curexp, newexp) \
1012     (u8)(128 + (((u32)(2*(base-128)*curexp + newexp)) / (2 * newexp)))
1013 #define EXP_FROM_COMP(basecomp, curcomp, curexp) \
1014     (u16)(((u32)(curexp * (u8)(curcomp + 128)) / (u8)(basecomp - 128)))
1015 #endif
1016
1017         struct sd *sd = (struct sd *) gspca_dev;
1018         int currentexp = sd->params.exposure.coarseExpLo +
1019                          sd->params.exposure.coarseExpHi * 256;
1020         int ret, startexp;
1021
1022         if (on) {
1023                 int cj = sd->params.flickerControl.coarseJump;
1024                 sd->params.flickerControl.flickerMode = 1;
1025                 sd->params.flickerControl.disabled = 0;
1026                 if (sd->params.exposure.expMode != 2) {
1027                         sd->params.exposure.expMode = 2;
1028                         sd->exposure_status = EXPOSURE_NORMAL;
1029                 }
1030                 if (sd->params.exposure.gain >= BITS_PER_TYPE(currentexp))
1031                         return -EINVAL;
1032                 currentexp = currentexp << sd->params.exposure.gain;
1033                 sd->params.exposure.gain = 0;
1034                 /* round down current exposure to nearest value */
1035                 startexp = (currentexp + ROUND_UP_EXP_FOR_FLICKER) / cj;
1036                 if (startexp < 1)
1037                         startexp = 1;
1038                 startexp = (startexp * cj) - 1;
1039                 if (FIRMWARE_VERSION(1, 2))
1040                         while (startexp > MAX_EXP_102)
1041                                 startexp -= cj;
1042                 else
1043                         while (startexp > MAX_EXP)
1044                                 startexp -= cj;
1045                 sd->params.exposure.coarseExpLo = startexp & 0xff;
1046                 sd->params.exposure.coarseExpHi = startexp >> 8;
1047                 if (currentexp > startexp) {
1048                         if (currentexp > (2 * startexp))
1049                                 currentexp = 2 * startexp;
1050                         sd->params.exposure.redComp =
1051                                 COMPGAIN(COMP_RED, currentexp, startexp);
1052                         sd->params.exposure.green1Comp =
1053                                 COMPGAIN(COMP_GREEN1, currentexp, startexp);
1054                         sd->params.exposure.green2Comp =
1055                                 COMPGAIN(COMP_GREEN2, currentexp, startexp);
1056                         sd->params.exposure.blueComp =
1057                                 COMPGAIN(COMP_BLUE, currentexp, startexp);
1058                 } else {
1059                         sd->params.exposure.redComp = COMP_RED;
1060                         sd->params.exposure.green1Comp = COMP_GREEN1;
1061                         sd->params.exposure.green2Comp = COMP_GREEN2;
1062                         sd->params.exposure.blueComp = COMP_BLUE;
1063                 }
1064                 if (FIRMWARE_VERSION(1, 2))
1065                         sd->params.exposure.compMode = 0;
1066                 else
1067                         sd->params.exposure.compMode = 1;
1068
1069                 sd->params.apcor.gain1 = 0x18;
1070                 sd->params.apcor.gain2 = 0x18;
1071                 sd->params.apcor.gain4 = 0x16;
1072                 sd->params.apcor.gain8 = 0x14;
1073         } else {
1074                 sd->params.flickerControl.flickerMode = 0;
1075                 sd->params.flickerControl.disabled = 1;
1076                 /* Average equivalent coarse for each comp channel */
1077                 startexp = EXP_FROM_COMP(COMP_RED,
1078                                 sd->params.exposure.redComp, currentexp);
1079                 startexp += EXP_FROM_COMP(COMP_GREEN1,
1080                                 sd->params.exposure.green1Comp, currentexp);
1081                 startexp += EXP_FROM_COMP(COMP_GREEN2,
1082                                 sd->params.exposure.green2Comp, currentexp);
1083                 startexp += EXP_FROM_COMP(COMP_BLUE,
1084                                 sd->params.exposure.blueComp, currentexp);
1085                 startexp = startexp >> 2;
1086                 while (startexp > MAX_EXP && sd->params.exposure.gain <
1087                        sd->params.exposure.gainMode - 1) {
1088                         startexp = startexp >> 1;
1089                         ++sd->params.exposure.gain;
1090                 }
1091                 if (FIRMWARE_VERSION(1, 2) && startexp > MAX_EXP_102)
1092                         startexp = MAX_EXP_102;
1093                 if (startexp > MAX_EXP)
1094                         startexp = MAX_EXP;
1095                 sd->params.exposure.coarseExpLo = startexp & 0xff;
1096                 sd->params.exposure.coarseExpHi = startexp >> 8;
1097                 sd->params.exposure.redComp = COMP_RED;
1098                 sd->params.exposure.green1Comp = COMP_GREEN1;
1099                 sd->params.exposure.green2Comp = COMP_GREEN2;
1100                 sd->params.exposure.blueComp = COMP_BLUE;
1101                 sd->params.exposure.compMode = 1;
1102                 sd->params.apcor.gain1 = 0x18;
1103                 sd->params.apcor.gain2 = 0x16;
1104                 sd->params.apcor.gain4 = 0x24;
1105                 sd->params.apcor.gain8 = 0x34;
1106         }
1107         sd->params.vlOffset.gain1 = 20;
1108         sd->params.vlOffset.gain2 = 24;
1109         sd->params.vlOffset.gain4 = 26;
1110         sd->params.vlOffset.gain8 = 26;
1111
1112         if (apply) {
1113                 ret = command_setexposure(gspca_dev);
1114                 if (ret)
1115                         return ret;
1116
1117                 ret = command_setapcor(gspca_dev);
1118                 if (ret)
1119                         return ret;
1120
1121                 ret = command_setvloffset(gspca_dev);
1122                 if (ret)
1123                         return ret;
1124
1125                 ret = command_setflickerctrl(gspca_dev);
1126                 if (ret)
1127                         return ret;
1128         }
1129
1130         return 0;
1131 #undef EXP_FROM_COMP
1132 #undef COMPGAIN
1133 }
1134
1135 /* monitor the exposure and adjust the sensor frame rate if needed */
1136 static void monitor_exposure(struct gspca_dev *gspca_dev)
1137 {
1138         struct sd *sd = (struct sd *) gspca_dev;
1139         u8 exp_acc, bcomp, cmd[8];
1140         int ret, light_exp, dark_exp, very_dark_exp;
1141         int old_exposure, new_exposure, framerate;
1142         int setfps = 0, setexp = 0, setflicker = 0;
1143
1144         /* get necessary stats and register settings from camera */
1145         /* do_command can't handle this, so do it ourselves */
1146         cmd[0] = CPIA_COMMAND_ReadVPRegs >> 8;
1147         cmd[1] = CPIA_COMMAND_ReadVPRegs & 0xff;
1148         cmd[2] = 30;
1149         cmd[3] = 4;
1150         cmd[4] = 9;
1151         cmd[5] = 8;
1152         cmd[6] = 8;
1153         cmd[7] = 0;
1154         ret = cpia_usb_transferCmd(gspca_dev, cmd);
1155         if (ret) {
1156                 pr_err("ReadVPRegs(30,4,9,8) - failed: %d\n", ret);
1157                 return;
1158         }
1159         exp_acc = gspca_dev->usb_buf[0];
1160         bcomp = gspca_dev->usb_buf[1];
1161
1162         light_exp = sd->params.colourParams.brightness +
1163                     TC - 50 + EXP_ACC_LIGHT;
1164         if (light_exp > 255)
1165                 light_exp = 255;
1166         dark_exp = sd->params.colourParams.brightness +
1167                    TC - 50 - EXP_ACC_DARK;
1168         if (dark_exp < 0)
1169                 dark_exp = 0;
1170         very_dark_exp = dark_exp / 2;
1171
1172         old_exposure = sd->params.exposure.coarseExpHi * 256 +
1173                        sd->params.exposure.coarseExpLo;
1174
1175         if (!sd->params.flickerControl.disabled) {
1176                 /* Flicker control on */
1177                 int max_comp = FIRMWARE_VERSION(1, 2) ? MAX_COMP :
1178                                                         HIGH_COMP_102;
1179                 bcomp += 128;   /* decode */
1180                 if (bcomp >= max_comp && exp_acc < dark_exp) {
1181                         /* dark */
1182                         if (exp_acc < very_dark_exp) {
1183                                 /* very dark */
1184                                 if (sd->exposure_status == EXPOSURE_VERY_DARK)
1185                                         ++sd->exposure_count;
1186                                 else {
1187                                         sd->exposure_status =
1188                                                 EXPOSURE_VERY_DARK;
1189                                         sd->exposure_count = 1;
1190                                 }
1191                         } else {
1192                                 /* just dark */
1193                                 if (sd->exposure_status == EXPOSURE_DARK)
1194                                         ++sd->exposure_count;
1195                                 else {
1196                                         sd->exposure_status = EXPOSURE_DARK;
1197                                         sd->exposure_count = 1;
1198                                 }
1199                         }
1200                 } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
1201                         /* light */
1202                         if (old_exposure <= VERY_LOW_EXP) {
1203                                 /* very light */
1204                                 if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
1205                                         ++sd->exposure_count;
1206                                 else {
1207                                         sd->exposure_status =
1208                                                 EXPOSURE_VERY_LIGHT;
1209                                         sd->exposure_count = 1;
1210                                 }
1211                         } else {
1212                                 /* just light */
1213                                 if (sd->exposure_status == EXPOSURE_LIGHT)
1214                                         ++sd->exposure_count;
1215                                 else {
1216                                         sd->exposure_status = EXPOSURE_LIGHT;
1217                                         sd->exposure_count = 1;
1218                                 }
1219                         }
1220                 } else {
1221                         /* not dark or light */
1222                         sd->exposure_status = EXPOSURE_NORMAL;
1223                 }
1224         } else {
1225                 /* Flicker control off */
1226                 if (old_exposure >= MAX_EXP && exp_acc < dark_exp) {
1227                         /* dark */
1228                         if (exp_acc < very_dark_exp) {
1229                                 /* very dark */
1230                                 if (sd->exposure_status == EXPOSURE_VERY_DARK)
1231                                         ++sd->exposure_count;
1232                                 else {
1233                                         sd->exposure_status =
1234                                                 EXPOSURE_VERY_DARK;
1235                                         sd->exposure_count = 1;
1236                                 }
1237                         } else {
1238                                 /* just dark */
1239                                 if (sd->exposure_status == EXPOSURE_DARK)
1240                                         ++sd->exposure_count;
1241                                 else {
1242                                         sd->exposure_status = EXPOSURE_DARK;
1243                                         sd->exposure_count = 1;
1244                                 }
1245                         }
1246                 } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
1247                         /* light */
1248                         if (old_exposure <= VERY_LOW_EXP) {
1249                                 /* very light */
1250                                 if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
1251                                         ++sd->exposure_count;
1252                                 else {
1253                                         sd->exposure_status =
1254                                                 EXPOSURE_VERY_LIGHT;
1255                                         sd->exposure_count = 1;
1256                                 }
1257                         } else {
1258                                 /* just light */
1259                                 if (sd->exposure_status == EXPOSURE_LIGHT)
1260                                         ++sd->exposure_count;
1261                                 else {
1262                                         sd->exposure_status = EXPOSURE_LIGHT;
1263                                         sd->exposure_count = 1;
1264                                 }
1265                         }
1266                 } else {
1267                         /* not dark or light */
1268                         sd->exposure_status = EXPOSURE_NORMAL;
1269                 }
1270         }
1271
1272         framerate = atomic_read(&sd->fps);
1273         if (framerate > 30 || framerate < 1)
1274                 framerate = 1;
1275
1276         if (!sd->params.flickerControl.disabled) {
1277                 /* Flicker control on */
1278                 if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
1279                      sd->exposure_status == EXPOSURE_DARK) &&
1280                     sd->exposure_count >= DARK_TIME * framerate &&
1281                     sd->params.sensorFps.divisor < 2) {
1282
1283                         /* dark for too long */
1284                         ++sd->params.sensorFps.divisor;
1285                         setfps = 1;
1286
1287                         sd->params.flickerControl.coarseJump =
1288                                 flicker_jumps[sd->mainsFreq]
1289                                              [sd->params.sensorFps.baserate]
1290                                              [sd->params.sensorFps.divisor];
1291                         setflicker = 1;
1292
1293                         new_exposure = sd->params.flickerControl.coarseJump-1;
1294                         while (new_exposure < old_exposure / 2)
1295                                 new_exposure +=
1296                                         sd->params.flickerControl.coarseJump;
1297                         sd->params.exposure.coarseExpLo = new_exposure & 0xff;
1298                         sd->params.exposure.coarseExpHi = new_exposure >> 8;
1299                         setexp = 1;
1300                         sd->exposure_status = EXPOSURE_NORMAL;
1301                         gspca_dbg(gspca_dev, D_CONF, "Automatically decreasing sensor_fps\n");
1302
1303                 } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
1304                             sd->exposure_status == EXPOSURE_LIGHT) &&
1305                            sd->exposure_count >= LIGHT_TIME * framerate &&
1306                            sd->params.sensorFps.divisor > 0) {
1307
1308                         /* light for too long */
1309                         int max_exp = FIRMWARE_VERSION(1, 2) ? MAX_EXP_102 :
1310                                                                MAX_EXP;
1311                         --sd->params.sensorFps.divisor;
1312                         setfps = 1;
1313
1314                         sd->params.flickerControl.coarseJump =
1315                                 flicker_jumps[sd->mainsFreq]
1316                                              [sd->params.sensorFps.baserate]
1317                                              [sd->params.sensorFps.divisor];
1318                         setflicker = 1;
1319
1320                         new_exposure = sd->params.flickerControl.coarseJump-1;
1321                         while (new_exposure < 2 * old_exposure &&
1322                                new_exposure +
1323                                sd->params.flickerControl.coarseJump < max_exp)
1324                                 new_exposure +=
1325                                         sd->params.flickerControl.coarseJump;
1326                         sd->params.exposure.coarseExpLo = new_exposure & 0xff;
1327                         sd->params.exposure.coarseExpHi = new_exposure >> 8;
1328                         setexp = 1;
1329                         sd->exposure_status = EXPOSURE_NORMAL;
1330                         gspca_dbg(gspca_dev, D_CONF, "Automatically increasing sensor_fps\n");
1331                 }
1332         } else {
1333                 /* Flicker control off */
1334                 if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
1335                      sd->exposure_status == EXPOSURE_DARK) &&
1336                     sd->exposure_count >= DARK_TIME * framerate &&
1337                     sd->params.sensorFps.divisor < 2) {
1338
1339                         /* dark for too long */
1340                         ++sd->params.sensorFps.divisor;
1341                         setfps = 1;
1342
1343                         if (sd->params.exposure.gain > 0) {
1344                                 --sd->params.exposure.gain;
1345                                 setexp = 1;
1346                         }
1347                         sd->exposure_status = EXPOSURE_NORMAL;
1348                         gspca_dbg(gspca_dev, D_CONF, "Automatically decreasing sensor_fps\n");
1349
1350                 } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
1351                             sd->exposure_status == EXPOSURE_LIGHT) &&
1352                            sd->exposure_count >= LIGHT_TIME * framerate &&
1353                            sd->params.sensorFps.divisor > 0) {
1354
1355                         /* light for too long */
1356                         --sd->params.sensorFps.divisor;
1357                         setfps = 1;
1358
1359                         if (sd->params.exposure.gain <
1360                             sd->params.exposure.gainMode - 1) {
1361                                 ++sd->params.exposure.gain;
1362                                 setexp = 1;
1363                         }
1364                         sd->exposure_status = EXPOSURE_NORMAL;
1365                         gspca_dbg(gspca_dev, D_CONF, "Automatically increasing sensor_fps\n");
1366                 }
1367         }
1368
1369         if (setexp)
1370                 command_setexposure(gspca_dev);
1371
1372         if (setfps)
1373                 command_setsensorfps(gspca_dev);
1374
1375         if (setflicker)
1376                 command_setflickerctrl(gspca_dev);
1377 }
1378
1379 /*-----------------------------------------------------------------*/
1380 /* if flicker is switched off, this function switches it back on.It checks,
1381    however, that conditions are suitable before restarting it.
1382    This should only be called for firmware version 1.2.
1383
1384    It also adjust the colour balance when an exposure step is detected - as
1385    long as flicker is running
1386 */
1387 static void restart_flicker(struct gspca_dev *gspca_dev)
1388 {
1389         struct sd *sd = (struct sd *) gspca_dev;
1390         int cam_exposure, old_exp;
1391
1392         if (!FIRMWARE_VERSION(1, 2))
1393                 return;
1394
1395         cam_exposure = atomic_read(&sd->cam_exposure);
1396
1397         if (sd->params.flickerControl.flickerMode == 0 ||
1398             cam_exposure == 0)
1399                 return;
1400
1401         old_exp = sd->params.exposure.coarseExpLo +
1402                   sd->params.exposure.coarseExpHi*256;
1403         /*
1404           see how far away camera exposure is from a valid
1405           flicker exposure value
1406         */
1407         cam_exposure %= sd->params.flickerControl.coarseJump;
1408         if (!sd->params.flickerControl.disabled &&
1409             cam_exposure <= sd->params.flickerControl.coarseJump - 3) {
1410                 /* Flicker control auto-disabled */
1411                 sd->params.flickerControl.disabled = 1;
1412         }
1413
1414         if (sd->params.flickerControl.disabled &&
1415             old_exp > sd->params.flickerControl.coarseJump +
1416                       ROUND_UP_EXP_FOR_FLICKER) {
1417                 /* exposure is now high enough to switch
1418                    flicker control back on */
1419                 set_flicker(gspca_dev, 1, 1);
1420         }
1421 }
1422
1423 /* this function is called at probe time */
1424 static int sd_config(struct gspca_dev *gspca_dev,
1425                         const struct usb_device_id *id)
1426 {
1427         struct sd *sd = (struct sd *) gspca_dev;
1428         struct cam *cam;
1429
1430         sd->mainsFreq = FREQ_DEF == V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
1431         reset_camera_params(gspca_dev);
1432
1433         gspca_dbg(gspca_dev, D_PROBE, "cpia CPiA camera detected (vid/pid 0x%04X:0x%04X)\n",
1434                   id->idVendor, id->idProduct);
1435
1436         cam = &gspca_dev->cam;
1437         cam->cam_mode = mode;
1438         cam->nmodes = ARRAY_SIZE(mode);
1439
1440         goto_low_power(gspca_dev);
1441         /* Check the firmware version. */
1442         sd->params.version.firmwareVersion = 0;
1443         get_version_information(gspca_dev);
1444         if (sd->params.version.firmwareVersion != 1) {
1445                 gspca_err(gspca_dev, "only firmware version 1 is supported (got: %d)\n",
1446                           sd->params.version.firmwareVersion);
1447                 return -ENODEV;
1448         }
1449
1450         /* A bug in firmware 1-02 limits gainMode to 2 */
1451         if (sd->params.version.firmwareRevision <= 2 &&
1452             sd->params.exposure.gainMode > 2) {
1453                 sd->params.exposure.gainMode = 2;
1454         }
1455
1456         /* set QX3 detected flag */
1457         sd->params.qx3.qx3_detected = (sd->params.pnpID.vendor == 0x0813 &&
1458                                        sd->params.pnpID.product == 0x0001);
1459         return 0;
1460 }
1461
1462 /* -- start the camera -- */
1463 static int sd_start(struct gspca_dev *gspca_dev)
1464 {
1465         struct sd *sd = (struct sd *) gspca_dev;
1466         int priv, ret;
1467
1468         /* Start the camera in low power mode */
1469         if (goto_low_power(gspca_dev)) {
1470                 if (sd->params.status.systemState != WARM_BOOT_STATE) {
1471                         gspca_err(gspca_dev, "unexpected systemstate: %02x\n",
1472                                   sd->params.status.systemState);
1473                         printstatus(gspca_dev, &sd->params);
1474                         return -ENODEV;
1475                 }
1476
1477                 /* FIXME: this is just dirty trial and error */
1478                 ret = goto_high_power(gspca_dev);
1479                 if (ret)
1480                         return ret;
1481
1482                 ret = do_command(gspca_dev, CPIA_COMMAND_DiscardFrame,
1483                                  0, 0, 0, 0);
1484                 if (ret)
1485                         return ret;
1486
1487                 ret = goto_low_power(gspca_dev);
1488                 if (ret)
1489                         return ret;
1490         }
1491
1492         /* procedure described in developer's guide p3-28 */
1493
1494         /* Check the firmware version. */
1495         sd->params.version.firmwareVersion = 0;
1496         get_version_information(gspca_dev);
1497
1498         /* The fatal error checking should be done after
1499          * the camera powers up (developer's guide p 3-38) */
1500
1501         /* Set streamState before transition to high power to avoid bug
1502          * in firmware 1-02 */
1503         ret = do_command(gspca_dev, CPIA_COMMAND_ModifyCameraStatus,
1504                          STREAMSTATE, 0, STREAM_NOT_READY, 0);
1505         if (ret)
1506                 return ret;
1507
1508         /* GotoHiPower */
1509         ret = goto_high_power(gspca_dev);
1510         if (ret)
1511                 return ret;
1512
1513         /* Check the camera status */
1514         ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
1515         if (ret)
1516                 return ret;
1517
1518         if (sd->params.status.fatalError) {
1519                 gspca_err(gspca_dev, "fatal_error: %04x, vp_status: %04x\n",
1520                           sd->params.status.fatalError,
1521                           sd->params.status.vpStatus);
1522                 return -EIO;
1523         }
1524
1525         /* VPVersion can't be retrieved before the camera is in HiPower,
1526          * so get it here instead of in get_version_information. */
1527         ret = do_command(gspca_dev, CPIA_COMMAND_GetVPVersion, 0, 0, 0, 0);
1528         if (ret)
1529                 return ret;
1530
1531         /* Determine video mode settings */
1532         sd->params.streamStartLine = 120;
1533
1534         priv = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1535         if (priv & 0x01) { /* crop */
1536                 sd->params.roi.colStart = 2;
1537                 sd->params.roi.rowStart = 6;
1538         } else {
1539                 sd->params.roi.colStart = 0;
1540                 sd->params.roi.rowStart = 0;
1541         }
1542
1543         if (priv & 0x02) { /* quarter */
1544                 sd->params.format.videoSize = VIDEOSIZE_QCIF;
1545                 sd->params.roi.colStart /= 2;
1546                 sd->params.roi.rowStart /= 2;
1547                 sd->params.streamStartLine /= 2;
1548         } else
1549                 sd->params.format.videoSize = VIDEOSIZE_CIF;
1550
1551         sd->params.roi.colEnd = sd->params.roi.colStart +
1552                                 (gspca_dev->pixfmt.width >> 3);
1553         sd->params.roi.rowEnd = sd->params.roi.rowStart +
1554                                 (gspca_dev->pixfmt.height >> 2);
1555
1556         /* And now set the camera to a known state */
1557         ret = do_command(gspca_dev, CPIA_COMMAND_SetGrabMode,
1558                          CPIA_GRAB_CONTINEOUS, 0, 0, 0);
1559         if (ret)
1560                 return ret;
1561         /* We start with compression disabled, as we need one uncompressed
1562            frame to handle later compressed frames */
1563         ret = do_command(gspca_dev, CPIA_COMMAND_SetCompression,
1564                          CPIA_COMPRESSION_NONE,
1565                          NO_DECIMATION, 0, 0);
1566         if (ret)
1567                 return ret;
1568         ret = command_setcompressiontarget(gspca_dev);
1569         if (ret)
1570                 return ret;
1571         ret = command_setcolourparams(gspca_dev);
1572         if (ret)
1573                 return ret;
1574         ret = command_setformat(gspca_dev);
1575         if (ret)
1576                 return ret;
1577         ret = command_setyuvtresh(gspca_dev);
1578         if (ret)
1579                 return ret;
1580         ret = command_setecptiming(gspca_dev);
1581         if (ret)
1582                 return ret;
1583         ret = command_setcompressionparams(gspca_dev);
1584         if (ret)
1585                 return ret;
1586         ret = command_setexposure(gspca_dev);
1587         if (ret)
1588                 return ret;
1589         ret = command_setcolourbalance(gspca_dev);
1590         if (ret)
1591                 return ret;
1592         ret = command_setsensorfps(gspca_dev);
1593         if (ret)
1594                 return ret;
1595         ret = command_setapcor(gspca_dev);
1596         if (ret)
1597                 return ret;
1598         ret = command_setflickerctrl(gspca_dev);
1599         if (ret)
1600                 return ret;
1601         ret = command_setvloffset(gspca_dev);
1602         if (ret)
1603                 return ret;
1604
1605         /* Start stream */
1606         ret = command_resume(gspca_dev);
1607         if (ret)
1608                 return ret;
1609
1610         /* Wait 6 frames before turning compression on for the sensor to get
1611            all settings and AEC/ACB to settle */
1612         sd->first_frame = 6;
1613         sd->exposure_status = EXPOSURE_NORMAL;
1614         sd->exposure_count = 0;
1615         atomic_set(&sd->cam_exposure, 0);
1616         atomic_set(&sd->fps, 0);
1617
1618         return 0;
1619 }
1620
1621 static void sd_stopN(struct gspca_dev *gspca_dev)
1622 {
1623         struct sd *sd __maybe_unused = (struct sd *) gspca_dev;
1624
1625         command_pause(gspca_dev);
1626
1627         /* save camera state for later open (developers guide ch 3.5.3) */
1628         save_camera_state(gspca_dev);
1629
1630         /* GotoLoPower */
1631         goto_low_power(gspca_dev);
1632
1633         /* Update the camera status */
1634         do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
1635
1636 #if IS_ENABLED(CONFIG_INPUT)
1637         /* If the last button state is pressed, release it now! */
1638         if (sd->params.qx3.button) {
1639                 /* The camera latch will hold the pressed state until we reset
1640                    the latch, so we do not reset sd->params.qx3.button now, to
1641                    avoid a false keypress being reported the next sd_start */
1642                 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1643                 input_sync(gspca_dev->input_dev);
1644         }
1645 #endif
1646 }
1647
1648 /* this function is called at probe and resume time */
1649 static int sd_init(struct gspca_dev *gspca_dev)
1650 {
1651         struct sd *sd = (struct sd *) gspca_dev;
1652         int ret;
1653
1654         /* Start / Stop the camera to make sure we are talking to
1655            a supported camera, and to get some information from it
1656            to print. */
1657         ret = sd_start(gspca_dev);
1658         if (ret)
1659                 return ret;
1660
1661         /* Ensure the QX3 illuminators' states are restored upon resume,
1662            or disable the illuminator controls, if this isn't a QX3 */
1663         if (sd->params.qx3.qx3_detected)
1664                 command_setlights(gspca_dev);
1665
1666         sd_stopN(gspca_dev);
1667
1668         gspca_dbg(gspca_dev, D_PROBE, "CPIA Version:             %d.%02d (%d.%d)\n",
1669                   sd->params.version.firmwareVersion,
1670                   sd->params.version.firmwareRevision,
1671                   sd->params.version.vcVersion,
1672                   sd->params.version.vcRevision);
1673         gspca_dbg(gspca_dev, D_PROBE, "CPIA PnP-ID:              %04x:%04x:%04x",
1674                   sd->params.pnpID.vendor, sd->params.pnpID.product,
1675                   sd->params.pnpID.deviceRevision);
1676         gspca_dbg(gspca_dev, D_PROBE, "VP-Version:               %d.%d %04x",
1677                   sd->params.vpVersion.vpVersion,
1678                   sd->params.vpVersion.vpRevision,
1679                   sd->params.vpVersion.cameraHeadID);
1680
1681         return 0;
1682 }
1683
1684 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1685                         u8 *data,
1686                         int len)
1687 {
1688         struct sd *sd = (struct sd *) gspca_dev;
1689
1690         /* Check for SOF */
1691         if (len >= 64 &&
1692             data[0] == MAGIC_0 && data[1] == MAGIC_1 &&
1693             data[16] == sd->params.format.videoSize &&
1694             data[17] == sd->params.format.subSample &&
1695             data[18] == sd->params.format.yuvOrder &&
1696             data[24] == sd->params.roi.colStart &&
1697             data[25] == sd->params.roi.colEnd &&
1698             data[26] == sd->params.roi.rowStart &&
1699             data[27] == sd->params.roi.rowEnd) {
1700                 u8 *image;
1701
1702                 atomic_set(&sd->cam_exposure, data[39] * 2);
1703                 atomic_set(&sd->fps, data[41]);
1704
1705                 /* Check for proper EOF for last frame */
1706                 image = gspca_dev->image;
1707                 if (image != NULL &&
1708                     gspca_dev->image_len > 4 &&
1709                     image[gspca_dev->image_len - 4] == 0xff &&
1710                     image[gspca_dev->image_len - 3] == 0xff &&
1711                     image[gspca_dev->image_len - 2] == 0xff &&
1712                     image[gspca_dev->image_len - 1] == 0xff)
1713                         gspca_frame_add(gspca_dev, LAST_PACKET,
1714                                                 NULL, 0);
1715
1716                 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
1717                 return;
1718         }
1719
1720         gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1721 }
1722
1723 static void sd_dq_callback(struct gspca_dev *gspca_dev)
1724 {
1725         struct sd *sd = (struct sd *) gspca_dev;
1726
1727         /* Set the normal compression settings once we have captured a
1728            few uncompressed frames (and AEC has hopefully settled) */
1729         if (sd->first_frame) {
1730                 sd->first_frame--;
1731                 if (sd->first_frame == 0)
1732                         command_setcompression(gspca_dev);
1733         }
1734
1735         /* Switch flicker control back on if it got turned off */
1736         restart_flicker(gspca_dev);
1737
1738         /* If AEC is enabled, monitor the exposure and
1739            adjust the sensor frame rate if needed */
1740         if (sd->params.exposure.expMode == 2)
1741                 monitor_exposure(gspca_dev);
1742
1743         /* Update our knowledge of the camera state */
1744         do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
1745         do_command(gspca_dev, CPIA_COMMAND_ReadMCPorts, 0, 0, 0, 0);
1746 }
1747
1748 static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
1749 {
1750         struct gspca_dev *gspca_dev =
1751                 container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
1752         struct sd *sd = (struct sd *)gspca_dev;
1753
1754         gspca_dev->usb_err = 0;
1755
1756         if (!gspca_dev->streaming && ctrl->id != V4L2_CID_POWER_LINE_FREQUENCY)
1757                 return 0;
1758
1759         switch (ctrl->id) {
1760         case V4L2_CID_BRIGHTNESS:
1761                 sd->params.colourParams.brightness = ctrl->val;
1762                 sd->params.flickerControl.allowableOverExposure =
1763                         find_over_exposure(sd->params.colourParams.brightness);
1764                 gspca_dev->usb_err = command_setcolourparams(gspca_dev);
1765                 if (!gspca_dev->usb_err)
1766                         gspca_dev->usb_err = command_setflickerctrl(gspca_dev);
1767                 break;
1768         case V4L2_CID_CONTRAST:
1769                 sd->params.colourParams.contrast = ctrl->val;
1770                 gspca_dev->usb_err = command_setcolourparams(gspca_dev);
1771                 break;
1772         case V4L2_CID_SATURATION:
1773                 sd->params.colourParams.saturation = ctrl->val;
1774                 gspca_dev->usb_err = command_setcolourparams(gspca_dev);
1775                 break;
1776         case V4L2_CID_POWER_LINE_FREQUENCY:
1777                 sd->mainsFreq = ctrl->val == V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
1778                 sd->params.flickerControl.coarseJump =
1779                         flicker_jumps[sd->mainsFreq]
1780                         [sd->params.sensorFps.baserate]
1781                         [sd->params.sensorFps.divisor];
1782
1783                 gspca_dev->usb_err = set_flicker(gspca_dev,
1784                         ctrl->val != V4L2_CID_POWER_LINE_FREQUENCY_DISABLED,
1785                         gspca_dev->streaming);
1786                 break;
1787         case V4L2_CID_ILLUMINATORS_1:
1788                 sd->params.qx3.bottomlight = ctrl->val;
1789                 gspca_dev->usb_err = command_setlights(gspca_dev);
1790                 break;
1791         case V4L2_CID_ILLUMINATORS_2:
1792                 sd->params.qx3.toplight = ctrl->val;
1793                 gspca_dev->usb_err = command_setlights(gspca_dev);
1794                 break;
1795         case CPIA1_CID_COMP_TARGET:
1796                 sd->params.compressionTarget.frTargeting = ctrl->val;
1797                 gspca_dev->usb_err = command_setcompressiontarget(gspca_dev);
1798                 break;
1799         }
1800         return gspca_dev->usb_err;
1801 }
1802
1803 static const struct v4l2_ctrl_ops sd_ctrl_ops = {
1804         .s_ctrl = sd_s_ctrl,
1805 };
1806
1807 static int sd_init_controls(struct gspca_dev *gspca_dev)
1808 {
1809         struct sd *sd = (struct sd *)gspca_dev;
1810         struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
1811         static const char * const comp_target_menu[] = {
1812                 "Quality",
1813                 "Framerate",
1814                 NULL
1815         };
1816         static const struct v4l2_ctrl_config comp_target = {
1817                 .ops = &sd_ctrl_ops,
1818                 .id = CPIA1_CID_COMP_TARGET,
1819                 .type = V4L2_CTRL_TYPE_MENU,
1820                 .name = "Compression Target",
1821                 .qmenu = comp_target_menu,
1822                 .max = 1,
1823                 .def = COMP_TARGET_DEF,
1824         };
1825
1826         gspca_dev->vdev.ctrl_handler = hdl;
1827         v4l2_ctrl_handler_init(hdl, 7);
1828         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1829                         V4L2_CID_BRIGHTNESS, 0, 100, 1, BRIGHTNESS_DEF);
1830         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1831                         V4L2_CID_CONTRAST, 0, 96, 8, CONTRAST_DEF);
1832         v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1833                         V4L2_CID_SATURATION, 0, 100, 1, SATURATION_DEF);
1834         sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
1835                         V4L2_CID_POWER_LINE_FREQUENCY,
1836                         V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
1837                         FREQ_DEF);
1838         if (sd->params.qx3.qx3_detected) {
1839                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1840                                 V4L2_CID_ILLUMINATORS_1, 0, 1, 1,
1841                                 ILLUMINATORS_1_DEF);
1842                 v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
1843                                 V4L2_CID_ILLUMINATORS_2, 0, 1, 1,
1844                                 ILLUMINATORS_2_DEF);
1845         }
1846         v4l2_ctrl_new_custom(hdl, &comp_target, NULL);
1847
1848         if (hdl->error) {
1849                 pr_err("Could not initialize controls\n");
1850                 return hdl->error;
1851         }
1852         return 0;
1853 }
1854
1855 /* sub-driver description */
1856 static const struct sd_desc sd_desc = {
1857         .name = MODULE_NAME,
1858         .config = sd_config,
1859         .init = sd_init,
1860         .init_controls = sd_init_controls,
1861         .start = sd_start,
1862         .stopN = sd_stopN,
1863         .dq_callback = sd_dq_callback,
1864         .pkt_scan = sd_pkt_scan,
1865 #if IS_ENABLED(CONFIG_INPUT)
1866         .other_input = 1,
1867 #endif
1868 };
1869
1870 /* -- module initialisation -- */
1871 static const struct usb_device_id device_table[] = {
1872         {USB_DEVICE(0x0553, 0x0002)},
1873         {USB_DEVICE(0x0813, 0x0001)},
1874         {}
1875 };
1876 MODULE_DEVICE_TABLE(usb, device_table);
1877
1878 /* -- device connect -- */
1879 static int sd_probe(struct usb_interface *intf,
1880                         const struct usb_device_id *id)
1881 {
1882         return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
1883                                 THIS_MODULE);
1884 }
1885
1886 static struct usb_driver sd_driver = {
1887         .name = MODULE_NAME,
1888         .id_table = device_table,
1889         .probe = sd_probe,
1890         .disconnect = gspca_disconnect,
1891 #ifdef CONFIG_PM
1892         .suspend = gspca_suspend,
1893         .resume = gspca_resume,
1894         .reset_resume = gspca_resume,
1895 #endif
1896 };
1897
1898 module_usb_driver(sd_driver);