drivers/media/video/gspca/cpia1.c

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