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