/*
 * cpia CPiA (1) gspca driver
 *
 * Copyright (C) 2010-2011 Hans de Goede <hdegoede@redhat.com>
 *
 * This module is adapted from the in kernel v4l1 cpia driver which is :
 *
 * (C) Copyright 1999-2000 Peter Pregler
 * (C) Copyright 1999-2000 Scott J. Bertin
 * (C) Copyright 1999-2000 Johannes Erdfelt <johannes@erdfelt.com>
 * (C) Copyright 2000 STMicroelectronics
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 *
 */

#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt

#define MODULE_NAME "cpia1"

#include <linux/input.h>
#include "gspca.h"

MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
MODULE_DESCRIPTION("Vision CPiA");
MODULE_LICENSE("GPL");

/* constant value's */
#define MAGIC_0         0x19
#define MAGIC_1         0x68
#define DATA_IN         0xc0
#define DATA_OUT        0x40
#define VIDEOSIZE_QCIF  0       /* 176x144 */
#define VIDEOSIZE_CIF   1       /* 352x288 */
#define SUBSAMPLE_420   0
#define SUBSAMPLE_422   1
#define YUVORDER_YUYV   0
#define YUVORDER_UYVY   1
#define NOT_COMPRESSED  0
#define COMPRESSED      1
#define NO_DECIMATION   0
#define DECIMATION_ENAB 1
#define EOI             0xff    /* End Of Image */
#define EOL             0xfd    /* End Of Line */
#define FRAME_HEADER_SIZE       64

/* Image grab modes */
#define CPIA_GRAB_SINGLE        0
#define CPIA_GRAB_CONTINEOUS    1

/* Compression parameters */
#define CPIA_COMPRESSION_NONE   0
#define CPIA_COMPRESSION_AUTO   1
#define CPIA_COMPRESSION_MANUAL 2
#define CPIA_COMPRESSION_TARGET_QUALITY         0
#define CPIA_COMPRESSION_TARGET_FRAMERATE       1

/* Return offsets for GetCameraState */
#define SYSTEMSTATE     0
#define GRABSTATE       1
#define STREAMSTATE     2
#define FATALERROR      3
#define CMDERROR        4
#define DEBUGFLAGS      5
#define VPSTATUS        6
#define ERRORCODE       7

/* SystemState */
#define UNINITIALISED_STATE     0
#define PASS_THROUGH_STATE      1
#define LO_POWER_STATE          2
#define HI_POWER_STATE          3
#define WARM_BOOT_STATE         4

/* GrabState */
#define GRAB_IDLE               0
#define GRAB_ACTIVE             1
#define GRAB_DONE               2

/* StreamState */
#define STREAM_NOT_READY        0
#define STREAM_READY            1
#define STREAM_OPEN             2
#define STREAM_PAUSED           3
#define STREAM_FINISHED         4

/* Fatal Error, CmdError, and DebugFlags */
#define CPIA_FLAG         1
#define SYSTEM_FLAG       2
#define INT_CTRL_FLAG     4
#define PROCESS_FLAG      8
#define COM_FLAG         16
#define VP_CTRL_FLAG     32
#define CAPTURE_FLAG     64
#define DEBUG_FLAG      128

/* VPStatus */
#define VP_STATE_OK                     0x00

#define VP_STATE_FAILED_VIDEOINIT       0x01
#define VP_STATE_FAILED_AECACBINIT      0x02
#define VP_STATE_AEC_MAX                0x04
#define VP_STATE_ACB_BMAX               0x08

#define VP_STATE_ACB_RMIN               0x10
#define VP_STATE_ACB_GMIN               0x20
#define VP_STATE_ACB_RMAX               0x40
#define VP_STATE_ACB_GMAX               0x80

/* default (minimum) compensation values */
#define COMP_RED        220
#define COMP_GREEN1     214
#define COMP_GREEN2     COMP_GREEN1
#define COMP_BLUE       230

/* exposure status */
#define EXPOSURE_VERY_LIGHT 0
#define EXPOSURE_LIGHT      1
#define EXPOSURE_NORMAL     2
#define EXPOSURE_DARK       3
#define EXPOSURE_VERY_DARK  4

#define CPIA_MODULE_CPIA                        (0 << 5)
#define CPIA_MODULE_SYSTEM                      (1 << 5)
#define CPIA_MODULE_VP_CTRL                     (5 << 5)
#define CPIA_MODULE_CAPTURE                     (6 << 5)
#define CPIA_MODULE_DEBUG                       (7 << 5)

#define INPUT (DATA_IN << 8)
#define OUTPUT (DATA_OUT << 8)

#define CPIA_COMMAND_GetCPIAVersion     (INPUT | CPIA_MODULE_CPIA | 1)
#define CPIA_COMMAND_GetPnPID           (INPUT | CPIA_MODULE_CPIA | 2)
#define CPIA_COMMAND_GetCameraStatus    (INPUT | CPIA_MODULE_CPIA | 3)
#define CPIA_COMMAND_GotoHiPower        (OUTPUT | CPIA_MODULE_CPIA | 4)
#define CPIA_COMMAND_GotoLoPower        (OUTPUT | CPIA_MODULE_CPIA | 5)
#define CPIA_COMMAND_GotoSuspend        (OUTPUT | CPIA_MODULE_CPIA | 7)
#define CPIA_COMMAND_GotoPassThrough    (OUTPUT | CPIA_MODULE_CPIA | 8)
#define CPIA_COMMAND_ModifyCameraStatus (OUTPUT | CPIA_MODULE_CPIA | 10)

#define CPIA_COMMAND_ReadVCRegs         (INPUT | CPIA_MODULE_SYSTEM | 1)
#define CPIA_COMMAND_WriteVCReg         (OUTPUT | CPIA_MODULE_SYSTEM | 2)
#define CPIA_COMMAND_ReadMCPorts        (INPUT | CPIA_MODULE_SYSTEM | 3)
#define CPIA_COMMAND_WriteMCPort        (OUTPUT | CPIA_MODULE_SYSTEM | 4)
#define CPIA_COMMAND_SetBaudRate        (OUTPUT | CPIA_MODULE_SYSTEM | 5)
#define CPIA_COMMAND_SetECPTiming       (OUTPUT | CPIA_MODULE_SYSTEM | 6)
#define CPIA_COMMAND_ReadIDATA          (INPUT | CPIA_MODULE_SYSTEM | 7)
#define CPIA_COMMAND_WriteIDATA         (OUTPUT | CPIA_MODULE_SYSTEM | 8)
#define CPIA_COMMAND_GenericCall        (OUTPUT | CPIA_MODULE_SYSTEM | 9)
#define CPIA_COMMAND_I2CStart           (OUTPUT | CPIA_MODULE_SYSTEM | 10)
#define CPIA_COMMAND_I2CStop            (OUTPUT | CPIA_MODULE_SYSTEM | 11)
#define CPIA_COMMAND_I2CWrite           (OUTPUT | CPIA_MODULE_SYSTEM | 12)
#define CPIA_COMMAND_I2CRead            (INPUT | CPIA_MODULE_SYSTEM | 13)

#define CPIA_COMMAND_GetVPVersion       (INPUT | CPIA_MODULE_VP_CTRL | 1)
#define CPIA_COMMAND_ResetFrameCounter  (INPUT | CPIA_MODULE_VP_CTRL | 2)
#define CPIA_COMMAND_SetColourParams    (OUTPUT | CPIA_MODULE_VP_CTRL | 3)
#define CPIA_COMMAND_SetExposure        (OUTPUT | CPIA_MODULE_VP_CTRL | 4)
#define CPIA_COMMAND_SetColourBalance   (OUTPUT | CPIA_MODULE_VP_CTRL | 6)
#define CPIA_COMMAND_SetSensorFPS       (OUTPUT | CPIA_MODULE_VP_CTRL | 7)
#define CPIA_COMMAND_SetVPDefaults      (OUTPUT | CPIA_MODULE_VP_CTRL | 8)
#define CPIA_COMMAND_SetApcor           (OUTPUT | CPIA_MODULE_VP_CTRL | 9)
#define CPIA_COMMAND_SetFlickerCtrl     (OUTPUT | CPIA_MODULE_VP_CTRL | 10)
#define CPIA_COMMAND_SetVLOffset        (OUTPUT | CPIA_MODULE_VP_CTRL | 11)
#define CPIA_COMMAND_GetColourParams    (INPUT | CPIA_MODULE_VP_CTRL | 16)
#define CPIA_COMMAND_GetColourBalance   (INPUT | CPIA_MODULE_VP_CTRL | 17)
#define CPIA_COMMAND_GetExposure        (INPUT | CPIA_MODULE_VP_CTRL | 18)
#define CPIA_COMMAND_SetSensorMatrix    (OUTPUT | CPIA_MODULE_VP_CTRL | 19)
#define CPIA_COMMAND_ColourBars         (OUTPUT | CPIA_MODULE_VP_CTRL | 25)
#define CPIA_COMMAND_ReadVPRegs         (INPUT | CPIA_MODULE_VP_CTRL | 30)
#define CPIA_COMMAND_WriteVPReg         (OUTPUT | CPIA_MODULE_VP_CTRL | 31)

