Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
cpia1.c
Go to the documentation of this file.
1 /*
2  * cpia CPiA (1) gspca driver
3  *
4  * Copyright (C) 2010-2011 Hans de Goede <[email protected]>
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 <[email protected]>
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 <[email protected]>");
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  ret = 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);
Generated on Thu Jan 10 2013 13:51:42 for Linux Kernel by   doxygen 1.8.2