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