xref: /openbmc/linux/drivers/media/usb/gspca/cpia1.c (revision e2d7149b) 
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 #include <linux/bitops.h>
22 
23 #include "gspca.h"
24 
25 MODULE_AUTHOR("Hans de Goede <hdegoede@redhat.com>");
26 MODULE_DESCRIPTION("Vision CPiA");
27 MODULE_LICENSE("GPL");
28 
29 /* constant value's */
30 #define MAGIC_0		0x19
31 #define MAGIC_1		0x68
32 #define DATA_IN		0xc0
33 #define DATA_OUT	0x40
34 #define VIDEOSIZE_QCIF	0	/* 176x144 */
35 #define VIDEOSIZE_CIF	1	/* 352x288 */
36 #define SUBSAMPLE_420	0
37 #define SUBSAMPLE_422	1
38 #define YUVORDER_YUYV	0
39 #define YUVORDER_UYVY	1
40 #define NOT_COMPRESSED	0
41 #define COMPRESSED	1
42 #define NO_DECIMATION	0
43 #define DECIMATION_ENAB	1
44 #define EOI		0xff	/* End Of Image */
45 #define EOL		0xfd	/* End Of Line */
46 #define FRAME_HEADER_SIZE	64
47 
48 /* Image grab modes */
49 #define CPIA_GRAB_SINGLE	0
50 #define CPIA_GRAB_CONTINEOUS	1
51 
52 /* Compression parameters */
53 #define CPIA_COMPRESSION_NONE	0
54 #define CPIA_COMPRESSION_AUTO	1
55 #define CPIA_COMPRESSION_MANUAL	2
56 #define CPIA_COMPRESSION_TARGET_QUALITY         0
57 #define CPIA_COMPRESSION_TARGET_FRAMERATE       1
58 
59 /* Return offsets for GetCameraState */
60 #define SYSTEMSTATE	0
61 #define GRABSTATE	1
62 #define STREAMSTATE	2
63 #define FATALERROR	3
64 #define CMDERROR	4
65 #define DEBUGFLAGS	5
66 #define VPSTATUS	6
67 #define ERRORCODE	7
68 
69 /* SystemState */
70 #define UNINITIALISED_STATE	0
71 #define PASS_THROUGH_STATE	1
72 #define LO_POWER_STATE		2
73 #define HI_POWER_STATE		3
74 #define WARM_BOOT_STATE		4
75 
76 /* GrabState */
77 #define GRAB_IDLE		0
78 #define GRAB_ACTIVE		1
79 #define GRAB_DONE		2
80 
81 /* StreamState */
82 #define STREAM_NOT_READY	0
83 #define STREAM_READY		1
84 #define STREAM_OPEN		2
85 #define STREAM_PAUSED		3
86 #define STREAM_FINISHED		4
87 
88 /* Fatal Error, CmdError, and DebugFlags */
89 #define CPIA_FLAG	  1
90 #define SYSTEM_FLAG	  2
91 #define INT_CTRL_FLAG	  4
92 #define PROCESS_FLAG	  8
93 #define COM_FLAG	 16
94 #define VP_CTRL_FLAG	 32
95 #define CAPTURE_FLAG	 64
96 #define DEBUG_FLAG	128
97 
98 /* VPStatus */
99 #define VP_STATE_OK			0x00
100 
101 #define VP_STATE_FAILED_VIDEOINIT	0x01
102 #define VP_STATE_FAILED_AECACBINIT	0x02
103 #define VP_STATE_AEC_MAX		0x04
104 #define VP_STATE_ACB_BMAX		0x08
105 
106 #define VP_STATE_ACB_RMIN		0x10
107 #define VP_STATE_ACB_GMIN		0x20
108 #define VP_STATE_ACB_RMAX		0x40
109 #define VP_STATE_ACB_GMAX		0x80
110 
111 /* default (minimum) compensation values */
112 #define COMP_RED        220
113 #define COMP_GREEN1     214
114 #define COMP_GREEN2     COMP_GREEN1
115 #define COMP_BLUE       230
116 
117 /* exposure status */
118 #define EXPOSURE_VERY_LIGHT 0
119 #define EXPOSURE_LIGHT      1
120 #define EXPOSURE_NORMAL     2
121 #define EXPOSURE_DARK       3
122 #define EXPOSURE_VERY_DARK  4
123 
124 #define CPIA_MODULE_CPIA			(0 << 5)
125 #define CPIA_MODULE_SYSTEM			(1 << 5)
126 #define CPIA_MODULE_VP_CTRL			(5 << 5)
127 #define CPIA_MODULE_CAPTURE			(6 << 5)
128 #define CPIA_MODULE_DEBUG			(7 << 5)
129 
130 #define INPUT (DATA_IN << 8)
131 #define OUTPUT (DATA_OUT << 8)
132 
133 #define CPIA_COMMAND_GetCPIAVersion	(INPUT | CPIA_MODULE_CPIA | 1)
134 #define CPIA_COMMAND_GetPnPID		(INPUT | CPIA_MODULE_CPIA | 2)
135 #define CPIA_COMMAND_GetCameraStatus	(INPUT | CPIA_MODULE_CPIA | 3)
136 #define CPIA_COMMAND_GotoHiPower	(OUTPUT | CPIA_MODULE_CPIA | 4)
137 #define CPIA_COMMAND_GotoLoPower	(OUTPUT | CPIA_MODULE_CPIA | 5)
138 #define CPIA_COMMAND_GotoSuspend	(OUTPUT | CPIA_MODULE_CPIA | 7)
139 #define CPIA_COMMAND_GotoPassThrough	(OUTPUT | CPIA_MODULE_CPIA | 8)
140 #define CPIA_COMMAND_ModifyCameraStatus	(OUTPUT | CPIA_MODULE_CPIA | 10)
141 
142 #define CPIA_COMMAND_ReadVCRegs		(INPUT | CPIA_MODULE_SYSTEM | 1)
143 #define CPIA_COMMAND_WriteVCReg		(OUTPUT | CPIA_MODULE_SYSTEM | 2)
144 #define CPIA_COMMAND_ReadMCPorts	(INPUT | CPIA_MODULE_SYSTEM | 3)
145 #define CPIA_COMMAND_WriteMCPort	(OUTPUT | CPIA_MODULE_SYSTEM | 4)
146 #define CPIA_COMMAND_SetBaudRate	(OUTPUT | CPIA_MODULE_SYSTEM | 5)
147 #define CPIA_COMMAND_SetECPTiming	(OUTPUT | CPIA_MODULE_SYSTEM | 6)
148 #define CPIA_COMMAND_ReadIDATA		(INPUT | CPIA_MODULE_SYSTEM | 7)
149 #define CPIA_COMMAND_WriteIDATA		(OUTPUT | CPIA_MODULE_SYSTEM | 8)
150 #define CPIA_COMMAND_GenericCall	(OUTPUT | CPIA_MODULE_SYSTEM | 9)
151 #define CPIA_COMMAND_I2CStart		(OUTPUT | CPIA_MODULE_SYSTEM | 10)
152 #define CPIA_COMMAND_I2CStop		(OUTPUT | CPIA_MODULE_SYSTEM | 11)
153 #define CPIA_COMMAND_I2CWrite		(OUTPUT | CPIA_MODULE_SYSTEM | 12)
154 #define CPIA_COMMAND_I2CRead		(INPUT | CPIA_MODULE_SYSTEM | 13)
155 
156 #define CPIA_COMMAND_GetVPVersion	(INPUT | CPIA_MODULE_VP_CTRL | 1)
157 #define CPIA_COMMAND_ResetFrameCounter	(INPUT | CPIA_MODULE_VP_CTRL | 2)
158 #define CPIA_COMMAND_SetColourParams	(OUTPUT | CPIA_MODULE_VP_CTRL | 3)
159 #define CPIA_COMMAND_SetExposure	(OUTPUT | CPIA_MODULE_VP_CTRL | 4)
160 #define CPIA_COMMAND_SetColourBalance	(OUTPUT | CPIA_MODULE_VP_CTRL | 6)
161 #define CPIA_COMMAND_SetSensorFPS	(OUTPUT | CPIA_MODULE_VP_CTRL | 7)
162 #define CPIA_COMMAND_SetVPDefaults	(OUTPUT | CPIA_MODULE_VP_CTRL | 8)
163 #define CPIA_COMMAND_SetApcor		(OUTPUT | CPIA_MODULE_VP_CTRL | 9)
164 #define CPIA_COMMAND_SetFlickerCtrl	(OUTPUT | CPIA_MODULE_VP_CTRL | 10)
165 #define CPIA_COMMAND_SetVLOffset	(OUTPUT | CPIA_MODULE_VP_CTRL | 11)
166 #define CPIA_COMMAND_GetColourParams	(INPUT | CPIA_MODULE_VP_CTRL | 16)
167 #define CPIA_COMMAND_GetColourBalance	(INPUT | CPIA_MODULE_VP_CTRL | 17)
168 #define CPIA_COMMAND_GetExposure	(INPUT | CPIA_MODULE_VP_CTRL | 18)
169 #define CPIA_COMMAND_SetSensorMatrix	(OUTPUT | CPIA_MODULE_VP_CTRL | 19)
170 #define CPIA_COMMAND_ColourBars		(OUTPUT | CPIA_MODULE_VP_CTRL | 25)
171 #define CPIA_COMMAND_ReadVPRegs		(INPUT | CPIA_MODULE_VP_CTRL | 30)
172 #define CPIA_COMMAND_WriteVPReg		(OUTPUT | CPIA_MODULE_VP_CTRL | 31)
173 
174 #define CPIA_COMMAND_GrabFrame		(OUTPUT | CPIA_MODULE_CAPTURE | 1)
175 #define CPIA_COMMAND_UploadFrame	(OUTPUT | CPIA_MODULE_CAPTURE | 2)
176 #define CPIA_COMMAND_SetGrabMode	(OUTPUT | CPIA_MODULE_CAPTURE | 3)
177 #define CPIA_COMMAND_InitStreamCap	(OUTPUT | CPIA_MODULE_CAPTURE | 4)
178 #define CPIA_COMMAND_FiniStreamCap	(OUTPUT | CPIA_MODULE_CAPTURE | 5)
179 #define CPIA_COMMAND_StartStreamCap	(OUTPUT | CPIA_MODULE_CAPTURE | 6)
180 #define CPIA_COMMAND_EndStreamCap	(OUTPUT | CPIA_MODULE_CAPTURE | 7)
181 #define CPIA_COMMAND_SetFormat		(OUTPUT | CPIA_MODULE_CAPTURE | 8)
182 #define CPIA_COMMAND_SetROI		(OUTPUT | CPIA_MODULE_CAPTURE | 9)
183 #define CPIA_COMMAND_SetCompression	(OUTPUT | CPIA_MODULE_CAPTURE | 10)
184 #define CPIA_COMMAND_SetCompressionTarget (OUTPUT | CPIA_MODULE_CAPTURE | 11)
185 #define CPIA_COMMAND_SetYUVThresh	(OUTPUT | CPIA_MODULE_CAPTURE | 12)
186 #define CPIA_COMMAND_SetCompressionParams (OUTPUT | CPIA_MODULE_CAPTURE | 13)
187 #define CPIA_COMMAND_DiscardFrame	(OUTPUT | CPIA_MODULE_CAPTURE | 14)
188 #define CPIA_COMMAND_GrabReset		(OUTPUT | CPIA_MODULE_CAPTURE | 15)
189 
190 #define CPIA_COMMAND_OutputRS232	(OUTPUT | CPIA_MODULE_DEBUG | 1)
191 #define CPIA_COMMAND_AbortProcess	(OUTPUT | CPIA_MODULE_DEBUG | 4)
192 #define CPIA_COMMAND_SetDramPage	(OUTPUT | CPIA_MODULE_DEBUG | 5)
193 #define CPIA_COMMAND_StartDramUpload	(OUTPUT | CPIA_MODULE_DEBUG | 6)
194 #define CPIA_COMMAND_StartDummyDtream	(OUTPUT | CPIA_MODULE_DEBUG | 8)
195 #define CPIA_COMMAND_AbortStream	(OUTPUT | CPIA_MODULE_DEBUG | 9)
196 #define CPIA_COMMAND_DownloadDRAM	(OUTPUT | CPIA_MODULE_DEBUG | 10)
197 #define CPIA_COMMAND_Null		(OUTPUT | CPIA_MODULE_DEBUG | 11)
198 
199 #define ROUND_UP_EXP_FOR_FLICKER 15
200 
201 /* Constants for automatic frame rate adjustment */
202 #define MAX_EXP       302
203 #define MAX_EXP_102   255
204 #define LOW_EXP       140
205 #define VERY_LOW_EXP   70
206 #define TC             94
207 #define	EXP_ACC_DARK   50
208 #define	EXP_ACC_LIGHT  90
209 #define HIGH_COMP_102 160
210 #define MAX_COMP      239
211 #define DARK_TIME       3
212 #define LIGHT_TIME      3
213 
214 #define FIRMWARE_VERSION(x, y) (sd->params.version.firmwareVersion == (x) && \
215 				sd->params.version.firmwareRevision == (y))
216 
217 #define CPIA1_CID_COMP_TARGET (V4L2_CTRL_CLASS_USER + 0x1000)
218 #define BRIGHTNESS_DEF 50
219 #define CONTRAST_DEF 48
220 #define SATURATION_DEF 50
221 #define FREQ_DEF V4L2_CID_POWER_LINE_FREQUENCY_50HZ
222 #define ILLUMINATORS_1_DEF 0
223 #define ILLUMINATORS_2_DEF 0
224 #define COMP_TARGET_DEF CPIA_COMPRESSION_TARGET_QUALITY
225 
226 /* Developer's Guide Table 5 p 3-34
227  * indexed by [mains][sensorFps.baserate][sensorFps.divisor]*/
228 static u8 flicker_jumps[2][2][4] =
229 { { { 76, 38, 19, 9 }, { 92, 46, 23, 11 } },
230   { { 64, 32, 16, 8 }, { 76, 38, 19, 9} }
231 };
232 
233 struct cam_params {
234 	struct {
235 		u8 firmwareVersion;
236 		u8 firmwareRevision;
237 		u8 vcVersion;
238 		u8 vcRevision;
239 	} version;
240 	struct {
241 		u16 vendor;
242 		u16 product;
243 		u16 deviceRevision;
244 	} pnpID;
245 	struct {
246 		u8 vpVersion;
247 		u8 vpRevision;
248 		u16 cameraHeadID;
249 	} vpVersion;
250 	struct {
251 		u8 systemState;
252 		u8 grabState;
253 		u8 streamState;
254 		u8 fatalError;
255 		u8 cmdError;
256 		u8 debugFlags;
257 		u8 vpStatus;
258 		u8 errorCode;
259 	} status;
260 	struct {
261 		u8 brightness;
262 		u8 contrast;
263 		u8 saturation;
264 	} colourParams;
265 	struct {
266 		u8 gainMode;
267 		u8 expMode;
268 		u8 compMode;
269 		u8 centreWeight;
270 		u8 gain;
271 		u8 fineExp;
272 		u8 coarseExpLo;
273 		u8 coarseExpHi;
274 		u8 redComp;
275 		u8 green1Comp;
276 		u8 green2Comp;
277 		u8 blueComp;
278 	} exposure;
279 	struct {
280 		u8 balanceMode;
281 		u8 redGain;
282 		u8 greenGain;
283 		u8 blueGain;
284 	} colourBalance;
285 	struct {
286 		u8 divisor;
287 		u8 baserate;
288 	} sensorFps;
289 	struct {
290 		u8 gain1;
291 		u8 gain2;
292 		u8 gain4;
293 		u8 gain8;
294 	} apcor;
295 	struct {
296 		u8 disabled;
297 		u8 flickerMode;
298 		u8 coarseJump;
299 		u8 allowableOverExposure;
300 	} flickerControl;
301 	struct {
302 		u8 gain1;
303 		u8 gain2;
304 		u8 gain4;
305 		u8 gain8;
306 	} vlOffset;
307 	struct {
308 		u8 mode;
309 		u8 decimation;
310 	} compression;
311 	struct {
312 		u8 frTargeting;
313 		u8 targetFR;
314 		u8 targetQ;
315 	} compressionTarget;
316 	struct {
317 		u8 yThreshold;
318 		u8 uvThreshold;
319 	} yuvThreshold;
320 	struct {
321 		u8 hysteresis;
322 		u8 threshMax;
323 		u8 smallStep;
324 		u8 largeStep;
325 		u8 decimationHysteresis;
326 		u8 frDiffStepThresh;
327 		u8 qDiffStepThresh;
328 		u8 decimationThreshMod;
329 	} compressionParams;
330 	struct {
331 		u8 videoSize;		/* CIF/QCIF */
332 		u8 subSample;
333 		u8 yuvOrder;
334 	} format;
335 	struct {                        /* Intel QX3 specific data */
336 		u8 qx3_detected;        /* a QX3 is present */
337 		u8 toplight;            /* top light lit , R/W */
338 		u8 bottomlight;         /* bottom light lit, R/W */
339 		u8 button;              /* snapshot button pressed (R/O) */
340 		u8 cradled;             /* microscope is in cradle (R/O) */
341 	} qx3;
342 	struct {
343 		u8 colStart;		/* skip first 8*colStart pixels */
344 		u8 colEnd;		/* finish at 8*colEnd pixels */
345 		u8 rowStart;		/* skip first 4*rowStart lines */
346 		u8 rowEnd;		/* finish at 4*rowEnd lines */
347 	} roi;
348 	u8 ecpTiming;
349 	u8 streamStartLine;
350 };
351 
352 /* specific webcam descriptor */
353 struct sd {
354 	struct gspca_dev gspca_dev;		/* !! must be the first item */
355 	struct cam_params params;		/* camera settings */
356 
357 	atomic_t cam_exposure;
358 	atomic_t fps;
359 	int exposure_count;
360 	u8 exposure_status;
361 	struct v4l2_ctrl *freq;
362 	u8 mainsFreq;				/* 0 = 50hz, 1 = 60hz */
363 	u8 first_frame;
364 };
365 
366 static const struct v4l2_pix_format mode[] = {
367 	{160, 120, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
368 		/* The sizeimage is trial and error, as with low framerates
369 		 *  the camera will pad out usb frames, making the image
370 		 *  data larger than strictly necessary
371 		 */
372 		.bytesperline = 160,
373 		.sizeimage = 65536,
374 		.colorspace = V4L2_COLORSPACE_SRGB,
375 		.priv = 3},
376 	{176, 144, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
377 		.bytesperline = 172,
378 		.sizeimage = 65536,
379 		.colorspace = V4L2_COLORSPACE_SRGB,
380 		.priv = 2},
381 	{320, 240, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
382 		.bytesperline = 320,
383 		.sizeimage = 262144,
384 		.colorspace = V4L2_COLORSPACE_SRGB,
385 		.priv = 1},
386 	{352, 288, V4L2_PIX_FMT_CPIA1, V4L2_FIELD_NONE,
387 		.bytesperline = 352,
388 		.sizeimage = 262144,
389 		.colorspace = V4L2_COLORSPACE_SRGB,
390 		.priv = 0},
391 };
392 
393 /**********************************************************************
394  *
395  * General functions
396  *
397  **********************************************************************/
398 
cpia_usb_transferCmd(struct gspca_dev * gspca_dev,u8 * command)399 static int cpia_usb_transferCmd(struct gspca_dev *gspca_dev, u8 *command)
400 {
401 	u8 requesttype;
402 	unsigned int pipe;
403 	int ret, databytes = command[6] | (command[7] << 8);
404 	/* Sometimes we see spurious EPIPE errors */
405 	int retries = 3;
406 
407 	if (command[0] == DATA_IN) {
408 		pipe = usb_rcvctrlpipe(gspca_dev->dev, 0);
409 		requesttype = USB_DIR_IN | USB_TYPE_VENDOR | USB_RECIP_DEVICE;
410 	} else if (command[0] == DATA_OUT) {
411 		pipe = usb_sndctrlpipe(gspca_dev->dev, 0);
412 		requesttype = USB_TYPE_VENDOR | USB_RECIP_DEVICE;
413 	} else {
414 		gspca_err(gspca_dev, "Unexpected first byte of command: %x\n",
415 			  command[0]);
416 		return -EINVAL;
417 	}
418 
419 retry:
420 	ret = usb_control_msg(gspca_dev->dev, pipe,
421 			      command[1],
422 			      requesttype,
423 			      command[2] | (command[3] << 8),
424 			      command[4] | (command[5] << 8),
425 			      gspca_dev->usb_buf, databytes, 1000);
426 
427 	if (ret < 0)
428 		pr_err("usb_control_msg %02x, error %d\n", command[1], ret);
429 
430 	if (ret == -EPIPE && retries > 0) {
431 		retries--;
432 		goto retry;
433 	}
434 
435 	return (ret < 0) ? ret : 0;
436 }
437 
438 /* send an arbitrary command to the camera */
do_command(struct gspca_dev * gspca_dev,u16 command,u8 a,u8 b,u8 c,u8 d)439 static int do_command(struct gspca_dev *gspca_dev, u16 command,
440 		      u8 a, u8 b, u8 c, u8 d)
441 {
442 	struct sd *sd = (struct sd *) gspca_dev;
443 	int ret, datasize;
444 	u8 cmd[8];
445 
446 	switch (command) {
447 	case CPIA_COMMAND_GetCPIAVersion:
448 	case CPIA_COMMAND_GetPnPID:
449 	case CPIA_COMMAND_GetCameraStatus:
450 	case CPIA_COMMAND_GetVPVersion:
451 	case CPIA_COMMAND_GetColourParams:
452 	case CPIA_COMMAND_GetColourBalance:
453 	case CPIA_COMMAND_GetExposure:
454 		datasize = 8;
455 		break;
456 	case CPIA_COMMAND_ReadMCPorts:
457 	case CPIA_COMMAND_ReadVCRegs:
458 		datasize = 4;
459 		break;
460 	default:
461 		datasize = 0;
462 		break;
463 	}
464 
465 	cmd[0] = command >> 8;
466 	cmd[1] = command & 0xff;
467 	cmd[2] = a;
468 	cmd[3] = b;
469 	cmd[4] = c;
470 	cmd[5] = d;
471 	cmd[6] = datasize;
472 	cmd[7] = 0;
473 
474 	ret = cpia_usb_transferCmd(gspca_dev, cmd);
475 	if (ret)
476 		return ret;
477 
478 	switch (command) {
479 	case CPIA_COMMAND_GetCPIAVersion:
480 		sd->params.version.firmwareVersion = gspca_dev->usb_buf[0];
481 		sd->params.version.firmwareRevision = gspca_dev->usb_buf[1];
482 		sd->params.version.vcVersion = gspca_dev->usb_buf[2];
483 		sd->params.version.vcRevision = gspca_dev->usb_buf[3];
484 		break;
485 	case CPIA_COMMAND_GetPnPID:
486 		sd->params.pnpID.vendor =
487 			gspca_dev->usb_buf[0] | (gspca_dev->usb_buf[1] << 8);
488 		sd->params.pnpID.product =
489 			gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
490 		sd->params.pnpID.deviceRevision =
491 			gspca_dev->usb_buf[4] | (gspca_dev->usb_buf[5] << 8);
492 		break;
493 	case CPIA_COMMAND_GetCameraStatus:
494 		sd->params.status.systemState = gspca_dev->usb_buf[0];
495 		sd->params.status.grabState = gspca_dev->usb_buf[1];
496 		sd->params.status.streamState = gspca_dev->usb_buf[2];
497 		sd->params.status.fatalError = gspca_dev->usb_buf[3];
498 		sd->params.status.cmdError = gspca_dev->usb_buf[4];
499 		sd->params.status.debugFlags = gspca_dev->usb_buf[5];
500 		sd->params.status.vpStatus = gspca_dev->usb_buf[6];
501 		sd->params.status.errorCode = gspca_dev->usb_buf[7];
502 		break;
503 	case CPIA_COMMAND_GetVPVersion:
504 		sd->params.vpVersion.vpVersion = gspca_dev->usb_buf[0];
505 		sd->params.vpVersion.vpRevision = gspca_dev->usb_buf[1];
506 		sd->params.vpVersion.cameraHeadID =
507 			gspca_dev->usb_buf[2] | (gspca_dev->usb_buf[3] << 8);
508 		break;
509 	case CPIA_COMMAND_GetColourParams:
510 		sd->params.colourParams.brightness = gspca_dev->usb_buf[0];
511 		sd->params.colourParams.contrast = gspca_dev->usb_buf[1];
512 		sd->params.colourParams.saturation = gspca_dev->usb_buf[2];
513 		break;
514 	case CPIA_COMMAND_GetColourBalance:
515 		sd->params.colourBalance.redGain = gspca_dev->usb_buf[0];
516 		sd->params.colourBalance.greenGain = gspca_dev->usb_buf[1];
517 		sd->params.colourBalance.blueGain = gspca_dev->usb_buf[2];
518 		break;
519 	case CPIA_COMMAND_GetExposure:
520 		sd->params.exposure.gain = gspca_dev->usb_buf[0];
521 		sd->params.exposure.fineExp = gspca_dev->usb_buf[1];
522 		sd->params.exposure.coarseExpLo = gspca_dev->usb_buf[2];
523 		sd->params.exposure.coarseExpHi = gspca_dev->usb_buf[3];
524 		sd->params.exposure.redComp = gspca_dev->usb_buf[4];
525 		sd->params.exposure.green1Comp = gspca_dev->usb_buf[5];
526 		sd->params.exposure.green2Comp = gspca_dev->usb_buf[6];
527 		sd->params.exposure.blueComp = gspca_dev->usb_buf[7];
528 		break;
529 
530 	case CPIA_COMMAND_ReadMCPorts:
531 		/* test button press */
532 		a = ((gspca_dev->usb_buf[1] & 0x02) == 0);
533 		if (a != sd->params.qx3.button) {
534 #if IS_ENABLED(CONFIG_INPUT)
535 			input_report_key(gspca_dev->input_dev, KEY_CAMERA, a);
536 			input_sync(gspca_dev->input_dev);
537 #endif
538 			sd->params.qx3.button = a;
539 		}
540 		if (sd->params.qx3.button) {
541 			/* button pressed - unlock the latch */
542 			ret = do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
543 				   3, 0xdf, 0xdf, 0);
544 			if (ret)
545 				return ret;
546 			ret = do_command(gspca_dev, CPIA_COMMAND_WriteMCPort,
547 				   3, 0xff, 0xff, 0);
548 			if (ret)
549 				return ret;
550 		}
551 
552 		/* test whether microscope is cradled */
553 		sd->params.qx3.cradled = ((gspca_dev->usb_buf[2] & 0x40) == 0);
554 		break;
555 	}
556 
557 	return 0;
558 }
559 
560 /* 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)561 static int do_command_extended(struct gspca_dev *gspca_dev, u16 command,
562 			       u8 a, u8 b, u8 c, u8 d,
563 			       u8 e, u8 f, u8 g, u8 h,
564 			       u8 i, u8 j, u8 k, u8 l)
565 {
566 	u8 cmd[8];
567 
568 	cmd[0] = command >> 8;
569 	cmd[1] = command & 0xff;
570 	cmd[2] = a;
571 	cmd[3] = b;
572 	cmd[4] = c;
573 	cmd[5] = d;
574 	cmd[6] = 8;
575 	cmd[7] = 0;
576 	gspca_dev->usb_buf[0] = e;
577 	gspca_dev->usb_buf[1] = f;
578 	gspca_dev->usb_buf[2] = g;
579 	gspca_dev->usb_buf[3] = h;
580 	gspca_dev->usb_buf[4] = i;
581 	gspca_dev->usb_buf[5] = j;
582 	gspca_dev->usb_buf[6] = k;
583 	gspca_dev->usb_buf[7] = l;
584 
585 	return cpia_usb_transferCmd(gspca_dev, cmd);
586 }
587 
588 /*  find_over_exposure
589  *  Finds a suitable value of OverExposure for use with SetFlickerCtrl
590  *  Some calculation is required because this value changes with the brightness
591  *  set with SetColourParameters
592  *
593  *  Parameters: Brightness - last brightness value set with SetColourParameters
594  *
595  *  Returns: OverExposure value to use with SetFlickerCtrl
596  */
597 #define FLICKER_MAX_EXPOSURE                    250
598 #define FLICKER_ALLOWABLE_OVER_EXPOSURE         146
599 #define FLICKER_BRIGHTNESS_CONSTANT             59
find_over_exposure(int brightness)600 static int find_over_exposure(int brightness)
601 {
602 	int MaxAllowableOverExposure, OverExposure;
603 
604 	MaxAllowableOverExposure = FLICKER_MAX_EXPOSURE - brightness -
605 				   FLICKER_BRIGHTNESS_CONSTANT;
606 
607 	if (MaxAllowableOverExposure < FLICKER_ALLOWABLE_OVER_EXPOSURE)
608 		OverExposure = MaxAllowableOverExposure;
609 	else
610 		OverExposure = FLICKER_ALLOWABLE_OVER_EXPOSURE;
611 
612 	return OverExposure;
613 }
614 #undef FLICKER_MAX_EXPOSURE
615 #undef FLICKER_ALLOWABLE_OVER_EXPOSURE
616 #undef FLICKER_BRIGHTNESS_CONSTANT
617 
618 /* initialise cam_data structure  */
reset_camera_params(struct gspca_dev * gspca_dev)619 static void reset_camera_params(struct gspca_dev *gspca_dev)
620 {
621 	struct sd *sd = (struct sd *) gspca_dev;
622 	struct cam_params *params = &sd->params;
623 
624 	/* The following parameter values are the defaults from
625 	 * "Software Developer's Guide for CPiA Cameras".  Any changes
626 	 * to the defaults are noted in comments. */
627 	params->colourParams.brightness = BRIGHTNESS_DEF;
628 	params->colourParams.contrast = CONTRAST_DEF;
629 	params->colourParams.saturation = SATURATION_DEF;
630 	params->exposure.gainMode = 4;
631 	params->exposure.expMode = 2;		/* AEC */
632 	params->exposure.compMode = 1;
633 	params->exposure.centreWeight = 1;
634 	params->exposure.gain = 0;
635 	params->exposure.fineExp = 0;
636 	params->exposure.coarseExpLo = 185;
637 	params->exposure.coarseExpHi = 0;
638 	params->exposure.redComp = COMP_RED;
639 	params->exposure.green1Comp = COMP_GREEN1;
640 	params->exposure.green2Comp = COMP_GREEN2;
641 	params->exposure.blueComp = COMP_BLUE;
642 	params->colourBalance.balanceMode = 2;	/* ACB */
643 	params->colourBalance.redGain = 32;
644 	params->colourBalance.greenGain = 6;
645 	params->colourBalance.blueGain = 92;
646 	params->apcor.gain1 = 0x18;
647 	params->apcor.gain2 = 0x16;
648 	params->apcor.gain4 = 0x24;
649 	params->apcor.gain8 = 0x34;
650 	params->vlOffset.gain1 = 20;
651 	params->vlOffset.gain2 = 24;
652 	params->vlOffset.gain4 = 26;
653 	params->vlOffset.gain8 = 26;
654 	params->compressionParams.hysteresis = 3;
655 	params->compressionParams.threshMax = 11;
656 	params->compressionParams.smallStep = 1;
657 	params->compressionParams.largeStep = 3;
658 	params->compressionParams.decimationHysteresis = 2;
659 	params->compressionParams.frDiffStepThresh = 5;
660 	params->compressionParams.qDiffStepThresh = 3;
661 	params->compressionParams.decimationThreshMod = 2;
662 	/* End of default values from Software Developer's Guide */
663 
664 	/* Set Sensor FPS to 15fps. This seems better than 30fps
665 	 * for indoor lighting. */
666 	params->sensorFps.divisor = 1;
667 	params->sensorFps.baserate = 1;
668 
669 	params->flickerControl.flickerMode = 0;
670 	params->flickerControl.disabled = 1;
671 	params->flickerControl.coarseJump =
672 		flicker_jumps[sd->mainsFreq]
673 			     [params->sensorFps.baserate]
674 			     [params->sensorFps.divisor];
675 	params->flickerControl.allowableOverExposure =
676 		find_over_exposure(params->colourParams.brightness);
677 
678 	params->yuvThreshold.yThreshold = 6; /* From windows driver */
679 	params->yuvThreshold.uvThreshold = 6; /* From windows driver */
680 
681 	params->format.subSample = SUBSAMPLE_420;
682 	params->format.yuvOrder = YUVORDER_YUYV;
683 
684 	params->compression.mode = CPIA_COMPRESSION_AUTO;
685 	params->compression.decimation = NO_DECIMATION;
686 
687 	params->compressionTarget.frTargeting = COMP_TARGET_DEF;
688 	params->compressionTarget.targetFR = 15; /* From windows driver */
689 	params->compressionTarget.targetQ = 5; /* From windows driver */
690 
691 	params->qx3.qx3_detected = 0;
692 	params->qx3.toplight = 0;
693 	params->qx3.bottomlight = 0;
694 	params->qx3.button = 0;
695 	params->qx3.cradled = 0;
696 }
697 
printstatus(struct gspca_dev * gspca_dev,struct cam_params * params)698 static void printstatus(struct gspca_dev *gspca_dev, struct cam_params *params)
699 {
700 	gspca_dbg(gspca_dev, D_PROBE, "status: %02x %02x %02x %02x %02x %02x %02x %02x\n",
701 		  params->status.systemState, params->status.grabState,
702 		  params->status.streamState, params->status.fatalError,
703 		  params->status.cmdError, params->status.debugFlags,
704 		  params->status.vpStatus, params->status.errorCode);
705 }
706 
goto_low_power(struct gspca_dev * gspca_dev)707 static int goto_low_power(struct gspca_dev *gspca_dev)
708 {
709 	struct sd *sd = (struct sd *) gspca_dev;
710 	int ret;
711 
712 	ret = do_command(gspca_dev, CPIA_COMMAND_GotoLoPower, 0, 0, 0, 0);
713 	if (ret)
714 		return ret;
715 
716 	ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
717 	if (ret)
718 		return ret;
719 
720 	if (sd->params.status.systemState != LO_POWER_STATE) {
721 		if (sd->params.status.systemState != WARM_BOOT_STATE) {
722 			gspca_err(gspca_dev, "unexpected state after lo power cmd: %02x\n",
723 				  sd->params.status.systemState);
724 			printstatus(gspca_dev, &sd->params);
725 		}
726 		return -EIO;
727 	}
728 
729 	gspca_dbg(gspca_dev, D_CONF, "camera now in LOW power state\n");
730 	return 0;
731 }
732 
goto_high_power(struct gspca_dev * gspca_dev)733 static int goto_high_power(struct gspca_dev *gspca_dev)
734 {
735 	struct sd *sd = (struct sd *) gspca_dev;
736 	int ret;
737 
738 	ret = do_command(gspca_dev, CPIA_COMMAND_GotoHiPower, 0, 0, 0, 0);
739 	if (ret)
740 		return ret;
741 
742 	msleep_interruptible(40);	/* windows driver does it too */
743 
744 	if (signal_pending(current))
745 		return -EINTR;
746 
747 	ret = do_command(gspca_dev, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
748 	if (ret)
749 		return ret;
750 
751 	if (sd->params.status.systemState != HI_POWER_STATE) {
752 		gspca_err(gspca_dev, "unexpected state after hi power cmd: %02x\n",
753 			  sd->params.status.systemState);
754 		printstatus(gspca_dev, &sd->params);
755 		return -EIO;
756 	}
757 
758 	gspca_dbg(gspca_dev, D_CONF, "camera now in HIGH power state\n");
759 	return 0;
760 }
761 
get_version_information(struct gspca_dev * gspca_dev)762 static int get_version_information(struct gspca_dev *gspca_dev)
763 {
764 	int ret;
765 
766 	/* GetCPIAVersion */
767 	ret = do_command(gspca_dev, CPIA_COMMAND_GetCPIAVersion, 0, 0, 0, 0);
768 	if (ret)
769 		return ret;
770 
771 	/* GetPnPID */
772 	return do_command(gspca_dev, CPIA_COMMAND_GetPnPID, 0, 0, 0, 0);
773 }
774 
save_camera_state(struct gspca_dev * gspca_dev)775 static int save_camera_state(struct gspca_dev *gspca_dev)
776 {
777 	int ret;
778 
779 	ret = do_command(gspca_dev, CPIA_COMMAND_GetColourBalance, 0, 0, 0, 0);
780 	if (ret)
781 		return ret;
782 
783 	return do_command(gspca_dev, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
784 }
785 
command_setformat(struct gspca_dev * gspca_dev)786 static int command_setformat(struct gspca_dev *gspca_dev)
787 {
788 	struct sd *sd = (struct sd *) gspca_dev;
789 	int ret;
790 
791 	ret = do_command(gspca_dev, CPIA_COMMAND_SetFormat,
792 			 sd->params.format.videoSize,
793 			 sd->params.format.subSample,
794 			 sd->params.format.yuvOrder, 0);
795 	if (ret)
796 		return ret;
797 
798 	return do_command(gspca_dev, CPIA_COMMAND_SetROI,
799 			  sd->params.roi.colStart, sd->params.roi.colEnd,
800 			  sd->params.roi.rowStart, sd->params.roi.rowEnd);
801 }
802 
command_setcolourparams(struct gspca_dev * gspca_dev)803 static int command_setcolourparams(struct gspca_dev *gspca_dev)
804 {
805 	struct sd *sd = (struct sd *) gspca_dev;
806 	return do_command(gspca_dev, CPIA_COMMAND_SetColourParams,
807 			  sd->params.colourParams.brightness,
808 			  sd->params.colourParams.contrast,
809 			  sd->params.colourParams.saturation, 0);
810 }
811 
command_setapcor(struct gspca_dev * gspca_dev)812 static int command_setapcor(struct gspca_dev *gspca_dev)
813 {
814 	struct sd *sd = (struct sd *) gspca_dev;
815 	return do_command(gspca_dev, CPIA_COMMAND_SetApcor,
816 			  sd->params.apcor.gain1,
817 			  sd->params.apcor.gain2,
818 			  sd->params.apcor.gain4,
819 			  sd->params.apcor.gain8);
820 }
821 
command_setvloffset(struct gspca_dev * gspca_dev)822 static int command_setvloffset(struct gspca_dev *gspca_dev)
823 {
824 	struct sd *sd = (struct sd *) gspca_dev;
825 	return do_command(gspca_dev, CPIA_COMMAND_SetVLOffset,
826 			  sd->params.vlOffset.gain1,
827 			  sd->params.vlOffset.gain2,
828 			  sd->params.vlOffset.gain4,
829 			  sd->params.vlOffset.gain8);
830 }
831 
command_setexposure(struct gspca_dev * gspca_dev)832 static int command_setexposure(struct gspca_dev *gspca_dev)
833 {
834 	struct sd *sd = (struct sd *) gspca_dev;
835 	int ret;
836 
837 	ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
838 				  sd->params.exposure.gainMode,
839 				  1,
840 				  sd->params.exposure.compMode,
841 				  sd->params.exposure.centreWeight,
842 				  sd->params.exposure.gain,
843 				  sd->params.exposure.fineExp,
844 				  sd->params.exposure.coarseExpLo,
845 				  sd->params.exposure.coarseExpHi,
846 				  sd->params.exposure.redComp,
847 				  sd->params.exposure.green1Comp,
848 				  sd->params.exposure.green2Comp,
849 				  sd->params.exposure.blueComp);
850 	if (ret)
851 		return ret;
852 
853 	if (sd->params.exposure.expMode != 1) {
854 		ret = do_command_extended(gspca_dev, CPIA_COMMAND_SetExposure,
855 					  0,
856 					  sd->params.exposure.expMode,
857 					  0, 0,
858 					  sd->params.exposure.gain,
859 					  sd->params.exposure.fineExp,
860 					  sd->params.exposure.coarseExpLo,
861 					  sd->params.exposure.coarseExpHi,
862 					  0, 0, 0, 0);
863 	}
864 
865 	return ret;
866 }
867 
command_setcolourbalance(struct gspca_dev * gspca_dev)868 static int command_setcolourbalance(struct gspca_dev *gspca_dev)
869 {
870 	struct sd *sd = (struct sd *) gspca_dev;
871 
872 	if (sd->params.colourBalance.balanceMode == 1) {
873 		int ret;
874 
875 		ret = do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
876 				 1,
877 				 sd->params.colourBalance.redGain,
878 				 sd->params.colourBalance.greenGain,
879 				 sd->params.colourBalance.blueGain);
880 		if (ret)
881 			return ret;
882 
883 		return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
884 				  3, 0, 0, 0);
885 	}
886 	if (sd->params.colourBalance.balanceMode == 2) {
887 		return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
888 				  2, 0, 0, 0);
889 	}
890 	if (sd->params.colourBalance.balanceMode == 3) {
891 		return do_command(gspca_dev, CPIA_COMMAND_SetColourBalance,
892 				  3, 0, 0, 0);
893 	}
894 
895 	return -EINVAL;
896 }
897 
command_setcompressiontarget(struct gspca_dev * gspca_dev)898 static int command_setcompressiontarget(struct gspca_dev *gspca_dev)
899 {
900 	struct sd *sd = (struct sd *) gspca_dev;
901 
902 	return do_command(gspca_dev, CPIA_COMMAND_SetCompressionTarget,
903 			  sd->params.compressionTarget.frTargeting,
904 			  sd->params.compressionTarget.targetFR,
905 			  sd->params.compressionTarget.targetQ, 0);
906 }
907 
command_setyuvtresh(struct gspca_dev * gspca_dev)908 static int command_setyuvtresh(struct gspca_dev *gspca_dev)
909 {
910 	struct sd *sd = (struct sd *) gspca_dev;
911 
912 	return do_command(gspca_dev, CPIA_COMMAND_SetYUVThresh,
913 			  sd->params.yuvThreshold.yThreshold,
914 			  sd->params.yuvThreshold.uvThreshold, 0, 0);
915 }
916 
command_setcompressionparams(struct gspca_dev * gspca_dev)917 static int command_setcompressionparams(struct gspca_dev *gspca_dev)
918 {
919 	struct sd *sd = (struct sd *) gspca_dev;
920 
921 	return do_command_extended(gspca_dev,
922 			    CPIA_COMMAND_SetCompressionParams,
923 			    0, 0, 0, 0,
924 			    sd->params.compressionParams.hysteresis,
925 			    sd->params.compressionParams.threshMax,
926 			    sd->params.compressionParams.smallStep,
927 			    sd->params.compressionParams.largeStep,
928 			    sd->params.compressionParams.decimationHysteresis,
929 			    sd->params.compressionParams.frDiffStepThresh,
930 			    sd->params.compressionParams.qDiffStepThresh,
931 			    sd->params.compressionParams.decimationThreshMod);
932 }
933 
command_setcompression(struct gspca_dev * gspca_dev)934 static int command_setcompression(struct gspca_dev *gspca_dev)
935 {
936 	struct sd *sd = (struct sd *) gspca_dev;
937 
938 	return do_command(gspca_dev, CPIA_COMMAND_SetCompression,
939 			  sd->params.compression.mode,
940 			  sd->params.compression.decimation, 0, 0);
941 }
942 
command_setsensorfps(struct gspca_dev * gspca_dev)943 static int command_setsensorfps(struct gspca_dev *gspca_dev)
944 {
945 	struct sd *sd = (struct sd *) gspca_dev;
946 
947 	return do_command(gspca_dev, CPIA_COMMAND_SetSensorFPS,
948 			  sd->params.sensorFps.divisor,
949 			  sd->params.sensorFps.baserate, 0, 0);
950 }
951 
command_setflickerctrl(struct gspca_dev * gspca_dev)952 static int command_setflickerctrl(struct gspca_dev *gspca_dev)
953 {
954 	struct sd *sd = (struct sd *) gspca_dev;
955 
956 	return do_command(gspca_dev, CPIA_COMMAND_SetFlickerCtrl,
957 			  sd->params.flickerControl.flickerMode,
958 			  sd->params.flickerControl.coarseJump,
959 			  sd->params.flickerControl.allowableOverExposure,
960 			  0);
961 }
962 
command_setecptiming(struct gspca_dev * gspca_dev)963 static int command_setecptiming(struct gspca_dev *gspca_dev)
964 {
965 	struct sd *sd = (struct sd *) gspca_dev;
966 
967 	return do_command(gspca_dev, CPIA_COMMAND_SetECPTiming,
968 			  sd->params.ecpTiming, 0, 0, 0);
969 }
970 
command_pause(struct gspca_dev * gspca_dev)971 static int command_pause(struct gspca_dev *gspca_dev)
972 {
973 	return do_command(gspca_dev, CPIA_COMMAND_EndStreamCap, 0, 0, 0, 0);
974 }
975 
command_resume(struct gspca_dev * gspca_dev)976 static int command_resume(struct gspca_dev *gspca_dev)
977 {
978 	struct sd *sd = (struct sd *) gspca_dev;
979 
980 	return do_command(gspca_dev, CPIA_COMMAND_InitStreamCap,
981 			  0, sd->params.streamStartLine, 0, 0);
982 }
983 
command_setlights(struct gspca_dev * gspca_dev)984 static int command_setlights(struct gspca_dev *gspca_dev)
985 {
986 	struct sd *sd = (struct sd *) gspca_dev;
987 	int ret, p1, p2;
988 
989 	p1 = (sd->params.qx3.bottomlight == 0) << 1;
990 	p2 = (sd->params.qx3.toplight == 0) << 3;
991 
992 	ret = do_command(gspca_dev, CPIA_COMMAND_WriteVCReg,
993 			 0x90, 0x8f, 0x50, 0);
994 	if (ret)
995 		return ret;
996 
997 	return do_command(gspca_dev, CPIA_COMMAND_WriteMCPort, 2, 0,
998 			  p1 | p2 | 0xe0, 0);
999 }
1000 
set_flicker(struct gspca_dev * gspca_dev,int on,int apply)1001 static int set_flicker(struct gspca_dev *gspca_dev, int on, int apply)
1002 {
1003 	/* Everything in here is from the Windows driver */
1004 /* define for compgain calculation */
1005 #if 0
1006 #define COMPGAIN(base, curexp, newexp) \
1007     (u8) ((((float) base - 128.0) * ((float) curexp / (float) newexp)) + 128.5)
1008 #define EXP_FROM_COMP(basecomp, curcomp, curexp) \
1009     (u16)((float)curexp * (float)(u8)(curcomp + 128) / \
1010     (float)(u8)(basecomp - 128))
1011 #else
1012   /* equivalent functions without floating point math */
1013 #define COMPGAIN(base, curexp, newexp) \
1014     (u8)(128 + (((u32)(2*(base-128)*curexp + newexp)) / (2 * newexp)))
1015 #define EXP_FROM_COMP(basecomp, curcomp, curexp) \
1016     (u16)(((u32)(curexp * (u8)(curcomp + 128)) / (u8)(basecomp - 128)))
1017 #endif
1018 
1019 	struct sd *sd = (struct sd *) gspca_dev;
1020 	int currentexp = sd->params.exposure.coarseExpLo +
1021 			 sd->params.exposure.coarseExpHi * 256;
1022 	int ret, startexp;
1023 
1024 	if (on) {
1025 		int cj = sd->params.flickerControl.coarseJump;
1026 		sd->params.flickerControl.flickerMode = 1;
1027 		sd->params.flickerControl.disabled = 0;
1028 		if (sd->params.exposure.expMode != 2) {
1029 			sd->params.exposure.expMode = 2;
1030 			sd->exposure_status = EXPOSURE_NORMAL;
1031 		}
1032 		if (sd->params.exposure.gain >= BITS_PER_TYPE(currentexp))
1033 			return -EINVAL;
1034 		currentexp = currentexp << sd->params.exposure.gain;
1035 		sd->params.exposure.gain = 0;
1036 		/* round down current exposure to nearest value */
1037 		startexp = (currentexp + ROUND_UP_EXP_FOR_FLICKER) / cj;
1038 		if (startexp < 1)
1039 			startexp = 1;
1040 		startexp = (startexp * cj) - 1;
1041 		if (FIRMWARE_VERSION(1, 2))
1042 			while (startexp > MAX_EXP_102)
1043 				startexp -= cj;
1044 		else
1045 			while (startexp > MAX_EXP)
1046 				startexp -= cj;
1047 		sd->params.exposure.coarseExpLo = startexp & 0xff;
1048 		sd->params.exposure.coarseExpHi = startexp >> 8;
1049 		if (currentexp > startexp) {
1050 			if (currentexp > (2 * startexp))
1051 				currentexp = 2 * startexp;
1052 			sd->params.exposure.redComp =
1053 				COMPGAIN(COMP_RED, currentexp, startexp);
1054 			sd->params.exposure.green1Comp =
1055 				COMPGAIN(COMP_GREEN1, currentexp, startexp);
1056 			sd->params.exposure.green2Comp =
1057 				COMPGAIN(COMP_GREEN2, currentexp, startexp);
1058 			sd->params.exposure.blueComp =
1059 				COMPGAIN(COMP_BLUE, currentexp, startexp);
1060 		} else {
1061 			sd->params.exposure.redComp = COMP_RED;
1062 			sd->params.exposure.green1Comp = COMP_GREEN1;
1063 			sd->params.exposure.green2Comp = COMP_GREEN2;
1064 			sd->params.exposure.blueComp = COMP_BLUE;
1065 		}
1066 		if (FIRMWARE_VERSION(1, 2))
1067 			sd->params.exposure.compMode = 0;
1068 		else
1069 			sd->params.exposure.compMode = 1;
1070 
1071 		sd->params.apcor.gain1 = 0x18;
1072 		sd->params.apcor.gain2 = 0x18;
1073 		sd->params.apcor.gain4 = 0x16;
1074 		sd->params.apcor.gain8 = 0x14;
1075 	} else {
1076 		sd->params.flickerControl.flickerMode = 0;
1077 		sd->params.flickerControl.disabled = 1;
1078 		/* Average equivalent coarse for each comp channel */
1079 		startexp = EXP_FROM_COMP(COMP_RED,
1080 				sd->params.exposure.redComp, currentexp);
1081 		startexp += EXP_FROM_COMP(COMP_GREEN1,
1082 				sd->params.exposure.green1Comp, currentexp);
1083 		startexp += EXP_FROM_COMP(COMP_GREEN2,
1084 				sd->params.exposure.green2Comp, currentexp);
1085 		startexp += EXP_FROM_COMP(COMP_BLUE,
1086 				sd->params.exposure.blueComp, currentexp);
1087 		startexp = startexp >> 2;
1088 		while (startexp > MAX_EXP && sd->params.exposure.gain <
1089 		       sd->params.exposure.gainMode - 1) {
1090 			startexp = startexp >> 1;
1091 			++sd->params.exposure.gain;
1092 		}
1093 		if (FIRMWARE_VERSION(1, 2) && startexp > MAX_EXP_102)
1094 			startexp = MAX_EXP_102;
1095 		if (startexp > MAX_EXP)
1096 			startexp = MAX_EXP;
1097 		sd->params.exposure.coarseExpLo = startexp & 0xff;
1098 		sd->params.exposure.coarseExpHi = startexp >> 8;
1099 		sd->params.exposure.redComp = COMP_RED;
1100 		sd->params.exposure.green1Comp = COMP_GREEN1;
1101 		sd->params.exposure.green2Comp = COMP_GREEN2;
1102 		sd->params.exposure.blueComp = COMP_BLUE;
1103 		sd->params.exposure.compMode = 1;
1104 		sd->params.apcor.gain1 = 0x18;
1105 		sd->params.apcor.gain2 = 0x16;
1106 		sd->params.apcor.gain4 = 0x24;
1107 		sd->params.apcor.gain8 = 0x34;
1108 	}
1109 	sd->params.vlOffset.gain1 = 20;
1110 	sd->params.vlOffset.gain2 = 24;
1111 	sd->params.vlOffset.gain4 = 26;
1112 	sd->params.vlOffset.gain8 = 26;
1113 
1114 	if (apply) {
1115 		ret = command_setexposure(gspca_dev);
1116 		if (ret)
1117 			return ret;
1118 
1119 		ret = command_setapcor(gspca_dev);
1120 		if (ret)
1121 			return ret;
1122 
1123 		ret = command_setvloffset(gspca_dev);
1124 		if (ret)
1125 			return ret;
1126 
1127 		ret = command_setflickerctrl(gspca_dev);
1128 		if (ret)
1129 			return ret;
1130 	}
1131 
1132 	return 0;
1133 #undef EXP_FROM_COMP
1134 #undef COMPGAIN
1135 }
1136 
1137 /* monitor the exposure and adjust the sensor frame rate if needed */
monitor_exposure(struct gspca_dev * gspca_dev)1138 static void monitor_exposure(struct gspca_dev *gspca_dev)
1139 {
1140 	struct sd *sd = (struct sd *) gspca_dev;
1141 	u8 exp_acc, bcomp, cmd[8];
1142 	int ret, light_exp, dark_exp, very_dark_exp;
1143 	int old_exposure, new_exposure, framerate;
1144 	int setfps = 0, setexp = 0, setflicker = 0;
1145 
1146 	/* get necessary stats and register settings from camera */
1147 	/* do_command can't handle this, so do it ourselves */
1148 	cmd[0] = CPIA_COMMAND_ReadVPRegs >> 8;
1149 	cmd[1] = CPIA_COMMAND_ReadVPRegs & 0xff;
1150 	cmd[2] = 30;
1151 	cmd[3] = 4;
1152 	cmd[4] = 9;
1153 	cmd[5] = 8;
1154 	cmd[6] = 8;
1155 	cmd[7] = 0;
1156 	ret = cpia_usb_transferCmd(gspca_dev, cmd);
1157 	if (ret) {
1158 		pr_err("ReadVPRegs(30,4,9,8) - failed: %d\n", ret);
1159 		return;
1160 	}
1161 	exp_acc = gspca_dev->usb_buf[0];
1162 	bcomp = gspca_dev->usb_buf[1];
1163 
1164 	light_exp = sd->params.colourParams.brightness +
1165 		    TC - 50 + EXP_ACC_LIGHT;
1166 	if (light_exp > 255)
1167 		light_exp = 255;
1168 	dark_exp = sd->params.colourParams.brightness +
1169 		   TC - 50 - EXP_ACC_DARK;
1170 	if (dark_exp < 0)
1171 		dark_exp = 0;
1172 	very_dark_exp = dark_exp / 2;
1173 
1174 	old_exposure = sd->params.exposure.coarseExpHi * 256 +
1175 		       sd->params.exposure.coarseExpLo;
1176 
1177 	if (!sd->params.flickerControl.disabled) {
1178 		/* Flicker control on */
1179 		int max_comp = FIRMWARE_VERSION(1, 2) ? MAX_COMP :
1180 							HIGH_COMP_102;
1181 		bcomp += 128;	/* decode */
1182 		if (bcomp >= max_comp && exp_acc < dark_exp) {
1183 			/* dark */
1184 			if (exp_acc < very_dark_exp) {
1185 				/* very dark */
1186 				if (sd->exposure_status == EXPOSURE_VERY_DARK)
1187 					++sd->exposure_count;
1188 				else {
1189 					sd->exposure_status =
1190 						EXPOSURE_VERY_DARK;
1191 					sd->exposure_count = 1;
1192 				}
1193 			} else {
1194 				/* just dark */
1195 				if (sd->exposure_status == EXPOSURE_DARK)
1196 					++sd->exposure_count;
1197 				else {
1198 					sd->exposure_status = EXPOSURE_DARK;
1199 					sd->exposure_count = 1;
1200 				}
1201 			}
1202 		} else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
1203 			/* light */
1204 			if (old_exposure <= VERY_LOW_EXP) {
1205 				/* very light */
1206 				if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
1207 					++sd->exposure_count;
1208 				else {
1209 					sd->exposure_status =
1210 						EXPOSURE_VERY_LIGHT;
1211 					sd->exposure_count = 1;
1212 				}
1213 			} else {
1214 				/* just light */
1215 				if (sd->exposure_status == EXPOSURE_LIGHT)
1216 					++sd->exposure_count;
1217 				else {
1218 					sd->exposure_status = EXPOSURE_LIGHT;
1219 					sd->exposure_count = 1;
1220 				}
1221 			}
1222 		} else {
1223 			/* not dark or light */
1224 			sd->exposure_status = EXPOSURE_NORMAL;
1225 		}
1226 	} else {
1227 		/* Flicker control off */
1228 		if (old_exposure >= MAX_EXP && exp_acc < dark_exp) {
1229 			/* dark */
1230 			if (exp_acc < very_dark_exp) {
1231 				/* very dark */
1232 				if (sd->exposure_status == EXPOSURE_VERY_DARK)
1233 					++sd->exposure_count;
1234 				else {
1235 					sd->exposure_status =
1236 						EXPOSURE_VERY_DARK;
1237 					sd->exposure_count = 1;
1238 				}
1239 			} else {
1240 				/* just dark */
1241 				if (sd->exposure_status == EXPOSURE_DARK)
1242 					++sd->exposure_count;
1243 				else {
1244 					sd->exposure_status = EXPOSURE_DARK;
1245 					sd->exposure_count = 1;
1246 				}
1247 			}
1248 		} else if (old_exposure <= LOW_EXP || exp_acc > light_exp) {
1249 			/* light */
1250 			if (old_exposure <= VERY_LOW_EXP) {
1251 				/* very light */
1252 				if (sd->exposure_status == EXPOSURE_VERY_LIGHT)
1253 					++sd->exposure_count;
1254 				else {
1255 					sd->exposure_status =
1256 						EXPOSURE_VERY_LIGHT;
1257 					sd->exposure_count = 1;
1258 				}
1259 			} else {
1260 				/* just light */
1261 				if (sd->exposure_status == EXPOSURE_LIGHT)
1262 					++sd->exposure_count;
1263 				else {
1264 					sd->exposure_status = EXPOSURE_LIGHT;
1265 					sd->exposure_count = 1;
1266 				}
1267 			}
1268 		} else {
1269 			/* not dark or light */
1270 			sd->exposure_status = EXPOSURE_NORMAL;
1271 		}
1272 	}
1273 
1274 	framerate = atomic_read(&sd->fps);
1275 	if (framerate > 30 || framerate < 1)
1276 		framerate = 1;
1277 
1278 	if (!sd->params.flickerControl.disabled) {
1279 		/* Flicker control on */
1280 		if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
1281 		     sd->exposure_status == EXPOSURE_DARK) &&
1282 		    sd->exposure_count >= DARK_TIME * framerate &&
1283 		    sd->params.sensorFps.divisor < 2) {
1284 
1285 			/* dark for too long */
1286 			++sd->params.sensorFps.divisor;
1287 			setfps = 1;
1288 
1289 			sd->params.flickerControl.coarseJump =
1290 				flicker_jumps[sd->mainsFreq]
1291 					     [sd->params.sensorFps.baserate]
1292 					     [sd->params.sensorFps.divisor];
1293 			setflicker = 1;
1294 
1295 			new_exposure = sd->params.flickerControl.coarseJump-1;
1296 			while (new_exposure < old_exposure / 2)
1297 				new_exposure +=
1298 					sd->params.flickerControl.coarseJump;
1299 			sd->params.exposure.coarseExpLo = new_exposure & 0xff;
1300 			sd->params.exposure.coarseExpHi = new_exposure >> 8;
1301 			setexp = 1;
1302 			sd->exposure_status = EXPOSURE_NORMAL;
1303 			gspca_dbg(gspca_dev, D_CONF, "Automatically decreasing sensor_fps\n");
1304 
1305 		} else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
1306 			    sd->exposure_status == EXPOSURE_LIGHT) &&
1307 			   sd->exposure_count >= LIGHT_TIME * framerate &&
1308 			   sd->params.sensorFps.divisor > 0) {
1309 
1310 			/* light for too long */
1311 			int max_exp = FIRMWARE_VERSION(1, 2) ? MAX_EXP_102 :
1312 							       MAX_EXP;
1313 			--sd->params.sensorFps.divisor;
1314 			setfps = 1;
1315 
1316 			sd->params.flickerControl.coarseJump =
1317 				flicker_jumps[sd->mainsFreq]
1318 					     [sd->params.sensorFps.baserate]
1319 					     [sd->params.sensorFps.divisor];
1320 			setflicker = 1;
1321 
1322 			new_exposure = sd->params.flickerControl.coarseJump-1;
1323 			while (new_exposure < 2 * old_exposure &&
1324 			       new_exposure +
1325 			       sd->params.flickerControl.coarseJump < max_exp)
1326 				new_exposure +=
1327 					sd->params.flickerControl.coarseJump;
1328 			sd->params.exposure.coarseExpLo = new_exposure & 0xff;
1329 			sd->params.exposure.coarseExpHi = new_exposure >> 8;
1330 			setexp = 1;
1331 			sd->exposure_status = EXPOSURE_NORMAL;
1332 			gspca_dbg(gspca_dev, D_CONF, "Automatically increasing sensor_fps\n");
1333 		}
1334 	} else {
1335 		/* Flicker control off */
1336 		if ((sd->exposure_status == EXPOSURE_VERY_DARK ||
1337 		     sd->exposure_status == EXPOSURE_DARK) &&
1338 		    sd->exposure_count >= DARK_TIME * framerate &&
1339 		    sd->params.sensorFps.divisor < 2) {
1340 
1341 			/* dark for too long */
1342 			++sd->params.sensorFps.divisor;
1343 			setfps = 1;
1344 
1345 			if (sd->params.exposure.gain > 0) {
1346 				--sd->params.exposure.gain;
1347 				setexp = 1;
1348 			}
1349 			sd->exposure_status = EXPOSURE_NORMAL;
1350 			gspca_dbg(gspca_dev, D_CONF, "Automatically decreasing sensor_fps\n");
1351 
1352 		} else if ((sd->exposure_status == EXPOSURE_VERY_LIGHT ||
1353 			    sd->exposure_status == EXPOSURE_LIGHT) &&
1354 			   sd->exposure_count >= LIGHT_TIME * framerate &&
1355 			   sd->params.sensorFps.divisor > 0) {
1356 
1357 			/* light for too long */
1358 			--sd->params.sensorFps.divisor;
1359 			setfps = 1;
1360 
1361 			if (sd->params.exposure.gain <
1362 			    sd->params.exposure.gainMode - 1) {
1363 				++sd->params.exposure.gain;
1364 				setexp = 1;
1365 			}
1366 			sd->exposure_status = EXPOSURE_NORMAL;
1367 			gspca_dbg(gspca_dev, D_CONF, "Automatically increasing sensor_fps\n");
1368 		}
1369 	}
1370 
1371 	if (setexp)
1372 		command_setexposure(gspca_dev);
1373 
1374 	if (setfps)
1375 		command_setsensorfps(gspca_dev);
1376 
1377 	if (setflicker)
1378 		command_setflickerctrl(gspca_dev);
1379 }
1380 
1381 /*-----------------------------------------------------------------*/
1382 /* if flicker is switched off, this function switches it back on.It checks,
1383    however, that conditions are suitable before restarting it.
1384    This should only be called for firmware version 1.2.
1385 
1386    It also adjust the colour balance when an exposure step is detected - as
1387    long as flicker is running
1388 */
restart_flicker(struct gspca_dev * gspca_dev)1389 static void restart_flicker(struct gspca_dev *gspca_dev)
1390 {
1391 	struct sd *sd = (struct sd *) gspca_dev;
1392 	int cam_exposure, old_exp;
1393 
1394 	if (!FIRMWARE_VERSION(1, 2))
1395 		return;
1396 
1397 	cam_exposure = atomic_read(&sd->cam_exposure);
1398 
1399 	if (sd->params.flickerControl.flickerMode == 0 ||
1400 	    cam_exposure == 0)
1401 		return;
1402 
1403 	old_exp = sd->params.exposure.coarseExpLo +
1404 		  sd->params.exposure.coarseExpHi*256;
1405 	/*
1406 	  see how far away camera exposure is from a valid
1407 	  flicker exposure value
1408 	*/
1409 	cam_exposure %= sd->params.flickerControl.coarseJump;
1410 	if (!sd->params.flickerControl.disabled &&
1411 	    cam_exposure <= sd->params.flickerControl.coarseJump - 3) {
1412 		/* Flicker control auto-disabled */
1413 		sd->params.flickerControl.disabled = 1;
1414 	}
1415 
1416 	if (sd->params.flickerControl.disabled &&
1417 	    old_exp > sd->params.flickerControl.coarseJump +
1418 		      ROUND_UP_EXP_FOR_FLICKER) {
1419 		/* exposure is now high enough to switch
1420 		   flicker control back on */
1421 		set_flicker(gspca_dev, 1, 1);
1422 	}
1423 }
1424 
1425 /* this function is called at probe time */
sd_config(struct gspca_dev * gspca_dev,const struct usb_device_id * id)1426 static int sd_config(struct gspca_dev *gspca_dev,
1427 			const struct usb_device_id *id)
1428 {
1429 	struct sd *sd = (struct sd *) gspca_dev;
1430 	struct cam *cam;
1431 
1432 	sd->mainsFreq = FREQ_DEF == V4L2_CID_POWER_LINE_FREQUENCY_60HZ;
1433 	reset_camera_params(gspca_dev);
1434 
1435 	gspca_dbg(gspca_dev, D_PROBE, "cpia CPiA camera detected (vid/pid 0x%04X:0x%04X)\n",
1436 		  id->idVendor, id->idProduct);
1437 
1438 	cam = &gspca_dev->cam;
1439 	cam->cam_mode = mode;
1440 	cam->nmodes = ARRAY_SIZE(mode);
1441 
1442 	goto_low_power(gspca_dev);
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