#define CPIA_COMMAND_GrabFrame          (OUTPUT | CPIA_MODULE_CAPTURE | 1)
#define CPIA_COMMAND_UploadFrame        (OUTPUT | CPIA_MODULE_CAPTURE | 2)
#define CPIA_COMMAND_SetGrabMode        (OUTPUT | CPIA_MODULE_CAPTURE | 3)
#define CPIA_COMMAND_InitStreamCap      (OUTPUT | CPIA_MODULE_CAPTURE | 4)
#define CPIA_COMMAND_FiniStreamCap      (OUTPUT | CPIA_MODULE_CAPTURE | 5)
#define CPIA_COMMAND_StartStreamCap     (OUTPUT | CPIA_MODULE_CAPTURE | 6)
#define CPIA_COMMAND_EndStreamCap       (OUTPUT | CPIA_MODULE_CAPTURE | 7)
#define CPIA_COMMAND_SetFormat          (OUTPUT | CPIA_MODULE_CAPTURE | 8)
#define CPIA_COMMAND_SetROI             (OUTPUT | CPIA_MODULE_CAPTURE | 9)
#define CPIA_COMMAND_SetCompression     (OUTPUT | CPIA_MODULE_CAPTURE | 10)
#define CPIA_COMMAND_SetCompressionTarget (OUTPUT | CPIA_MODULE_CAPTURE | 11)
#define CPIA_COMMAND_SetYUVThresh       (OUTPUT | CPIA_MODULE_CAPTURE | 12)
#define CPIA_COMMAND_SetCompressionParams (OUTPUT | CPIA_MODULE_CAPTURE | 13)
#define CPIA_COMMAND_DiscardFrame       (OUTPUT | CPIA_MODULE_CAPTURE | 14)
#define CPIA_COMMAND_GrabReset          (OUTPUT | CPIA_MODULE_CAPTURE | 15)

#define CPIA_COMMAND_OutputRS232        (OUTPUT | CPIA_MODULE_DEBUG | 1)
#define CPIA_COMMAND_AbortProcess       (OUTPUT | CPIA_MODULE_DEBUG | 4)
#define CPIA_COMMAND_SetDramPage        (OUTPUT | CPIA_MODULE_DEBUG | 5)
#define CPIA_COMMAND_StartDramUpload    (OUTPUT | CPIA_MODULE_DEBUG | 6)
#define CPIA_COMMAND_StartDummyDtream   (OUTPUT | CPIA_MODULE_DEBUG | 8)
#define CPIA_COMMAND_AbortStream        (OUTPUT | CPIA_MODULE_DEBUG | 9)
#define CPIA_COMMAND_DownloadDRAM       (OUTPUT | CPIA_MODULE_DEBUG | 10)
#define CPIA_COMMAND_Null               (OUTPUT | CPIA_MODULE_DEBUG | 11)

#define ROUND_UP_EXP_FOR_FLICKER 15

/* Constants for automatic frame rate adjustment */
#define MAX_EXP       302
#define MAX_EXP_102   255
#define LOW_EXP       140
#define VERY_LOW_EXP   70
#define TC             94
#define EXP_ACC_DARK   50
#define EXP_ACC_LIGHT  90
#define HIGH_COMP_102 160
#define MAX_COMP      239
#define DARK_TIME       3
#define LIGHT_TIME      3

#define FIRMWARE_VERSION(x, y) (sd->params.version.firmwareVersion == (x) && \
                                sd->params.version.firmwareRevision == (y))

#define CPIA1_CID_COMP_TARGET (V4L2_CTRL_CLASS_USER + 0x1000)
#define BRIGHTNESS_DEF 50
#define CONTRAST_DEF 48
#define SATURATION_DEF 50
#define FREQ_DEF V4L2_CID_POWER_LINE_FREQUENCY_50HZ
#define ILLUMINATORS_1_DEF 0
#define ILLUMINATORS_2_DEF 0
#define COMP_TARGET_DEF CPIA_COMPRESSION_TARGET_QUALITY

/* Developer's Guide Table 5 p 3-34
 * indexed by [mains][sensorFps.baserate][sensorFps.divisor]*/
static u8 flicker_jumps[2][2][4] =
{ { { 76, 38, 19, 9 }, { 92, 46, 23, 11 } },
  { { 64, 32, 16, 8 }, { 76, 38, 19, 9} }
};

struct cam_params {
        struct {
                u8 firmwareVersion;
                u8 firmwareRevision;
                u8 vcVersion;
                u8 vcRevision;
        } version;
        struct {
                u16 vendor;
                u16 product;
                u16 deviceRevision;
        } pnpID;
        struct {
                u8 vpVersion;
                u8 vpRevision;
                u16 cameraHeadID;
        } vpVersion;
        struct {
                u8 systemState;
                u8 grabState;
                u8 streamState;
                u8 fatalError;
                u8 cmdError;
                u8 debugFlags;
                u8 vpStatus;
                u8 errorCode;
        } status;
        struct {
                u8 brightness;
                u8 contrast;
                u8 saturation;
        } colourParams;
        struct {
                u8 gainMode;
                u8 expMode;
                u8 compMode;
                u8 centreWeight;
                u8 gain;
                u8 fineExp;
                u8 coarseExpLo;
                u8 coarseExpHi;
                u8 redComp;
                u8 green1Comp;
                u8 green2Comp;
                u8 blueComp;
        } exposure;
        struct {
                u8 balanceMode;
                u8 redGain;
                u8 greenGain;
                u8 blueGain;
        } colourBalance;
        struct {
                u8 divisor;
                u8 baserate;
        } sensorFps;
        struct {
                u8 gain1;
                u8 gain2;
                u8 gain4;
                u8 gain8;
        } apcor;
        struct {
                u8 disabled;
                u8 flickerMode;
                u8 coarseJump;
                u8 allowableOverExposure;
        } flickerControl;
        struct {
                u8 gain1;
                u8 gain2;
                u8 gain4;
                u8 gain8;
        } vlOffset;
        struct {
                u8 mode;
                u8 decimation;
        } compression;
        struct {
                u8 frTargeting;
                u8 targetFR;
                u8 targetQ;
        } compressionTarget;
        struct {
                u8 yThreshold;
                u8 uvThreshold;
        } yuvThreshold;
        struct {
                u8 hysteresis;
                u8 threshMax;
                u8 smallStep;
                u8 largeStep;
                u8 decimationHysteresis;
                u8 frDiffStepThresh;
                u8 qDiffStepThresh;
                u8 decimationThreshMod;
        } compressionParams;
        struct {
                u8 videoSize;           /* CIF/QCIF */
                u8 subSample;
                u8 yuvOrder;
        } format;
        struct {                        /* Intel QX3 specific data */
                u8 qx3_detected;        /* a QX3 is present */
                u8 toplight;            /* top light lit , R/W */
                u8 bottomlight;         /* bottom light lit, R/W */
                u8 button;              /* snapshot button pressed (R/O) */
                u8 cradled;             /* microscope is in cradle (R/O) */
        } qx3;
        struct {
                u8 colStart;            /* skip first 8*colStart pixels */
                u8 colEnd;              /* finish at 8*colEnd pixels */
                u8 rowStart;            /* skip first 4*rowStart lines */
                u8 rowEnd;              /* finish at 4*rowEnd lines */
        } roi;
        u8 ecpTiming;
        u8 streamStartLine;
};

/* specific webcam descriptor */
struct sd {
        struct gspca_dev gspca_dev;             /* !! must be the first item */
        struct cam_params params;               /* camera settings */

        atomic_t cam_exposure;
        atomic_t fps;
        int exposure_count;
        u8 exposure_status;
        struct v4l2_ctrl *freq;
        u8 mainsFreq;                           /* 0 = 50hz, 1 = 60hz */
        u8 first_frame;
};

