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