?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'for-linus' of git://git.infradead.org/users/sameo/mfd-2.6
[linux-btrfs-devel.git] / drivers / media / video / gspca / cpia1.c
blobf2a9451eea19ba87042be32c7dd184c9d4b45016
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, 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
1288 light_exp = sd->params.colourParams.brightness +
1289 TC - 50 + EXP_ACC_LIGHT;
1290 if (light_exp > 255)
1291 light_exp = 255;
1292 dark_exp = sd->params.colourParams.brightness +
1293 TC - 50 - EXP_ACC_DARK;
1294 if (dark_exp < 0)
1295 dark_exp = 0;
1296 very_dark_exp = dark_exp / 2;
1297
1298 old_exposure = sd->params.exposure.coarseExpHi * 256 +
1299 sd->params.exposure.coarseExpLo;
1300
1301 if (!sd->params.flickerControl.disabled) {
1302 /* Flicker control on */
1303 int max_comp = FIRMWARE_VERSION(1, 2) ? MAX_COMP :
1304 HIGH_COMP_102;
1305 bcomp += 128; /* decode */
1306 if (bcomp >= max_comp && exp_acc < dark_exp) {
1307 /* dark */
1308 if (exp_acc < very_dark_exp) {
1309 /* very dark */
1310 if (sd->exposure_status == EXPOSURE_VERY_DARK)
1311 ++sd->exposure_count;
1312 else {
1313 sd->exposure_status =
1314 EXPOSURE_VERY_DARK;
1315 sd->exposure_count = 1;
1316 }
1317 } else {
1318 /* just dark */
1319 if (sd->exposure_status == EXPOSURE_DARK)
1320 ++sd->exposure_count;
1321 else {
1322 sd->exposure_status = EXPOSURE_DARK;
1323 sd->exposure_count = 1;
1324 }
1325 }
1326 } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
1327 /* light */
1328 if (old_exposure <= VERY_LOW_EXP) {
1329 /* very light */
1330 if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
1331 ++sd->exposure_count;
1332 else {
1333 sd->exposure_status =
1334 EXPOSURE_VERY_LIGHT;
1335 sd->exposure_count = 1;
1336 }
1337 } else {
1338 /* just light */
1339 if (sd->exposure_status == EXPOSURE_LIGHT)
1340 ++sd->exposure_count;
1341 else {
1342 sd->exposure_status = EXPOSURE_LIGHT;
1343 sd->exposure_count = 1;
1344 }
1345 }
1346 } else {
1347 /* not dark or light */
1348 sd->exposure_status = EXPOSURE_NORMAL;
1349 }
1350 } else {
1351 /* Flicker control off */
1352 if (old_exposure >= MAX_EXP && exp_acc < dark_exp) {
1353 /* dark */
1354 if (exp_acc < very_dark_exp) {
1355 /* very dark */
1356 if (sd->exposure_status == EXPOSURE_VERY_DARK)
1357 ++sd->exposure_count;
1358 else {
1359 sd->exposure_status =
1360 EXPOSURE_VERY_DARK;
1361 sd->exposure_count = 1;
1362 }
1363 } else {
1364 /* just dark */
1365 if (sd->exposure_status == EXPOSURE_DARK)
1366 ++sd->exposure_count;
1367 else {
1368 sd->exposure_status = EXPOSURE_DARK;
1369 sd->exposure_count = 1;
1370 }
1371 }
1372 } else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
1373 /* light */
1374 if (old_exposure <= VERY_LOW_EXP) {
1375 /* very light */
1376 if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
1377 ++sd->exposure_count;
1378 else {
1379 sd->exposure_status =
1380 EXPOSURE_VERY_LIGHT;
1381 sd->exposure_count = 1;
1382 }
1383 } else {
1384 /* just light */
1385 if (sd->exposure_status == EXPOSURE_LIGHT)
1386 ++sd->exposure_count;
1387 else {
1388 sd->exposure_status = EXPOSURE_LIGHT;
1389 sd->exposure_count = 1;
1390 }
1391 }
1392 } else {
1393 /* not dark or light */
1394 sd->exposure_status = EXPOSURE_NORMAL;
1395 }
1396 }
1397
1398 framerate = atomic_read(&sd->fps);
1399 if (framerate > 30 || framerate < 1)
1400 framerate = 1;
1401
1402 if (!sd->params.flickerControl.disabled) {
1403 /* Flicker control on */
1404 if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
1405 sd->exposure_status == EXPOSURE_DARK) &&
1406 sd->exposure_count >= DARK_TIME * framerate &&
1407 sd->params.sensorFps.divisor < 2) {
1408
1409 /* dark for too long */
1410 ++sd->params.sensorFps.divisor;
1411 setfps = 1;
1412
1413 sd->params.flickerControl.coarseJump =
1414 flicker_jumps[sd->mainsFreq]
1415 [sd->params.sensorFps.baserate]
1416 [sd->params.sensorFps.divisor];
1417 setflicker = 1;
1418
1419 new_exposure = sd->params.flickerControl.coarseJump-1;
1420 while (new_exposure < old_exposure / 2)
1421 new_exposure +=
1422 sd->params.flickerControl.coarseJump;
1423 sd->params.exposure.coarseExpLo = new_exposure & 0xff;
1424 sd->params.exposure.coarseExpHi = new_exposure >> 8;
1425 setexp = 1;
1426 sd->exposure_status = EXPOSURE_NORMAL;
1427 PDEBUG(D_CONF, "Automatically decreasing sensor_fps");
1428
1429 } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
1430 sd->exposure_status == EXPOSURE_LIGHT) &&
1431 sd->exposure_count >= LIGHT_TIME * framerate &&
1432 sd->params.sensorFps.divisor > 0) {
1433
1434 /* light for too long */
1435 int max_exp = FIRMWARE_VERSION(1, 2) ? MAX_EXP_102 :
1436 MAX_EXP;
1437 --sd->params.sensorFps.divisor;
1438 setfps = 1;
1439
1440 sd->params.flickerControl.coarseJump =
1441 flicker_jumps[sd->mainsFreq]
1442 [sd->params.sensorFps.baserate]
1443 [sd->params.sensorFps.divisor];
1444 setflicker = 1;
1445
1446 new_exposure = sd->params.flickerControl.coarseJump-1;
1447 while (new_exposure < 2 * old_exposure &&
1448 new_exposure +
1449 sd->params.flickerControl.coarseJump < max_exp)
1450 new_exposure +=
1451 sd->params.flickerControl.coarseJump;
1452 sd->params.exposure.coarseExpLo = new_exposure & 0xff;
1453 sd->params.exposure.coarseExpHi = new_exposure >> 8;
1454 setexp = 1;
1455 sd->exposure_status = EXPOSURE_NORMAL;
1456 PDEBUG(D_CONF, "Automatically increasing sensor_fps");
1457 }
1458 } else {
1459 /* Flicker control off */
1460 if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
1461 sd->exposure_status == EXPOSURE_DARK) &&
1462 sd->exposure_count >= DARK_TIME * framerate &&
1463 sd->params.sensorFps.divisor < 2) {
1464
1465 /* dark for too long */
1466 ++sd->params.sensorFps.divisor;
1467 setfps = 1;
1468
1469 if (sd->params.exposure.gain > 0) {
1470 --sd->params.exposure.gain;
1471 setexp = 1;
1472 }
1473 sd->exposure_status = EXPOSURE_NORMAL;
1474 PDEBUG(D_CONF, "Automatically decreasing sensor_fps");
1475
1476 } else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
1477 sd->exposure_status == EXPOSURE_LIGHT) &&
1478 sd->exposure_count >= LIGHT_TIME * framerate &&
1479 sd->params.sensorFps.divisor > 0) {
1480
1481 /* light for too long */
1482 --sd->params.sensorFps.divisor;
1483 setfps = 1;
1484
1485 if (sd->params.exposure.gain <
1486 sd->params.exposure.gainMode - 1) {
1487 ++sd->params.exposure.gain;
1488 setexp = 1;
1489 }
1490 sd->exposure_status = EXPOSURE_NORMAL;
1491 PDEBUG(D_CONF, "Automatically increasing sensor_fps");
1492 }
1493 }
1494
1495 if (setexp)
1496 command_setexposure(gspca_dev);
1497
1498 if (setfps)
1499 command_setsensorfps(gspca_dev);
1500
1501 if (setflicker)
1502 command_setflickerctrl(gspca_dev);
1503 }
1504
1505 /*-----------------------------------------------------------------*/
1506 /* if flicker is switched off, this function switches it back on.It checks,
1507 however, that conditions are suitable before restarting it.
1508 This should only be called for firmware version 1.2.
1509
1510 It also adjust the colour balance when an exposure step is detected - as
1511 long as flicker is running
1512 */
1513 static void restart_flicker(struct gspca_dev *gspca_dev)
1514 {
1515 struct sd *sd = (struct sd *) gspca_dev;
1516 int cam_exposure, old_exp;
1517
1518 if (!FIRMWARE_VERSION(1, 2))
1519 return;
1520
1521 cam_exposure = atomic_read(&sd->cam_exposure);
1522
1523 if (sd->params.flickerControl.flickerMode == 0 ||
1524 cam_exposure == 0)
1525 return;
1526
1527 old_exp = sd->params.exposure.coarseExpLo +
1528 sd->params.exposure.coarseExpHi*256;
1529 /*
1530 see how far away camera exposure is from a valid
1531 flicker exposure value
1532 */
1533 cam_exposure %= sd->params.flickerControl.coarseJump;
1534 if (!sd->params.flickerControl.disabled &&
1535 cam_exposure <= sd->params.flickerControl.coarseJump - 3) {
1536 /* Flicker control auto-disabled */
1537 sd->params.flickerControl.disabled = 1;
1538 }
1539
1540 if (sd->params.flickerControl.disabled &&
1541 old_exp > sd->params.flickerControl.coarseJump +
1542 ROUND_UP_EXP_FOR_FLICKER) {
1543 /* exposure is now high enough to switch
1544 flicker control back on */
1545 set_flicker(gspca_dev, 1, 1);
1546 }
1547 }
1548
1549 /* this function is called at probe time */
1550 static int sd_config(struct gspca_dev *gspca_dev,
1551 const struct usb_device_id *id)
1552 {
1553 struct cam *cam;
1554
1555 reset_camera_params(gspca_dev);
1556
1557 PDEBUG(D_PROBE, "cpia CPiA camera detected (vid/pid 0x%04X:0x%04X)",
1558 id->idVendor, id->idProduct);
1559
1560 cam = &gspca_dev->cam;
1561 cam->cam_mode = mode;
1562 cam->nmodes = ARRAY_SIZE(mode);
1563
1564 sd_setfreq(gspca_dev, FREQ_DEF);
1565
1566 return 0;
1567 }
1568
1569 /* -- start the camera -- */
1570 static int sd_start(struct gspca_dev *gspca_dev)
1571 {
1572 struct sd *sd = (struct sd *) gspca_dev;
1573 int priv, ret;
1574
1575 /* Start the camera in low power mode */
1576 if (goto_low_power(gspca_dev)) {
1577 if (sd->params.status.systemState != WARM_BOOT_STATE) {
1578 PDEBUG(D_ERR, "unexpected systemstate: %02x",
1579 sd->params.status.systemState);
1580 printstatus(&sd->params);
1581 return -ENODEV;
1582 }
1583
1584 /* FIXME: this is just dirty trial and error */
1585 ret = goto_high_power(gspca_dev);
1586 if (ret)
1587 return ret;
1588
1589 ret = do_command(gspca_dev, CPIA_COMMAND_DiscardFrame,
1590 0, 0, 0, 0);
1591 if (ret)
1592 return ret;
1593
1594 ret = goto_low_power(gspca_dev);
1595 if (ret)
1596 return ret;
1597 }
1598
1599 /* procedure described in developer's guide p3-28 */
1600
1601 /* Check the firmware version. */
1602 sd->params.version.firmwareVersion = 0;
1603 get_version_information(gspca_dev);
1604 if (sd->params.version.firmwareVersion != 1) {
1605 PDEBUG(D_ERR, "only firmware version 1 is supported (got: %d)",
1606 sd->params.version.firmwareVersion);
1607 return -ENODEV;
1608 }
1609
1610 /* A bug in firmware 1-02 limits gainMode to 2 */
1611 if (sd->params.version.firmwareRevision <= 2 &&
1612 sd->params.exposure.gainMode > 2) {
1613 sd->params.exposure.gainMode = 2;
1614 }
1615
1616 /* set QX3 detected flag */
1617 sd->params.qx3.qx3_detected = (sd->params.pnpID.vendor == 0x0813 &&
1618 sd->params.pnpID.product == 0x0001);
1619
1620 /* The fatal error checking should be done after
1621 * the camera powers up (developer's guide p 3-38) */
1622
1623 /* Set streamState before transition to high power to avoid bug
1624 * in firmware 1-02 */
1625 ret = do_command(gspca_dev, CPIA_COMMAND_ModifyCameraStatus,
1626 STREAMSTATE, 0, STREAM_NOT_READY, 0);
1627 if (ret)
1628 return ret;
1629
1630 /* GotoHiPower */
1631 ret = goto_high_power(gspca_dev);
1632 if (ret)
1633 return ret;
1634
1635 /* Check the camera status */
1636 ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
1637 if (ret)
1638 return ret;
1639
1640 if (sd->params.status.fatalError) {
1641 PDEBUG(D_ERR, "fatal_error: %04x, vp_status: %04x",
1642 sd->params.status.fatalError,
1643 sd->params.status.vpStatus);
1644 return -EIO;
1645 }
1646
1647 /* VPVersion can't be retrieved before the camera is in HiPower,
1648 * so get it here instead of in get_version_information. */
1649 ret = do_command(gspca_dev, CPIA_COMMAND_GetVPVersion, 0, 0, 0, 0);
1650 if (ret)
1651 return ret;
1652
1653 /* Determine video mode settings */
1654 sd->params.streamStartLine = 120;
1655
1656 priv = gspca_dev->cam.cam_mode[gspca_dev->curr_mode].priv;
1657 if (priv & 0x01) { /* crop */
1658 sd->params.roi.colStart = 2;
1659 sd->params.roi.rowStart = 6;
1660 } else {
1661 sd->params.roi.colStart = 0;
1662 sd->params.roi.rowStart = 0;
1663 }
1664
1665 if (priv & 0x02) { /* quarter */
1666 sd->params.format.videoSize = VIDEOSIZE_QCIF;
1667 sd->params.roi.colStart /= 2;
1668 sd->params.roi.rowStart /= 2;
1669 sd->params.streamStartLine /= 2;
1670 } else
1671 sd->params.format.videoSize = VIDEOSIZE_CIF;
1672
1673 sd->params.roi.colEnd = sd->params.roi.colStart +
1674 (gspca_dev->width >> 3);
1675 sd->params.roi.rowEnd = sd->params.roi.rowStart +
1676 (gspca_dev->height >> 2);
1677
1678 /* And now set the camera to a known state */
1679 ret = do_command(gspca_dev, CPIA_COMMAND_SetGrabMode,
1680 CPIA_GRAB_CONTINEOUS, 0, 0, 0);
1681 if (ret)
1682 return ret;
1683 /* We start with compression disabled, as we need one uncompressed
1684 frame to handle later compressed frames */
1685 ret = do_command(gspca_dev, CPIA_COMMAND_SetCompression,
1686 CPIA_COMPRESSION_NONE,
1687 NO_DECIMATION, 0, 0);
1688 if (ret)
1689 return ret;
1690 ret = command_setcompressiontarget(gspca_dev);
1691 if (ret)
1692 return ret;
1693 ret = command_setcolourparams(gspca_dev);
1694 if (ret)
1695 return ret;
1696 ret = command_setformat(gspca_dev);
1697 if (ret)
1698 return ret;
1699 ret = command_setyuvtresh(gspca_dev);
1700 if (ret)
1701 return ret;
1702 ret = command_setecptiming(gspca_dev);
1703 if (ret)
1704 return ret;
1705 ret = command_setcompressionparams(gspca_dev);
1706 if (ret)
1707 return ret;
1708 ret = command_setexposure(gspca_dev);
1709 if (ret)
1710 return ret;
1711 ret = command_setcolourbalance(gspca_dev);
1712 if (ret)
1713 return ret;
1714 ret = command_setsensorfps(gspca_dev);
1715 if (ret)
1716 return ret;
1717 ret = command_setapcor(gspca_dev);
1718 if (ret)
1719 return ret;
1720 ret = command_setflickerctrl(gspca_dev);
1721 if (ret)
1722 return ret;
1723 ret = command_setvloffset(gspca_dev);
1724 if (ret)
1725 return ret;
1726
1727 /* Start stream */
1728 ret = command_resume(gspca_dev);
1729 if (ret)
1730 return ret;
1731
1732 /* Wait 6 frames before turning compression on for the sensor to get
1733 all settings and AEC/ACB to settle */
1734 sd->first_frame = 6;
1735 sd->exposure_status = EXPOSURE_NORMAL;
1736 sd->exposure_count = 0;
1737 atomic_set(&sd->cam_exposure, 0);
1738 atomic_set(&sd->fps, 0);
1739
1740 return 0;
1741 }
1742
1743 static void sd_stopN(struct gspca_dev *gspca_dev)
1744 {
1745 struct sd *sd = (struct sd *) gspca_dev;
1746
1747 command_pause(gspca_dev);
1748
1749 /* save camera state for later open (developers guide ch 3.5.3) */
1750 save_camera_state(gspca_dev);
1751
1752 /* GotoLoPower */
1753 goto_low_power(gspca_dev);
1754
1755 /* Update the camera status */
1756 do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
1757
1758 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
1759 /* If the last button state is pressed, release it now! */
1760 if (sd->params.qx3.button) {
1761 /* The camera latch will hold the pressed state until we reset
1762 the latch, so we do not reset sd->params.qx3.button now, to
1763 avoid a false keypress being reported the next sd_start */
1764 input_report_key(gspca_dev->input_dev, KEY_CAMERA, 0);
1765 input_sync(gspca_dev->input_dev);
1766 }
1767 #endif
1768 }
1769
1770 /* this function is called at probe and resume time */
1771 static int sd_init(struct gspca_dev *gspca_dev)
1772 {
1773 struct sd *sd = (struct sd *) gspca_dev;
1774 int ret;
1775
1776 /* Start / Stop the camera to make sure we are talking to
1777 a supported camera, and to get some information from it
1778 to print. */
1779 ret = sd_start(gspca_dev);
1780 if (ret)
1781 return ret;
1782
1783 /* Ensure the QX3 illuminators' states are restored upon resume,
1784 or disable the illuminator controls, if this isn't a QX3 */
1785 if (sd->params.qx3.qx3_detected)
1786 command_setlights(gspca_dev);
1787 else
1788 gspca_dev->ctrl_dis |=
1789 ((1 << ILLUMINATORS_1_IDX) | (1 << ILLUMINATORS_2_IDX));
1790
1791 sd_stopN(gspca_dev);
1792
1793 PDEBUG(D_PROBE, "CPIA Version: %d.%02d (%d.%d)",
1794 sd->params.version.firmwareVersion,
1795 sd->params.version.firmwareRevision,
1796 sd->params.version.vcVersion,
1797 sd->params.version.vcRevision);
1798 PDEBUG(D_PROBE, "CPIA PnP-ID: %04x:%04x:%04x",
1799 sd->params.pnpID.vendor, sd->params.pnpID.product,
1800 sd->params.pnpID.deviceRevision);
1801 PDEBUG(D_PROBE, "VP-Version: %d.%d %04x",
1802 sd->params.vpVersion.vpVersion,
1803 sd->params.vpVersion.vpRevision,
1804 sd->params.vpVersion.cameraHeadID);
1805
1806 return 0;
1807 }
1808
1809 static void sd_pkt_scan(struct gspca_dev *gspca_dev,
1810 u8 *data,
1811 int len)
1812 {
1813 struct sd *sd = (struct sd *) gspca_dev;
1814
1815 /* Check for SOF */
1816 if (len >= 64 &&
1817 data[0] == MAGIC_0 && data[1] == MAGIC_1 &&
1818 data[16] == sd->params.format.videoSize &&
1819 data[17] == sd->params.format.subSample &&
1820 data[18] == sd->params.format.yuvOrder &&
1821 data[24] == sd->params.roi.colStart &&
1822 data[25] == sd->params.roi.colEnd &&
1823 data[26] == sd->params.roi.rowStart &&
1824 data[27] == sd->params.roi.rowEnd) {
1825 u8 *image;
1826
1827 atomic_set(&sd->cam_exposure, data[39] * 2);
1828 atomic_set(&sd->fps, data[41]);
1829
1830 /* Check for proper EOF for last frame */
1831 image = gspca_dev->image;
1832 if (image != NULL &&
1833 gspca_dev->image_len > 4 &&
1834 image[gspca_dev->image_len - 4] == 0xff &&
1835 image[gspca_dev->image_len - 3] == 0xff &&
1836 image[gspca_dev->image_len - 2] == 0xff &&
1837 image[gspca_dev->image_len - 1] == 0xff)
1838 gspca_frame_add(gspca_dev, LAST_PACKET,
1839 NULL, 0);
1840
1841 gspca_frame_add(gspca_dev, FIRST_PACKET, data, len);
1842 return;
1843 }
1844
1845 gspca_frame_add(gspca_dev, INTER_PACKET, data, len);
1846 }
1847
1848 static void sd_dq_callback(struct gspca_dev *gspca_dev)
1849 {
1850 struct sd *sd = (struct sd *) gspca_dev;
1851
1852 /* Set the normal compression settings once we have captured a
1853 few uncompressed frames (and AEC has hopefully settled) */
1854 if (sd->first_frame) {
1855 sd->first_frame--;
1856 if (sd->first_frame == 0)
1857 command_setcompression(gspca_dev);
1858 }
1859
1860 /* Switch flicker control back on if it got turned off */
1861 restart_flicker(gspca_dev);
1862
1863 /* If AEC is enabled, monitor the exposure and
1864 adjust the sensor frame rate if needed */
1865 if (sd->params.exposure.expMode == 2)
1866 monitor_exposure(gspca_dev);
1867
1868 /* Update our knowledge of the camera state */
1869 do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
1870 do_command(gspca_dev, CPIA_COMMAND_ReadMCPorts, 0, 0, 0, 0);
1871 }
1872
1873 static int sd_setbrightness(struct gspca_dev *gspca_dev, __s32 val)
1874 {
1875 struct sd *sd = (struct sd *) gspca_dev;
1876 int ret;
1877
1878 sd->params.colourParams.brightness = val;
1879 sd->params.flickerControl.allowableOverExposure =
1880 find_over_exposure(sd->params.colourParams.brightness);
1881 if (gspca_dev->streaming) {
1882 ret = command_setcolourparams(gspca_dev);
1883 if (ret)
1884 return ret;
1885 return command_setflickerctrl(gspca_dev);
1886 }
1887 return 0;
1888 }
1889
1890 static int sd_getbrightness(struct gspca_dev *gspca_dev, __s32 *val)
1891 {
1892 struct sd *sd = (struct sd *) gspca_dev;
1893
1894 *val = sd->params.colourParams.brightness;
1895 return 0;
1896 }
1897
1898 static int sd_setcontrast(struct gspca_dev *gspca_dev, __s32 val)
1899 {
1900 struct sd *sd = (struct sd *) gspca_dev;
1901
1902 sd->params.colourParams.contrast = val;
1903 if (gspca_dev->streaming)
1904 return command_setcolourparams(gspca_dev);
1905
1906 return 0;
1907 }
1908
1909 static int sd_getcontrast(struct gspca_dev *gspca_dev, __s32 *val)
1910 {
1911 struct sd *sd = (struct sd *) gspca_dev;
1912
1913 *val = sd->params.colourParams.contrast;
1914 return 0;
1915 }
1916
1917 static int sd_setsaturation(struct gspca_dev *gspca_dev, __s32 val)
1918 {
1919 struct sd *sd = (struct sd *) gspca_dev;
1920
1921 sd->params.colourParams.saturation = val;
1922 if (gspca_dev->streaming)
1923 return command_setcolourparams(gspca_dev);
1924
1925 return 0;
1926 }
1927
1928 static int sd_getsaturation(struct gspca_dev *gspca_dev, __s32 *val)
1929 {
1930 struct sd *sd = (struct sd *) gspca_dev;
1931
1932 *val = sd->params.colourParams.saturation;
1933 return 0;
1934 }
1935
1936 static int sd_setfreq(struct gspca_dev *gspca_dev, __s32 val)
1937 {
1938 struct sd *sd = (struct sd *) gspca_dev;
1939 int on;
1940
1941 switch (val) {
1942 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
1943 on = 0;
1944 break;
1945 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
1946 on = 1;
1947 sd->mainsFreq = 0;
1948 break;
1949 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
1950 on = 1;
1951 sd->mainsFreq = 1;
1952 break;
1953 default:
1954 return -EINVAL;
1955 }
1956
1957 sd->freq = val;
1958 sd->params.flickerControl.coarseJump =
1959 flicker_jumps[sd->mainsFreq]
1960 [sd->params.sensorFps.baserate]
1961 [sd->params.sensorFps.divisor];
1962
1963 return set_flicker(gspca_dev, on, gspca_dev->streaming);
1964 }
1965
1966 static int sd_getfreq(struct gspca_dev *gspca_dev, __s32 *val)
1967 {
1968 struct sd *sd = (struct sd *) gspca_dev;
1969
1970 *val = sd->freq;
1971 return 0;
1972 }
1973
1974 static int sd_setcomptarget(struct gspca_dev *gspca_dev, __s32 val)
1975 {
1976 struct sd *sd = (struct sd *) gspca_dev;
1977
1978 sd->params.compressionTarget.frTargeting = val;
1979 if (gspca_dev->streaming)
1980 return command_setcompressiontarget(gspca_dev);
1981
1982 return 0;
1983 }
1984
1985 static int sd_getcomptarget(struct gspca_dev *gspca_dev, __s32 *val)
1986 {
1987 struct sd *sd = (struct sd *) gspca_dev;
1988
1989 *val = sd->params.compressionTarget.frTargeting;
1990 return 0;
1991 }
1992
1993 static int sd_setilluminator(struct gspca_dev *gspca_dev, __s32 val, int n)
1994 {
1995 struct sd *sd = (struct sd *) gspca_dev;
1996 int ret;
1997
1998 if (!sd->params.qx3.qx3_detected)
1999 return -EINVAL;
2000
2001 switch (n) {
2002 case 1:
2003 sd->params.qx3.bottomlight = val ? 1 : 0;
2004 break;
2005 case 2:
2006 sd->params.qx3.toplight = val ? 1 : 0;
2007 break;
2008 default:
2009 return -EINVAL;
2010 }
2011
2012 ret = command_setlights(gspca_dev);
2013 if (ret && ret != -EINVAL)
2014 ret = -EBUSY;
2015
2016 return ret;
2017 }
2018
2019 static int sd_setilluminator1(struct gspca_dev *gspca_dev, __s32 val)
2020 {
2021 return sd_setilluminator(gspca_dev, val, 1);
2022 }
2023
2024 static int sd_setilluminator2(struct gspca_dev *gspca_dev, __s32 val)
2025 {
2026 return sd_setilluminator(gspca_dev, val, 2);
2027 }
2028
2029 static int sd_getilluminator(struct gspca_dev *gspca_dev, __s32 *val, int n)
2030 {
2031 struct sd *sd = (struct sd *) gspca_dev;
2032
2033 if (!sd->params.qx3.qx3_detected)
2034 return -EINVAL;
2035
2036 switch (n) {
2037 case 1:
2038 *val = sd->params.qx3.bottomlight;
2039 break;
2040 case 2:
2041 *val = sd->params.qx3.toplight;
2042 break;
2043 default:
2044 return -EINVAL;
2045 }
2046 return 0;
2047 }
2048
2049 static int sd_getilluminator1(struct gspca_dev *gspca_dev, __s32 *val)
2050 {
2051 return sd_getilluminator(gspca_dev, val, 1);
2052 }
2053
2054 static int sd_getilluminator2(struct gspca_dev *gspca_dev, __s32 *val)
2055 {
2056 return sd_getilluminator(gspca_dev, val, 2);
2057 }
2058
2059 static int sd_querymenu(struct gspca_dev *gspca_dev,
2060 struct v4l2_querymenu *menu)
2061 {
2062 switch (menu->id) {
2063 case V4L2_CID_POWER_LINE_FREQUENCY:
2064 switch (menu->index) {
2065 case 0: /* V4L2_CID_POWER_LINE_FREQUENCY_DISABLED */
2066 strcpy((char *) menu->name, "NoFliker");
2067 return 0;
2068 case 1: /* V4L2_CID_POWER_LINE_FREQUENCY_50HZ */
2069 strcpy((char *) menu->name, "50 Hz");
2070 return 0;
2071 case 2: /* V4L2_CID_POWER_LINE_FREQUENCY_60HZ */
2072 strcpy((char *) menu->name, "60 Hz");
2073 return 0;
2074 }
2075 break;
2076 case V4L2_CID_COMP_TARGET:
2077 switch (menu->index) {
2078 case CPIA_COMPRESSION_TARGET_QUALITY:
2079 strcpy((char *) menu->name, "Quality");
2080 return 0;
2081 case CPIA_COMPRESSION_TARGET_FRAMERATE:
2082 strcpy((char *) menu->name, "Framerate");
2083 return 0;
2084 }
2085 break;
2086 }
2087 return -EINVAL;
2088 }
2089
2090 /* sub-driver description */
2091 static const struct sd_desc sd_desc = {
2092 .name = MODULE_NAME,
2093 .ctrls = sd_ctrls,
2094 .nctrls = ARRAY_SIZE(sd_ctrls),
2095 .config = sd_config,
2096 .init = sd_init,
2097 .start = sd_start,
2098 .stopN = sd_stopN,
2099 .dq_callback = sd_dq_callback,
2100 .pkt_scan = sd_pkt_scan,
2101 .querymenu = sd_querymenu,
2102 #if defined(CONFIG_INPUT) || defined(CONFIG_INPUT_MODULE)
2103 .other_input = 1,
2104 #endif
2105 };
2106
2107 /* -- module initialisation -- */
2108 static const struct usb_device_id device_table[] = {
2109 {USB_DEVICE(0x0553, 0x0002)},
2110 {USB_DEVICE(0x0813, 0x0001)},
2111 {}
2112 };
2113 MODULE_DEVICE_TABLE(usb, device_table);
2114
2115 /* -- device connect -- */
2116 static int sd_probe(struct usb_interface *intf,
2117 const struct usb_device_id *id)
2118 {
2119 return gspca_dev_probe(intf, id, &sd_desc, sizeof(struct sd),
2120 THIS_MODULE);
2121 }
2122
2123 static struct usb_driver sd_driver = {
2124 .name = MODULE_NAME,
2125 .id_table = device_table,
2126 .probe = sd_probe,
2127 .disconnect = gspca_disconnect,
2128 #ifdef CONFIG_PM
2129 .suspend = gspca_suspend,
2130 .resume = gspca_resume,
2131 #endif
2132 };
2133
2134 /* -- module insert / remove -- */
2135 static int __init sd_mod_init(void)
2136 {
2137 return usb_register(&sd_driver);
2138 }
2139 static void __exit sd_mod_exit(void)
2140 {
2141 usb_deregister(&sd_driver);
2142 }
2143
2144 module_init(sd_mod_init);
2145 module_exit(sd_mod_exit);
Linux Btrfs Development