static const struct v4l2_pix_format mode[] = {
        {160, 120, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
                /* The sizeimage is trial and error, as with low framerates
                   the camera will pad out usb frames, making the image
                   data larger then strictly necessary */
                .bytesperline = 160,
                .sizeimage = 65536,
                .colorspace = V4L2_COLORSPACE_SRGB,
                .priv = 3},
        {176, 144, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
                .bytesperline = 172,
                .sizeimage = 65536,
                .colorspace = V4L2_COLORSPACE_SRGB,
                .priv = 2},
        {320, 240, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
                .bytesperline = 320,
                .sizeimage = 262144,
                .colorspace = V4L2_COLORSPACE_SRGB,
                .priv = 1},
        {352, 288, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
                .bytesperline = 352,
                .sizeimage = 262144,
                .colorspace = V4L2_COLORSPACE_SRGB,
                .priv = 0},
};

/**********************************************************************
 *
 * General functions
 *
 **********************************************************************/

static int cpia_usb_transferCmd(struct gspca_dev *gspca_dev, u8 *command)
{
        u8 requesttype;
        unsigned int pipe;
        int ret, databytes = command[6] | (command[7] << 8);
        /* Sometimes we see spurious EPIPE errors */
        int retries = 3;

        if (command[0] == DATA_IN) {
                pipe = usb_rcvctrlpipe(gspca_dev->dev, 0);
                requesttype = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        } else if (command[0] == DATA_OUT) {
                pipe = usb_sndctrlpipe(gspca_dev->dev, 0);
                requesttype = USB_TYPE_VENDOR | USB_RECIP_DEVICE;
        } else {
                PERR("Unexpected first byte of command: %x", command[0]);
                return -EINVAL;
        }

retry:
        ret = usb_control_msg(gspca_dev->dev, pipe,
                              command[1],
                              requesttype,
                              command[2] | (command[3] << 8),
                              command[4] | (command[5] << 8),
                              gspca_dev->usb_buf, databytes, 1000);

        if (ret < 0)
                pr_err("usb_control_msg %02x, error %d\n", command[1], ret);

        if (ret == -EPIPE && retries > 0) {
                retries--;
                goto retry;
        }

        return (ret < 0) ? ret : 0;
}

/* send an arbitrary command to the camera */
static int do_command(struct gspca_dev *gspca_dev, u16 command,
                      u8 a, u8 b, u8 c, u8 d)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret, datasize;
        u8 cmd[8];

        switch (command) {
        case CPIA_COMMAND_GetCPIAVersion:
        case CPIA_COMMAND_GetPnPID:
        case CPIA_COMMAND_GetCameraStatus:
        case CPIA_COMMAND_GetVPVersion:
        case CPIA_COMMAND_GetColourParams:
        case CPIA_COMMAND_GetColourBalance:
        case CPIA_COMMAND_GetExposure:
                datasize = 8;
                break;
        case CPIA_COMMAND_ReadMCPorts:
        case CPIA_COMMAND_ReadVCRegs:
                datasize = 4;
                break;
        default:
                datasize = 0;
                break;
        }

        cmd[0] = command >> 8;
        cmd[1] = command & 0xff;
        cmd[2] = a;
        cmd[3] = b;
        cmd[4] = c;
        cmd[5] = d;
        cmd[6] = datasize;
        cmd[7] = 0;

        ret = cpia_usb_transferCmd(gspca_dev, cmd);
        if (ret)
                return ret;

        switch (command) {
        case CPIA_COMMAND_GetCPIAVersion:
                sd->params.version.firmwareVersion = gspca_dev->usb_buf[0];
                sd->params.version.firmwareRevision = gspca_dev->usb_buf[1];
                sd->params.version.vcVersion = gspca_dev->usb_buf[2];
                sd->params.version.vcRevision = gspca_dev->usb_buf[3];
                break;
        case CPIA_COMMAND_GetPnPID:
                sd->params.pnpID.vendor =
                        gspca_dev->usb_buf[0] | (gspca_dev->usb_buf[1] << 8);
                sd->params.pnpID.product =
                        gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
                sd->params.pnpID.deviceRevision =
                        gspca_dev->usb_buf[4] | (gspca_dev->usb_buf[5] << 8);
                break;
        case CPIA_COMMAND_GetCameraStatus:
                sd->params.status.systemState = gspca_dev->usb_buf[0];
                sd->params.status.grabState = gspca_dev->usb_buf[1];
                sd->params.status.streamState = gspca_dev->usb_buf[2];
                sd->params.status.fatalError = gspca_dev->usb_buf[3];
                sd->params.status.cmdError = gspca_dev->usb_buf[4];
                sd->params.status.debugFlags = gspca_dev->usb_buf[5];
                sd->params.status.vpStatus = gspca_dev->usb_buf[6];
                sd->params.status.errorCode = gspca_dev->usb_buf[7];
                break;
        case CPIA_COMMAND_GetVPVersion:
                sd->params.vpVersion.vpVersion = gspca_dev->usb_buf[0];
                sd->params.vpVersion.vpRevision = gspca_dev->usb_buf[1];
                sd->params.vpVersion.cameraHeadID =
                        gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
                break;
        case CPIA_COMMAND_GetColourParams:
                sd->params.colourParams.brightness = gspca_dev->usb_buf[0];
                sd->params.colourParams.contrast = gspca_dev->usb_buf[1];
                sd->params.colourParams.saturation = gspca_dev->usb_buf[2];
                break;
        case CPIA_COMMAND_GetColourBalance:
                sd->params.colourBalance.redGain = gspca_dev->usb_buf[0];
                sd->params.colourBalance.greenGain = gspca_dev->usb_buf[1];
                sd->params.colourBalance.blueGain = gspca_dev->usb_buf[2];
                break;
        case CPIA_COMMAND_GetExposure:
                sd->params.exposure.gain = gspca_dev->usb_buf[0];
                sd->params.exposure.fineExp = gspca_dev->usb_buf[1];
                sd->params.exposure.coarseExpLo = gspca_dev->usb_buf[2];
                sd->params.exposure.coarseExpHi = gspca_dev->usb_buf[3];
                sd->params.exposure.redComp = gspca_dev->usb_buf[4];
                sd->params.exposure.green1Comp = gspca_dev->usb_buf[5];
                sd->params.exposure.green2Comp = gspca_dev->usb_buf[6];
                sd->params.exposure.blueComp = gspca_dev->usb_buf[7];
                break;

        case CPIA_COMMAND_ReadMCPorts:
                /* test button press */
                a = ((gspca_dev->usb_buf[1] & 0x02) == 0);
                if (a != sd->params.qx3.button) {
#if IS_ENABLED(CONFIG_INPUT)
                        input_report_key(gspca_dev->input_dev, KEY_CAMERA, a);
                        input_sync(gspca_dev->input_dev);
#endif
                        sd->params.qx3.button = a;
                }
                if (sd->params.qx3.button) {
                        /* button pressed - unlock the latch */
                        do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
                                   3, 0xdf, 0xdf, 0);
                        do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
                                   3, 0xff, 0xff, 0);
                }

                /* test whether microscope is cradled */
                sd->params.qx3.cradled = ((gspca_dev->usb_buf[2] & 0x40) == 0);
                break;
        }

        return 0;
}

/* send a command to the camera with an additional data transaction */
static int do_command_extended(struct gspca_dev *gspca_dev, u16 command,
                               u8 a, u8 b, u8 c, u8 d,
                               u8 e, u8 f, u8 g, u8 h,
                               u8 i, u8 j, u8 k, u8 l)
{
        u8 cmd[8];

        cmd[0] = command >> 8;
        cmd[1] = command & 0xff;
        cmd[2] = a;
        cmd[3] = b;
        cmd[4] = c;
        cmd[5] = d;
        cmd[6] = 8;
        cmd[7] = 0;
        gspca_dev->usb_buf[0] = e;
        gspca_dev->usb_buf[1] = f;
        gspca_dev->usb_buf[2] = g;
        gspca_dev->usb_buf[3] = h;
        gspca_dev->usb_buf[4] = i;
        gspca_dev->usb_buf[5] = j;
        gspca_dev->usb_buf[6] = k;
        gspca_dev->usb_buf[7] = l;

        return cpia_usb_transferCmd(gspca_dev, cmd);
}

/*  find_over_exposure
 *  Finds a suitable value of OverExposure for use with SetFlickerCtrl
 *  Some calculation is required because this value changes with the brightness
 *  set with SetColourParameters
 *
 *  Parameters: Brightness - last brightness value set with SetColourParameters
 *
 *  Returns: OverExposure value to use with SetFlickerCtrl
 */
