]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/media/video/cpia.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'upstream' of git://ftp.linux-mips.org/pub/scm/upstream-linus
[mirror_ubuntu-artful-kernel.git] / drivers / media / video / cpia.c
1 /*
2 * cpia CPiA driver
3 *
4 * Supports CPiA based Video Camera's.
5 *
6 * (C) Copyright 1999-2000 Peter Pregler
7 * (C) Copyright 1999-2000 Scott J. Bertin
8 * (C) Copyright 1999-2000 Johannes Erdfelt <johannes@erdfelt.com>
9 * (C) Copyright 2000 STMicroelectronics
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 /* define _CPIA_DEBUG_ for verbose debug output (see cpia.h) */
27 /* #define _CPIA_DEBUG_ 1 */
28
29
30 #include <linux/module.h>
31 #include <linux/init.h>
32 #include <linux/fs.h>
33 #include <linux/vmalloc.h>
34 #include <linux/slab.h>
35 #include <linux/proc_fs.h>
36 #include <linux/ctype.h>
37 #include <linux/pagemap.h>
38 #include <linux/delay.h>
39 #include <asm/io.h>
40 #include <linux/mutex.h>
41
42 #ifdef CONFIG_KMOD
43 #include <linux/kmod.h>
44 #endif
45
46 #include "cpia.h"
47
48 static int video_nr = -1;
49
50 #ifdef MODULE
51 module_param(video_nr, int, 0);
52 MODULE_AUTHOR("Scott J. Bertin <sbertin@securenym.net> & Peter Pregler <Peter_Pregler@email.com> & Johannes Erdfelt <johannes@erdfelt.com>");
53 MODULE_DESCRIPTION("V4L-driver for Vision CPiA based cameras");
54 MODULE_LICENSE("GPL");
55 MODULE_SUPPORTED_DEVICE("video");
56 #endif
57
58 static unsigned short colorspace_conv;
59 module_param(colorspace_conv, ushort, 0444);
60 MODULE_PARM_DESC(colorspace_conv,
61 " Colorspace conversion:"
62 "\n 0 = disable, 1 = enable"
63 "\n Default value is 0"
64 );
65
66 #define ABOUT "V4L-Driver for Vision CPiA based cameras"
67
68 #ifndef VID_HARDWARE_CPIA
69 #define VID_HARDWARE_CPIA 24 /* FIXME -> from linux/videodev.h */
70 #endif
71
72 #define CPIA_MODULE_CPIA (0<<5)
73 #define CPIA_MODULE_SYSTEM (1<<5)
74 #define CPIA_MODULE_VP_CTRL (5<<5)
75 #define CPIA_MODULE_CAPTURE (6<<5)
76 #define CPIA_MODULE_DEBUG (7<<5)
77
78 #define INPUT (DATA_IN << 8)
79 #define OUTPUT (DATA_OUT << 8)
80
81 #define CPIA_COMMAND_GetCPIAVersion (INPUT | CPIA_MODULE_CPIA | 1)
82 #define CPIA_COMMAND_GetPnPID (INPUT | CPIA_MODULE_CPIA | 2)
83 #define CPIA_COMMAND_GetCameraStatus (INPUT | CPIA_MODULE_CPIA | 3)
84 #define CPIA_COMMAND_GotoHiPower (OUTPUT | CPIA_MODULE_CPIA | 4)
85 #define CPIA_COMMAND_GotoLoPower (OUTPUT | CPIA_MODULE_CPIA | 5)
86 #define CPIA_COMMAND_GotoSuspend (OUTPUT | CPIA_MODULE_CPIA | 7)
87 #define CPIA_COMMAND_GotoPassThrough (OUTPUT | CPIA_MODULE_CPIA | 8)
88 #define CPIA_COMMAND_ModifyCameraStatus (OUTPUT | CPIA_MODULE_CPIA | 10)
89
90 #define CPIA_COMMAND_ReadVCRegs (INPUT | CPIA_MODULE_SYSTEM | 1)
91 #define CPIA_COMMAND_WriteVCReg (OUTPUT | CPIA_MODULE_SYSTEM | 2)
92 #define CPIA_COMMAND_ReadMCPorts (INPUT | CPIA_MODULE_SYSTEM | 3)
93 #define CPIA_COMMAND_WriteMCPort (OUTPUT | CPIA_MODULE_SYSTEM | 4)
94 #define CPIA_COMMAND_SetBaudRate (OUTPUT | CPIA_MODULE_SYSTEM | 5)
95 #define CPIA_COMMAND_SetECPTiming (OUTPUT | CPIA_MODULE_SYSTEM | 6)
96 #define CPIA_COMMAND_ReadIDATA (INPUT | CPIA_MODULE_SYSTEM | 7)
97 #define CPIA_COMMAND_WriteIDATA (OUTPUT | CPIA_MODULE_SYSTEM | 8)
98 #define CPIA_COMMAND_GenericCall (OUTPUT | CPIA_MODULE_SYSTEM | 9)
99 #define CPIA_COMMAND_I2CStart (OUTPUT | CPIA_MODULE_SYSTEM | 10)
100 #define CPIA_COMMAND_I2CStop (OUTPUT | CPIA_MODULE_SYSTEM | 11)
101 #define CPIA_COMMAND_I2CWrite (OUTPUT | CPIA_MODULE_SYSTEM | 12)
102 #define CPIA_COMMAND_I2CRead (INPUT | CPIA_MODULE_SYSTEM | 13)
103
104 #define CPIA_COMMAND_GetVPVersion (INPUT | CPIA_MODULE_VP_CTRL | 1)
105 #define CPIA_COMMAND_ResetFrameCounter (INPUT | CPIA_MODULE_VP_CTRL | 2)
106 #define CPIA_COMMAND_SetColourParams (OUTPUT | CPIA_MODULE_VP_CTRL | 3)
107 #define CPIA_COMMAND_SetExposure (OUTPUT | CPIA_MODULE_VP_CTRL | 4)
108 #define CPIA_COMMAND_SetColourBalance (OUTPUT | CPIA_MODULE_VP_CTRL | 6)
109 #define CPIA_COMMAND_SetSensorFPS (OUTPUT | CPIA_MODULE_VP_CTRL | 7)
110 #define CPIA_COMMAND_SetVPDefaults (OUTPUT | CPIA_MODULE_VP_CTRL | 8)
111 #define CPIA_COMMAND_SetApcor (OUTPUT | CPIA_MODULE_VP_CTRL | 9)
112 #define CPIA_COMMAND_SetFlickerCtrl (OUTPUT | CPIA_MODULE_VP_CTRL | 10)
113 #define CPIA_COMMAND_SetVLOffset (OUTPUT | CPIA_MODULE_VP_CTRL | 11)
114 #define CPIA_COMMAND_GetColourParams (INPUT | CPIA_MODULE_VP_CTRL | 16)
115 #define CPIA_COMMAND_GetColourBalance (INPUT | CPIA_MODULE_VP_CTRL | 17)
116 #define CPIA_COMMAND_GetExposure (INPUT | CPIA_MODULE_VP_CTRL | 18)
117 #define CPIA_COMMAND_SetSensorMatrix (OUTPUT | CPIA_MODULE_VP_CTRL | 19)
118 #define CPIA_COMMAND_ColourBars (OUTPUT | CPIA_MODULE_VP_CTRL | 25)
119 #define CPIA_COMMAND_ReadVPRegs (INPUT | CPIA_MODULE_VP_CTRL | 30)
120 #define CPIA_COMMAND_WriteVPReg (OUTPUT | CPIA_MODULE_VP_CTRL | 31)
121
122 #define CPIA_COMMAND_GrabFrame (OUTPUT | CPIA_MODULE_CAPTURE | 1)
123 #define CPIA_COMMAND_UploadFrame (OUTPUT | CPIA_MODULE_CAPTURE | 2)
124 #define CPIA_COMMAND_SetGrabMode (OUTPUT | CPIA_MODULE_CAPTURE | 3)
125 #define CPIA_COMMAND_InitStreamCap (OUTPUT | CPIA_MODULE_CAPTURE | 4)
126 #define CPIA_COMMAND_FiniStreamCap (OUTPUT | CPIA_MODULE_CAPTURE | 5)
127 #define CPIA_COMMAND_StartStreamCap (OUTPUT | CPIA_MODULE_CAPTURE | 6)
128 #define CPIA_COMMAND_EndStreamCap (OUTPUT | CPIA_MODULE_CAPTURE | 7)
129 #define CPIA_COMMAND_SetFormat (OUTPUT | CPIA_MODULE_CAPTURE | 8)
130 #define CPIA_COMMAND_SetROI (OUTPUT | CPIA_MODULE_CAPTURE | 9)
131 #define CPIA_COMMAND_SetCompression (OUTPUT | CPIA_MODULE_CAPTURE | 10)
132 #define CPIA_COMMAND_SetCompressionTarget (OUTPUT | CPIA_MODULE_CAPTURE | 11)
133 #define CPIA_COMMAND_SetYUVThresh (OUTPUT | CPIA_MODULE_CAPTURE | 12)
134 #define CPIA_COMMAND_SetCompressionParams (OUTPUT | CPIA_MODULE_CAPTURE | 13)
135 #define CPIA_COMMAND_DiscardFrame (OUTPUT | CPIA_MODULE_CAPTURE | 14)
136 #define CPIA_COMMAND_GrabReset (OUTPUT | CPIA_MODULE_CAPTURE | 15)
137
138 #define CPIA_COMMAND_OutputRS232 (OUTPUT | CPIA_MODULE_DEBUG | 1)
139 #define CPIA_COMMAND_AbortProcess (OUTPUT | CPIA_MODULE_DEBUG | 4)
140 #define CPIA_COMMAND_SetDramPage (OUTPUT | CPIA_MODULE_DEBUG | 5)
141 #define CPIA_COMMAND_StartDramUpload (OUTPUT | CPIA_MODULE_DEBUG | 6)
142 #define CPIA_COMMAND_StartDummyDtream (OUTPUT | CPIA_MODULE_DEBUG | 8)
143 #define CPIA_COMMAND_AbortStream (OUTPUT | CPIA_MODULE_DEBUG | 9)
144 #define CPIA_COMMAND_DownloadDRAM (OUTPUT | CPIA_MODULE_DEBUG | 10)
145 #define CPIA_COMMAND_Null (OUTPUT | CPIA_MODULE_DEBUG | 11)
146
147 enum {
148 FRAME_READY, /* Ready to grab into */
149 FRAME_GRABBING, /* In the process of being grabbed into */
150 FRAME_DONE, /* Finished grabbing, but not been synced yet */
151 FRAME_UNUSED, /* Unused (no MCAPTURE) */
152 };
153
154 #define COMMAND_NONE 0x0000
155 #define COMMAND_SETCOMPRESSION 0x0001
156 #define COMMAND_SETCOMPRESSIONTARGET 0x0002
157 #define COMMAND_SETCOLOURPARAMS 0x0004
158 #define COMMAND_SETFORMAT 0x0008
159 #define COMMAND_PAUSE 0x0010
160 #define COMMAND_RESUME 0x0020
161 #define COMMAND_SETYUVTHRESH 0x0040
162 #define COMMAND_SETECPTIMING 0x0080
163 #define COMMAND_SETCOMPRESSIONPARAMS 0x0100
164 #define COMMAND_SETEXPOSURE 0x0200
165 #define COMMAND_SETCOLOURBALANCE 0x0400
166 #define COMMAND_SETSENSORFPS 0x0800
167 #define COMMAND_SETAPCOR 0x1000
168 #define COMMAND_SETFLICKERCTRL 0x2000
169 #define COMMAND_SETVLOFFSET 0x4000
170 #define COMMAND_SETLIGHTS 0x8000
171
172 #define ROUND_UP_EXP_FOR_FLICKER 15
173
174 /* Constants for automatic frame rate adjustment */
175 #define MAX_EXP 302
176 #define MAX_EXP_102 255
177 #define LOW_EXP 140
178 #define VERY_LOW_EXP 70
179 #define TC 94
180 #define EXP_ACC_DARK 50
181 #define EXP_ACC_LIGHT 90
182 #define HIGH_COMP_102 160
183 #define MAX_COMP 239
184 #define DARK_TIME 3
185 #define LIGHT_TIME 3
186
187 /* Maximum number of 10ms loops to wait for the stream to become ready */
188 #define READY_TIMEOUT 100
189
190 /* Developer's Guide Table 5 p 3-34
191 * indexed by [mains][sensorFps.baserate][sensorFps.divisor]*/
192 static u8 flicker_jumps[2][2][4] =
193 { { { 76, 38, 19, 9 }, { 92, 46, 23, 11 } },
194 { { 64, 32, 16, 8 }, { 76, 38, 19, 9} }
195 };
196
197 /* forward declaration of local function */
198 static void reset_camera_struct(struct cam_data *cam);
199 static int find_over_exposure(int brightness);
200 static void set_flicker(struct cam_params *params, volatile u32 *command_flags,
201 int on);
202
203
204 /**********************************************************************
205 *
206 * Memory management
207 *
208 **********************************************************************/
209 static void *rvmalloc(unsigned long size)
210 {
211 void *mem;
212 unsigned long adr;
213
214 size = PAGE_ALIGN(size);
215 mem = vmalloc_32(size);
216 if (!mem)
217 return NULL;
218
219 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
220 adr = (unsigned long) mem;
221 while (size > 0) {
222 SetPageReserved(vmalloc_to_page((void *)adr));
223 adr += PAGE_SIZE;
224 size -= PAGE_SIZE;
225 }
226
227 return mem;
228 }
229
230 static void rvfree(void *mem, unsigned long size)
231 {
232 unsigned long adr;
233
234 if (!mem)
235 return;
236
237 adr = (unsigned long) mem;
238 while ((long) size > 0) {
239 ClearPageReserved(vmalloc_to_page((void *)adr));
240 adr += PAGE_SIZE;
241 size -= PAGE_SIZE;
242 }
243 vfree(mem);
244 }
245
246 /**********************************************************************
247 *
248 * /proc interface
249 *
250 **********************************************************************/
251 #ifdef CONFIG_PROC_FS
252 static struct proc_dir_entry *cpia_proc_root=NULL;
253
254 static int cpia_read_proc(char *page, char **start, off_t off,
255 int count, int *eof, void *data)
256 {
257 char *out = page;
258 int len, tmp;
259 struct cam_data *cam = data;
260 char tmpstr[29];
261
262 /* IMPORTANT: This output MUST be kept under PAGE_SIZE
263 * or we need to get more sophisticated. */
264
265 out += sprintf(out, "read-only\n-----------------------\n");
266 out += sprintf(out, "V4L Driver version: %d.%d.%d\n",
267 CPIA_MAJ_VER, CPIA_MIN_VER, CPIA_PATCH_VER);
268 out += sprintf(out, "CPIA Version: %d.%02d (%d.%d)\n",
269 cam->params.version.firmwareVersion,
270 cam->params.version.firmwareRevision,
271 cam->params.version.vcVersion,
272 cam->params.version.vcRevision);
273 out += sprintf(out, "CPIA PnP-ID: %04x:%04x:%04x\n",
274 cam->params.pnpID.vendor, cam->params.pnpID.product,
275 cam->params.pnpID.deviceRevision);
276 out += sprintf(out, "VP-Version: %d.%d %04x\n",
277 cam->params.vpVersion.vpVersion,
278 cam->params.vpVersion.vpRevision,
279 cam->params.vpVersion.cameraHeadID);
280
281 out += sprintf(out, "system_state: %#04x\n",
282 cam->params.status.systemState);
283 out += sprintf(out, "grab_state: %#04x\n",
284 cam->params.status.grabState);
285 out += sprintf(out, "stream_state: %#04x\n",
286 cam->params.status.streamState);
287 out += sprintf(out, "fatal_error: %#04x\n",
288 cam->params.status.fatalError);
289 out += sprintf(out, "cmd_error: %#04x\n",
290 cam->params.status.cmdError);
291 out += sprintf(out, "debug_flags: %#04x\n",
292 cam->params.status.debugFlags);
293 out += sprintf(out, "vp_status: %#04x\n",
294 cam->params.status.vpStatus);
295 out += sprintf(out, "error_code: %#04x\n",
296 cam->params.status.errorCode);
297 /* QX3 specific entries */
298 if (cam->params.qx3.qx3_detected) {
299 out += sprintf(out, "button: %4d\n",
300 cam->params.qx3.button);
301 out += sprintf(out, "cradled: %4d\n",
302 cam->params.qx3.cradled);
303 }
304 out += sprintf(out, "video_size: %s\n",
305 cam->params.format.videoSize == VIDEOSIZE_CIF ?
306 "CIF " : "QCIF");
307 out += sprintf(out, "roi: (%3d, %3d) to (%3d, %3d)\n",
308 cam->params.roi.colStart*8,
309 cam->params.roi.rowStart*4,
310 cam->params.roi.colEnd*8,
311 cam->params.roi.rowEnd*4);
312 out += sprintf(out, "actual_fps: %3d\n", cam->fps);
313 out += sprintf(out, "transfer_rate: %4dkB/s\n",
314 cam->transfer_rate);
315
316 out += sprintf(out, "\nread-write\n");
317 out += sprintf(out, "----------------------- current min"
318 " max default comment\n");
319 out += sprintf(out, "brightness: %8d %8d %8d %8d\n",
320 cam->params.colourParams.brightness, 0, 100, 50);
321 if (cam->params.version.firmwareVersion == 1 &&
322 cam->params.version.firmwareRevision == 2)
323 /* 1-02 firmware limits contrast to 80 */
324 tmp = 80;
325 else
326 tmp = 96;
327
328 out += sprintf(out, "contrast: %8d %8d %8d %8d"
329 " steps of 8\n",
330 cam->params.colourParams.contrast, 0, tmp, 48);
331 out += sprintf(out, "saturation: %8d %8d %8d %8d\n",
332 cam->params.colourParams.saturation, 0, 100, 50);
333 tmp = (25000+5000*cam->params.sensorFps.baserate)/
334 (1<<cam->params.sensorFps.divisor);
335 out += sprintf(out, "sensor_fps: %4d.%03d %8d %8d %8d\n",
336 tmp/1000, tmp%1000, 3, 30, 15);
337 out += sprintf(out, "stream_start_line: %8d %8d %8d %8d\n",
338 2*cam->params.streamStartLine, 0,
339 cam->params.format.videoSize == VIDEOSIZE_CIF ? 288:144,
340 cam->params.format.videoSize == VIDEOSIZE_CIF ? 240:120);
341 out += sprintf(out, "sub_sample: %8s %8s %8s %8s\n",
342 cam->params.format.subSample == SUBSAMPLE_420 ?
343 "420" : "422", "420", "422", "422");
344 out += sprintf(out, "yuv_order: %8s %8s %8s %8s\n",
345 cam->params.format.yuvOrder == YUVORDER_YUYV ?
346 "YUYV" : "UYVY", "YUYV" , "UYVY", "YUYV");
347 out += sprintf(out, "ecp_timing: %8s %8s %8s %8s\n",
348 cam->params.ecpTiming ? "slow" : "normal", "slow",
349 "normal", "normal");
350
351 if (cam->params.colourBalance.balanceMode == 2) {
352 sprintf(tmpstr, "auto");
353 } else {
354 sprintf(tmpstr, "manual");
355 }
356 out += sprintf(out, "color_balance_mode: %8s %8s %8s"
357 " %8s\n", tmpstr, "manual", "auto", "auto");
358 out += sprintf(out, "red_gain: %8d %8d %8d %8d\n",
359 cam->params.colourBalance.redGain, 0, 212, 32);
360 out += sprintf(out, "green_gain: %8d %8d %8d %8d\n",
361 cam->params.colourBalance.greenGain, 0, 212, 6);
362 out += sprintf(out, "blue_gain: %8d %8d %8d %8d\n",
363 cam->params.colourBalance.blueGain, 0, 212, 92);
364
365 if (cam->params.version.firmwareVersion == 1 &&
366 cam->params.version.firmwareRevision == 2)
367 /* 1-02 firmware limits gain to 2 */
368 sprintf(tmpstr, "%8d %8d %8d", 1, 2, 2);
369 else
370 sprintf(tmpstr, "%8d %8d %8d", 1, 8, 2);
371
372 if (cam->params.exposure.gainMode == 0)
373 out += sprintf(out, "max_gain: unknown %28s"
374 " powers of 2\n", tmpstr);
375 else
376 out += sprintf(out, "max_gain: %8d %28s"
377 " 1,2,4 or 8 \n",
378 1<<(cam->params.exposure.gainMode-1), tmpstr);
379
380 switch(cam->params.exposure.expMode) {
381 case 1:
382 case 3:
383 sprintf(tmpstr, "manual");
384 break;
385 case 2:
386 sprintf(tmpstr, "auto");
387 break;
388 default:
389 sprintf(tmpstr, "unknown");
390 break;
391 }
392 out += sprintf(out, "exposure_mode: %8s %8s %8s"
393 " %8s\n", tmpstr, "manual", "auto", "auto");
394 out += sprintf(out, "centre_weight: %8s %8s %8s %8s\n",
395 (2-cam->params.exposure.centreWeight) ? "on" : "off",
396 "off", "on", "on");
397 out += sprintf(out, "gain: %8d %8d max_gain %8d 1,2,4,8 possible\n",
398 1<<cam->params.exposure.gain, 1, 1);
399 if (cam->params.version.firmwareVersion == 1 &&
400 cam->params.version.firmwareRevision == 2)
401 /* 1-02 firmware limits fineExp/2 to 127 */
402 tmp = 254;
403 else
404 tmp = 510;
405
406 out += sprintf(out, "fine_exp: %8d %8d %8d %8d\n",
407 cam->params.exposure.fineExp*2, 0, tmp, 0);
408 if (cam->params.version.firmwareVersion == 1 &&
409 cam->params.version.firmwareRevision == 2)
410 /* 1-02 firmware limits coarseExpHi to 0 */
411 tmp = MAX_EXP_102;
412 else
413 tmp = MAX_EXP;
414
415 out += sprintf(out, "coarse_exp: %8d %8d %8d"
416 " %8d\n", cam->params.exposure.coarseExpLo+
417 256*cam->params.exposure.coarseExpHi, 0, tmp, 185);
418 out += sprintf(out, "red_comp: %8d %8d %8d %8d\n",
419 cam->params.exposure.redComp, COMP_RED, 255, COMP_RED);
420 out += sprintf(out, "green1_comp: %8d %8d %8d %8d\n",
421 cam->params.exposure.green1Comp, COMP_GREEN1, 255,
422 COMP_GREEN1);
423 out += sprintf(out, "green2_comp: %8d %8d %8d %8d\n",
424 cam->params.exposure.green2Comp, COMP_GREEN2, 255,
425 COMP_GREEN2);
426 out += sprintf(out, "blue_comp: %8d %8d %8d %8d\n",
427 cam->params.exposure.blueComp, COMP_BLUE, 255, COMP_BLUE);
428
429 out += sprintf(out, "apcor_gain1: %#8x %#8x %#8x %#8x\n",
430 cam->params.apcor.gain1, 0, 0xff, 0x1c);
431 out += sprintf(out, "apcor_gain2: %#8x %#8x %#8x %#8x\n",
432 cam->params.apcor.gain2, 0, 0xff, 0x1a);
433 out += sprintf(out, "apcor_gain4: %#8x %#8x %#8x %#8x\n",
434 cam->params.apcor.gain4, 0, 0xff, 0x2d);
435 out += sprintf(out, "apcor_gain8: %#8x %#8x %#8x %#8x\n",
436 cam->params.apcor.gain8, 0, 0xff, 0x2a);
437 out += sprintf(out, "vl_offset_gain1: %8d %8d %8d %8d\n",
438 cam->params.vlOffset.gain1, 0, 255, 24);
439 out += sprintf(out, "vl_offset_gain2: %8d %8d %8d %8d\n",
440 cam->params.vlOffset.gain2, 0, 255, 28);
441 out += sprintf(out, "vl_offset_gain4: %8d %8d %8d %8d\n",
442 cam->params.vlOffset.gain4, 0, 255, 30);
443 out += sprintf(out, "vl_offset_gain8: %8d %8d %8d %8d\n",
444 cam->params.vlOffset.gain8, 0, 255, 30);
445 out += sprintf(out, "flicker_control: %8s %8s %8s %8s\n",
446 cam->params.flickerControl.flickerMode ? "on" : "off",
447 "off", "on", "off");
448 out += sprintf(out, "mains_frequency: %8d %8d %8d %8d"
449 " only 50/60\n",
450 cam->mainsFreq ? 60 : 50, 50, 60, 50);
451 if(cam->params.flickerControl.allowableOverExposure < 0)
452 out += sprintf(out, "allowable_overexposure: %4dauto auto %8d auto\n",
453 -cam->params.flickerControl.allowableOverExposure,
454 255);
455 else
456 out += sprintf(out, "allowable_overexposure: %8d auto %8d auto\n",
457 cam->params.flickerControl.allowableOverExposure,
458 255);
459 out += sprintf(out, "compression_mode: ");
460 switch(cam->params.compression.mode) {
461 case CPIA_COMPRESSION_NONE:
462 out += sprintf(out, "%8s", "none");
463 break;
464 case CPIA_COMPRESSION_AUTO:
465 out += sprintf(out, "%8s", "auto");
466 break;
467 case CPIA_COMPRESSION_MANUAL:
468 out += sprintf(out, "%8s", "manual");
469 break;
470 default:
471 out += sprintf(out, "%8s", "unknown");
472 break;
473 }
474 out += sprintf(out, " none,auto,manual auto\n");
475 out += sprintf(out, "decimation_enable: %8s %8s %8s %8s\n",
476 cam->params.compression.decimation ==
477 DECIMATION_ENAB ? "on":"off", "off", "on",
478 "off");
479 out += sprintf(out, "compression_target: %9s %9s %9s %9s\n",
480 cam->params.compressionTarget.frTargeting ==
481 CPIA_COMPRESSION_TARGET_FRAMERATE ?
482 "framerate":"quality",
483 "framerate", "quality", "quality");
484 out += sprintf(out, "target_framerate: %8d %8d %8d %8d\n",
485 cam->params.compressionTarget.targetFR, 1, 30, 15);
486 out += sprintf(out, "target_quality: %8d %8d %8d %8d\n",
487 cam->params.compressionTarget.targetQ, 1, 64, 5);
488 out += sprintf(out, "y_threshold: %8d %8d %8d %8d\n",
489 cam->params.yuvThreshold.yThreshold, 0, 31, 6);
490 out += sprintf(out, "uv_threshold: %8d %8d %8d %8d\n",
491 cam->params.yuvThreshold.uvThreshold, 0, 31, 6);
492 out += sprintf(out, "hysteresis: %8d %8d %8d %8d\n",
493 cam->params.compressionParams.hysteresis, 0, 255, 3);
494 out += sprintf(out, "threshold_max: %8d %8d %8d %8d\n",
495 cam->params.compressionParams.threshMax, 0, 255, 11);
496 out += sprintf(out, "small_step: %8d %8d %8d %8d\n",
497 cam->params.compressionParams.smallStep, 0, 255, 1);
498 out += sprintf(out, "large_step: %8d %8d %8d %8d\n",
499 cam->params.compressionParams.largeStep, 0, 255, 3);
500 out += sprintf(out, "decimation_hysteresis: %8d %8d %8d %8d\n",
501 cam->params.compressionParams.decimationHysteresis,
502 0, 255, 2);
503 out += sprintf(out, "fr_diff_step_thresh: %8d %8d %8d %8d\n",
504 cam->params.compressionParams.frDiffStepThresh,
505 0, 255, 5);
506 out += sprintf(out, "q_diff_step_thresh: %8d %8d %8d %8d\n",
507 cam->params.compressionParams.qDiffStepThresh,
508 0, 255, 3);
509 out += sprintf(out, "decimation_thresh_mod: %8d %8d %8d %8d\n",
510 cam->params.compressionParams.decimationThreshMod,
511 0, 255, 2);
512 /* QX3 specific entries */
513 if (cam->params.qx3.qx3_detected) {
514 out += sprintf(out, "toplight: %8s %8s %8s %8s\n",
515 cam->params.qx3.toplight ? "on" : "off",
516 "off", "on", "off");
517 out += sprintf(out, "bottomlight: %8s %8s %8s %8s\n",
518 cam->params.qx3.bottomlight ? "on" : "off",
519 "off", "on", "off");
520 }
521
522 len = out - page;
523 len -= off;
524 if (len < count) {
525 *eof = 1;
526 if (len <= 0) return 0;
527 } else
528 len = count;
529
530 *start = page + off;
531 return len;
532 }
533
534
535 static int match(char *checkstr, char **buffer, unsigned long *count,
536 int *find_colon, int *err)
537 {
538 int ret, colon_found = 1;
539 int len = strlen(checkstr);
540 ret = (len <= *count && strncmp(*buffer, checkstr, len) == 0);
541 if (ret) {
542 *buffer += len;
543 *count -= len;
544 if (*find_colon) {
545 colon_found = 0;
546 while (*count && (**buffer == ' ' || **buffer == '\t' ||
547 (!colon_found && **buffer == ':'))) {
548 if (**buffer == ':')
549 colon_found = 1;
550 --*count;
551 ++*buffer;
552 }
553 if (!*count || !colon_found)
554 *err = -EINVAL;
555 *find_colon = 0;
556 }
557 }
558 return ret;
559 }
560
561 static unsigned long int value(char **buffer, unsigned long *count, int *err)
562 {
563 char *p;
564 unsigned long int ret;
565 ret = simple_strtoul(*buffer, &p, 0);
566 if (p == *buffer)
567 *err = -EINVAL;
568 else {
569 *count -= p - *buffer;
570 *buffer = p;
571 }
572 return ret;
573 }
574
575 static int cpia_write_proc(struct file *file, const char __user *buf,
576 unsigned long count, void *data)
577 {
578 struct cam_data *cam = data;
579 struct cam_params new_params;
580 char *page, *buffer;
581 int retval, find_colon;
582 int size = count;
583 unsigned long val = 0;
584 u32 command_flags = 0;
585 u8 new_mains;
586
587 /*
588 * This code to copy from buf to page is shamelessly copied
589 * from the comx driver
590 */
591 if (count > PAGE_SIZE) {
592 printk(KERN_ERR "count is %lu > %d!!!\n", count, (int)PAGE_SIZE);
593 return -ENOSPC;
594 }
595
596 if (!(page = (char *)__get_free_page(GFP_KERNEL))) return -ENOMEM;
597
598 if(copy_from_user(page, buf, count))
599 {
600 retval = -EFAULT;
601 goto out;
602 }
603
604 if (page[count-1] == '\n')
605 page[count-1] = '\0';
606 else if (count < PAGE_SIZE)
607 page[count] = '\0';
608 else if (page[count]) {
609 retval = -EINVAL;
610 goto out;
611 }
612
613 buffer = page;
614
615 if (mutex_lock_interruptible(&cam->param_lock))
616 return -ERESTARTSYS;
617
618 /*
619 * Skip over leading whitespace
620 */
621 while (count && isspace(*buffer)) {
622 --count;
623 ++buffer;
624 }
625
626 memcpy(&new_params, &cam->params, sizeof(struct cam_params));
627 new_mains = cam->mainsFreq;
628
629 #define MATCH(x) (match(x, &buffer, &count, &find_colon, &retval))
630 #define VALUE (value(&buffer,&count, &retval))
631 #define FIRMWARE_VERSION(x,y) (new_params.version.firmwareVersion == (x) && \
632 new_params.version.firmwareRevision == (y))
633
634 retval = 0;
635 while (count && !retval) {
636 find_colon = 1;
637 if (MATCH("brightness")) {
638 if (!retval)
639 val = VALUE;
640
641 if (!retval) {
642 if (val <= 100)
643 new_params.colourParams.brightness = val;
644 else
645 retval = -EINVAL;
646 }
647 command_flags |= COMMAND_SETCOLOURPARAMS;
648 if(new_params.flickerControl.allowableOverExposure < 0)
649 new_params.flickerControl.allowableOverExposure =
650 -find_over_exposure(new_params.colourParams.brightness);
651 if(new_params.flickerControl.flickerMode != 0)
652 command_flags |= COMMAND_SETFLICKERCTRL;
653
654 } else if (MATCH("contrast")) {
655 if (!retval)
656 val = VALUE;
657
658 if (!retval) {
659 if (val <= 100) {
660 /* contrast is in steps of 8, so round*/
661 val = ((val + 3) / 8) * 8;
662 /* 1-02 firmware limits contrast to 80*/
663 if (FIRMWARE_VERSION(1,2) && val > 80)
664 val = 80;
665
666 new_params.colourParams.contrast = val;
667 } else
668 retval = -EINVAL;
669 }
670 command_flags |= COMMAND_SETCOLOURPARAMS;
671 } else if (MATCH("saturation")) {
672 if (!retval)
673 val = VALUE;
674
675 if (!retval) {
676 if (val <= 100)
677 new_params.colourParams.saturation = val;
678 else
679 retval = -EINVAL;
680 }
681 command_flags |= COMMAND_SETCOLOURPARAMS;
682 } else if (MATCH("sensor_fps")) {
683 if (!retval)
684 val = VALUE;
685
686 if (!retval) {
687 /* find values so that sensorFPS is minimized,
688 * but >= val */
689 if (val > 30)
690 retval = -EINVAL;
691 else if (val > 25) {
692 new_params.sensorFps.divisor = 0;
693 new_params.sensorFps.baserate = 1;
694 } else if (val > 15) {
695 new_params.sensorFps.divisor = 0;
696 new_params.sensorFps.baserate = 0;
697 } else if (val > 12) {
698 new_params.sensorFps.divisor = 1;
699 new_params.sensorFps.baserate = 1;
700 } else if (val > 7) {
701 new_params.sensorFps.divisor = 1;
702 new_params.sensorFps.baserate = 0;
703 } else if (val > 6) {
704 new_params.sensorFps.divisor = 2;
705 new_params.sensorFps.baserate = 1;
706 } else if (val > 3) {
707 new_params.sensorFps.divisor = 2;
708 new_params.sensorFps.baserate = 0;
709 } else {
710 new_params.sensorFps.divisor = 3;
711 /* Either base rate would work here */
712 new_params.sensorFps.baserate = 1;
713 }
714 new_params.flickerControl.coarseJump =
715 flicker_jumps[new_mains]
716 [new_params.sensorFps.baserate]
717 [new_params.sensorFps.divisor];
718 if (new_params.flickerControl.flickerMode)
719 command_flags |= COMMAND_SETFLICKERCTRL;
720 }
721 command_flags |= COMMAND_SETSENSORFPS;
722 cam->exposure_status = EXPOSURE_NORMAL;
723 } else if (MATCH("stream_start_line")) {
724 if (!retval)
725 val = VALUE;
726
727 if (!retval) {
728 int max_line = 288;
729
730 if (new_params.format.videoSize == VIDEOSIZE_QCIF)
731 max_line = 144;
732 if (val <= max_line)
733 new_params.streamStartLine = val/2;
734 else
735 retval = -EINVAL;
736 }
737 } else if (MATCH("sub_sample")) {
738 if (!retval && MATCH("420"))
739 new_params.format.subSample = SUBSAMPLE_420;
740 else if (!retval && MATCH("422"))
741 new_params.format.subSample = SUBSAMPLE_422;
742 else
743 retval = -EINVAL;
744
745 command_flags |= COMMAND_SETFORMAT;
746 } else if (MATCH("yuv_order")) {
747 if (!retval && MATCH("YUYV"))
748 new_params.format.yuvOrder = YUVORDER_YUYV;
749 else if (!retval && MATCH("UYVY"))
750 new_params.format.yuvOrder = YUVORDER_UYVY;
751 else
752 retval = -EINVAL;
753
754 command_flags |= COMMAND_SETFORMAT;
755 } else if (MATCH("ecp_timing")) {
756 if (!retval && MATCH("normal"))
757 new_params.ecpTiming = 0;
758 else if (!retval && MATCH("slow"))
759 new_params.ecpTiming = 1;
760 else
761 retval = -EINVAL;
762
763 command_flags |= COMMAND_SETECPTIMING;
764 } else if (MATCH("color_balance_mode")) {
765 if (!retval && MATCH("manual"))
766 new_params.colourBalance.balanceMode = 3;
767 else if (!retval && MATCH("auto"))
768 new_params.colourBalance.balanceMode = 2;
769 else
770 retval = -EINVAL;
771
772 command_flags |= COMMAND_SETCOLOURBALANCE;
773 } else if (MATCH("red_gain")) {
774 if (!retval)
775 val = VALUE;
776
777 if (!retval) {
778 if (val <= 212) {
779 new_params.colourBalance.redGain = val;
780 new_params.colourBalance.balanceMode = 1;
781 } else
782 retval = -EINVAL;
783 }
784 command_flags |= COMMAND_SETCOLOURBALANCE;
785 } else if (MATCH("green_gain")) {
786 if (!retval)
787 val = VALUE;
788
789 if (!retval) {
790 if (val <= 212) {
791 new_params.colourBalance.greenGain = val;
792 new_params.colourBalance.balanceMode = 1;
793 } else
794 retval = -EINVAL;
795 }
796 command_flags |= COMMAND_SETCOLOURBALANCE;
797 } else if (MATCH("blue_gain")) {
798 if (!retval)
799 val = VALUE;
800
801 if (!retval) {
802 if (val <= 212) {
803 new_params.colourBalance.blueGain = val;
804 new_params.colourBalance.balanceMode = 1;
805 } else
806 retval = -EINVAL;
807 }
808 command_flags |= COMMAND_SETCOLOURBALANCE;
809 } else if (MATCH("max_gain")) {
810 if (!retval)
811 val = VALUE;
812
813 if (!retval) {
814 /* 1-02 firmware limits gain to 2 */
815 if (FIRMWARE_VERSION(1,2) && val > 2)
816 val = 2;
817 switch(val) {
818 case 1:
819 new_params.exposure.gainMode = 1;
820 break;
821 case 2:
822 new_params.exposure.gainMode = 2;
823 break;
824 case 4:
825 new_params.exposure.gainMode = 3;
826 break;
827 case 8:
828 new_params.exposure.gainMode = 4;
829 break;
830 default:
831 retval = -EINVAL;
832 break;
833 }
834 }
835 command_flags |= COMMAND_SETEXPOSURE;
836 } else if (MATCH("exposure_mode")) {
837 if (!retval && MATCH("auto"))
838 new_params.exposure.expMode = 2;
839 else if (!retval && MATCH("manual")) {
840 if (new_params.exposure.expMode == 2)
841 new_params.exposure.expMode = 3;
842 if(new_params.flickerControl.flickerMode != 0)
843 command_flags |= COMMAND_SETFLICKERCTRL;
844 new_params.flickerControl.flickerMode = 0;
845 } else
846 retval = -EINVAL;
847
848 command_flags |= COMMAND_SETEXPOSURE;
849 } else if (MATCH("centre_weight")) {
850 if (!retval && MATCH("on"))
851 new_params.exposure.centreWeight = 1;
852 else if (!retval && MATCH("off"))
853 new_params.exposure.centreWeight = 2;
854 else
855 retval = -EINVAL;
856
857 command_flags |= COMMAND_SETEXPOSURE;
858 } else if (MATCH("gain")) {
859 if (!retval)
860 val = VALUE;
861
862 if (!retval) {
863 switch(val) {
864 case 1:
865 new_params.exposure.gain = 0;
866 break;
867 case 2:
868 new_params.exposure.gain = 1;
869 break;
870 case 4:
871 new_params.exposure.gain = 2;
872 break;
873 case 8:
874 new_params.exposure.gain = 3;
875 break;
876 default:
877 retval = -EINVAL;
878 break;
879 }
880 new_params.exposure.expMode = 1;
881 if(new_params.flickerControl.flickerMode != 0)
882 command_flags |= COMMAND_SETFLICKERCTRL;
883 new_params.flickerControl.flickerMode = 0;
884 command_flags |= COMMAND_SETEXPOSURE;
885 if (new_params.exposure.gain >
886 new_params.exposure.gainMode-1)
887 retval = -EINVAL;
888 }
889 } else if (MATCH("fine_exp")) {
890 if (!retval)
891 val = VALUE/2;
892
893 if (!retval) {
894 if (val < 256) {
895 /* 1-02 firmware limits fineExp/2 to 127*/
896 if (FIRMWARE_VERSION(1,2) && val > 127)
897 val = 127;
898 new_params.exposure.fineExp = val;
899 new_params.exposure.expMode = 1;
900 command_flags |= COMMAND_SETEXPOSURE;
901 if(new_params.flickerControl.flickerMode != 0)
902 command_flags |= COMMAND_SETFLICKERCTRL;
903 new_params.flickerControl.flickerMode = 0;
904 command_flags |= COMMAND_SETFLICKERCTRL;
905 } else
906 retval = -EINVAL;
907 }
908 } else if (MATCH("coarse_exp")) {
909 if (!retval)
910 val = VALUE;
911
912 if (!retval) {
913 if (val <= MAX_EXP) {
914 if (FIRMWARE_VERSION(1,2) &&
915 val > MAX_EXP_102)
916 val = MAX_EXP_102;
917 new_params.exposure.coarseExpLo =
918 val & 0xff;
919 new_params.exposure.coarseExpHi =
920 val >> 8;
921 new_params.exposure.expMode = 1;
922 command_flags |= COMMAND_SETEXPOSURE;
923 if(new_params.flickerControl.flickerMode != 0)
924 command_flags |= COMMAND_SETFLICKERCTRL;
925 new_params.flickerControl.flickerMode = 0;
926 command_flags |= COMMAND_SETFLICKERCTRL;
927 } else
928 retval = -EINVAL;
929 }
930 } else if (MATCH("red_comp")) {
931 if (!retval)
932 val = VALUE;
933
934 if (!retval) {
935 if (val >= COMP_RED && val <= 255) {
936 new_params.exposure.redComp = val;
937 new_params.exposure.compMode = 1;
938 command_flags |= COMMAND_SETEXPOSURE;
939 } else
940 retval = -EINVAL;
941 }
942 } else if (MATCH("green1_comp")) {
943 if (!retval)
944 val = VALUE;
945
946 if (!retval) {
947 if (val >= COMP_GREEN1 && val <= 255) {
948 new_params.exposure.green1Comp = val;
949 new_params.exposure.compMode = 1;
950 command_flags |= COMMAND_SETEXPOSURE;
951 } else
952 retval = -EINVAL;
953 }
954 } else if (MATCH("green2_comp")) {
955 if (!retval)
956 val = VALUE;
957
958 if (!retval) {
959 if (val >= COMP_GREEN2 && val <= 255) {
960 new_params.exposure.green2Comp = val;
961 new_params.exposure.compMode = 1;
962 command_flags |= COMMAND_SETEXPOSURE;
963 } else
964 retval = -EINVAL;
965 }
966 } else if (MATCH("blue_comp")) {
967 if (!retval)
968 val = VALUE;
969
970 if (!retval) {
971 if (val >= COMP_BLUE && val <= 255) {
972 new_params.exposure.blueComp = val;
973 new_params.exposure.compMode = 1;
974 command_flags |= COMMAND_SETEXPOSURE;
975 } else
976 retval = -EINVAL;
977 }
978 } else if (MATCH("apcor_gain1")) {
979 if (!retval)
980 val = VALUE;
981
982 if (!retval) {
983 command_flags |= COMMAND_SETAPCOR;
984 if (val <= 0xff)
985 new_params.apcor.gain1 = val;
986 else
987 retval = -EINVAL;
988 }
989 } else if (MATCH("apcor_gain2")) {
990 if (!retval)
991 val = VALUE;
992
993 if (!retval) {
994 command_flags |= COMMAND_SETAPCOR;
995 if (val <= 0xff)
996 new_params.apcor.gain2 = val;
997 else
998 retval = -EINVAL;
999 }
1000 } else if (MATCH("apcor_gain4")) {
1001 if (!retval)
1002 val = VALUE;
1003
1004 if (!retval) {
1005 command_flags |= COMMAND_SETAPCOR;
1006 if (val <= 0xff)
1007 new_params.apcor.gain4 = val;
1008 else
1009 retval = -EINVAL;
1010 }
1011 } else if (MATCH("apcor_gain8")) {
1012 if (!retval)
1013 val = VALUE;
1014
1015 if (!retval) {
1016 command_flags |= COMMAND_SETAPCOR;
1017 if (val <= 0xff)
1018 new_params.apcor.gain8 = val;
1019 else
1020 retval = -EINVAL;
1021 }
1022 } else if (MATCH("vl_offset_gain1")) {
1023 if (!retval)
1024 val = VALUE;
1025
1026 if (!retval) {
1027 if (val <= 0xff)
1028 new_params.vlOffset.gain1 = val;
1029 else
1030 retval = -EINVAL;
1031 }
1032 command_flags |= COMMAND_SETVLOFFSET;
1033 } else if (MATCH("vl_offset_gain2")) {
1034 if (!retval)
1035 val = VALUE;
1036
1037 if (!retval) {
1038 if (val <= 0xff)
1039 new_params.vlOffset.gain2 = val;
1040 else
1041 retval = -EINVAL;
1042 }
1043 command_flags |= COMMAND_SETVLOFFSET;
1044 } else if (MATCH("vl_offset_gain4")) {
1045 if (!retval)
1046 val = VALUE;
1047
1048 if (!retval) {
1049 if (val <= 0xff)
1050 new_params.vlOffset.gain4 = val;
1051 else
1052 retval = -EINVAL;
1053 }
1054 command_flags |= COMMAND_SETVLOFFSET;
1055 } else if (MATCH("vl_offset_gain8")) {
1056 if (!retval)
1057 val = VALUE;
1058
1059 if (!retval) {
1060 if (val <= 0xff)
1061 new_params.vlOffset.gain8 = val;
1062 else
1063 retval = -EINVAL;
1064 }
1065 command_flags |= COMMAND_SETVLOFFSET;
1066 } else if (MATCH("flicker_control")) {
1067 if (!retval && MATCH("on")) {
1068 set_flicker(&new_params, &command_flags, 1);
1069 } else if (!retval && MATCH("off")) {
1070 set_flicker(&new_params, &command_flags, 0);
1071 } else
1072 retval = -EINVAL;
1073
1074 command_flags |= COMMAND_SETFLICKERCTRL;
1075 } else if (MATCH("mains_frequency")) {
1076 if (!retval && MATCH("50")) {
1077 new_mains = 0;
1078 new_params.flickerControl.coarseJump =
1079 flicker_jumps[new_mains]
1080 [new_params.sensorFps.baserate]
1081 [new_params.sensorFps.divisor];
1082 if (new_params.flickerControl.flickerMode)
1083 command_flags |= COMMAND_SETFLICKERCTRL;
1084 } else if (!retval && MATCH("60")) {
1085 new_mains = 1;
1086 new_params.flickerControl.coarseJump =
1087 flicker_jumps[new_mains]
1088 [new_params.sensorFps.baserate]
1089 [new_params.sensorFps.divisor];
1090 if (new_params.flickerControl.flickerMode)
1091 command_flags |= COMMAND_SETFLICKERCTRL;
1092 } else
1093 retval = -EINVAL;
1094 } else if (MATCH("allowable_overexposure")) {
1095 if (!retval && MATCH("auto")) {
1096 new_params.flickerControl.allowableOverExposure =
1097 -find_over_exposure(new_params.colourParams.brightness);
1098 if(new_params.flickerControl.flickerMode != 0)
1099 command_flags |= COMMAND_SETFLICKERCTRL;
1100 } else {
1101 if (!retval)
1102 val = VALUE;
1103
1104 if (!retval) {
1105 if (val <= 0xff) {
1106 new_params.flickerControl.
1107 allowableOverExposure = val;
1108 if(new_params.flickerControl.flickerMode != 0)
1109 command_flags |= COMMAND_SETFLICKERCTRL;
1110 } else
1111 retval = -EINVAL;
1112 }
1113 }
1114 } else if (MATCH("compression_mode")) {
1115 if (!retval && MATCH("none"))
1116 new_params.compression.mode =
1117 CPIA_COMPRESSION_NONE;
1118 else if (!retval && MATCH("auto"))
1119 new_params.compression.mode =
1120 CPIA_COMPRESSION_AUTO;
1121 else if (!retval && MATCH("manual"))
1122 new_params.compression.mode =
1123 CPIA_COMPRESSION_MANUAL;
1124 else
1125 retval = -EINVAL;
1126
1127 command_flags |= COMMAND_SETCOMPRESSION;
1128 } else if (MATCH("decimation_enable")) {
1129 if (!retval && MATCH("off"))
1130 new_params.compression.decimation = 0;
1131 else if (!retval && MATCH("on"))
1132 new_params.compression.decimation = 1;
1133 else
1134 retval = -EINVAL;
1135
1136 command_flags |= COMMAND_SETCOMPRESSION;
1137 } else if (MATCH("compression_target")) {
1138 if (!retval && MATCH("quality"))
1139 new_params.compressionTarget.frTargeting =
1140 CPIA_COMPRESSION_TARGET_QUALITY;
1141 else if (!retval && MATCH("framerate"))
1142 new_params.compressionTarget.frTargeting =
1143 CPIA_COMPRESSION_TARGET_FRAMERATE;
1144 else
1145 retval = -EINVAL;
1146
1147 command_flags |= COMMAND_SETCOMPRESSIONTARGET;
1148 } else if (MATCH("target_framerate")) {
1149 if (!retval)
1150 val = VALUE;
1151
1152 if (!retval) {
1153 if(val > 0 && val <= 30)
1154 new_params.compressionTarget.targetFR = val;
1155 else
1156 retval = -EINVAL;
1157 }
1158 command_flags |= COMMAND_SETCOMPRESSIONTARGET;
1159 } else if (MATCH("target_quality")) {
1160 if (!retval)
1161 val = VALUE;
1162
1163 if (!retval) {
1164 if(val > 0 && val <= 64)
1165 new_params.compressionTarget.targetQ = val;
1166 else
1167 retval = -EINVAL;
1168 }
1169 command_flags |= COMMAND_SETCOMPRESSIONTARGET;
1170 } else if (MATCH("y_threshold")) {
1171 if (!retval)
1172 val = VALUE;
1173
1174 if (!retval) {
1175 if (val < 32)
1176 new_params.yuvThreshold.yThreshold = val;
1177 else
1178 retval = -EINVAL;
1179 }
1180 command_flags |= COMMAND_SETYUVTHRESH;
1181 } else if (MATCH("uv_threshold")) {
1182 if (!retval)
1183 val = VALUE;
1184
1185 if (!retval) {
1186 if (val < 32)
1187 new_params.yuvThreshold.uvThreshold = val;
1188 else
1189 retval = -EINVAL;
1190 }
1191 command_flags |= COMMAND_SETYUVTHRESH;
1192 } else if (MATCH("hysteresis")) {
1193 if (!retval)
1194 val = VALUE;
1195
1196 if (!retval) {
1197 if (val <= 0xff)
1198 new_params.compressionParams.hysteresis = val;
1199 else
1200 retval = -EINVAL;
1201 }
1202 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1203 } else if (MATCH("threshold_max")) {
1204 if (!retval)
1205 val = VALUE;
1206
1207 if (!retval) {
1208 if (val <= 0xff)
1209 new_params.compressionParams.threshMax = val;
1210 else
1211 retval = -EINVAL;
1212 }
1213 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1214 } else if (MATCH("small_step")) {
1215 if (!retval)
1216 val = VALUE;
1217
1218 if (!retval) {
1219 if (val <= 0xff)
1220 new_params.compressionParams.smallStep = val;
1221 else
1222 retval = -EINVAL;
1223 }
1224 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1225 } else if (MATCH("large_step")) {
1226 if (!retval)
1227 val = VALUE;
1228
1229 if (!retval) {
1230 if (val <= 0xff)
1231 new_params.compressionParams.largeStep = val;
1232 else
1233 retval = -EINVAL;
1234 }
1235 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1236 } else if (MATCH("decimation_hysteresis")) {
1237 if (!retval)
1238 val = VALUE;
1239
1240 if (!retval) {
1241 if (val <= 0xff)
1242 new_params.compressionParams.decimationHysteresis = val;
1243 else
1244 retval = -EINVAL;
1245 }
1246 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1247 } else if (MATCH("fr_diff_step_thresh")) {
1248 if (!retval)
1249 val = VALUE;
1250
1251 if (!retval) {
1252 if (val <= 0xff)
1253 new_params.compressionParams.frDiffStepThresh = val;
1254 else
1255 retval = -EINVAL;
1256 }
1257 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1258 } else if (MATCH("q_diff_step_thresh")) {
1259 if (!retval)
1260 val = VALUE;
1261
1262 if (!retval) {
1263 if (val <= 0xff)
1264 new_params.compressionParams.qDiffStepThresh = val;
1265 else
1266 retval = -EINVAL;
1267 }
1268 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1269 } else if (MATCH("decimation_thresh_mod")) {
1270 if (!retval)
1271 val = VALUE;
1272
1273 if (!retval) {
1274 if (val <= 0xff)
1275 new_params.compressionParams.decimationThreshMod = val;
1276 else
1277 retval = -EINVAL;
1278 }
1279 command_flags |= COMMAND_SETCOMPRESSIONPARAMS;
1280 } else if (MATCH("toplight")) {
1281 if (!retval && MATCH("on"))
1282 new_params.qx3.toplight = 1;
1283 else if (!retval && MATCH("off"))
1284 new_params.qx3.toplight = 0;
1285 else
1286 retval = -EINVAL;
1287 command_flags |= COMMAND_SETLIGHTS;
1288 } else if (MATCH("bottomlight")) {
1289 if (!retval && MATCH("on"))
1290 new_params.qx3.bottomlight = 1;
1291 else if (!retval && MATCH("off"))
1292 new_params.qx3.bottomlight = 0;
1293 else
1294 retval = -EINVAL;
1295 command_flags |= COMMAND_SETLIGHTS;
1296 } else {
1297 DBG("No match found\n");
1298 retval = -EINVAL;
1299 }
1300
1301 if (!retval) {
1302 while (count && isspace(*buffer) && *buffer != '\n') {
1303 --count;
1304 ++buffer;
1305 }
1306 if (count) {
1307 if (*buffer == '\0' && count != 1)
1308 retval = -EINVAL;
1309 else if (*buffer != '\n' && *buffer != ';' &&
1310 *buffer != '\0')
1311 retval = -EINVAL;
1312 else {
1313 --count;
1314 ++buffer;
1315 }
1316 }
1317 }
1318 }
1319 #undef MATCH
1320 #undef VALUE
1321 #undef FIRMWARE_VERSION
1322 if (!retval) {
1323 if (command_flags & COMMAND_SETCOLOURPARAMS) {
1324 /* Adjust cam->vp to reflect these changes */
1325 cam->vp.brightness =
1326 new_params.colourParams.brightness*65535/100;
1327 cam->vp.contrast =
1328 new_params.colourParams.contrast*65535/100;
1329 cam->vp.colour =
1330 new_params.colourParams.saturation*65535/100;
1331 }
1332 if((command_flags & COMMAND_SETEXPOSURE) &&
1333 new_params.exposure.expMode == 2)
1334 cam->exposure_status = EXPOSURE_NORMAL;
1335
1336 memcpy(&cam->params, &new_params, sizeof(struct cam_params));
1337 cam->mainsFreq = new_mains;
1338 cam->cmd_queue |= command_flags;
1339 retval = size;
1340 } else
1341 DBG("error: %d\n", retval);
1342
1343 mutex_unlock(&cam->param_lock);
1344
1345 out:
1346 free_page((unsigned long)page);
1347 return retval;
1348 }
1349
1350 static void create_proc_cpia_cam(struct cam_data *cam)
1351 {
1352 char name[5 + 1 + 10 + 1];
1353 struct proc_dir_entry *ent;
1354
1355 if (!cpia_proc_root || !cam)
1356 return;
1357
1358 snprintf(name, sizeof(name), "video%d", cam->vdev.minor);
1359
1360 ent = create_proc_entry(name, S_IFREG|S_IRUGO|S_IWUSR, cpia_proc_root);
1361 if (!ent)
1362 return;
1363
1364 ent->data = cam;
1365 ent->read_proc = cpia_read_proc;
1366 ent->write_proc = cpia_write_proc;
1367 /*
1368 size of the proc entry is 3736 bytes for the standard webcam;
1369 the extra features of the QX3 microscope add 189 bytes.
1370 (we have not yet probed the camera to see which type it is).
1371 */
1372 ent->size = 3736 + 189;
1373 cam->proc_entry = ent;
1374 }
1375
1376 static void destroy_proc_cpia_cam(struct cam_data *cam)
1377 {
1378 char name[5 + 1 + 10 + 1];
1379
1380 if (!cam || !cam->proc_entry)
1381 return;
1382
1383 snprintf(name, sizeof(name), "video%d", cam->vdev.minor);
1384 remove_proc_entry(name, cpia_proc_root);
1385 cam->proc_entry = NULL;
1386 }
1387
1388 static void proc_cpia_create(void)
1389 {
1390 cpia_proc_root = proc_mkdir("cpia", NULL);
1391
1392 if (cpia_proc_root)
1393 cpia_proc_root->owner = THIS_MODULE;
1394 else
1395 LOG("Unable to initialise /proc/cpia\n");
1396 }
1397
1398 static void __exit proc_cpia_destroy(void)
1399 {
1400 remove_proc_entry("cpia", NULL);
1401 }
1402 #endif /* CONFIG_PROC_FS */
1403
1404 /* ----------------------- debug functions ---------------------- */
1405
1406 #define printstatus(cam) \
1407 DBG("%02x %02x %02x %02x %02x %02x %02x %02x\n",\
1408 cam->params.status.systemState, cam->params.status.grabState, \
1409 cam->params.status.streamState, cam->params.status.fatalError, \
1410 cam->params.status.cmdError, cam->params.status.debugFlags, \
1411 cam->params.status.vpStatus, cam->params.status.errorCode);
1412
1413 /* ----------------------- v4l helpers -------------------------- */
1414
1415 /* supported frame palettes and depths */
1416 static inline int valid_mode(u16 palette, u16 depth)
1417 {
1418 if ((palette == VIDEO_PALETTE_YUV422 && depth == 16) ||
1419 (palette == VIDEO_PALETTE_YUYV && depth == 16))
1420 return 1;
1421
1422 if (colorspace_conv)
1423 return (palette == VIDEO_PALETTE_GREY && depth == 8) ||
1424 (palette == VIDEO_PALETTE_RGB555 && depth == 16) ||
1425 (palette == VIDEO_PALETTE_RGB565 && depth == 16) ||
1426 (palette == VIDEO_PALETTE_RGB24 && depth == 24) ||
1427 (palette == VIDEO_PALETTE_RGB32 && depth == 32) ||
1428 (palette == VIDEO_PALETTE_UYVY && depth == 16);
1429
1430 return 0;
1431 }
1432
1433 static int match_videosize( int width, int height )
1434 {
1435 /* return the best match, where 'best' is as always
1436 * the largest that is not bigger than what is requested. */
1437 if (width>=352 && height>=288)
1438 return VIDEOSIZE_352_288; /* CIF */
1439
1440 if (width>=320 && height>=240)
1441 return VIDEOSIZE_320_240; /* SIF */
1442
1443 if (width>=288 && height>=216)
1444 return VIDEOSIZE_288_216;
1445
1446 if (width>=256 && height>=192)
1447 return VIDEOSIZE_256_192;
1448
1449 if (width>=224 && height>=168)
1450 return VIDEOSIZE_224_168;
1451
1452 if (width>=192 && height>=144)
1453 return VIDEOSIZE_192_144;
1454
1455 if (width>=176 && height>=144)
1456 return VIDEOSIZE_176_144; /* QCIF */
1457
1458 if (width>=160 && height>=120)
1459 return VIDEOSIZE_160_120; /* QSIF */
1460
1461 if (width>=128 && height>=96)
1462 return VIDEOSIZE_128_96;
1463
1464 if (width>=88 && height>=72)
1465 return VIDEOSIZE_88_72;
1466
1467 if (width>=64 && height>=48)
1468 return VIDEOSIZE_64_48;
1469
1470 if (width>=48 && height>=48)
1471 return VIDEOSIZE_48_48;
1472
1473 return -1;
1474 }
1475
1476 /* these are the capture sizes we support */
1477 static void set_vw_size(struct cam_data *cam)
1478 {
1479 /* the col/row/start/end values are the result of simple math */
1480 /* study the SetROI-command in cpia developers guide p 2-22 */
1481 /* streamStartLine is set to the recommended value in the cpia */
1482 /* developers guide p 3-37 */
1483 switch(cam->video_size) {
1484 case VIDEOSIZE_CIF:
1485 cam->vw.width = 352;
1486 cam->vw.height = 288;
1487 cam->params.format.videoSize=VIDEOSIZE_CIF;
1488 cam->params.roi.colStart=0;
1489 cam->params.roi.rowStart=0;
1490 cam->params.streamStartLine = 120;
1491 break;
1492 case VIDEOSIZE_SIF:
1493 cam->vw.width = 320;
1494 cam->vw.height = 240;
1495 cam->params.format.videoSize=VIDEOSIZE_CIF;
1496 cam->params.roi.colStart=2;
1497 cam->params.roi.rowStart=6;
1498 cam->params.streamStartLine = 120;
1499 break;
1500 case VIDEOSIZE_288_216:
1501 cam->vw.width = 288;
1502 cam->vw.height = 216;
1503 cam->params.format.videoSize=VIDEOSIZE_CIF;
1504 cam->params.roi.colStart=4;
1505 cam->params.roi.rowStart=9;
1506 cam->params.streamStartLine = 120;
1507 break;
1508 case VIDEOSIZE_256_192:
1509 cam->vw.width = 256;
1510 cam->vw.height = 192;
1511 cam->params.format.videoSize=VIDEOSIZE_CIF;
1512 cam->params.roi.colStart=6;
1513 cam->params.roi.rowStart=12;
1514 cam->params.streamStartLine = 120;
1515 break;
1516 case VIDEOSIZE_224_168:
1517 cam->vw.width = 224;
1518 cam->vw.height = 168;
1519 cam->params.format.videoSize=VIDEOSIZE_CIF;
1520 cam->params.roi.colStart=8;
1521 cam->params.roi.rowStart=15;
1522 cam->params.streamStartLine = 120;
1523 break;
1524 case VIDEOSIZE_192_144:
1525 cam->vw.width = 192;
1526 cam->vw.height = 144;
1527 cam->params.format.videoSize=VIDEOSIZE_CIF;
1528 cam->params.roi.colStart=10;
1529 cam->params.roi.rowStart=18;
1530 cam->params.streamStartLine = 120;
1531 break;
1532 case VIDEOSIZE_QCIF:
1533 cam->vw.width = 176;
1534 cam->vw.height = 144;
1535 cam->params.format.videoSize=VIDEOSIZE_QCIF;
1536 cam->params.roi.colStart=0;
1537 cam->params.roi.rowStart=0;
1538 cam->params.streamStartLine = 60;
1539 break;
1540 case VIDEOSIZE_QSIF:
1541 cam->vw.width = 160;
1542 cam->vw.height = 120;
1543 cam->params.format.videoSize=VIDEOSIZE_QCIF;
1544 cam->params.roi.colStart=1;
1545 cam->params.roi.rowStart=3;
1546 cam->params.streamStartLine = 60;
1547 break;
1548 case VIDEOSIZE_128_96:
1549 cam->vw.width = 128;
1550 cam->vw.height = 96;
1551 cam->params.format.videoSize=VIDEOSIZE_QCIF;
1552 cam->params.roi.colStart=3;
1553 cam->params.roi.rowStart=6;
1554 cam->params.streamStartLine = 60;
1555 break;
1556 case VIDEOSIZE_88_72:
1557 cam->vw.width = 88;
1558 cam->vw.height = 72;
1559 cam->params.format.videoSize=VIDEOSIZE_QCIF;
1560 cam->params.roi.colStart=5;
1561 cam->params.roi.rowStart=9;
1562 cam->params.streamStartLine = 60;
1563 break;
1564 case VIDEOSIZE_64_48:
1565 cam->vw.width = 64;
1566 cam->vw.height = 48;
1567 cam->params.format.videoSize=VIDEOSIZE_QCIF;
1568 cam->params.roi.colStart=7;
1569 cam->params.roi.rowStart=12;
1570 cam->params.streamStartLine = 60;
1571 break;
1572 case VIDEOSIZE_48_48:
1573 cam->vw.width = 48;
1574 cam->vw.height = 48;
1575 cam->params.format.videoSize=VIDEOSIZE_QCIF;
1576 cam->params.roi.colStart=8;
1577 cam->params.roi.rowStart=6;
1578 cam->params.streamStartLine = 60;
1579 break;
1580 default:
1581 LOG("bad videosize value: %d\n", cam->video_size);
1582 return;
1583 }
1584
1585 if(cam->vc.width == 0)
1586 cam->vc.width = cam->vw.width;
1587 if(cam->vc.height == 0)
1588 cam->vc.height = cam->vw.height;
1589
1590 cam->params.roi.colStart += cam->vc.x >> 3;
1591 cam->params.roi.colEnd = cam->params.roi.colStart +
1592 (cam->vc.width >> 3);
1593 cam->params.roi.rowStart += cam->vc.y >> 2;
1594 cam->params.roi.rowEnd = cam->params.roi.rowStart +
1595 (cam->vc.height >> 2);
1596
1597 return;
1598 }
1599
1600 static int allocate_frame_buf(struct cam_data *cam)
1601 {
1602 int i;
1603
1604 cam->frame_buf = rvmalloc(FRAME_NUM * CPIA_MAX_FRAME_SIZE);
1605 if (!cam->frame_buf)
1606 return -ENOBUFS;
1607
1608 for (i = 0; i < FRAME_NUM; i++)
1609 cam->frame[i].data = cam->frame_buf + i * CPIA_MAX_FRAME_SIZE;
1610
1611 return 0;
1612 }
1613
1614 static int free_frame_buf(struct cam_data *cam)
1615 {
1616 int i;
1617
1618 rvfree(cam->frame_buf, FRAME_NUM*CPIA_MAX_FRAME_SIZE);
1619 cam->frame_buf = NULL;
1620 for (i=0; i < FRAME_NUM; i++)
1621 cam->frame[i].data = NULL;
1622
1623 return 0;
1624 }
1625
1626
1627 static inline void free_frames(struct cpia_frame frame[FRAME_NUM])
1628 {
1629 int i;
1630
1631 for (i=0; i < FRAME_NUM; i++)
1632 frame[i].state = FRAME_UNUSED;
1633 return;
1634 }
1635
1636 /**********************************************************************
1637 *
1638 * General functions
1639 *
1640 **********************************************************************/
1641 /* send an arbitrary command to the camera */
1642 static int do_command(struct cam_data *cam, u16 command, u8 a, u8 b, u8 c, u8 d)
1643 {
1644 int retval, datasize;
1645 u8 cmd[8], data[8];
1646
1647 switch(command) {
1648 case CPIA_COMMAND_GetCPIAVersion:
1649 case CPIA_COMMAND_GetPnPID:
1650 case CPIA_COMMAND_GetCameraStatus:
1651 case CPIA_COMMAND_GetVPVersion:
1652 datasize=8;
1653 break;
1654 case CPIA_COMMAND_GetColourParams:
1655 case CPIA_COMMAND_GetColourBalance:
1656 case CPIA_COMMAND_GetExposure:
1657 mutex_lock(&cam->param_lock);
1658 datasize=8;
1659 break;
1660 case CPIA_COMMAND_ReadMCPorts:
1661 case CPIA_COMMAND_ReadVCRegs:
1662 datasize = 4;
1663 break;
1664 default:
1665 datasize=0;
1666 break;
1667 }
1668
1669 cmd[0] = command>>8;
1670 cmd[1] = command&0xff;
1671 cmd[2] = a;
1672 cmd[3] = b;
1673 cmd[4] = c;
1674 cmd[5] = d;
1675 cmd[6] = datasize;
1676 cmd[7] = 0;
1677
1678 retval = cam->ops->transferCmd(cam->lowlevel_data, cmd, data);
1679 if (retval) {
1680 DBG("%x - failed, retval=%d\n", command, retval);
1681 if (command == CPIA_COMMAND_GetColourParams ||
1682 command == CPIA_COMMAND_GetColourBalance ||
1683 command == CPIA_COMMAND_GetExposure)
1684 mutex_unlock(&cam->param_lock);
1685 } else {
1686 switch(command) {
1687 case CPIA_COMMAND_GetCPIAVersion:
1688 cam->params.version.firmwareVersion = data[0];
1689 cam->params.version.firmwareRevision = data[1];
1690 cam->params.version.vcVersion = data[2];
1691 cam->params.version.vcRevision = data[3];
1692 break;
1693 case CPIA_COMMAND_GetPnPID:
1694 cam->params.pnpID.vendor = data[0]+(((u16)data[1])<<8);
1695 cam->params.pnpID.product = data[2]+(((u16)data[3])<<8);
1696 cam->params.pnpID.deviceRevision =
1697 data[4]+(((u16)data[5])<<8);
1698 break;
1699 case CPIA_COMMAND_GetCameraStatus:
1700 cam->params.status.systemState = data[0];
1701 cam->params.status.grabState = data[1];
1702 cam->params.status.streamState = data[2];
1703 cam->params.status.fatalError = data[3];
1704 cam->params.status.cmdError = data[4];
1705 cam->params.status.debugFlags = data[5];
1706 cam->params.status.vpStatus = data[6];
1707 cam->params.status.errorCode = data[7];
1708 break;
1709 case CPIA_COMMAND_GetVPVersion:
1710 cam->params.vpVersion.vpVersion = data[0];
1711 cam->params.vpVersion.vpRevision = data[1];
1712 cam->params.vpVersion.cameraHeadID =
1713 data[2]+(((u16)data[3])<<8);
1714 break;
1715 case CPIA_COMMAND_GetColourParams:
1716 cam->params.colourParams.brightness = data[0];
1717 cam->params.colourParams.contrast = data[1];
1718 cam->params.colourParams.saturation = data[2];
1719 mutex_unlock(&cam->param_lock);
1720 break;
1721 case CPIA_COMMAND_GetColourBalance:
1722 cam->params.colourBalance.redGain = data[0];
1723 cam->params.colourBalance.greenGain = data[1];
1724 cam->params.colourBalance.blueGain = data[2];
1725 mutex_unlock(&cam->param_lock);
1726 break;
1727 case CPIA_COMMAND_GetExposure:
1728 cam->params.exposure.gain = data[0];
1729 cam->params.exposure.fineExp = data[1];
1730 cam->params.exposure.coarseExpLo = data[2];
1731 cam->params.exposure.coarseExpHi = data[3];
1732 cam->params.exposure.redComp = data[4];
1733 cam->params.exposure.green1Comp = data[5];
1734 cam->params.exposure.green2Comp = data[6];
1735 cam->params.exposure.blueComp = data[7];
1736 mutex_unlock(&cam->param_lock);
1737 break;
1738
1739 case CPIA_COMMAND_ReadMCPorts:
1740 if (!cam->params.qx3.qx3_detected)
1741 break;
1742 /* test button press */
1743 cam->params.qx3.button = ((data[1] & 0x02) == 0);
1744 if (cam->params.qx3.button) {
1745 /* button pressed - unlock the latch */
1746 do_command(cam,CPIA_COMMAND_WriteMCPort,3,0xDF,0xDF,0);
1747 do_command(cam,CPIA_COMMAND_WriteMCPort,3,0xFF,0xFF,0);
1748 }
1749
1750 /* test whether microscope is cradled */
1751 cam->params.qx3.cradled = ((data[2] & 0x40) == 0);
1752 break;
1753
1754 default:
1755 break;
1756 }
1757 }
1758 return retval;
1759 }
1760
1761 /* send a command to the camera with an additional data transaction */
1762 static int do_command_extended(struct cam_data *cam, u16 command,
1763 u8 a, u8 b, u8 c, u8 d,
1764 u8 e, u8 f, u8 g, u8 h,
1765 u8 i, u8 j, u8 k, u8 l)
1766 {
1767 int retval;
1768 u8 cmd[8], data[8];
1769
1770 cmd[0] = command>>8;
1771 cmd[1] = command&0xff;
1772 cmd[2] = a;
1773 cmd[3] = b;
1774 cmd[4] = c;
1775 cmd[5] = d;
1776 cmd[6] = 8;
1777 cmd[7] = 0;
1778 data[0] = e;
1779 data[1] = f;
1780 data[2] = g;
1781 data[3] = h;
1782 data[4] = i;
1783 data[5] = j;
1784 data[6] = k;
1785 data[7] = l;
1786
1787 retval = cam->ops->transferCmd(cam->lowlevel_data, cmd, data);
1788 if (retval)
1789 DBG("%x - failed\n", command);
1790
1791 return retval;
1792 }
1793
1794 /**********************************************************************
1795 *
1796 * Colorspace conversion
1797 *
1798 **********************************************************************/
1799 #define LIMIT(x) ((((x)>0xffffff)?0xff0000:(((x)<=0xffff)?0:(x)&0xff0000))>>16)
1800
1801 static int convert420(unsigned char *yuv, unsigned char *rgb, int out_fmt,
1802 int linesize, int mmap_kludge)
1803 {
1804 int y, u, v, r, g, b, y1;
1805
1806 /* Odd lines use the same u and v as the previous line.
1807 * Because of compression, it is necessary to get this
1808 * information from the decoded image. */
1809 switch(out_fmt) {
1810 case VIDEO_PALETTE_RGB555:
1811 y = (*yuv++ - 16) * 76310;
1812 y1 = (*yuv - 16) * 76310;
1813 r = ((*(rgb+1-linesize)) & 0x7c) << 1;
1814 g = ((*(rgb-linesize)) & 0xe0) >> 4 |
1815 ((*(rgb+1-linesize)) & 0x03) << 6;
1816 b = ((*(rgb-linesize)) & 0x1f) << 3;
1817 u = (-53294 * r - 104635 * g + 157929 * b) / 5756495;
1818 v = (157968 * r - 132278 * g - 25690 * b) / 5366159;
1819 r = 104635 * v;
1820 g = -25690 * u - 53294 * v;
1821 b = 132278 * u;
1822 *rgb++ = ((LIMIT(g+y) & 0xf8) << 2) | (LIMIT(b+y) >> 3);
1823 *rgb++ = ((LIMIT(r+y) & 0xf8) >> 1) | (LIMIT(g+y) >> 6);
1824 *rgb++ = ((LIMIT(g+y1) & 0xf8) << 2) | (LIMIT(b+y1) >> 3);
1825 *rgb = ((LIMIT(r+y1) & 0xf8) >> 1) | (LIMIT(g+y1) >> 6);
1826 return 4;
1827 case VIDEO_PALETTE_RGB565:
1828 y = (*yuv++ - 16) * 76310;
1829 y1 = (*yuv - 16) * 76310;
1830 r = (*(rgb+1-linesize)) & 0xf8;
1831 g = ((*(rgb-linesize)) & 0xe0) >> 3 |
1832 ((*(rgb+1-linesize)) & 0x07) << 5;
1833 b = ((*(rgb-linesize)) & 0x1f) << 3;
1834 u = (-53294 * r - 104635 * g + 157929 * b) / 5756495;
1835 v = (157968 * r - 132278 * g - 25690 * b) / 5366159;
1836 r = 104635 * v;
1837 g = -25690 * u - 53294 * v;
1838 b = 132278 * u;
1839 *rgb++ = ((LIMIT(g+y) & 0xfc) << 3) | (LIMIT(b+y) >> 3);
1840 *rgb++ = (LIMIT(r+y) & 0xf8) | (LIMIT(g+y) >> 5);
1841 *rgb++ = ((LIMIT(g+y1) & 0xfc) << 3) | (LIMIT(b+y1) >> 3);
1842 *rgb = (LIMIT(r+y1) & 0xf8) | (LIMIT(g+y1) >> 5);
1843 return 4;
1844 break;
1845 case VIDEO_PALETTE_RGB24:
1846 case VIDEO_PALETTE_RGB32:
1847 y = (*yuv++ - 16) * 76310;
1848 y1 = (*yuv - 16) * 76310;
1849 if (mmap_kludge) {
1850 r = *(rgb+2-linesize);
1851 g = *(rgb+1-linesize);
1852 b = *(rgb-linesize);
1853 } else {
1854 r = *(rgb-linesize);
1855 g = *(rgb+1-linesize);
1856 b = *(rgb+2-linesize);
1857 }
1858 u = (-53294 * r - 104635 * g + 157929 * b) / 5756495;
1859 v = (157968 * r - 132278 * g - 25690 * b) / 5366159;
1860 r = 104635 * v;
1861 g = -25690 * u + -53294 * v;
1862 b = 132278 * u;
1863 if (mmap_kludge) {
1864 *rgb++ = LIMIT(b+y);
1865 *rgb++ = LIMIT(g+y);
1866 *rgb++ = LIMIT(r+y);
1867 if(out_fmt == VIDEO_PALETTE_RGB32)
1868 rgb++;
1869 *rgb++ = LIMIT(b+y1);
1870 *rgb++ = LIMIT(g+y1);
1871 *rgb = LIMIT(r+y1);
1872 } else {
1873 *rgb++ = LIMIT(r+y);
1874 *rgb++ = LIMIT(g+y);
1875 *rgb++ = LIMIT(b+y);
1876 if(out_fmt == VIDEO_PALETTE_RGB32)
1877 rgb++;
1878 *rgb++ = LIMIT(r+y1);
1879 *rgb++ = LIMIT(g+y1);
1880 *rgb = LIMIT(b+y1);
1881 }
1882 if(out_fmt == VIDEO_PALETTE_RGB32)
1883 return 8;
1884 return 6;
1885 case VIDEO_PALETTE_YUV422:
1886 case VIDEO_PALETTE_YUYV:
1887 y = *yuv++;
1888 u = *(rgb+1-linesize);
1889 y1 = *yuv;
1890 v = *(rgb+3-linesize);
1891 *rgb++ = y;
1892 *rgb++ = u;
1893 *rgb++ = y1;
1894 *rgb = v;
1895 return 4;
1896 case VIDEO_PALETTE_UYVY:
1897 u = *(rgb-linesize);
1898 y = *yuv++;
1899 v = *(rgb+2-linesize);
1900 y1 = *yuv;
1901 *rgb++ = u;
1902 *rgb++ = y;
1903 *rgb++ = v;
1904 *rgb = y1;
1905 return 4;
1906 case VIDEO_PALETTE_GREY:
1907 *rgb++ = *yuv++;
1908 *rgb = *yuv;
1909 return 2;
1910 default:
1911 DBG("Empty: %d\n", out_fmt);
1912 return 0;
1913 }
1914 }
1915
1916
1917 static int yuvconvert(unsigned char *yuv, unsigned char *rgb, int out_fmt,
1918 int in_uyvy, int mmap_kludge)
1919 {
1920 int y, u, v, r, g, b, y1;
1921
1922 switch(out_fmt) {
1923 case VIDEO_PALETTE_RGB555:
1924 case VIDEO_PALETTE_RGB565:
1925 case VIDEO_PALETTE_RGB24:
1926 case VIDEO_PALETTE_RGB32:
1927 if (in_uyvy) {
1928 u = *yuv++ - 128;
1929 y = (*yuv++ - 16) * 76310;
1930 v = *yuv++ - 128;
1931 y1 = (*yuv - 16) * 76310;
1932 } else {
1933 y = (*yuv++ - 16) * 76310;
1934 u = *yuv++ - 128;
1935 y1 = (*yuv++ - 16) * 76310;
1936 v = *yuv - 128;
1937 }
1938 r = 104635 * v;
1939 g = -25690 * u + -53294 * v;
1940 b = 132278 * u;
1941 break;
1942 default:
1943 y = *yuv++;
1944 u = *yuv++;
1945 y1 = *yuv++;
1946 v = *yuv;
1947 /* Just to avoid compiler warnings */
1948 r = 0;
1949 g = 0;
1950 b = 0;
1951 break;
1952 }
1953 switch(out_fmt) {
1954 case VIDEO_PALETTE_RGB555:
1955 *rgb++ = ((LIMIT(g+y) & 0xf8) << 2) | (LIMIT(b+y) >> 3);
1956 *rgb++ = ((LIMIT(r+y) & 0xf8) >> 1) | (LIMIT(g+y) >> 6);
1957 *rgb++ = ((LIMIT(g+y1) & 0xf8) << 2) | (LIMIT(b+y1) >> 3);
1958 *rgb = ((LIMIT(r+y1) & 0xf8) >> 1) | (LIMIT(g+y1) >> 6);
1959 return 4;
1960 case VIDEO_PALETTE_RGB565:
1961 *rgb++ = ((LIMIT(g+y) & 0xfc) << 3) | (LIMIT(b+y) >> 3);
1962 *rgb++ = (LIMIT(r+y) & 0xf8) | (LIMIT(g+y) >> 5);
1963 *rgb++ = ((LIMIT(g+y1) & 0xfc) << 3) | (LIMIT(b+y1) >> 3);
1964 *rgb = (LIMIT(r+y1) & 0xf8) | (LIMIT(g+y1) >> 5);
1965 return 4;
1966 case VIDEO_PALETTE_RGB24:
1967 if (mmap_kludge) {
1968 *rgb++ = LIMIT(b+y);
1969 *rgb++ = LIMIT(g+y);
1970 *rgb++ = LIMIT(r+y);
1971 *rgb++ = LIMIT(b+y1);
1972 *rgb++ = LIMIT(g+y1);
1973 *rgb = LIMIT(r+y1);
1974 } else {
1975 *rgb++ = LIMIT(r+y);
1976 *rgb++ = LIMIT(g+y);
1977 *rgb++ = LIMIT(b+y);
1978 *rgb++ = LIMIT(r+y1);
1979 *rgb++ = LIMIT(g+y1);
1980 *rgb = LIMIT(b+y1);
1981 }
1982 return 6;
1983 case VIDEO_PALETTE_RGB32:
1984 if (mmap_kludge) {
1985 *rgb++ = LIMIT(b+y);
1986 *rgb++ = LIMIT(g+y);
1987 *rgb++ = LIMIT(r+y);
1988 rgb++;
1989 *rgb++ = LIMIT(b+y1);
1990 *rgb++ = LIMIT(g+y1);
1991 *rgb = LIMIT(r+y1);
1992 } else {
1993 *rgb++ = LIMIT(r+y);
1994 *rgb++ = LIMIT(g+y);
1995 *rgb++ = LIMIT(b+y);
1996 rgb++;
1997 *rgb++ = LIMIT(r+y1);
1998 *rgb++ = LIMIT(g+y1);
1999 *rgb = LIMIT(b+y1);
2000 }
2001 return 8;
2002 case VIDEO_PALETTE_GREY:
2003 *rgb++ = y;
2004 *rgb = y1;
2005 return 2;
2006 case VIDEO_PALETTE_YUV422:
2007 case VIDEO_PALETTE_YUYV:
2008 *rgb++ = y;
2009 *rgb++ = u;
2010 *rgb++ = y1;
2011 *rgb = v;
2012 return 4;
2013 case VIDEO_PALETTE_UYVY:
2014 *rgb++ = u;
2015 *rgb++ = y;
2016 *rgb++ = v;
2017 *rgb = y1;
2018 return 4;
2019 default:
2020 DBG("Empty: %d\n", out_fmt);
2021 return 0;
2022 }
2023 }
2024
2025 static int skipcount(int count, int fmt)
2026 {
2027 switch(fmt) {
2028 case VIDEO_PALETTE_GREY:
2029 return count;
2030 case VIDEO_PALETTE_RGB555:
2031 case VIDEO_PALETTE_RGB565:
2032 case VIDEO_PALETTE_YUV422:
2033 case VIDEO_PALETTE_YUYV:
2034 case VIDEO_PALETTE_UYVY:
2035 return 2*count;
2036 case VIDEO_PALETTE_RGB24:
2037 return 3*count;
2038 case VIDEO_PALETTE_RGB32:
2039 return 4*count;
2040 default:
2041 return 0;
2042 }
2043 }
2044
2045 static int parse_picture(struct cam_data *cam, int size)
2046 {
2047 u8 *obuf, *ibuf, *end_obuf;
2048 int ll, in_uyvy, compressed, decimation, even_line, origsize, out_fmt;
2049 int rows, cols, linesize, subsample_422;
2050
2051 /* make sure params don't change while we are decoding */
2052 mutex_lock(&cam->param_lock);
2053
2054 obuf = cam->decompressed_frame.data;
2055 end_obuf = obuf+CPIA_MAX_FRAME_SIZE;
2056 ibuf = cam->raw_image;
2057 origsize = size;
2058 out_fmt = cam->vp.palette;
2059
2060 if ((ibuf[0] != MAGIC_0) || (ibuf[1] != MAGIC_1)) {
2061 LOG("header not found\n");
2062 mutex_unlock(&cam->param_lock);
2063 return -1;
2064 }
2065
2066 if ((ibuf[16] != VIDEOSIZE_QCIF) && (ibuf[16] != VIDEOSIZE_CIF)) {
2067 LOG("wrong video size\n");
2068 mutex_unlock(&cam->param_lock);
2069 return -1;
2070 }
2071
2072 if (ibuf[17] != SUBSAMPLE_420 && ibuf[17] != SUBSAMPLE_422) {
2073 LOG("illegal subtype %d\n",ibuf[17]);
2074 mutex_unlock(&cam->param_lock);
2075 return -1;
2076 }
2077 subsample_422 = ibuf[17] == SUBSAMPLE_422;
2078
2079 if (ibuf[18] != YUVORDER_YUYV && ibuf[18] != YUVORDER_UYVY) {
2080 LOG("illegal yuvorder %d\n",ibuf[18]);
2081 mutex_unlock(&cam->param_lock);
2082 return -1;
2083 }
2084 in_uyvy = ibuf[18] == YUVORDER_UYVY;
2085
2086 if ((ibuf[24] != cam->params.roi.colStart) ||
2087 (ibuf[25] != cam->params.roi.colEnd) ||
2088 (ibuf[26] != cam->params.roi.rowStart) ||
2089 (ibuf[27] != cam->params.roi.rowEnd)) {
2090 LOG("ROI mismatch\n");
2091 mutex_unlock(&cam->param_lock);
2092 return -1;
2093 }
2094 cols = 8*(ibuf[25] - ibuf[24]);
2095 rows = 4*(ibuf[27] - ibuf[26]);
2096
2097
2098 if ((ibuf[28] != NOT_COMPRESSED) && (ibuf[28] != COMPRESSED)) {
2099 LOG("illegal compression %d\n",ibuf[28]);
2100 mutex_unlock(&cam->param_lock);
2101 return -1;
2102 }
2103 compressed = (ibuf[28] == COMPRESSED);
2104
2105 if (ibuf[29] != NO_DECIMATION && ibuf[29] != DECIMATION_ENAB) {
2106 LOG("illegal decimation %d\n",ibuf[29]);
2107 mutex_unlock(&cam->param_lock);
2108 return -1;
2109 }
2110 decimation = (ibuf[29] == DECIMATION_ENAB);
2111
2112 cam->params.yuvThreshold.yThreshold = ibuf[30];
2113 cam->params.yuvThreshold.uvThreshold = ibuf[31];
2114 cam->params.status.systemState = ibuf[32];
2115 cam->params.status.grabState = ibuf[33];
2116 cam->params.status.streamState = ibuf[34];
2117 cam->params.status.fatalError = ibuf[35];
2118 cam->params.status.cmdError = ibuf[36];
2119 cam->params.status.debugFlags = ibuf[37];
2120 cam->params.status.vpStatus = ibuf[38];
2121 cam->params.status.errorCode = ibuf[39];
2122 cam->fps = ibuf[41];
2123 mutex_unlock(&cam->param_lock);
2124
2125 linesize = skipcount(cols, out_fmt);
2126 ibuf += FRAME_HEADER_SIZE;
2127 size -= FRAME_HEADER_SIZE;
2128 ll = ibuf[0] | (ibuf[1] << 8);
2129 ibuf += 2;
2130 even_line = 1;
2131
2132 while (size > 0) {
2133 size -= (ll+2);
2134 if (size < 0) {
2135 LOG("Insufficient data in buffer\n");
2136 return -1;
2137 }
2138
2139 while (ll > 1) {
2140 if (!compressed || (compressed && !(*ibuf & 1))) {
2141 if(subsample_422 || even_line) {
2142 obuf += yuvconvert(ibuf, obuf, out_fmt,
2143 in_uyvy, cam->mmap_kludge);
2144 ibuf += 4;
2145 ll -= 4;
2146 } else {
2147 /* SUBSAMPLE_420 on an odd line */
2148 obuf += convert420(ibuf, obuf,
2149 out_fmt, linesize,
2150 cam->mmap_kludge);
2151 ibuf += 2;
2152 ll -= 2;
2153 }
2154 } else {
2155 /*skip compressed interval from previous frame*/
2156 obuf += skipcount(*ibuf >> 1, out_fmt);
2157 if (obuf > end_obuf) {
2158 LOG("Insufficient buffer size\n");
2159 return -1;
2160 }
2161 ++ibuf;
2162 ll--;
2163 }
2164 }
2165 if (ll == 1) {
2166 if (*ibuf != EOL) {
2167 DBG("EOL not found giving up after %d/%d"
2168 " bytes\n", origsize-size, origsize);
2169 return -1;
2170 }
2171
2172 ++ibuf; /* skip over EOL */
2173
2174 if ((size > 3) && (ibuf[0] == EOI) && (ibuf[1] == EOI) &&
2175 (ibuf[2] == EOI) && (ibuf[3] == EOI)) {
2176 size -= 4;
2177 break;
2178 }
2179
2180 if(decimation) {
2181 /* skip the odd lines for now */
2182 obuf += linesize;
2183 }
2184
2185 if (size > 1) {
2186 ll = ibuf[0] | (ibuf[1] << 8);
2187 ibuf += 2; /* skip over line length */
2188 }
2189 if(!decimation)
2190 even_line = !even_line;
2191 } else {
2192 LOG("line length was not 1 but %d after %d/%d bytes\n",
2193 ll, origsize-size, origsize);
2194 return -1;
2195 }
2196 }
2197
2198 if(decimation) {
2199 /* interpolate odd rows */
2200 int i, j;
2201 u8 *prev, *next;
2202 prev = cam->decompressed_frame.data;
2203 obuf = prev+linesize;
2204 next = obuf+linesize;
2205 for(i=1; i<rows-1; i+=2) {
2206 for(j=0; j<linesize; ++j) {
2207 *obuf++ = ((int)*prev++ + *next++) / 2;
2208 }
2209 prev += linesize;
2210 obuf += linesize;
2211 next += linesize;
2212 }
2213 /* last row is odd, just copy previous row */
2214 memcpy(obuf, prev, linesize);
2215 }
2216
2217 cam->decompressed_frame.count = obuf-cam->decompressed_frame.data;
2218
2219 return cam->decompressed_frame.count;
2220 }
2221
2222 /* InitStreamCap wrapper to select correct start line */
2223 static inline int init_stream_cap(struct cam_data *cam)
2224 {
2225 return do_command(cam, CPIA_COMMAND_InitStreamCap,
2226 0, cam->params.streamStartLine, 0, 0);
2227 }
2228
2229
2230 /* find_over_exposure
2231 * Finds a suitable value of OverExposure for use with SetFlickerCtrl
2232 * Some calculation is required because this value changes with the brightness
2233 * set with SetColourParameters
2234 *
2235 * Parameters: Brightness - last brightness value set with SetColourParameters
2236 *
2237 * Returns: OverExposure value to use with SetFlickerCtrl
2238 */
2239 #define FLICKER_MAX_EXPOSURE 250
2240 #define FLICKER_ALLOWABLE_OVER_EXPOSURE 146
2241 #define FLICKER_BRIGHTNESS_CONSTANT 59
2242 static int find_over_exposure(int brightness)
2243 {
2244 int MaxAllowableOverExposure, OverExposure;
2245
2246 MaxAllowableOverExposure = FLICKER_MAX_EXPOSURE - brightness -
2247 FLICKER_BRIGHTNESS_CONSTANT;
2248
2249 if (MaxAllowableOverExposure < FLICKER_ALLOWABLE_OVER_EXPOSURE) {
2250 OverExposure = MaxAllowableOverExposure;
2251 } else {
2252 OverExposure = FLICKER_ALLOWABLE_OVER_EXPOSURE;
2253 }
2254
2255 return OverExposure;
2256 }
2257 #undef FLICKER_MAX_EXPOSURE
2258 #undef FLICKER_ALLOWABLE_OVER_EXPOSURE
2259 #undef FLICKER_BRIGHTNESS_CONSTANT
2260
2261 /* update various camera modes and settings */
2262 static void dispatch_commands(struct cam_data *cam)
2263 {
2264 mutex_lock(&cam->param_lock);
2265 if (cam->cmd_queue==COMMAND_NONE) {
2266 mutex_unlock(&cam->param_lock);
2267 return;
2268 }
2269 DEB_BYTE(cam->cmd_queue);
2270 DEB_BYTE(cam->cmd_queue>>8);
2271 if (cam->cmd_queue & COMMAND_SETFORMAT) {
2272 do_command(cam, CPIA_COMMAND_SetFormat,
2273 cam->params.format.videoSize,
2274 cam->params.format.subSample,
2275 cam->params.format.yuvOrder, 0);
2276 do_command(cam, CPIA_COMMAND_SetROI,
2277 cam->params.roi.colStart, cam->params.roi.colEnd,
2278 cam->params.roi.rowStart, cam->params.roi.rowEnd);
2279 cam->first_frame = 1;
2280 }
2281
2282 if (cam->cmd_queue & COMMAND_SETCOLOURPARAMS)
2283 do_command(cam, CPIA_COMMAND_SetColourParams,
2284 cam->params.colourParams.brightness,
2285 cam->params.colourParams.contrast,
2286 cam->params.colourParams.saturation, 0);
2287
2288 if (cam->cmd_queue & COMMAND_SETAPCOR)
2289 do_command(cam, CPIA_COMMAND_SetApcor,
2290 cam->params.apcor.gain1,
2291 cam->params.apcor.gain2,
2292 cam->params.apcor.gain4,
2293 cam->params.apcor.gain8);
2294
2295 if (cam->cmd_queue & COMMAND_SETVLOFFSET)
2296 do_command(cam, CPIA_COMMAND_SetVLOffset,
2297 cam->params.vlOffset.gain1,
2298 cam->params.vlOffset.gain2,
2299 cam->params.vlOffset.gain4,
2300 cam->params.vlOffset.gain8);
2301
2302 if (cam->cmd_queue & COMMAND_SETEXPOSURE) {
2303 do_command_extended(cam, CPIA_COMMAND_SetExposure,
2304 cam->params.exposure.gainMode,
2305 1,
2306 cam->params.exposure.compMode,
2307 cam->params.exposure.centreWeight,
2308 cam->params.exposure.gain,
2309 cam->params.exposure.fineExp,
2310 cam->params.exposure.coarseExpLo,
2311 cam->params.exposure.coarseExpHi,
2312 cam->params.exposure.redComp,
2313 cam->params.exposure.green1Comp,
2314 cam->params.exposure.green2Comp,
2315 cam->params.exposure.blueComp);
2316 if(cam->params.exposure.expMode != 1) {
2317 do_command_extended(cam, CPIA_COMMAND_SetExposure,
2318 0,
2319 cam->params.exposure.expMode,
2320 0, 0,
2321 cam->params.exposure.gain,
2322 cam->params.exposure.fineExp,
2323 cam->params.exposure.coarseExpLo,
2324 cam->params.exposure.coarseExpHi,
2325 0, 0, 0, 0);
2326 }
2327 }
2328
2329 if (cam->cmd_queue & COMMAND_SETCOLOURBALANCE) {
2330 if (cam->params.colourBalance.balanceMode == 1) {
2331 do_command(cam, CPIA_COMMAND_SetColourBalance,
2332 1,
2333 cam->params.colourBalance.redGain,
2334 cam->params.colourBalance.greenGain,
2335 cam->params.colourBalance.blueGain);
2336 do_command(cam, CPIA_COMMAND_SetColourBalance,
2337 3, 0, 0, 0);
2338 }
2339 if (cam->params.colourBalance.balanceMode == 2) {
2340 do_command(cam, CPIA_COMMAND_SetColourBalance,
2341 2, 0, 0, 0);
2342 }
2343 if (cam->params.colourBalance.balanceMode == 3) {
2344 do_command(cam, CPIA_COMMAND_SetColourBalance,
2345 3, 0, 0, 0);
2346 }
2347 }
2348
2349 if (cam->cmd_queue & COMMAND_SETCOMPRESSIONTARGET)
2350 do_command(cam, CPIA_COMMAND_SetCompressionTarget,
2351 cam->params.compressionTarget.frTargeting,
2352 cam->params.compressionTarget.targetFR,
2353 cam->params.compressionTarget.targetQ, 0);
2354
2355 if (cam->cmd_queue & COMMAND_SETYUVTHRESH)
2356 do_command(cam, CPIA_COMMAND_SetYUVThresh,
2357 cam->params.yuvThreshold.yThreshold,
2358 cam->params.yuvThreshold.uvThreshold, 0, 0);
2359
2360 if (cam->cmd_queue & COMMAND_SETCOMPRESSIONPARAMS)
2361 do_command_extended(cam, CPIA_COMMAND_SetCompressionParams,
2362 0, 0, 0, 0,
2363 cam->params.compressionParams.hysteresis,
2364 cam->params.compressionParams.threshMax,
2365 cam->params.compressionParams.smallStep,
2366 cam->params.compressionParams.largeStep,
2367 cam->params.compressionParams.decimationHysteresis,
2368 cam->params.compressionParams.frDiffStepThresh,
2369 cam->params.compressionParams.qDiffStepThresh,
2370 cam->params.compressionParams.decimationThreshMod);
2371
2372 if (cam->cmd_queue & COMMAND_SETCOMPRESSION)
2373 do_command(cam, CPIA_COMMAND_SetCompression,
2374 cam->params.compression.mode,
2375 cam->params.compression.decimation, 0, 0);
2376
2377 if (cam->cmd_queue & COMMAND_SETSENSORFPS)
2378 do_command(cam, CPIA_COMMAND_SetSensorFPS,
2379 cam->params.sensorFps.divisor,
2380 cam->params.sensorFps.baserate, 0, 0);
2381
2382 if (cam->cmd_queue & COMMAND_SETFLICKERCTRL)
2383 do_command(cam, CPIA_COMMAND_SetFlickerCtrl,
2384 cam->params.flickerControl.flickerMode,
2385 cam->params.flickerControl.coarseJump,
2386 abs(cam->params.flickerControl.allowableOverExposure),
2387 0);
2388
2389 if (cam->cmd_queue & COMMAND_SETECPTIMING)
2390 do_command(cam, CPIA_COMMAND_SetECPTiming,
2391 cam->params.ecpTiming, 0, 0, 0);
2392
2393 if (cam->cmd_queue & COMMAND_PAUSE)
2394 do_command(cam, CPIA_COMMAND_EndStreamCap, 0, 0, 0, 0);
2395
2396 if (cam->cmd_queue & COMMAND_RESUME)
2397 init_stream_cap(cam);
2398
2399 if (cam->cmd_queue & COMMAND_SETLIGHTS && cam->params.qx3.qx3_detected)
2400 {
2401 int p1 = (cam->params.qx3.bottomlight == 0) << 1;
2402 int p2 = (cam->params.qx3.toplight == 0) << 3;
2403 do_command(cam, CPIA_COMMAND_WriteVCReg, 0x90, 0x8F, 0x50, 0);
2404 do_command(cam, CPIA_COMMAND_WriteMCPort, 2, 0, (p1|p2|0xE0), 0);
2405 }
2406
2407 cam->cmd_queue = COMMAND_NONE;
2408 mutex_unlock(&cam->param_lock);
2409 return;
2410 }
2411
2412
2413
2414 static void set_flicker(struct cam_params *params, volatile u32 *command_flags,
2415 int on)
2416 {
2417 /* Everything in here is from the Windows driver */
2418 #define FIRMWARE_VERSION(x,y) (params->version.firmwareVersion == (x) && \
2419 params->version.firmwareRevision == (y))
2420 /* define for compgain calculation */
2421 #if 0
2422 #define COMPGAIN(base, curexp, newexp) \
2423 (u8) ((((float) base - 128.0) * ((float) curexp / (float) newexp)) + 128.5)
2424 #define EXP_FROM_COMP(basecomp, curcomp, curexp) \
2425 (u16)((float)curexp * (float)(u8)(curcomp + 128) / (float)(u8)(basecomp - 128))
2426 #else
2427 /* equivalent functions without floating point math */
2428 #define COMPGAIN(base, curexp, newexp) \
2429 (u8)(128 + (((u32)(2*(base-128)*curexp + newexp)) / (2* newexp)) )
2430 #define EXP_FROM_COMP(basecomp, curcomp, curexp) \
2431 (u16)(((u32)(curexp * (u8)(curcomp + 128)) / (u8)(basecomp - 128)))
2432 #endif
2433
2434
2435 int currentexp = params->exposure.coarseExpLo +
2436 params->exposure.coarseExpHi*256;
2437 int startexp;
2438 if (on) {
2439 int cj = params->flickerControl.coarseJump;
2440 params->flickerControl.flickerMode = 1;
2441 params->flickerControl.disabled = 0;
2442 if(params->exposure.expMode != 2)
2443 *command_flags |= COMMAND_SETEXPOSURE;
2444 params->exposure.expMode = 2;
2445 currentexp = currentexp << params->exposure.gain;
2446 params->exposure.gain = 0;
2447 /* round down current exposure to nearest value */
2448 startexp = (currentexp + ROUND_UP_EXP_FOR_FLICKER) / cj;
2449 if(startexp < 1)
2450 startexp = 1;
2451 startexp = (startexp * cj) - 1;
2452 if(FIRMWARE_VERSION(1,2))
2453 while(startexp > MAX_EXP_102)
2454 startexp -= cj;
2455 else
2456 while(startexp > MAX_EXP)
2457 startexp -= cj;
2458 params->exposure.coarseExpLo = startexp & 0xff;
2459 params->exposure.coarseExpHi = startexp >> 8;
2460 if (currentexp > startexp) {
2461 if (currentexp > (2 * startexp))
2462 currentexp = 2 * startexp;
2463 params->exposure.redComp = COMPGAIN (COMP_RED, currentexp, startexp);
2464 params->exposure.green1Comp = COMPGAIN (COMP_GREEN1, currentexp, startexp);
2465 params->exposure.green2Comp = COMPGAIN (COMP_GREEN2, currentexp, startexp);
2466 params->exposure.blueComp = COMPGAIN (COMP_BLUE, currentexp, startexp);
2467 } else {
2468 params->exposure.redComp = COMP_RED;
2469 params->exposure.green1Comp = COMP_GREEN1;
2470 params->exposure.green2Comp = COMP_GREEN2;
2471 params->exposure.blueComp = COMP_BLUE;
2472 }
2473 if(FIRMWARE_VERSION(1,2))
2474 params->exposure.compMode = 0;
2475 else
2476 params->exposure.compMode = 1;
2477
2478 params->apcor.gain1 = 0x18;
2479 params->apcor.gain2 = 0x18;
2480 params->apcor.gain4 = 0x16;
2481 params->apcor.gain8 = 0x14;
2482 *command_flags |= COMMAND_SETAPCOR;
2483 } else {
2484 params->flickerControl.flickerMode = 0;
2485 params->flickerControl.disabled = 1;
2486 /* Coarse = average of equivalent coarse for each comp channel */
2487 startexp = EXP_FROM_COMP(COMP_RED, params->exposure.redComp, currentexp);
2488 startexp += EXP_FROM_COMP(COMP_GREEN1, params->exposure.green1Comp, currentexp);
2489 startexp += EXP_FROM_COMP(COMP_GREEN2, params->exposure.green2Comp, currentexp);
2490 startexp += EXP_FROM_COMP(COMP_BLUE, params->exposure.blueComp, currentexp);
2491 startexp = startexp >> 2;
2492 while(startexp > MAX_EXP &&
2493 params->exposure.gain < params->exposure.gainMode-1) {
2494 startexp = startexp >> 1;
2495 ++params->exposure.gain;
2496 }
2497 if(FIRMWARE_VERSION(1,2) && startexp > MAX_EXP_102)
2498 startexp = MAX_EXP_102;
2499 if(startexp > MAX_EXP)
2500 startexp = MAX_EXP;
2501 params->exposure.coarseExpLo = startexp&0xff;
2502 params->exposure.coarseExpHi = startexp >> 8;
2503 params->exposure.redComp = COMP_RED;
2504 params->exposure.green1Comp = COMP_GREEN1;
2505 params->exposure.green2Comp = COMP_GREEN2;
2506 params->exposure.blueComp = COMP_BLUE;
2507 params->exposure.compMode = 1;
2508 *command_flags |= COMMAND_SETEXPOSURE;
2509 params->apcor.gain1 = 0x18;
2510 params->apcor.gain2 = 0x16;
2511 params->apcor.gain4 = 0x24;
2512 params->apcor.gain8 = 0x34;
2513 *command_flags |= COMMAND_SETAPCOR;
2514 }
2515 params->vlOffset.gain1 = 20;
2516 params->vlOffset.gain2 = 24;
2517 params->vlOffset.gain4 = 26;
2518 params->vlOffset.gain8 = 26;
2519 *command_flags |= COMMAND_SETVLOFFSET;
2520 #undef FIRMWARE_VERSION
2521 #undef EXP_FROM_COMP
2522 #undef COMPGAIN
2523 }
2524
2525 #define FIRMWARE_VERSION(x,y) (cam->params.version.firmwareVersion == (x) && \
2526 cam->params.version.firmwareRevision == (y))
2527 /* monitor the exposure and adjust the sensor frame rate if needed */
2528 static void monitor_exposure(struct cam_data *cam)
2529 {
2530 u8 exp_acc, bcomp, gain, coarseL, cmd[8], data[8];
2531 int retval, light_exp, dark_exp, very_dark_exp;
2532 int old_exposure, new_exposure, framerate;
2533
2534 /* get necessary stats and register settings from camera */
2535 /* do_command can't handle this, so do it ourselves */
2536 cmd[0] = CPIA_COMMAND_ReadVPRegs>>8;
2537 cmd[1] = CPIA_COMMAND_ReadVPRegs&0xff;
2538 cmd[2] = 30;
2539 cmd[3] = 4;
2540 cmd[4] = 9;
2541 cmd[5] = 8;
2542 cmd[6] = 8;
2543 cmd[7] = 0;
2544 retval = cam->ops->transferCmd(cam->lowlevel_data, cmd, data);
2545 if (retval) {
2546 LOG("ReadVPRegs(30,4,9,8) - failed, retval=%d\n",
2547 retval);
2548 return;
2549 }
2550 exp_acc = data[0];
2551 bcomp = data[1];
2552 gain = data[2];
2553 coarseL = data[3];
2554
2555 mutex_lock(&cam->param_lock);
2556 light_exp = cam->params.colourParams.brightness +
2557 TC - 50 + EXP_ACC_LIGHT;
2558 if(light_exp > 255)
2559 light_exp = 255;
2560 dark_exp = cam->params.colourParams.brightness +
2561 TC - 50 - EXP_ACC_DARK;
2562 if(dark_exp < 0)
2563 dark_exp = 0;
2564 very_dark_exp = dark_exp/2;
2565
2566 old_exposure = cam->params.exposure.coarseExpHi * 256 +
2567 cam->params.exposure.coarseExpLo;
2568
2569 if(!cam->params.flickerControl.disabled) {
2570 /* Flicker control on */
2571 int max_comp = FIRMWARE_VERSION(1,2) ? MAX_COMP : HIGH_COMP_102;
2572 bcomp += 128; /* decode */
2573 if(bcomp >= max_comp && exp_acc < dark_exp) {
2574 /* dark */
2575 if(exp_acc < very_dark_exp) {
2576 /* very dark */
2577 if(cam->exposure_status == EXPOSURE_VERY_DARK)
2578 ++cam->exposure_count;
2579 else {
2580 cam->exposure_status = EXPOSURE_VERY_DARK;
2581 cam->exposure_count = 1;
2582 }
2583 } else {
2584 /* just dark */
2585 if(cam->exposure_status == EXPOSURE_DARK)
2586 ++cam->exposure_count;
2587 else {
2588 cam->exposure_status = EXPOSURE_DARK;
2589 cam->exposure_count = 1;
2590 }
2591 }
2592 } else if(old_exposure <= LOW_EXP || exp_acc > light_exp) {
2593 /* light */
2594 if(old_exposure <= VERY_LOW_EXP) {
2595 /* very light */
2596 if(cam->exposure_status == EXPOSURE_VERY_LIGHT)
2597 ++cam->exposure_count;
2598 else {
2599 cam->exposure_status = EXPOSURE_VERY_LIGHT;
2600 cam->exposure_count = 1;
2601 }
2602 } else {
2603 /* just light */
2604 if(cam->exposure_status == EXPOSURE_LIGHT)
2605 ++cam->exposure_count;
2606 else {
2607 cam->exposure_status = EXPOSURE_LIGHT;
2608 cam->exposure_count = 1;
2609 }
2610 }
2611 } else {
2612 /* not dark or light */
2613 cam->exposure_status = EXPOSURE_NORMAL;
2614 }
2615 } else {
2616 /* Flicker control off */
2617 if(old_exposure >= MAX_EXP && exp_acc < dark_exp) {
2618 /* dark */
2619 if(exp_acc < very_dark_exp) {
2620 /* very dark */
2621 if(cam->exposure_status == EXPOSURE_VERY_DARK)
2622 ++cam->exposure_count;
2623 else {
2624 cam->exposure_status = EXPOSURE_VERY_DARK;
2625 cam->exposure_count = 1;
2626 }
2627 } else {
2628 /* just dark */
2629 if(cam->exposure_status == EXPOSURE_DARK)
2630 ++cam->exposure_count;
2631 else {
2632 cam->exposure_status = EXPOSURE_DARK;
2633 cam->exposure_count = 1;
2634 }
2635 }
2636 } else if(old_exposure <= LOW_EXP || exp_acc > light_exp) {
2637 /* light */
2638 if(old_exposure <= VERY_LOW_EXP) {
2639 /* very light */
2640 if(cam->exposure_status == EXPOSURE_VERY_LIGHT)
2641 ++cam->exposure_count;
2642 else {
2643 cam->exposure_status = EXPOSURE_VERY_LIGHT;
2644 cam->exposure_count = 1;
2645 }
2646 } else {
2647 /* just light */
2648 if(cam->exposure_status == EXPOSURE_LIGHT)
2649 ++cam->exposure_count;
2650 else {
2651 cam->exposure_status = EXPOSURE_LIGHT;
2652 cam->exposure_count = 1;
2653 }
2654 }
2655 } else {
2656 /* not dark or light */
2657 cam->exposure_status = EXPOSURE_NORMAL;
2658 }
2659 }
2660
2661 framerate = cam->fps;
2662 if(framerate > 30 || framerate < 1)
2663 framerate = 1;
2664
2665 if(!cam->params.flickerControl.disabled) {
2666 /* Flicker control on */
2667 if((cam->exposure_status == EXPOSURE_VERY_DARK ||
2668 cam->exposure_status == EXPOSURE_DARK) &&
2669 cam->exposure_count >= DARK_TIME*framerate &&
2670 cam->params.sensorFps.divisor < 3) {
2671
2672 /* dark for too long */
2673 ++cam->params.sensorFps.divisor;
2674 cam->cmd_queue |= COMMAND_SETSENSORFPS;
2675
2676 cam->params.flickerControl.coarseJump =
2677 flicker_jumps[cam->mainsFreq]
2678 [cam->params.sensorFps.baserate]
2679 [cam->params.sensorFps.divisor];
2680 cam->cmd_queue |= COMMAND_SETFLICKERCTRL;
2681
2682 new_exposure = cam->params.flickerControl.coarseJump-1;
2683 while(new_exposure < old_exposure/2)
2684 new_exposure += cam->params.flickerControl.coarseJump;
2685 cam->params.exposure.coarseExpLo = new_exposure & 0xff;
2686 cam->params.exposure.coarseExpHi = new_exposure >> 8;
2687 cam->cmd_queue |= COMMAND_SETEXPOSURE;
2688 cam->exposure_status = EXPOSURE_NORMAL;
2689 LOG("Automatically decreasing sensor_fps\n");
2690
2691 } else if((cam->exposure_status == EXPOSURE_VERY_LIGHT ||
2692 cam->exposure_status == EXPOSURE_LIGHT) &&
2693 cam->exposure_count >= LIGHT_TIME*framerate &&
2694 cam->params.sensorFps.divisor > 0) {
2695
2696 /* light for too long */
2697 int max_exp = FIRMWARE_VERSION(1,2) ? MAX_EXP_102 : MAX_EXP ;
2698
2699 --cam->params.sensorFps.divisor;
2700 cam->cmd_queue |= COMMAND_SETSENSORFPS;
2701
2702 cam->params.flickerControl.coarseJump =
2703 flicker_jumps[cam->mainsFreq]
2704 [cam->params.sensorFps.baserate]
2705 [cam->params.sensorFps.divisor];
2706 cam->cmd_queue |= COMMAND_SETFLICKERCTRL;
2707
2708 new_exposure = cam->params.flickerControl.coarseJump-1;
2709 while(new_exposure < 2*old_exposure &&
2710 new_exposure+
2711 cam->params.flickerControl.coarseJump < max_exp)
2712 new_exposure += cam->params.flickerControl.coarseJump;
2713 cam->params.exposure.coarseExpLo = new_exposure & 0xff;
2714 cam->params.exposure.coarseExpHi = new_exposure >> 8;
2715 cam->cmd_queue |= COMMAND_SETEXPOSURE;
2716 cam->exposure_status = EXPOSURE_NORMAL;
2717 LOG("Automatically increasing sensor_fps\n");
2718 }
2719 } else {
2720 /* Flicker control off */
2721 if((cam->exposure_status == EXPOSURE_VERY_DARK ||
2722 cam->exposure_status == EXPOSURE_DARK) &&
2723 cam->exposure_count >= DARK_TIME*framerate &&
2724 cam->params.sensorFps.divisor < 3) {
2725
2726 /* dark for too long */
2727 ++cam->params.sensorFps.divisor;
2728 cam->cmd_queue |= COMMAND_SETSENSORFPS;
2729
2730 if(cam->params.exposure.gain > 0) {
2731 --cam->params.exposure.gain;
2732 cam->cmd_queue |= COMMAND_SETEXPOSURE;
2733 }
2734 cam->exposure_status = EXPOSURE_NORMAL;
2735 LOG("Automatically decreasing sensor_fps\n");
2736
2737 } else if((cam->exposure_status == EXPOSURE_VERY_LIGHT ||
2738 cam->exposure_status == EXPOSURE_LIGHT) &&
2739 cam->exposure_count >= LIGHT_TIME*framerate &&
2740 cam->params.sensorFps.divisor > 0) {
2741
2742 /* light for too long */
2743 --cam->params.sensorFps.divisor;
2744 cam->cmd_queue |= COMMAND_SETSENSORFPS;
2745
2746 if(cam->params.exposure.gain <
2747 cam->params.exposure.gainMode-1) {
2748 ++cam->params.exposure.gain;
2749 cam->cmd_queue |= COMMAND_SETEXPOSURE;
2750 }
2751 cam->exposure_status = EXPOSURE_NORMAL;
2752 LOG("Automatically increasing sensor_fps\n");
2753 }
2754 }
2755 mutex_unlock(&cam->param_lock);
2756 }
2757
2758 /*-----------------------------------------------------------------*/
2759 /* if flicker is switched off, this function switches it back on.It checks,
2760 however, that conditions are suitable before restarting it.
2761 This should only be called for firmware version 1.2.
2762
2763 It also adjust the colour balance when an exposure step is detected - as
2764 long as flicker is running
2765 */
2766 static void restart_flicker(struct cam_data *cam)
2767 {
2768 int cam_exposure, old_exp;
2769 if(!FIRMWARE_VERSION(1,2))
2770 return;
2771 mutex_lock(&cam->param_lock);
2772 if(cam->params.flickerControl.flickerMode == 0 ||
2773 cam->raw_image[39] == 0) {
2774 mutex_unlock(&cam->param_lock);
2775 return;
2776 }
2777 cam_exposure = cam->raw_image[39]*2;
2778 old_exp = cam->params.exposure.coarseExpLo +
2779 cam->params.exposure.coarseExpHi*256;
2780 /*
2781 see how far away camera exposure is from a valid
2782 flicker exposure value
2783 */
2784 cam_exposure %= cam->params.flickerControl.coarseJump;
2785 if(!cam->params.flickerControl.disabled &&
2786 cam_exposure <= cam->params.flickerControl.coarseJump - 3) {
2787 /* Flicker control auto-disabled */
2788 cam->params.flickerControl.disabled = 1;
2789 }
2790
2791 if(cam->params.flickerControl.disabled &&
2792 cam->params.flickerControl.flickerMode &&
2793 old_exp > cam->params.flickerControl.coarseJump +
2794 ROUND_UP_EXP_FOR_FLICKER) {
2795 /* exposure is now high enough to switch
2796 flicker control back on */
2797 set_flicker(&cam->params, &cam->cmd_queue, 1);
2798 if((cam->cmd_queue & COMMAND_SETEXPOSURE) &&
2799 cam->params.exposure.expMode == 2)
2800 cam->exposure_status = EXPOSURE_NORMAL;
2801
2802 }
2803 mutex_unlock(&cam->param_lock);
2804 }
2805 #undef FIRMWARE_VERSION
2806
2807 static int clear_stall(struct cam_data *cam)
2808 {
2809 /* FIXME: Does this actually work? */
2810 LOG("Clearing stall\n");
2811
2812 cam->ops->streamRead(cam->lowlevel_data, cam->raw_image, 0);
2813 do_command(cam, CPIA_COMMAND_GetCameraStatus,0,0,0,0);
2814 return cam->params.status.streamState != STREAM_PAUSED;
2815 }
2816
2817 /* kernel thread function to read image from camera */
2818 static int fetch_frame(void *data)
2819 {
2820 int image_size, retry;
2821 struct cam_data *cam = (struct cam_data *)data;
2822 unsigned long oldjif, rate, diff;
2823
2824 /* Allow up to two bad images in a row to be read and
2825 * ignored before an error is reported */
2826 for (retry = 0; retry < 3; ++retry) {
2827 if (retry)
2828 DBG("retry=%d\n", retry);
2829
2830 if (!cam->ops)
2831 continue;
2832
2833 /* load first frame always uncompressed */
2834 if (cam->first_frame &&
2835 cam->params.compression.mode != CPIA_COMPRESSION_NONE) {
2836 do_command(cam, CPIA_COMMAND_SetCompression,
2837 CPIA_COMPRESSION_NONE,
2838 NO_DECIMATION, 0, 0);
2839 /* Trial & error - Discarding a frame prevents the
2840 first frame from having an error in the data. */
2841 do_command(cam, CPIA_COMMAND_DiscardFrame, 0, 0, 0, 0);
2842 }
2843
2844 /* init camera upload */
2845 if (do_command(cam, CPIA_COMMAND_GrabFrame, 0,
2846 cam->params.streamStartLine, 0, 0))
2847 continue;
2848
2849 if (cam->ops->wait_for_stream_ready) {
2850 /* loop until image ready */
2851 int count = 0;
2852 do_command(cam, CPIA_COMMAND_GetCameraStatus,0,0,0,0);
2853 while (cam->params.status.streamState != STREAM_READY) {
2854 if(++count > READY_TIMEOUT)
2855 break;
2856 if(cam->params.status.streamState ==
2857 STREAM_PAUSED) {
2858 /* Bad news */
2859 if(!clear_stall(cam))
2860 return -EIO;
2861 }
2862
2863 cond_resched();
2864
2865 /* sleep for 10 ms, hopefully ;) */
2866 msleep_interruptible(10);
2867 if (signal_pending(current))
2868 return -EINTR;
2869
2870 do_command(cam, CPIA_COMMAND_GetCameraStatus,
2871 0, 0, 0, 0);
2872 }
2873 if(cam->params.status.streamState != STREAM_READY) {
2874 continue;
2875 }
2876 }
2877
2878 cond_resched();
2879
2880 /* grab image from camera */
2881 oldjif = jiffies;
2882 image_size = cam->ops->streamRead(cam->lowlevel_data,
2883 cam->raw_image, 0);
2884 if (image_size <= 0) {
2885 DBG("streamRead failed: %d\n", image_size);
2886 continue;
2887 }
2888
2889 rate = image_size * HZ / 1024;
2890 diff = jiffies-oldjif;
2891 cam->transfer_rate = diff==0 ? rate : rate/diff;
2892 /* diff==0 ? unlikely but possible */
2893
2894 /* Switch flicker control back on if it got turned off */
2895 restart_flicker(cam);
2896
2897 /* If AEC is enabled, monitor the exposure and
2898 adjust the sensor frame rate if needed */
2899 if(cam->params.exposure.expMode == 2)
2900 monitor_exposure(cam);
2901
2902 /* camera idle now so dispatch queued commands */
2903 dispatch_commands(cam);
2904
2905 /* Update our knowledge of the camera state */
2906 do_command(cam, CPIA_COMMAND_GetColourBalance, 0, 0, 0, 0);
2907 do_command(cam, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
2908 do_command(cam, CPIA_COMMAND_ReadMCPorts, 0, 0, 0, 0);
2909
2910 /* decompress and convert image to by copying it from
2911 * raw_image to decompressed_frame
2912 */
2913
2914 cond_resched();
2915
2916 cam->image_size = parse_picture(cam, image_size);
2917 if (cam->image_size <= 0) {
2918 DBG("parse_picture failed %d\n", cam->image_size);
2919 if(cam->params.compression.mode !=
2920 CPIA_COMPRESSION_NONE) {
2921 /* Compression may not work right if we
2922 had a bad frame, get the next one
2923 uncompressed. */
2924 cam->first_frame = 1;
2925 do_command(cam, CPIA_COMMAND_SetGrabMode,
2926 CPIA_GRAB_SINGLE, 0, 0, 0);
2927 /* FIXME: Trial & error - need up to 70ms for
2928 the grab mode change to complete ? */
2929 msleep_interruptible(70);
2930 if (signal_pending(current))
2931 return -EINTR;
2932 }
2933 } else
2934 break;
2935 }
2936
2937 if (retry < 3) {
2938 /* FIXME: this only works for double buffering */
2939 if (cam->frame[cam->curframe].state == FRAME_READY) {
2940 memcpy(cam->frame[cam->curframe].data,
2941 cam->decompressed_frame.data,
2942 cam->decompressed_frame.count);
2943 cam->frame[cam->curframe].state = FRAME_DONE;
2944 } else
2945 cam->decompressed_frame.state = FRAME_DONE;
2946
2947 if (cam->first_frame) {
2948 cam->first_frame = 0;
2949 do_command(cam, CPIA_COMMAND_SetCompression,
2950 cam->params.compression.mode,
2951 cam->params.compression.decimation, 0, 0);
2952
2953 /* Switch from single-grab to continuous grab */
2954 do_command(cam, CPIA_COMMAND_SetGrabMode,
2955 CPIA_GRAB_CONTINUOUS, 0, 0, 0);
2956 }
2957 return 0;
2958 }
2959 return -EIO;
2960 }
2961
2962 static int capture_frame(struct cam_data *cam, struct video_mmap *vm)
2963 {
2964 if (!cam->frame_buf) {
2965 /* we do lazy allocation */
2966 int err;
2967 if ((err = allocate_frame_buf(cam)))
2968 return err;
2969 }
2970
2971 cam->curframe = vm->frame;
2972 cam->frame[cam->curframe].state = FRAME_READY;
2973 return fetch_frame(cam);
2974 }
2975
2976 static int goto_high_power(struct cam_data *cam)
2977 {
2978 if (do_command(cam, CPIA_COMMAND_GotoHiPower, 0, 0, 0, 0))
2979 return -EIO;
2980 msleep_interruptible(40); /* windows driver does it too */
2981 if(signal_pending(current))
2982 return -EINTR;
2983 if (do_command(cam, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0))
2984 return -EIO;
2985 if (cam->params.status.systemState == HI_POWER_STATE) {
2986 DBG("camera now in HIGH power state\n");
2987 return 0;
2988 }
2989 printstatus(cam);
2990 return -EIO;
2991 }
2992
2993 static int goto_low_power(struct cam_data *cam)
2994 {
2995 if (do_command(cam, CPIA_COMMAND_GotoLoPower, 0, 0, 0, 0))
2996 return -1;
2997 if (do_command(cam, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0))
2998 return -1;
2999 if (cam->params.status.systemState == LO_POWER_STATE) {
3000 DBG("camera now in LOW power state\n");
3001 return 0;
3002 }
3003 printstatus(cam);
3004 return -1;
3005 }
3006
3007 static void save_camera_state(struct cam_data *cam)
3008 {
3009 if(!(cam->cmd_queue & COMMAND_SETCOLOURBALANCE))
3010 do_command(cam, CPIA_COMMAND_GetColourBalance, 0, 0, 0, 0);
3011 if(!(cam->cmd_queue & COMMAND_SETEXPOSURE))
3012 do_command(cam, CPIA_COMMAND_GetExposure, 0, 0, 0, 0);
3013
3014 DBG("%d/%d/%d/%d/%d/%d/%d/%d\n",
3015 cam->params.exposure.gain,
3016 cam->params.exposure.fineExp,
3017 cam->params.exposure.coarseExpLo,
3018 cam->params.exposure.coarseExpHi,
3019 cam->params.exposure.redComp,
3020 cam->params.exposure.green1Comp,
3021 cam->params.exposure.green2Comp,
3022 cam->params.exposure.blueComp);
3023 DBG("%d/%d/%d\n",
3024 cam->params.colourBalance.redGain,
3025 cam->params.colourBalance.greenGain,
3026 cam->params.colourBalance.blueGain);
3027 }
3028
3029 static int set_camera_state(struct cam_data *cam)
3030 {
3031 cam->cmd_queue = COMMAND_SETCOMPRESSION |
3032 COMMAND_SETCOMPRESSIONTARGET |
3033 COMMAND_SETCOLOURPARAMS |
3034 COMMAND_SETFORMAT |
3035 COMMAND_SETYUVTHRESH |
3036 COMMAND_SETECPTIMING |
3037 COMMAND_SETCOMPRESSIONPARAMS |
3038 COMMAND_SETEXPOSURE |
3039 COMMAND_SETCOLOURBALANCE |
3040 COMMAND_SETSENSORFPS |
3041 COMMAND_SETAPCOR |
3042 COMMAND_SETFLICKERCTRL |
3043 COMMAND_SETVLOFFSET;
3044
3045 do_command(cam, CPIA_COMMAND_SetGrabMode, CPIA_GRAB_SINGLE,0,0,0);
3046 dispatch_commands(cam);
3047
3048 /* Wait 6 frames for the sensor to get all settings and
3049 AEC/ACB to settle */
3050 msleep_interruptible(6*(cam->params.sensorFps.baserate ? 33 : 40) *
3051 (1 << cam->params.sensorFps.divisor) + 10);
3052
3053 if(signal_pending(current))
3054 return -EINTR;
3055
3056 save_camera_state(cam);
3057
3058 return 0;
3059 }
3060
3061 static void get_version_information(struct cam_data *cam)
3062 {
3063 /* GetCPIAVersion */
3064 do_command(cam, CPIA_COMMAND_GetCPIAVersion, 0, 0, 0, 0);
3065
3066 /* GetPnPID */
3067 do_command(cam, CPIA_COMMAND_GetPnPID, 0, 0, 0, 0);
3068 }
3069
3070 /* initialize camera */
3071 static int reset_camera(struct cam_data *cam)
3072 {
3073 int err;
3074 /* Start the camera in low power mode */
3075 if (goto_low_power(cam)) {
3076 if (cam->params.status.systemState != WARM_BOOT_STATE)
3077 return -ENODEV;
3078
3079 /* FIXME: this is just dirty trial and error */
3080 err = goto_high_power(cam);
3081 if(err)
3082 return err;
3083 do_command(cam, CPIA_COMMAND_DiscardFrame, 0, 0, 0, 0);
3084 if (goto_low_power(cam))
3085 return -ENODEV;
3086 }
3087
3088 /* procedure described in developer's guide p3-28 */
3089
3090 /* Check the firmware version. */
3091 cam->params.version.firmwareVersion = 0;
3092 get_version_information(cam);
3093 if (cam->params.version.firmwareVersion != 1)
3094 return -ENODEV;
3095
3096 /* A bug in firmware 1-02 limits gainMode to 2 */
3097 if(cam->params.version.firmwareRevision <= 2 &&
3098 cam->params.exposure.gainMode > 2) {
3099 cam->params.exposure.gainMode = 2;
3100 }
3101
3102 /* set QX3 detected flag */
3103 cam->params.qx3.qx3_detected = (cam->params.pnpID.vendor == 0x0813 &&
3104 cam->params.pnpID.product == 0x0001);
3105
3106 /* The fatal error checking should be done after
3107 * the camera powers up (developer's guide p 3-38) */
3108
3109 /* Set streamState before transition to high power to avoid bug
3110 * in firmware 1-02 */
3111 do_command(cam, CPIA_COMMAND_ModifyCameraStatus, STREAMSTATE, 0,
3112 STREAM_NOT_READY, 0);
3113
3114 /* GotoHiPower */
3115 err = goto_high_power(cam);
3116 if (err)
3117 return err;
3118
3119 /* Check the camera status */
3120 if (do_command(cam, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0))
3121 return -EIO;
3122
3123 if (cam->params.status.fatalError) {
3124 DBG("fatal_error: %#04x\n",
3125 cam->params.status.fatalError);
3126 DBG("vp_status: %#04x\n",
3127 cam->params.status.vpStatus);
3128 if (cam->params.status.fatalError & ~(COM_FLAG|CPIA_FLAG)) {
3129 /* Fatal error in camera */
3130 return -EIO;
3131 } else if (cam->params.status.fatalError & (COM_FLAG|CPIA_FLAG)) {
3132 /* Firmware 1-02 may do this for parallel port cameras,
3133 * just clear the flags (developer's guide p 3-38) */
3134 do_command(cam, CPIA_COMMAND_ModifyCameraStatus,
3135 FATALERROR, ~(COM_FLAG|CPIA_FLAG), 0, 0);
3136 }
3137 }
3138
3139 /* Check the camera status again */
3140 if (cam->params.status.fatalError) {
3141 if (cam->params.status.fatalError)
3142 return -EIO;
3143 }
3144
3145 /* VPVersion can't be retrieved before the camera is in HiPower,
3146 * so get it here instead of in get_version_information. */
3147 do_command(cam, CPIA_COMMAND_GetVPVersion, 0, 0, 0, 0);
3148
3149 /* set camera to a known state */
3150 return set_camera_state(cam);
3151 }
3152
3153 static void put_cam(struct cpia_camera_ops* ops)
3154 {
3155 module_put(ops->owner);
3156 }
3157
3158 /* ------------------------- V4L interface --------------------- */
3159 static int cpia_open(struct inode *inode, struct file *file)
3160 {
3161 struct video_device *dev = video_devdata(file);
3162 struct cam_data *cam = dev->priv;
3163 int err;
3164
3165 if (!cam) {
3166 DBG("Internal error, cam_data not found!\n");
3167 return -ENODEV;
3168 }
3169
3170 if (cam->open_count > 0) {
3171 DBG("Camera already open\n");
3172 return -EBUSY;
3173 }
3174
3175 if (!try_module_get(cam->ops->owner))
3176 return -ENODEV;
3177
3178 mutex_lock(&cam->busy_lock);
3179 err = -ENOMEM;
3180 if (!cam->raw_image) {
3181 cam->raw_image = rvmalloc(CPIA_MAX_IMAGE_SIZE);
3182 if (!cam->raw_image)
3183 goto oops;
3184 }
3185
3186 if (!cam->decompressed_frame.data) {
3187 cam->decompressed_frame.data = rvmalloc(CPIA_MAX_FRAME_SIZE);
3188 if (!cam->decompressed_frame.data)
3189 goto oops;
3190 }
3191
3192 /* open cpia */
3193 err = -ENODEV;
3194 if (cam->ops->open(cam->lowlevel_data))
3195 goto oops;
3196
3197 /* reset the camera */
3198 if ((err = reset_camera(cam)) != 0) {
3199 cam->ops->close(cam->lowlevel_data);
3200 goto oops;
3201 }
3202
3203 err = -EINTR;
3204 if(signal_pending(current))
3205 goto oops;
3206
3207 /* Set ownership of /proc/cpia/videoX to current user */
3208 if(cam->proc_entry)
3209 cam->proc_entry->uid = current->uid;
3210
3211 /* set mark for loading first frame uncompressed */
3212 cam->first_frame = 1;
3213
3214 /* init it to something */
3215 cam->mmap_kludge = 0;
3216
3217 ++cam->open_count;
3218 file->private_data = dev;
3219 mutex_unlock(&cam->busy_lock);
3220 return 0;
3221
3222 oops:
3223 if (cam->decompressed_frame.data) {
3224 rvfree(cam->decompressed_frame.data, CPIA_MAX_FRAME_SIZE);
3225 cam->decompressed_frame.data = NULL;
3226 }
3227 if (cam->raw_image) {
3228 rvfree(cam->raw_image, CPIA_MAX_IMAGE_SIZE);
3229 cam->raw_image = NULL;
3230 }
3231 mutex_unlock(&cam->busy_lock);
3232 put_cam(cam->ops);
3233 return err;
3234 }
3235
3236 static int cpia_close(struct inode *inode, struct file *file)
3237 {
3238 struct video_device *dev = file->private_data;
3239 struct cam_data *cam = dev->priv;
3240
3241 if (cam->ops) {
3242 /* Return ownership of /proc/cpia/videoX to root */
3243 if(cam->proc_entry)
3244 cam->proc_entry->uid = 0;
3245
3246 /* save camera state for later open (developers guide ch 3.5.3) */
3247 save_camera_state(cam);
3248
3249 /* GotoLoPower */
3250 goto_low_power(cam);
3251
3252 /* Update the camera status */
3253 do_command(cam, CPIA_COMMAND_GetCameraStatus, 0, 0, 0, 0);
3254
3255 /* cleanup internal state stuff */
3256 free_frames(cam->frame);
3257
3258 /* close cpia */
3259 cam->ops->close(cam->lowlevel_data);
3260
3261 put_cam(cam->ops);
3262 }
3263
3264 if (--cam->open_count == 0) {
3265 /* clean up capture-buffers */
3266 if (cam->raw_image) {
3267 rvfree(cam->raw_image, CPIA_MAX_IMAGE_SIZE);
3268 cam->raw_image = NULL;
3269 }
3270
3271 if (cam->decompressed_frame.data) {
3272 rvfree(cam->decompressed_frame.data, CPIA_MAX_FRAME_SIZE);
3273 cam->decompressed_frame.data = NULL;
3274 }
3275
3276 if (cam->frame_buf)
3277 free_frame_buf(cam);
3278
3279 if (!cam->ops)
3280 kfree(cam);
3281 }
3282 file->private_data = NULL;
3283
3284 return 0;
3285 }
3286
3287 static ssize_t cpia_read(struct file *file, char __user *buf,
3288 size_t count, loff_t *ppos)
3289 {
3290 struct video_device *dev = file->private_data;
3291 struct cam_data *cam = dev->priv;
3292 int err;
3293
3294 /* make this _really_ smp and multithread-safe */
3295 if (mutex_lock_interruptible(&cam->busy_lock))
3296 return -EINTR;
3297
3298 if (!buf) {
3299 DBG("buf NULL\n");
3300 mutex_unlock(&cam->busy_lock);
3301 return -EINVAL;
3302 }
3303
3304 if (!count) {
3305 DBG("count 0\n");
3306 mutex_unlock(&cam->busy_lock);
3307 return 0;
3308 }
3309
3310 if (!cam->ops) {
3311 DBG("ops NULL\n");
3312 mutex_unlock(&cam->busy_lock);
3313 return -ENODEV;
3314 }
3315
3316 /* upload frame */
3317 cam->decompressed_frame.state = FRAME_READY;
3318 cam->mmap_kludge=0;
3319 if((err = fetch_frame(cam)) != 0) {
3320 DBG("ERROR from fetch_frame: %d\n", err);
3321 mutex_unlock(&cam->busy_lock);
3322 return err;
3323 }
3324 cam->decompressed_frame.state = FRAME_UNUSED;
3325
3326 /* copy data to user space */
3327 if (cam->decompressed_frame.count > count) {
3328 DBG("count wrong: %d, %lu\n", cam->decompressed_frame.count,
3329 (unsigned long) count);
3330 mutex_unlock(&cam->busy_lock);
3331 return -EFAULT;
3332 }
3333 if (copy_to_user(buf, cam->decompressed_frame.data,
3334 cam->decompressed_frame.count)) {
3335 DBG("copy_to_user failed\n");
3336 mutex_unlock(&cam->busy_lock);
3337 return -EFAULT;
3338 }
3339
3340 mutex_unlock(&cam->busy_lock);
3341 return cam->decompressed_frame.count;
3342 }
3343
3344 static int cpia_do_ioctl(struct inode *inode, struct file *file,
3345 unsigned int ioctlnr, void *arg)
3346 {
3347 struct video_device *dev = file->private_data;
3348 struct cam_data *cam = dev->priv;
3349 int retval = 0;
3350
3351 if (!cam || !cam->ops)
3352 return -ENODEV;
3353
3354 /* make this _really_ smp-safe */
3355 if (mutex_lock_interruptible(&cam->busy_lock))
3356 return -EINTR;
3357
3358 //DBG("cpia_ioctl: %u\n", ioctlnr);
3359
3360 switch (ioctlnr) {
3361 /* query capabilities */
3362 case VIDIOCGCAP:
3363 {
3364 struct video_capability *b = arg;
3365
3366 DBG("VIDIOCGCAP\n");
3367 strcpy(b->name, "CPiA Camera");
3368 b->type = VID_TYPE_CAPTURE | VID_TYPE_SUBCAPTURE;
3369 b->channels = 1;
3370 b->audios = 0;
3371 b->maxwidth = 352; /* VIDEOSIZE_CIF */
3372 b->maxheight = 288;
3373 b->minwidth = 48; /* VIDEOSIZE_48_48 */
3374 b->minheight = 48;
3375 break;
3376 }
3377
3378 /* get/set video source - we are a camera and nothing else */
3379 case VIDIOCGCHAN:
3380 {
3381 struct video_channel *v = arg;
3382
3383 DBG("VIDIOCGCHAN\n");
3384 if (v->channel != 0) {
3385 retval = -EINVAL;
3386 break;
3387 }
3388
3389 v->channel = 0;
3390 strcpy(v->name, "Camera");
3391 v->tuners = 0;
3392 v->flags = 0;
3393 v->type = VIDEO_TYPE_CAMERA;
3394 v->norm = 0;
3395 break;
3396 }
3397
3398 case VIDIOCSCHAN:
3399 {
3400 struct video_channel *v = arg;
3401
3402 DBG("VIDIOCSCHAN\n");
3403 if (v->channel != 0)
3404 retval = -EINVAL;
3405 break;
3406 }
3407
3408 /* image properties */
3409 case VIDIOCGPICT:
3410 {
3411 struct video_picture *pic = arg;
3412 DBG("VIDIOCGPICT\n");
3413 *pic = cam->vp;
3414 break;
3415 }
3416
3417 case VIDIOCSPICT:
3418 {
3419 struct video_picture *vp = arg;
3420
3421 DBG("VIDIOCSPICT\n");
3422
3423 /* check validity */
3424 DBG("palette: %d\n", vp->palette);
3425 DBG("depth: %d\n", vp->depth);
3426 if (!valid_mode(vp->palette, vp->depth)) {
3427 retval = -EINVAL;
3428 break;
3429 }
3430
3431 mutex_lock(&cam->param_lock);
3432 /* brightness, colour, contrast need no check 0-65535 */
3433 cam->vp = *vp;
3434 /* update cam->params.colourParams */
3435 cam->params.colourParams.brightness = vp->brightness*100/65535;
3436 cam->params.colourParams.contrast = vp->contrast*100/65535;
3437 cam->params.colourParams.saturation = vp->colour*100/65535;
3438 /* contrast is in steps of 8, so round */
3439 cam->params.colourParams.contrast =
3440 ((cam->params.colourParams.contrast + 3) / 8) * 8;
3441 if (cam->params.version.firmwareVersion == 1 &&
3442 cam->params.version.firmwareRevision == 2 &&
3443 cam->params.colourParams.contrast > 80) {
3444 /* 1-02 firmware limits contrast to 80 */
3445 cam->params.colourParams.contrast = 80;
3446 }
3447
3448 /* Adjust flicker control if necessary */
3449 if(cam->params.flickerControl.allowableOverExposure < 0)
3450 cam->params.flickerControl.allowableOverExposure =
3451 -find_over_exposure(cam->params.colourParams.brightness);
3452 if(cam->params.flickerControl.flickerMode != 0)
3453 cam->cmd_queue |= COMMAND_SETFLICKERCTRL;
3454
3455
3456 /* queue command to update camera */
3457 cam->cmd_queue |= COMMAND_SETCOLOURPARAMS;
3458 mutex_unlock(&cam->param_lock);
3459 DBG("VIDIOCSPICT: %d / %d // %d / %d / %d / %d\n",
3460 vp->depth, vp->palette, vp->brightness, vp->hue, vp->colour,
3461 vp->contrast);
3462 break;
3463 }
3464
3465 /* get/set capture window */
3466 case VIDIOCGWIN:
3467 {
3468 struct video_window *vw = arg;
3469 DBG("VIDIOCGWIN\n");
3470
3471 *vw = cam->vw;
3472 break;
3473 }
3474
3475 case VIDIOCSWIN:
3476 {
3477 /* copy_from_user, check validity, copy to internal structure */
3478 struct video_window *vw = arg;
3479 DBG("VIDIOCSWIN\n");
3480
3481 if (vw->clipcount != 0) { /* clipping not supported */
3482 retval = -EINVAL;
3483 break;
3484 }
3485 if (vw->clips != NULL) { /* clipping not supported */
3486 retval = -EINVAL;
3487 break;
3488 }
3489
3490 /* we set the video window to something smaller or equal to what
3491 * is requested by the user???
3492 */
3493 mutex_lock(&cam->param_lock);
3494 if (vw->width != cam->vw.width || vw->height != cam->vw.height) {
3495 int video_size = match_videosize(vw->width, vw->height);
3496
3497 if (video_size < 0) {
3498 retval = -EINVAL;
3499 mutex_unlock(&cam->param_lock);
3500 break;
3501 }
3502 cam->video_size = video_size;
3503
3504 /* video size is changing, reset the subcapture area */
3505 memset(&cam->vc, 0, sizeof(cam->vc));
3506
3507 set_vw_size(cam);
3508 DBG("%d / %d\n", cam->vw.width, cam->vw.height);
3509 cam->cmd_queue |= COMMAND_SETFORMAT;
3510 }
3511
3512 mutex_unlock(&cam->param_lock);
3513
3514 /* setformat ignored by camera during streaming,
3515 * so stop/dispatch/start */
3516 if (cam->cmd_queue & COMMAND_SETFORMAT) {
3517 DBG("\n");
3518 dispatch_commands(cam);
3519 }
3520 DBG("%d/%d:%d\n", cam->video_size,
3521 cam->vw.width, cam->vw.height);
3522 break;
3523 }
3524
3525 /* mmap interface */
3526 case VIDIOCGMBUF:
3527 {
3528 struct video_mbuf *vm = arg;
3529 int i;
3530
3531 DBG("VIDIOCGMBUF\n");
3532 memset(vm, 0, sizeof(*vm));
3533 vm->size = CPIA_MAX_FRAME_SIZE*FRAME_NUM;
3534 vm->frames = FRAME_NUM;
3535 for (i = 0; i < FRAME_NUM; i++)
3536 vm->offsets[i] = CPIA_MAX_FRAME_SIZE * i;
3537 break;
3538 }
3539
3540 case VIDIOCMCAPTURE:
3541 {
3542 struct video_mmap *vm = arg;
3543 int video_size;
3544
3545 DBG("VIDIOCMCAPTURE: %d / %d / %dx%d\n", vm->format, vm->frame,
3546 vm->width, vm->height);
3547 if (vm->frame<0||vm->frame>=FRAME_NUM) {
3548 retval = -EINVAL;
3549 break;
3550 }
3551
3552 /* set video format */
3553 cam->vp.palette = vm->format;
3554 switch(vm->format) {
3555 case VIDEO_PALETTE_GREY:
3556 cam->vp.depth=8;
3557 break;
3558 case VIDEO_PALETTE_RGB555:
3559 case VIDEO_PALETTE_RGB565:
3560 case VIDEO_PALETTE_YUV422:
3561 case VIDEO_PALETTE_YUYV:
3562 case VIDEO_PALETTE_UYVY:
3563 cam->vp.depth = 16;
3564 break;
3565 case VIDEO_PALETTE_RGB24:
3566 cam->vp.depth = 24;
3567 break;
3568 case VIDEO_PALETTE_RGB32:
3569 cam->vp.depth = 32;
3570 break;
3571 default:
3572 retval = -EINVAL;
3573 break;
3574 }
3575 if (retval)
3576 break;
3577
3578 /* set video size */
3579 video_size = match_videosize(vm->width, vm->height);
3580 if (video_size < 0) {
3581 retval = -EINVAL;
3582 break;
3583 }
3584 if (video_size != cam->video_size) {
3585 cam->video_size = video_size;
3586
3587 /* video size is changing, reset the subcapture area */
3588 memset(&cam->vc, 0, sizeof(cam->vc));
3589
3590 set_vw_size(cam);
3591 cam->cmd_queue |= COMMAND_SETFORMAT;
3592 dispatch_commands(cam);
3593 }
3594 /* according to v4l-spec we must start streaming here */
3595 cam->mmap_kludge = 1;
3596 retval = capture_frame(cam, vm);
3597
3598 break;
3599 }
3600
3601 case VIDIOCSYNC:
3602 {
3603 int *frame = arg;
3604
3605 //DBG("VIDIOCSYNC: %d\n", *frame);
3606
3607 if (*frame<0 || *frame >= FRAME_NUM) {
3608 retval = -EINVAL;
3609 break;
3610 }
3611
3612 switch (cam->frame[*frame].state) {
3613 case FRAME_UNUSED:
3614 case FRAME_READY:
3615 case FRAME_GRABBING:
3616 DBG("sync to unused frame %d\n", *frame);
3617 retval = -EINVAL;
3618 break;
3619
3620 case FRAME_DONE:
3621 cam->frame[*frame].state = FRAME_UNUSED;
3622 //DBG("VIDIOCSYNC: %d synced\n", *frame);
3623 break;
3624 }
3625 if (retval == -EINTR) {
3626 /* FIXME - xawtv does not handle this nice */
3627 retval = 0;
3628 }
3629 break;
3630 }
3631
3632 case VIDIOCGCAPTURE:
3633 {
3634 struct video_capture *vc = arg;
3635
3636 DBG("VIDIOCGCAPTURE\n");
3637
3638 *vc = cam->vc;
3639
3640 break;
3641 }
3642
3643 case VIDIOCSCAPTURE:
3644 {
3645 struct video_capture *vc = arg;
3646
3647 DBG("VIDIOCSCAPTURE\n");
3648
3649 if (vc->decimation != 0) { /* How should this be used? */
3650 retval = -EINVAL;
3651 break;
3652 }
3653 if (vc->flags != 0) { /* Even/odd grab not supported */
3654 retval = -EINVAL;
3655 break;
3656 }
3657
3658 /* Clip to the resolution we can set for the ROI
3659 (every 8 columns and 4 rows) */
3660 vc->x = vc->x & ~(__u32)7;
3661 vc->y = vc->y & ~(__u32)3;
3662 vc->width = vc->width & ~(__u32)7;
3663 vc->height = vc->height & ~(__u32)3;
3664
3665 if(vc->width == 0 || vc->height == 0 ||
3666 vc->x + vc->width > cam->vw.width ||
3667 vc->y + vc->height > cam->vw.height) {
3668 retval = -EINVAL;
3669 break;
3670 }
3671
3672 DBG("%d,%d/%dx%d\n", vc->x,vc->y,vc->width, vc->height);
3673
3674 mutex_lock(&cam->param_lock);
3675
3676 cam->vc.x = vc->x;
3677 cam->vc.y = vc->y;
3678 cam->vc.width = vc->width;
3679 cam->vc.height = vc->height;
3680
3681 set_vw_size(cam);
3682 cam->cmd_queue |= COMMAND_SETFORMAT;
3683
3684 mutex_unlock(&cam->param_lock);
3685
3686 /* setformat ignored by camera during streaming,
3687 * so stop/dispatch/start */
3688 dispatch_commands(cam);
3689 break;
3690 }
3691
3692 case VIDIOCGUNIT:
3693 {
3694 struct video_unit *vu = arg;
3695
3696 DBG("VIDIOCGUNIT\n");
3697
3698 vu->video = cam->vdev.minor;
3699 vu->vbi = VIDEO_NO_UNIT;
3700 vu->radio = VIDEO_NO_UNIT;
3701 vu->audio = VIDEO_NO_UNIT;
3702 vu->teletext = VIDEO_NO_UNIT;
3703
3704 break;
3705 }
3706
3707
3708 /* pointless to implement overlay with this camera */
3709 case VIDIOCCAPTURE:
3710 case VIDIOCGFBUF:
3711 case VIDIOCSFBUF:
3712 case VIDIOCKEY:
3713 /* tuner interface - we have none */
3714 case VIDIOCGTUNER:
3715 case VIDIOCSTUNER:
3716 case VIDIOCGFREQ:
3717 case VIDIOCSFREQ:
3718 /* audio interface - we have none */
3719 case VIDIOCGAUDIO:
3720 case VIDIOCSAUDIO:
3721 retval = -EINVAL;
3722 break;
3723 default:
3724 retval = -ENOIOCTLCMD;
3725 break;
3726 }
3727
3728 mutex_unlock(&cam->busy_lock);
3729 return retval;
3730 }
3731
3732 static int cpia_ioctl(struct inode *inode, struct file *file,
3733 unsigned int cmd, unsigned long arg)
3734 {
3735 return video_usercopy(inode, file, cmd, arg, cpia_do_ioctl);
3736 }
3737
3738
3739 /* FIXME */
3740 static int cpia_mmap(struct file *file, struct vm_area_struct *vma)
3741 {
3742 struct video_device *dev = file->private_data;
3743 unsigned long start = vma->vm_start;
3744 unsigned long size = vma->vm_end - vma->vm_start;
3745 unsigned long page, pos;
3746 struct cam_data *cam = dev->priv;
3747 int retval;
3748
3749 if (!cam || !cam->ops)
3750 return -ENODEV;
3751
3752 DBG("cpia_mmap: %ld\n", size);
3753
3754 if (size > FRAME_NUM*CPIA_MAX_FRAME_SIZE)
3755 return -EINVAL;
3756
3757 if (!cam || !cam->ops)
3758 return -ENODEV;
3759
3760 /* make this _really_ smp-safe */
3761 if (mutex_lock_interruptible(&cam->busy_lock))
3762 return -EINTR;
3763
3764 if (!cam->frame_buf) { /* we do lazy allocation */
3765 if ((retval = allocate_frame_buf(cam))) {
3766 mutex_unlock(&cam->busy_lock);
3767 return retval;
3768 }
3769 }
3770
3771 pos = (unsigned long)(cam->frame_buf);
3772 while (size > 0) {
3773 page = vmalloc_to_pfn((void *)pos);
3774 if (remap_pfn_range(vma, start, page, PAGE_SIZE, PAGE_SHARED)) {
3775 mutex_unlock(&cam->busy_lock);
3776 return -EAGAIN;
3777 }
3778 start += PAGE_SIZE;
3779 pos += PAGE_SIZE;
3780 if (size > PAGE_SIZE)
3781 size -= PAGE_SIZE;
3782 else
3783 size = 0;
3784 }
3785
3786 DBG("cpia_mmap: %ld\n", size);
3787 mutex_unlock(&cam->busy_lock);
3788
3789 return 0;
3790 }
3791
3792 static const struct file_operations cpia_fops = {
3793 .owner = THIS_MODULE,
3794 .open = cpia_open,
3795 .release = cpia_close,
3796 .read = cpia_read,
3797 .mmap = cpia_mmap,
3798 .ioctl = cpia_ioctl,
3799 .compat_ioctl = v4l_compat_ioctl32,
3800 .llseek = no_llseek,
3801 };
3802
3803 static struct video_device cpia_template = {
3804 .owner = THIS_MODULE,
3805 .name = "CPiA Camera",
3806 .type = VID_TYPE_CAPTURE,
3807 .hardware = VID_HARDWARE_CPIA,
3808 .fops = &cpia_fops,
3809 };
3810
3811 /* initialise cam_data structure */
3812 static void reset_camera_struct(struct cam_data *cam)
3813 {
3814 /* The following parameter values are the defaults from
3815 * "Software Developer's Guide for CPiA Cameras". Any changes
3816 * to the defaults are noted in comments. */
3817 cam->params.colourParams.brightness = 50;
3818 cam->params.colourParams.contrast = 48;
3819 cam->params.colourParams.saturation = 50;
3820 cam->params.exposure.gainMode = 4;
3821 cam->params.exposure.expMode = 2; /* AEC */
3822 cam->params.exposure.compMode = 1;
3823 cam->params.exposure.centreWeight = 1;
3824 cam->params.exposure.gain = 0;
3825 cam->params.exposure.fineExp = 0;
3826 cam->params.exposure.coarseExpLo = 185;
3827 cam->params.exposure.coarseExpHi = 0;
3828 cam->params.exposure.redComp = COMP_RED;
3829 cam->params.exposure.green1Comp = COMP_GREEN1;
3830 cam->params.exposure.green2Comp = COMP_GREEN2;
3831 cam->params.exposure.blueComp = COMP_BLUE;
3832 cam->params.colourBalance.balanceMode = 2; /* ACB */
3833 cam->params.colourBalance.redGain = 32;
3834 cam->params.colourBalance.greenGain = 6;
3835 cam->params.colourBalance.blueGain = 92;
3836 cam->params.apcor.gain1 = 0x18;
3837 cam->params.apcor.gain2 = 0x16;
3838 cam->params.apcor.gain4 = 0x24;
3839 cam->params.apcor.gain8 = 0x34;
3840 cam->params.flickerControl.flickerMode = 0;
3841 cam->params.flickerControl.disabled = 1;
3842
3843 cam->params.flickerControl.coarseJump =
3844 flicker_jumps[cam->mainsFreq]
3845 [cam->params.sensorFps.baserate]
3846 [cam->params.sensorFps.divisor];
3847 cam->params.flickerControl.allowableOverExposure =
3848 -find_over_exposure(cam->params.colourParams.brightness);
3849 cam->params.vlOffset.gain1 = 20;
3850 cam->params.vlOffset.gain2 = 24;
3851 cam->params.vlOffset.gain4 = 26;
3852 cam->params.vlOffset.gain8 = 26;
3853 cam->params.compressionParams.hysteresis = 3;
3854 cam->params.compressionParams.threshMax = 11;
3855 cam->params.compressionParams.smallStep = 1;
3856 cam->params.compressionParams.largeStep = 3;
3857 cam->params.compressionParams.decimationHysteresis = 2;
3858 cam->params.compressionParams.frDiffStepThresh = 5;
3859 cam->params.compressionParams.qDiffStepThresh = 3;
3860 cam->params.compressionParams.decimationThreshMod = 2;
3861 /* End of default values from Software Developer's Guide */
3862
3863 cam->transfer_rate = 0;
3864 cam->exposure_status = EXPOSURE_NORMAL;
3865
3866 /* Set Sensor FPS to 15fps. This seems better than 30fps
3867 * for indoor lighting. */
3868 cam->params.sensorFps.divisor = 1;
3869 cam->params.sensorFps.baserate = 1;
3870
3871 cam->params.yuvThreshold.yThreshold = 6; /* From windows driver */
3872 cam->params.yuvThreshold.uvThreshold = 6; /* From windows driver */
3873
3874 cam->params.format.subSample = SUBSAMPLE_422;
3875 cam->params.format.yuvOrder = YUVORDER_YUYV;
3876
3877 cam->params.compression.mode = CPIA_COMPRESSION_AUTO;
3878 cam->params.compressionTarget.frTargeting =
3879 CPIA_COMPRESSION_TARGET_QUALITY;
3880 cam->params.compressionTarget.targetFR = 15; /* From windows driver */
3881 cam->params.compressionTarget.targetQ = 5; /* From windows driver */
3882
3883 cam->params.qx3.qx3_detected = 0;
3884 cam->params.qx3.toplight = 0;
3885 cam->params.qx3.bottomlight = 0;
3886 cam->params.qx3.button = 0;
3887 cam->params.qx3.cradled = 0;
3888
3889 cam->video_size = VIDEOSIZE_CIF;
3890
3891 cam->vp.colour = 32768; /* 50% */
3892 cam->vp.hue = 32768; /* 50% */
3893 cam->vp.brightness = 32768; /* 50% */
3894 cam->vp.contrast = 32768; /* 50% */
3895 cam->vp.whiteness = 0; /* not used -> grayscale only */
3896 cam->vp.depth = 24; /* to be set by user */
3897 cam->vp.palette = VIDEO_PALETTE_RGB24; /* to be set by user */
3898
3899 cam->vc.x = 0;
3900 cam->vc.y = 0;
3901 cam->vc.width = 0;
3902 cam->vc.height = 0;
3903
3904 cam->vw.x = 0;
3905 cam->vw.y = 0;
3906 set_vw_size(cam);
3907 cam->vw.chromakey = 0;
3908 cam->vw.flags = 0;
3909 cam->vw.clipcount = 0;
3910 cam->vw.clips = NULL;
3911
3912 cam->cmd_queue = COMMAND_NONE;
3913 cam->first_frame = 1;
3914
3915 return;
3916 }
3917
3918 /* initialize cam_data structure */
3919 static void init_camera_struct(struct cam_data *cam,
3920 struct cpia_camera_ops *ops )
3921 {
3922 int i;
3923
3924 /* Default everything to 0 */
3925 memset(cam, 0, sizeof(struct cam_data));
3926
3927 cam->ops = ops;
3928 mutex_init(&cam->param_lock);
3929 mutex_init(&cam->busy_lock);
3930
3931 reset_camera_struct(cam);
3932
3933 cam->proc_entry = NULL;
3934
3935 memcpy(&cam->vdev, &cpia_template, sizeof(cpia_template));
3936 cam->vdev.priv = cam;
3937
3938 cam->curframe = 0;
3939 for (i = 0; i < FRAME_NUM; i++) {
3940 cam->frame[i].width = 0;
3941 cam->frame[i].height = 0;
3942 cam->frame[i].state = FRAME_UNUSED;
3943 cam->frame[i].data = NULL;
3944 }
3945 cam->decompressed_frame.width = 0;
3946 cam->decompressed_frame.height = 0;
3947 cam->decompressed_frame.state = FRAME_UNUSED;
3948 cam->decompressed_frame.data = NULL;
3949 }
3950
3951 struct cam_data *cpia_register_camera(struct cpia_camera_ops *ops, void *lowlevel)
3952 {
3953 struct cam_data *camera;
3954
3955 if ((camera = kmalloc(sizeof(struct cam_data), GFP_KERNEL)) == NULL)
3956 return NULL;
3957
3958
3959 init_camera_struct( camera, ops );
3960 camera->lowlevel_data = lowlevel;
3961
3962 /* register v4l device */
3963 if (video_register_device(&camera->vdev, VFL_TYPE_GRABBER, video_nr) == -1) {
3964 kfree(camera);
3965 printk(KERN_DEBUG "video_register_device failed\n");
3966 return NULL;
3967 }
3968
3969 /* get version information from camera: open/reset/close */
3970
3971 /* open cpia */
3972 if (camera->ops->open(camera->lowlevel_data))
3973 return camera;
3974
3975 /* reset the camera */
3976 if (reset_camera(camera) != 0) {
3977 camera->ops->close(camera->lowlevel_data);
3978 return camera;
3979 }
3980
3981 /* close cpia */
3982 camera->ops->close(camera->lowlevel_data);
3983
3984 #ifdef CONFIG_PROC_FS
3985 create_proc_cpia_cam(camera);
3986 #endif
3987
3988 printk(KERN_INFO " CPiA Version: %d.%02d (%d.%d)\n",
3989 camera->params.version.firmwareVersion,
3990 camera->params.version.firmwareRevision,
3991 camera->params.version.vcVersion,
3992 camera->params.version.vcRevision);
3993 printk(KERN_INFO " CPiA PnP-ID: %04x:%04x:%04x\n",
3994 camera->params.pnpID.vendor,
3995 camera->params.pnpID.product,
3996 camera->params.pnpID.deviceRevision);
3997 printk(KERN_INFO " VP-Version: %d.%d %04x\n",
3998 camera->params.vpVersion.vpVersion,
3999 camera->params.vpVersion.vpRevision,
4000 camera->params.vpVersion.cameraHeadID);
4001
4002 return camera;
4003 }
4004
4005 void cpia_unregister_camera(struct cam_data *cam)
4006 {
4007 DBG("unregistering video\n");
4008 video_unregister_device(&cam->vdev);
4009 if (cam->open_count) {
4010 put_cam(cam->ops);
4011 DBG("camera open -- setting ops to NULL\n");
4012 cam->ops = NULL;
4013 }
4014
4015 #ifdef CONFIG_PROC_FS
4016 DBG("destroying /proc/cpia/video%d\n", cam->vdev.minor);
4017 destroy_proc_cpia_cam(cam);
4018 #endif
4019 if (!cam->open_count) {
4020 DBG("freeing camera\n");
4021 kfree(cam);
4022 }
4023 }
4024
4025 static int __init cpia_init(void)
4026 {
4027 printk(KERN_INFO "%s v%d.%d.%d\n", ABOUT,
4028 CPIA_MAJ_VER, CPIA_MIN_VER, CPIA_PATCH_VER);
4029
4030 printk(KERN_WARNING "Since in-kernel colorspace conversion is not "
4031 "allowed, it is disabled by default now. Users should fix the "
4032 "applications in case they don't work without conversion "
4033 "reenabled by setting the 'colorspace_conv' module "
4034 "parameter to 1\n");
4035
4036 #ifdef CONFIG_PROC_FS
4037 proc_cpia_create();
4038 #endif
4039
4040 return 0;
4041 }
4042
4043 static void __exit cpia_exit(void)
4044 {
4045 #ifdef CONFIG_PROC_FS
4046 proc_cpia_destroy();
4047 #endif
4048 }
4049
4050 module_init(cpia_init);
4051 module_exit(cpia_exit);
4052
4053 /* Exported symbols for modules. */
4054
4055 EXPORT_SYMBOL(cpia_register_camera);
4056 EXPORT_SYMBOL(cpia_unregister_camera);
Ubuntu Artful kernel mirror