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