#define FLICKER_MAX_EXPOSURE                    250
#define FLICKER_ALLOWABLE_OVER_EXPOSURE         146
#define FLICKER_BRIGHTNESS_CONSTANT             59
static int find_over_exposure(int brightness)
{
        int MaxAllowableOverExposure, OverExposure;

        MaxAllowableOverExposure = FLICKER_MAX_EXPOSURE - brightness -
                                   FLICKER_BRIGHTNESS_CONSTANT;

        if (MaxAllowableOverExposure < FLICKER_ALLOWABLE_OVER_EXPOSURE)
                OverExposure = MaxAllowableOverExposure;
        else
                OverExposure = FLICKER_ALLOWABLE_OVER_EXPOSURE;

        return OverExposure;
}
#undef FLICKER_MAX_EXPOSURE
#undef FLICKER_ALLOWABLE_OVER_EXPOSURE
#undef FLICKER_BRIGHTNESS_CONSTANT

/* initialise cam_data structure  */
static void reset_camera_params(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        struct cam_params *params = &sd->params;

        /* The following parameter values are the defaults from
         * "Software Developer's Guide for CPiA Cameras".  Any changes
         * to the defaults are noted in comments. */
        params->colourParams.brightness = BRIGHTNESS_DEF;
        params->colourParams.contrast = CONTRAST_DEF;
        params->colourParams.saturation = SATURATION_DEF;
        params->exposure.gainMode = 4;
        params->exposure.expMode = 2;           /* AEC */
        params->exposure.compMode = 1;
        params->exposure.centreWeight = 1;
        params->exposure.gain = 0;
        params->exposure.fineExp = 0;
        params->exposure.coarseExpLo = 185;
        params->exposure.coarseExpHi = 0;
        params->exposure.redComp = COMP_RED;
        params->exposure.green1Comp = COMP_GREEN1;
        params->exposure.green2Comp = COMP_GREEN2;
        params->exposure.blueComp = COMP_BLUE;
        params->colourBalance.balanceMode = 2;  /* ACB */
        params->colourBalance.redGain = 32;
        params->colourBalance.greenGain = 6;
        params->colourBalance.blueGain = 92;
        params->apcor.gain1 = 0x18;
        params->apcor.gain2 = 0x16;
        params->apcor.gain4 = 0x24;
        params->apcor.gain8 = 0x34;
        params->vlOffset.gain1 = 20;
        params->vlOffset.gain2 = 24;
        params->vlOffset.gain4 = 26;
        params->vlOffset.gain8 = 26;
        params->compressionParams.hysteresis = 3;
        params->compressionParams.threshMax = 11;
        params->compressionParams.smallStep = 1;
        params->compressionParams.largeStep = 3;
        params->compressionParams.decimationHysteresis = 2;
        params->compressionParams.frDiffStepThresh = 5;
        params->compressionParams.qDiffStepThresh = 3;
        params->compressionParams.decimationThreshMod = 2;
        /* End of default values from Software Developer's Guide */

        /* Set Sensor FPS to 15fps. This seems better than 30fps
         * for indoor lighting. */
        params->sensorFps.divisor = 1;
        params->sensorFps.baserate = 1;

        params->flickerControl.flickerMode = 0;
        params->flickerControl.disabled = 1;
        params->flickerControl.coarseJump =
                flicker_jumps[sd->mainsFreq]
                             [params->sensorFps.baserate]
                             [params->sensorFps.divisor];
        params->flickerControl.allowableOverExposure =
                find_over_exposure(params->colourParams.brightness);

        params->yuvThreshold.yThreshold = 6; /* From windows driver */
        params->yuvThreshold.uvThreshold = 6; /* From windows driver */

        params->format.subSample = SUBSAMPLE_420;
        params->format.yuvOrder = YUVORDER_YUYV;

        params->compression.mode = CPIA_COMPRESSION_AUTO;
        params->compression.decimation = NO_DECIMATION;

        params->compressionTarget.frTargeting = COMP_TARGET_DEF;
        params->compressionTarget.targetFR = 15; /* From windows driver */
        params->compressionTarget.targetQ = 5; /* From windows driver */

        params->qx3.qx3_detected = 0;
        params->qx3.toplight = 0;
        params->qx3.bottomlight = 0;
        params->qx3.button = 0;
        params->qx3.cradled = 0;
}

static void printstatus(struct gspca_dev *gspca_dev, struct cam_params *params)
{
        PDEBUG(D_PROBE, "status: %02x %02x %02x %02x %02x %02x %02x %02x",
               params->status.systemState, params->status.grabState,
               params->status.streamState, params->status.fatalError,
               params->status.cmdError, params->status.debugFlags,
               params->status.vpStatus, params->status.errorCode);
}

static int goto_low_power(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;

        ret = do_command(gspca_dev, CPIA_COMMAND_GotoLoPower, 0, 0, 0, 0);
        if (ret)
                return ret;

        ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
        if (ret)
                return ret;

        if (sd->params.status.systemState != LO_POWER_STATE) {
                if (sd->params.status.systemState != WARM_BOOT_STATE) {
                        PERR("unexpected state after lo power cmd: %02x",
                             sd->params.status.systemState);
                        printstatus(gspca_dev, &sd->params);
                }
                return -EIO;
        }

        PDEBUG(D_CONF, "camera now in LOW power state");
        return 0;
}

static int goto_high_power(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;

        ret = do_command(gspca_dev, CPIA_COMMAND_GotoHiPower, 0, 0, 0, 0);
        if (ret)
                return ret;

        msleep_interruptible(40);       /* windows driver does it too */

        if (signal_pending(current))
                return -EINTR;

        ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
        if (ret)
                return ret;

        if (sd->params.status.systemState != HI_POWER_STATE) {
                PERR("unexpected state after hi power cmd: %02x",
                     sd->params.status.systemState);
                printstatus(gspca_dev, &sd->params);
                return -EIO;
        }

        PDEBUG(D_CONF, "camera now in HIGH power state");
        return 0;
}

static int get_version_information(struct gspca_dev *gspca_dev)
{
        int ret;

        /* GetCPIAVersion */
        ret = do_command(gspca_dev, CPIA_COMMAND_GetCPIAVersion, 0, 0, 0, 0);
        if (ret)
                return ret;

        /* GetPnPID */
        return do_command(gspca_dev, CPIA_COMMAND_GetPnPID, 0, 0, 0, 0);
}

static int save_camera_state(struct gspca_dev *gspca_dev)
{
        int ret;

        ret = do_command(gspca_dev, CPIA_COMMAND_GetColourBalance, 0, 0, 0, 0);
        if (ret)
                return ret;

        return do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
}

static int command_setformat(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;

        ret = do_command(gspca_dev, CPIA_COMMAND_SetFormat,
                         sd->params.format.videoSize,
                         sd->params.format.subSample,
                         sd->params.format.yuvOrder, 0);
        if (ret)
                return ret;

        return do_command(gspca_dev, CPIA_COMMAND_SetROI,
                          sd->params.roi.colStart, sd->params.roi.colEnd,
                          sd->params.roi.rowStart, sd->params.roi.rowEnd);
}

static int command_setcolourparams(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        return do_command(gspca_dev, CPIA_COMMAND_SetColourParams,
                          sd->params.colourParams.brightness,
                          sd->params.colourParams.contrast,
                          sd->params.colourParams.saturation, 0);
}

static int command_setapcor(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        return do_command(gspca_dev, CPIA_COMMAND_SetApcor,
                          sd->params.apcor.gain1,
                          sd->params.apcor.gain2,
                          sd->params.apcor.gain4,
                          sd->params.apcor.gain8);
}

static int command_setvloffset(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        return do_command(gspca_dev, CPIA_COMMAND_SetVLOffset,
                          sd->params.vlOffset.gain1,
                          sd->params.vlOffset.gain2,
                          sd->params.vlOffset.gain4,
                          sd->params.vlOffset.gain8);
}

static int command_setexposure(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;

        ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
                                  sd->params.exposure.gainMode,
                                  1,
                                  sd->params.exposure.compMode,
                                  sd->params.exposure.centreWeight,
                                  sd->params.exposure.gain,
                                  sd->params.exposure.fineExp,
                                  sd->params.exposure.coarseExpLo,
                                  sd->params.exposure.coarseExpHi,
                                  sd->params.exposure.redComp,
                                  sd->params.exposure.green1Comp,
                                  sd->params.exposure.green2Comp,
                                  sd->params.exposure.blueComp);
        if (ret)
                return ret;

        if (sd->params.exposure.expMode != 1) {
                ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
                                          0,
                                          sd->params.exposure.expMode,
                                          0, 0,
                                          sd->params.exposure.gain,
                                          sd->params.exposure.fineExp,
                                          sd->params.exposure.coarseExpLo,
                                          sd->params.exposure.coarseExpHi,
                                          0, 0, 0, 0);
        }

        return ret;
}

