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