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