static int command_setcolourbalance(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        if (sd->params.colourBalance.balanceMode == 1) {
                int ret;

                ret = do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
                                 1,
                                 sd->params.colourBalance.redGain,
                                 sd->params.colourBalance.greenGain,
                                 sd->params.colourBalance.blueGain);
                if (ret)
                        return ret;

                return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
                                  3, 0, 0, 0);
        }
        if (sd->params.colourBalance.balanceMode == 2) {
                return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
                                  2, 0, 0, 0);
        }
        if (sd->params.colourBalance.balanceMode == 3) {
                return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
                                  3, 0, 0, 0);
        }

        return -EINVAL;
}

static int command_setcompressiontarget(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_SetCompressionTarget,
                          sd->params.compressionTarget.frTargeting,
                          sd->params.compressionTarget.targetFR,
                          sd->params.compressionTarget.targetQ, 0);
}

static int command_setyuvtresh(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_SetYUVThresh,
                          sd->params.yuvThreshold.yThreshold,
                          sd->params.yuvThreshold.uvThreshold, 0, 0);
}

static int command_setcompressionparams(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command_extended(gspca_dev,
                            CPIA_COMMAND_SetCompressionParams,
                            0, 0, 0, 0,
                            sd->params.compressionParams.hysteresis,
                            sd->params.compressionParams.threshMax,
                            sd->params.compressionParams.smallStep,
                            sd->params.compressionParams.largeStep,
                            sd->params.compressionParams.decimationHysteresis,
                            sd->params.compressionParams.frDiffStepThresh,
                            sd->params.compressionParams.qDiffStepThresh,
                            sd->params.compressionParams.decimationThreshMod);
}

static int command_setcompression(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_SetCompression,
                          sd->params.compression.mode,
                          sd->params.compression.decimation, 0, 0);
}

static int command_setsensorfps(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_SetSensorFPS,
                          sd->params.sensorFps.divisor,
                          sd->params.sensorFps.baserate, 0, 0);
}

static int command_setflickerctrl(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_SetFlickerCtrl,
                          sd->params.flickerControl.flickerMode,
                          sd->params.flickerControl.coarseJump,
                          sd->params.flickerControl.allowableOverExposure,
                          0);
}

static int command_setecptiming(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_SetECPTiming,
                          sd->params.ecpTiming, 0, 0, 0);
}

static int command_pause(struct gspca_dev *gspca_dev)
{
        return do_command(gspca_dev, CPIA_COMMAND_EndStreamCap, 0, 0, 0, 0);
}

static int command_resume(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        return do_command(gspca_dev, CPIA_COMMAND_InitStreamCap,
                          0, sd->params.streamStartLine, 0, 0);
}

static int command_setlights(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret, p1, p2;

        p1 = (sd->params.qx3.bottomlight == 0) << 1;
        p2 = (sd->params.qx3.toplight == 0) << 3;

        ret = do_command(gspca_dev, CPIA_COMMAND_WriteVCReg,
                         0x90, 0x8f, 0x50, 0);
        if (ret)
                return ret;

        return do_command(gspca_dev, CPIA_COMMAND_WriteMCPort, 2, 0,
                          p1 | p2 | 0xe0, 0);
}

static int set_flicker(struct gspca_dev *gspca_dev, int on, int apply)
{
        /* Everything in here is from the Windows driver */
/* define for compgain calculation */
#if 0
#define COMPGAIN(base, curexp, newexp) \
    (u8) ((((float) base - 128.0) * ((float) curexp / (float) newexp)) + 128.5)
#define EXP_FROM_COMP(basecomp, curcomp, curexp) \
    (u16)((float)curexp * (float)(u8)(curcomp + 128) / \
    (float)(u8)(basecomp - 128))
#else
  /* equivalent functions without floating point math */
#define COMPGAIN(base, curexp, newexp) \
    (u8)(128 + (((u32)(2*(base-128)*curexp + newexp)) / (2 * newexp)))
#define EXP_FROM_COMP(basecomp, curcomp, curexp) \
    (u16)(((u32)(curexp * (u8)(curcomp + 128)) / (u8)(basecomp - 128)))
#endif

        struct sd *sd = (struct sd *) gspca_dev;
        int currentexp = sd->params.exposure.coarseExpLo +
                         sd->params.exposure.coarseExpHi * 256;
        int ret, startexp;

        if (on) {
                int cj = sd->params.flickerControl.coarseJump;
                sd->params.flickerControl.flickerMode = 1;
                sd->params.flickerControl.disabled = 0;
                if (sd->params.exposure.expMode != 2) {
                        sd->params.exposure.expMode = 2;
                        sd->exposure_status = EXPOSURE_NORMAL;
                }
                currentexp = currentexp << sd->params.exposure.gain;
                sd->params.exposure.gain = 0;
                /* round down current exposure to nearest value */
                startexp = (currentexp + ROUND_UP_EXP_FOR_FLICKER) / cj;
                if (startexp < 1)
                        startexp = 1;
                startexp = (startexp * cj) - 1;
                if (FIRMWARE_VERSION(1, 2))
                        while (startexp > MAX_EXP_102)
                                startexp -= cj;
                else
                        while (startexp > MAX_EXP)
                                startexp -= cj;
                sd->params.exposure.coarseExpLo = startexp & 0xff;
                sd->params.exposure.coarseExpHi = startexp >> 8;
                if (currentexp > startexp) {
                        if (currentexp > (2 * startexp))
                                currentexp = 2 * startexp;
                        sd->params.exposure.redComp =
                                COMPGAIN(COMP_RED, currentexp, startexp);
                        sd->params.exposure.green1Comp =
                                COMPGAIN(COMP_GREEN1, currentexp, startexp);
                        sd->params.exposure.green2Comp =
                                COMPGAIN(COMP_GREEN2, currentexp, startexp);
                        sd->params.exposure.blueComp =
                                COMPGAIN(COMP_BLUE, currentexp, startexp);
                } else {
                        sd->params.exposure.redComp = COMP_RED;
                        sd->params.exposure.green1Comp = COMP_GREEN1;
                        sd->params.exposure.green2Comp = COMP_GREEN2;
                        sd->params.exposure.blueComp = COMP_BLUE;
                }
                if (FIRMWARE_VERSION(1, 2))
                        sd->params.exposure.compMode = 0;
                else
                        sd->params.exposure.compMode = 1;

                sd->params.apcor.gain1 = 0x18;
                sd->params.apcor.gain2 = 0x18;
                sd->params.apcor.gain4 = 0x16;
                sd->params.apcor.gain8 = 0x14;
        } else {
                sd->params.flickerControl.flickerMode = 0;
                sd->params.flickerControl.disabled = 1;
                /* Average equivalent coarse for each comp channel */
                startexp = EXP_FROM_COMP(COMP_RED,
                                sd->params.exposure.redComp, currentexp);
                startexp += EXP_FROM_COMP(COMP_GREEN1,
                                sd->params.exposure.green1Comp, currentexp);
                startexp += EXP_FROM_COMP(COMP_GREEN2,
                                sd->params.exposure.green2Comp, currentexp);
                startexp += EXP_FROM_COMP(COMP_BLUE,
                                sd->params.exposure.blueComp, currentexp);
                startexp = startexp >> 2;
                while (startexp > MAX_EXP && sd->params.exposure.gain <
                       sd->params.exposure.gainMode - 1) {
                        startexp = startexp >> 1;
                        ++sd->params.exposure.gain;
                }
                if (FIRMWARE_VERSION(1, 2) && startexp > MAX_EXP_102)
                        startexp = MAX_EXP_102;
                if (startexp > MAX_EXP)
                        startexp = MAX_EXP;
                sd->params.exposure.coarseExpLo = startexp & 0xff;
                sd->params.exposure.coarseExpHi = startexp >> 8;
                sd->params.exposure.redComp = COMP_RED;
                sd->params.exposure.green1Comp = COMP_GREEN1;
                sd->params.exposure.green2Comp = COMP_GREEN2;
                sd->params.exposure.blueComp = COMP_BLUE;
                sd->params.exposure.compMode = 1;
                sd->params.apcor.gain1 = 0x18;
                sd->params.apcor.gain2 = 0x16;
                sd->params.apcor.gain4 = 0x24;
                sd->params.apcor.gain8 = 0x34;
        }
        sd->params.vlOffset.gain1 = 20;
        sd->params.vlOffset.gain2 = 24;
        sd->params.vlOffset.gain4 = 26;
        sd->params.vlOffset.gain8 = 26;

        if (apply) {
                ret = command_setexposure(gspca_dev);
                if (ret)
                        return ret;

                ret = command_setapcor(gspca_dev);
                if (ret)
                        return ret;

                ret = command_setvloffset(gspca_dev);
                if (ret)
                        return ret;

                ret = command_setflickerctrl(gspca_dev);
                if (ret)
                        return ret;
        }

        return 0;
#undef EXP_FROM_COMP
#undef COMPGAIN
}

/* monitor the exposure and adjust the sensor frame rate if needed */
static void monitor_exposure(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        u8 exp_acc, bcomp, cmd[8];
        int ret, light_exp, dark_exp, very_dark_exp;
        int old_exposure, new_exposure, framerate;
        int setfps = 0, setexp = 0, setflicker = 0;

        /* get necessary stats and register settings from camera */
        /* do_command can't handle this, so do it ourselves */
        cmd[0] = CPIA_COMMAND_ReadVPRegs >> 8;
        cmd[1] = CPIA_COMMAND_ReadVPRegs & 0xff;
        cmd[2] = 30;
        cmd[3] = 4;
        cmd[4] = 9;
        cmd[5] = 8;
        cmd[6] = 8;
        cmd[7] = 0;
        ret = cpia_usb_transferCmd(gspca_dev, cmd);
        if (ret) {
                pr_err("ReadVPRegs(30,4,9,8) - failed: %d\n", ret);
                return;
        }
        exp_acc = gspca_dev->usb_buf[0];
        bcomp = gspca_dev->usb_buf[1];

        light_exp = sd->params.colourParams.brightness +
                    TC - 50 + EXP_ACC_LIGHT;
        if (light_exp > 255)
                light_exp = 255;
        dark_exp = sd->params.colourParams.brightness +
                   TC - 50 - EXP_ACC_DARK;
        if (dark_exp < 0)
                dark_exp = 0;
        very_dark_exp = dark_exp / 2;

        old_exposure = sd->params.exposure.coarseExpHi * 256 +
                       sd->params.exposure.coarseExpLo;

        if (!sd->params.flickerControl.disabled) {
                /* Flicker control on */
                int max_comp = FIRMWARE_VERSION(1, 2) ? MAX_COMP :
                                                        HIGH_COMP_102;
                bcomp += 128;   /* decode */
                if (bcomp >= max_comp && exp_acc < dark_exp) {
                        /* dark */
                        if (exp_acc < very_dark_exp) {
                                /* very dark */
                                if (sd->exposure_status == EXPOSURE_VERY_DARK)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status =
                                                EXPOSURE_VERY_DARK;
                                        sd->exposure_count = 1;
                                }
                        } else {
                                /* just dark */
                                if (sd->exposure_status == EXPOSURE_DARK)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status = EXPOSURE_DARK;
                                        sd->exposure_count = 1;
                                }
                        }
                } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
                        /* light */
                        if (old_exposure <= VERY_LOW_EXP) {
                                /* very light */
                                if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status =
                                                EXPOSURE_VERY_LIGHT;
                                        sd->exposure_count = 1;
                                }
                        } else {
                                /* just light */
                                if (sd->exposure_status == EXPOSURE_LIGHT)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status = EXPOSURE_LIGHT;
                                        sd->exposure_count = 1;
                                }
                        }
                } else {
                        /* not dark or light */
                        sd->exposure_status = EXPOSURE_NORMAL;
                }
        } else {
                /* Flicker control off */
                if (old_exposure >= MAX_EXP && exp_acc < dark_exp) {
                        /* dark */
                        if (exp_acc < very_dark_exp) {
                                /* very dark */
                                if (sd->exposure_status == EXPOSURE_VERY_DARK)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status =
                                                EXPOSURE_VERY_DARK;
                                        sd->exposure_count = 1;
                                }
                        } else {
                                /* just dark */
                                if (sd->exposure_status == EXPOSURE_DARK)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status = EXPOSURE_DARK;
                                        sd->exposure_count = 1;
                                }
                        }
                } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
                        /* light */
                        if (old_exposure <= VERY_LOW_EXP) {
                                /* very light */
                                if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status =
                                                EXPOSURE_VERY_LIGHT;
                                        sd->exposure_count = 1;
                                }
                        } else {
                                /* just light */
                                if (sd->exposure_status == EXPOSURE_LIGHT)
                                        ++sd->exposure_count;
                                else {
                                        sd->exposure_status = EXPOSURE_LIGHT;
                                        sd->exposure_count = 1;
                                }
                        }
                } else {
                        /* not dark or light */
                        sd->exposure_status = EXPOSURE_NORMAL;
                }
        }

        framerate = atomic_read(&sd->fps);
        if (framerate > 30 || framerate < 1)
                framerate = 1;

        if (!sd->params.flickerControl.disabled) {
                /* Flicker control on */
                if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
                     sd->exposure_status == EXPOSURE_DARK) &&
                    sd->exposure_count >= DARK_TIME * framerate &&
                    sd->params.sensorFps.divisor < 2) {

                        /* dark for too long */
                        ++sd->params.sensorFps.divisor;
                        setfps = 1;

                        sd->params.flickerControl.coarseJump =
                                flicker_jumps[sd->mainsFreq]
                                             [sd->params.sensorFps.baserate]
                                             [sd->params.sensorFps.divisor];
                        setflicker = 1;

                        new_exposure = sd->params.flickerControl.coarseJump-1;
                        while (new_exposure < old_exposure / 2)
                                new_exposure +=
                                        sd->params.flickerControl.coarseJump;
                        sd->params.exposure.coarseExpLo = new_exposure & 0xff;
                        sd->params.exposure.coarseExpHi = new_exposure >> 8;
                        setexp = 1;
                        sd->exposure_status = EXPOSURE_NORMAL;
                        PDEBUG(D_CONF, "Automatically decreasing sensor_fps");

                } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
                            sd->exposure_status == EXPOSURE_LIGHT) &&
                           sd->exposure_count >= LIGHT_TIME * framerate &&
                           sd->params.sensorFps.divisor > 0) {

                        /* light for too long */
                        int max_exp = FIRMWARE_VERSION(1, 2) ? MAX_EXP_102 :
                                                               MAX_EXP;
                        --sd->params.sensorFps.divisor;
                        setfps = 1;

                        sd->params.flickerControl.coarseJump =
                                flicker_jumps[sd->mainsFreq]
                                             [sd->params.sensorFps.baserate]
                                             [sd->params.sensorFps.divisor];
                        setflicker = 1;

                        new_exposure = sd->params.flickerControl.coarseJump-1;
                        while (new_exposure < 2 * old_exposure &&
                               new_exposure +
                               sd->params.flickerControl.coarseJump < max_exp)
                                new_exposure +=
                                        sd->params.flickerControl.coarseJump;
                        sd->params.exposure.coarseExpLo = new_exposure & 0xff;
                        sd->params.exposure.coarseExpHi = new_exposure >> 8;
                        setexp = 1;
                        sd->exposure_status = EXPOSURE_NORMAL;
                        PDEBUG(D_CONF, "Automatically increasing sensor_fps");
                }
        } else {
                /* Flicker control off */
                if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
                     sd->exposure_status == EXPOSURE_DARK) &&
                    sd->exposure_count >= DARK_TIME * framerate &&
                    sd->params.sensorFps.divisor < 2) {

                        /* dark for too long */
                        ++sd->params.sensorFps.divisor;
                        setfps = 1;

                        if (sd->params.exposure.gain > 0) {
                                --sd->params.exposure.gain;
                                setexp = 1;
                        }
                        sd->exposure_status = EXPOSURE_NORMAL;
                        PDEBUG(D_CONF, "Automatically decreasing sensor_fps");

                } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
                            sd->exposure_status == EXPOSURE_LIGHT) &&
                           sd->exposure_count >= LIGHT_TIME * framerate &&
                           sd->params.sensorFps.divisor > 0) {

                        /* light for too long */
                        --sd->params.sensorFps.divisor;
                        setfps = 1;

                        if (sd->params.exposure.gain <
                            sd->params.exposure.gainMode - 1) {
                                ++sd->params.exposure.gain;
                                setexp = 1;
                        }
                        sd->exposure_status = EXPOSURE_NORMAL;
                        PDEBUG(D_CONF, "Automatically increasing sensor_fps");
                }
        }

        if (setexp)
                command_setexposure(gspca_dev);

        if (setfps)
                command_setsensorfps(gspca_dev);

        if (setflicker)
                command_setflickerctrl(gspca_dev);
}

/*-----------------------------------------------------------------*/
/* if flicker is switched off, this function switches it back on.It checks,
   however, that conditions are suitable before restarting it.
   This should only be called for firmware version 1.2.

   It also adjust the colour balance when an exposure step is detected - as
   long as flicker is running
*/
static void restart_flicker(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int cam_exposure, old_exp;

        if (!FIRMWARE_VERSION(1, 2))
                return;

        cam_exposure = atomic_read(&sd->cam_exposure);

        if (sd->params.flickerControl.flickerMode == 0 ||
            cam_exposure == 0)
                return;

        old_exp = sd->params.exposure.coarseExpLo +
                  sd->params.exposure.coarseExpHi*256;
        /*
          see how far away camera exposure is from a valid
          flicker exposure value
        */
        cam_exposure %= sd->params.flickerControl.coarseJump;
        if (!sd->params.flickerControl.disabled &&
            cam_exposure <= sd->params.flickerControl.coarseJump - 3) {
                /* Flicker control auto-disabled */
                sd->params.flickerControl.disabled = 1;
        }

        if (sd->params.flickerControl.disabled &&
            old_exp > sd->params.flickerControl.coarseJump +
                      ROUND_UP_EXP_FOR_FLICKER) {
                /* exposure is now high enough to switch
                   flicker control back on */
                set_flicker(gspca_dev, 1, 1);
        }
}

/* this function is called at probe time */
static int sd_config(struct gspca_dev *gspca_dev,
                        const struct usb_device_id *id)
{
        struct sd *sd = (struct sd *) gspca_dev;
        struct cam *cam;

        sd->mainsFreq = FREQ_DEF == V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
        reset_camera_params(gspca_dev);

        PDEBUG(D_PROBE, "cpia CPiA camera detected (vid/pid 0x%04X:0x%04X)",
               id->idVendor, id->idProduct);

        cam = &gspca_dev->cam;
        cam->cam_mode = mode;
        cam->nmodes = ARRAY_SIZE(mode);

        goto_low_power(gspca_dev);
        /* Check the firmware version. */
        sd->params.version.firmwareVersion = 0;
        get_version_information(gspca_dev);
        if (sd->params.version.firmwareVersion != 1) {
                PERR("only firmware version 1 is supported (got: %d)",
                     sd->params.version.firmwareVersion);
                return -ENODEV;
        }

        /* A bug in firmware 1-02 limits gainMode to 2 */
        if (sd->params.version.firmwareRevision <= 2 &&
            sd->params.exposure.gainMode > 2) {
                sd->params.exposure.gainMode = 2;
        }

        /* set QX3 detected flag */
        sd->params.qx3.qx3_detected = (sd->params.pnpID.vendor == 0x0813 &&
                                       sd->params.pnpID.product == 0x0001);
        return 0;
}

/* -- start the camera -- */
static int sd_start(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int priv, ret;

        /* Start the camera in low power mode */
        if (goto_low_power(gspca_dev)) {
                if (sd->params.status.systemState != WARM_BOOT_STATE) {
                        PERR("unexpected systemstate: %02x",
                             sd->params.status.systemState);
                        printstatus(gspca_dev, &sd->params);
                        return -ENODEV;
                }

                /* FIXME: this is just dirty trial and error */
                ret = goto_high_power(gspca_dev);
                if (ret)
                        return ret;

                ret = do_command(gspca_dev, CPIA_COMMAND_DiscardFrame,
                                 0, 0, 0, 0);
                if (ret)
                        return ret;

                ret = goto_low_power(gspca_dev);
                if (ret)
                        return ret;
        }

        /* procedure described in developer's guide p3-28 */

        /* Check the firmware version. */
        sd->params.version.firmwareVersion = 0;
        get_version_information(gspca_dev);

        /* The fatal error checking should be done after
         * the camera powers up (developer's guide p 3-38) */

        /* Set streamState before transition to high power to avoid bug
         * in firmware 1-02 */
        ret = do_command(gspca_dev, CPIA_COMMAND_ModifyCameraStatus,
                         STREAMSTATE, 0, STREAM_NOT_READY, 0);
        if (ret)
                return ret;

        /* GotoHiPower */
        ret = goto_high_power(gspca_dev);
        if (ret)
                return ret;

        /* Check the camera status */
        ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
        if (ret)
                return ret;

        if (sd->params.status.fatalError) {
                PERR("fatal_error: %04x, vp_status: %04x",
                     sd->params.status.fatalError, sd->params.status.vpStatus);
                return -EIO;
        }

        /* VPVersion can't be retrieved before the camera is in HiPower,
         * so get it here instead of in get_version_information. */
        ret = do_command(gspca_dev, CPIA_COMMAND_GetVPVersion, 0, 0, 0, 0);
        if (ret)
                return ret;

        /* Determine video mode settings */
        sd->params.streamStartLine = 120;

        priv = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
        if (priv & 0x01) { /* crop */
                sd->params.roi.colStart = 2;
                sd->params.roi.rowStart = 6;
        } else {
                sd->params.roi.colStart = 0;
                sd->params.roi.rowStart = 0;
        }

        if (priv & 0x02) { /* quarter */
                sd->params.format.videoSize = VIDEOSIZE_QCIF;
                sd->params.roi.colStart /= 2;
                sd->params.roi.rowStart /= 2;
                sd->params.streamStartLine /= 2;
        } else
                sd->params.format.videoSize = VIDEOSIZE_CIF;

        sd->params.roi.colEnd = sd->params.roi.colStart +
                                (gspca_dev->pixfmt.width >> 3);
        sd->params.roi.rowEnd = sd->params.roi.rowStart +
                                (gspca_dev->pixfmt.height >> 2);

        /* And now set the camera to a known state */
        ret = do_command(gspca_dev, CPIA_COMMAND_SetGrabMode,
                         CPIA_GRAB_CONTINEOUS, 0, 0, 0);
        if (ret)
                return ret;
        /* We start with compression disabled, as we need one uncompressed
           frame to handle later compressed frames */
        ret = do_command(gspca_dev, CPIA_COMMAND_SetCompression,
                         CPIA_COMPRESSION_NONE,
                         NO_DECIMATION, 0, 0);
        if (ret)
                return ret;
        ret = command_setcompressiontarget(gspca_dev);
        if (ret)
                return ret;
        ret = command_setcolourparams(gspca_dev);
        if (ret)
                return ret;
        ret = command_setformat(gspca_dev);
        if (ret)
                return ret;
        ret = command_setyuvtresh(gspca_dev);
        if (ret)
                return ret;
        ret = command_setecptiming(gspca_dev);
        if (ret)
                return ret;
        ret = command_setcompressionparams(gspca_dev);
        if (ret)
                return ret;
        ret = command_setexposure(gspca_dev);
        if (ret)
                return ret;
        ret = command_setcolourbalance(gspca_dev);
        if (ret)
                return ret;
        ret = command_setsensorfps(gspca_dev);
        if (ret)
                return ret;
        ret = command_setapcor(gspca_dev);
        if (ret)
                return ret;
        ret = command_setflickerctrl(gspca_dev);
        if (ret)
                return ret;
        ret = command_setvloffset(gspca_dev);
        if (ret)
                return ret;

        /* Start stream */
        ret = command_resume(gspca_dev);
        if (ret)
                return ret;

        /* Wait 6 frames before turning compression on for the sensor to get
           all settings and AEC/ACB to settle */
        sd->first_frame = 6;
        sd->exposure_status = EXPOSURE_NORMAL;
        sd->exposure_count = 0;
        atomic_set(&sd->cam_exposure, 0);
        atomic_set(&sd->fps, 0);

        return 0;
}

static void sd_stopN(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        command_pause(gspca_dev);

        /* save camera state for later open (developers guide ch 3.5.3) */
        save_camera_state(gspca_dev);

        /* GotoLoPower */
        goto_low_power(gspca_dev);

        /* Update the camera status */
        do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);

#if IS_ENABLED(CONFIG_INPUT)
        /* If the last button state is pressed, release it now! */
        if (sd->params.qx3.button) {
                /* The camera latch will hold the pressed state until we reset
                   the latch, so we do not reset sd->params.qx3.button now, to
                   avoid a false keypress being reported the next sd_start */
                input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
                input_sync(gspca_dev->input_dev);
        }
#endif
}

/* this function is called at probe and resume time */
static int sd_init(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;
        int ret;

        /* Start / Stop the camera to make sure we are talking to
           a supported camera, and to get some information from it
           to print. */
        ret = sd_start(gspca_dev);
        if (ret)
                return ret;

        /* Ensure the QX3 illuminators' states are restored upon resume,
           or disable the illuminator controls, if this isn't a QX3 */
        if (sd->params.qx3.qx3_detected)
                command_setlights(gspca_dev);

        sd_stopN(gspca_dev);

        PDEBUG(D_PROBE, "CPIA Version:             %d.%02d (%d.%d)",
                        sd->params.version.firmwareVersion,
                        sd->params.version.firmwareRevision,
                        sd->params.version.vcVersion,
                        sd->params.version.vcRevision);
        PDEBUG(D_PROBE, "CPIA PnP-ID:              %04x:%04x:%04x",
                        sd->params.pnpID.vendor, sd->params.pnpID.product,
                        sd->params.pnpID.deviceRevision);
        PDEBUG(D_PROBE, "VP-Version:               %d.%d %04x",
                        sd->params.vpVersion.vpVersion,
                        sd->params.vpVersion.vpRevision,
                        sd->params.vpVersion.cameraHeadID);

        return 0;
}

static void sd_pkt_scan(struct gspca_dev *gspca_dev,
                        u8 *data,
                        int len)
{
        struct sd *sd = (struct sd *) gspca_dev;

        /* Check for SOF */
        if (len >= 64 &&
            data[0] == MAGIC_0 && data[1] == MAGIC_1 &&
            data[16] == sd->params.format.videoSize &&
            data[17] == sd->params.format.subSample &&
            data[18] == sd->params.format.yuvOrder &&
            data[24] == sd->params.roi.colStart &&
            data[25] == sd->params.roi.colEnd &&
            data[26] == sd->params.roi.rowStart &&
            data[27] == sd->params.roi.rowEnd) {
                u8 *image;

                atomic_set(&sd->cam_exposure, data[39] * 2);
                atomic_set(&sd->fps, data[41]);

                /* Check for proper EOF for last frame */
                image = gspca_dev->image;
                if (image != NULL &&
                    gspca_dev->image_len > 4 &&
                    image[gspca_dev->image_len - 4] == 0xff &&
                    image[gspca_dev->image_len - 3] == 0xff &&
                    image[gspca_dev->image_len - 2] == 0xff &&
                    image[gspca_dev->image_len - 1] == 0xff)
                        gspca_frame_add(gspca_dev, LAST_PACKET,
                                                NULL, 0);

                gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
                return;
        }

        gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
}

static void sd_dq_callback(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *) gspca_dev;

        /* Set the normal compression settings once we have captured a
           few uncompressed frames (and AEC has hopefully settled) */
        if (sd->first_frame) {
                sd->first_frame--;
                if (sd->first_frame == 0)
                        command_setcompression(gspca_dev);
        }

        /* Switch flicker control back on if it got turned off */
        restart_flicker(gspca_dev);

        /* If AEC is enabled, monitor the exposure and
           adjust the sensor frame rate if needed */
        if (sd->params.exposure.expMode == 2)
                monitor_exposure(gspca_dev);

        /* Update our knowledge of the camera state */
        do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
        do_command(gspca_dev, CPIA_COMMAND_ReadMCPorts, 0, 0, 0, 0);
}

static int sd_s_ctrl(struct v4l2_ctrl *ctrl)
{
        struct gspca_dev *gspca_dev =
                container_of(ctrl->handler, struct gspca_dev, ctrl_handler);
        struct sd *sd = (struct sd *)gspca_dev;

        gspca_dev->usb_err = 0;

        if (!gspca_dev->streaming && ctrl->id != V4L2_CID_POWER_LINE_FREQUENCY)
                return 0;

        switch (ctrl->id) {
        case V4L2_CID_BRIGHTNESS:
                sd->params.colourParams.brightness = ctrl->val;
                sd->params.flickerControl.allowableOverExposure =
                        find_over_exposure(sd->params.colourParams.brightness);
                gspca_dev->usb_err = command_setcolourparams(gspca_dev);
                if (!gspca_dev->usb_err)
                        gspca_dev->usb_err = command_setflickerctrl(gspca_dev);
                break;
        case V4L2_CID_CONTRAST:
                sd->params.colourParams.contrast = ctrl->val;
                gspca_dev->usb_err = command_setcolourparams(gspca_dev);
                break;
        case V4L2_CID_SATURATION:
                sd->params.colourParams.saturation = ctrl->val;
                gspca_dev->usb_err = command_setcolourparams(gspca_dev);
                break;
        case V4L2_CID_POWER_LINE_FREQUENCY:
                sd->mainsFreq = ctrl->val == V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
                sd->params.flickerControl.coarseJump =
                        flicker_jumps[sd->mainsFreq]
                        [sd->params.sensorFps.baserate]
                        [sd->params.sensorFps.divisor];

                gspca_dev->usb_err = set_flicker(gspca_dev,
                        ctrl->val != V4L2_CID_POWER_LINE_FREQUENCY_DISABLED,
                        gspca_dev->streaming);
                break;
        case V4L2_CID_ILLUMINATORS_1:
                sd->params.qx3.bottomlight = ctrl->val;
                gspca_dev->usb_err = command_setlights(gspca_dev);
                break;
        case V4L2_CID_ILLUMINATORS_2:
                sd->params.qx3.toplight = ctrl->val;
                gspca_dev->usb_err = command_setlights(gspca_dev);
                break;
        case CPIA1_CID_COMP_TARGET:
                sd->params.compressionTarget.frTargeting = ctrl->val;
                gspca_dev->usb_err = command_setcompressiontarget(gspca_dev);
                break;
        }
        return gspca_dev->usb_err;
}

static const struct v4l2_ctrl_ops sd_ctrl_ops = {
        .s_ctrl = sd_s_ctrl,
};

static int sd_init_controls(struct gspca_dev *gspca_dev)
{
        struct sd *sd = (struct sd *)gspca_dev;
        struct v4l2_ctrl_handler *hdl = &gspca_dev->ctrl_handler;
        static const char * const comp_target_menu[] = {
                "Quality",
                "Framerate",
                NULL
        };
        static const struct v4l2_ctrl_config comp_target = {
                .ops = &sd_ctrl_ops,
                .id = CPIA1_CID_COMP_TARGET,
                .type = V4L2_CTRL_TYPE_MENU,
                .name = "Compression Target",
                .qmenu = comp_target_menu,
                .max = 1,
                .def = COMP_TARGET_DEF,
        };

        gspca_dev->vdev.ctrl_handler = hdl;
        v4l2_ctrl_handler_init(hdl, 7);
        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
                        V4L2_CID_BRIGHTNESS, 0, 100, 1, BRIGHTNESS_DEF);
        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
                        V4L2_CID_CONTRAST, 0, 96, 8, CONTRAST_DEF);
        v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
                        V4L2_CID_SATURATION, 0, 100, 1, SATURATION_DEF);
        sd->freq = v4l2_ctrl_new_std_menu(hdl, &sd_ctrl_ops,
                        V4L2_CID_POWER_LINE_FREQUENCY,
                        V4L2_CID_POWER_LINE_FREQUENCY_60HZ, 0,
                        FREQ_DEF);
        if (sd->params.qx3.qx3_detected) {
                v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
                                V4L2_CID_ILLUMINATORS_1, 0, 1, 1,
                                ILLUMINATORS_1_DEF);
                v4l2_ctrl_new_std(hdl, &sd_ctrl_ops,
                                V4L2_CID_ILLUMINATORS_2, 0, 1, 1,
                                ILLUMINATORS_2_DEF);
        }
        v4l2_ctrl_new_custom(hdl, &comp_target, NULL);

        if (hdl->error) {
                pr_err("Could not initialize controls\n");
                return hdl->error;
        }
        return 0;
}

/* sub-driver description */
static const struct sd_desc sd_desc = {
        .name = MODULE_NAME,
        .config = sd_config,
        .init = sd_init,
        .init_controls = sd_init_controls,
        .start = sd_start,
        .stopN = sd_stopN,
        .dq_callback = sd_dq_callback,
        .pkt_scan = sd_pkt_scan,
#if IS_ENABLED(CONFIG_INPUT)
        .other_input = 1,
#endif
};

/* -- module initialisation -- */
static const struct usb_device_id device_table[] = {
        {USB_DEVICE(0x0553, 0x0002)},
        {USB_DEVICE(0x0813, 0x0001)},
        {}
};
MODULE_DEVICE_TABLE(usb, device_table);

/* -- device connect -- */
static int sd_probe(struct usb_interface *intf,
                        const struct usb_device_id *id)
{
        return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
                                THIS_MODULE);
}

static struct usb_driver sd_driver = {
        .name = MODULE_NAME,
        .id_table = device_table,
        .probe = sd_probe,
        .disconnect = gspca_disconnect,
#ifdef CONFIG_PM
        .suspend = gspca_suspend,
        .resume = gspca_resume,
        .reset_resume = gspca_resume,
#endif
};

module_usb_driver(sd_driver);