]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - drivers/media/usb/cpia2/cpia2_core.c
projects / thirdparty / kernel / stable.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 157
[thirdparty/kernel/stable.git] / drivers / media / usb / cpia2 / cpia2_core.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /****************************************************************************
3 *
4 * Filename: cpia2_core.c
5 *
6 * Copyright 2001, STMicrolectronics, Inc.
7 * Contact: steve.miller@st.com
8 *
9 * Description:
10 * This is a USB driver for CPia2 based video cameras.
11 * The infrastructure of this driver is based on the cpia usb driver by
12 * Jochen Scharrlach and Johannes Erdfeldt.
13 *
14 * Stripped of 2.4 stuff ready for main kernel submit by
15 * Alan Cox <alan@lxorguk.ukuu.org.uk>
16 *
17 ****************************************************************************/
18
19 #include "cpia2.h"
20
21 #include <linux/module.h>
22 #include <linux/slab.h>
23 #include <linux/mm.h>
24 #include <linux/vmalloc.h>
25 #include <linux/firmware.h>
26 #include <linux/sched/signal.h>
27
28 #define FIRMWARE "cpia2/stv0672_vp4.bin"
29 MODULE_FIRMWARE(FIRMWARE);
30
31 /* #define _CPIA2_DEBUG_ */
32
33 #ifdef _CPIA2_DEBUG_
34
35 static const char *block_name[] = {
36 "System",
37 "VC",
38 "VP",
39 "IDATA"
40 };
41 #endif
42
43 static unsigned int debugs_on; /* default 0 - DEBUG_REG */
44
45
46 /******************************************************************************
47 *
48 * Forward Declarations
49 *
50 *****************************************************************************/
51 static int apply_vp_patch(struct camera_data *cam);
52 static int set_default_user_mode(struct camera_data *cam);
53 static int set_vw_size(struct camera_data *cam, int size);
54 static int configure_sensor(struct camera_data *cam,
55 int reqwidth, int reqheight);
56 static int config_sensor_410(struct camera_data *cam,
57 int reqwidth, int reqheight);
58 static int config_sensor_500(struct camera_data *cam,
59 int reqwidth, int reqheight);
60 static int set_all_properties(struct camera_data *cam);
61 static void wake_system(struct camera_data *cam);
62 static void set_lowlight_boost(struct camera_data *cam);
63 static void reset_camera_struct(struct camera_data *cam);
64 static int cpia2_set_high_power(struct camera_data *cam);
65
66 /* Here we want the physical address of the memory.
67 * This is used when initializing the contents of the
68 * area and marking the pages as reserved.
69 */
70 static inline unsigned long kvirt_to_pa(unsigned long adr)
71 {
72 unsigned long kva, ret;
73
74 kva = (unsigned long) page_address(vmalloc_to_page((void *)adr));
75 kva |= adr & (PAGE_SIZE-1); /* restore the offset */
76 ret = __pa(kva);
77 return ret;
78 }
79
80 static void *rvmalloc(unsigned long size)
81 {
82 void *mem;
83 unsigned long adr;
84
85 /* Round it off to PAGE_SIZE */
86 size = PAGE_ALIGN(size);
87
88 mem = vmalloc_32(size);
89 if (!mem)
90 return NULL;
91
92 memset(mem, 0, size); /* Clear the ram out, no junk to the user */
93 adr = (unsigned long) mem;
94
95 while ((long)size > 0) {
96 SetPageReserved(vmalloc_to_page((void *)adr));
97 adr += PAGE_SIZE;
98 size -= PAGE_SIZE;
99 }
100 return mem;
101 }
102
103 static void rvfree(void *mem, unsigned long size)
104 {
105 unsigned long adr;
106
107 if (!mem)
108 return;
109
110 size = PAGE_ALIGN(size);
111
112 adr = (unsigned long) mem;
113 while ((long)size > 0) {
114 ClearPageReserved(vmalloc_to_page((void *)adr));
115 adr += PAGE_SIZE;
116 size -= PAGE_SIZE;
117 }
118 vfree(mem);
119 }
120
121 /******************************************************************************
122 *
123 * cpia2_do_command
124 *
125 * Send an arbitrary command to the camera. For commands that read from
126 * the camera, copy the buffers into the proper param structures.
127 *****************************************************************************/
128 int cpia2_do_command(struct camera_data *cam,
129 u32 command, u8 direction, u8 param)
130 {
131 int retval = 0;
132 struct cpia2_command cmd;
133 unsigned int device = cam->params.pnp_id.device_type;
134
135 cmd.command = command;
136 cmd.reg_count = 2; /* default */
137 cmd.direction = direction;
138
139 /***
140 * Set up the command.
141 ***/
142 switch (command) {
143 case CPIA2_CMD_GET_VERSION:
144 cmd.req_mode =
145 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
146 cmd.start = CPIA2_SYSTEM_DEVICE_HI;
147 break;
148 case CPIA2_CMD_GET_PNP_ID:
149 cmd.req_mode =
150 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
151 cmd.reg_count = 8;
152 cmd.start = CPIA2_SYSTEM_DESCRIP_VID_HI;
153 break;
154 case CPIA2_CMD_GET_ASIC_TYPE:
155 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
156 cmd.start = CPIA2_VC_ASIC_ID;
157 break;
158 case CPIA2_CMD_GET_SENSOR:
159 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
160 cmd.start = CPIA2_VP_SENSOR_FLAGS;
161 break;
162 case CPIA2_CMD_GET_VP_DEVICE:
163 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
164 cmd.start = CPIA2_VP_DEVICEH;
165 break;
166 case CPIA2_CMD_SET_VP_BRIGHTNESS:
167 cmd.buffer.block_data[0] = param;
168 /* fall through */
169 case CPIA2_CMD_GET_VP_BRIGHTNESS:
170 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
171 cmd.reg_count = 1;
172 if (device == DEVICE_STV_672)
173 cmd.start = CPIA2_VP4_EXPOSURE_TARGET;
174 else
175 cmd.start = CPIA2_VP5_EXPOSURE_TARGET;
176 break;
177 case CPIA2_CMD_SET_CONTRAST:
178 cmd.buffer.block_data[0] = param;
179 /* fall through */
180 case CPIA2_CMD_GET_CONTRAST:
181 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
182 cmd.reg_count = 1;
183 cmd.start = CPIA2_VP_YRANGE;
184 break;
185 case CPIA2_CMD_SET_VP_SATURATION:
186 cmd.buffer.block_data[0] = param;
187 /* fall through */
188 case CPIA2_CMD_GET_VP_SATURATION:
189 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
190 cmd.reg_count = 1;
191 if (device == DEVICE_STV_672)
192 cmd.start = CPIA2_VP_SATURATION;
193 else
194 cmd.start = CPIA2_VP5_MCUVSATURATION;
195 break;
196 case CPIA2_CMD_SET_VP_GPIO_DATA:
197 cmd.buffer.block_data[0] = param;
198 /* fall through */
199 case CPIA2_CMD_GET_VP_GPIO_DATA:
200 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
201 cmd.reg_count = 1;
202 cmd.start = CPIA2_VP_GPIO_DATA;
203 break;
204 case CPIA2_CMD_SET_VP_GPIO_DIRECTION:
205 cmd.buffer.block_data[0] = param;
206 /* fall through */
207 case CPIA2_CMD_GET_VP_GPIO_DIRECTION:
208 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
209 cmd.reg_count = 1;
210 cmd.start = CPIA2_VP_GPIO_DIRECTION;
211 break;
212 case CPIA2_CMD_SET_VC_MP_GPIO_DATA:
213 cmd.buffer.block_data[0] = param;
214 /* fall through */
215 case CPIA2_CMD_GET_VC_MP_GPIO_DATA:
216 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
217 cmd.reg_count = 1;
218 cmd.start = CPIA2_VC_MP_DATA;
219 break;
220 case CPIA2_CMD_SET_VC_MP_GPIO_DIRECTION:
221 cmd.buffer.block_data[0] = param;
222 /*fall through */
223 case CPIA2_CMD_GET_VC_MP_GPIO_DIRECTION:
224 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
225 cmd.reg_count = 1;
226 cmd.start = CPIA2_VC_MP_DIR;
227 break;
228 case CPIA2_CMD_ENABLE_PACKET_CTRL:
229 cmd.req_mode =
230 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
231 cmd.start = CPIA2_SYSTEM_INT_PACKET_CTRL;
232 cmd.reg_count = 1;
233 cmd.buffer.block_data[0] = param;
234 break;
235 case CPIA2_CMD_SET_FLICKER_MODES:
236 cmd.buffer.block_data[0] = param;
237 /* fall through */
238 case CPIA2_CMD_GET_FLICKER_MODES:
239 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
240 cmd.reg_count = 1;
241 cmd.start = CPIA2_VP_FLICKER_MODES;
242 break;
243 case CPIA2_CMD_RESET_FIFO: /* clear fifo and enable stream block */
244 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VC;
245 cmd.reg_count = 2;
246 cmd.start = 0;
247 cmd.buffer.registers[0].index = CPIA2_VC_ST_CTRL;
248 cmd.buffer.registers[0].value = CPIA2_VC_ST_CTRL_SRC_VC |
249 CPIA2_VC_ST_CTRL_DST_USB | CPIA2_VC_ST_CTRL_EOF_DETECT;
250 cmd.buffer.registers[1].index = CPIA2_VC_ST_CTRL;
251 cmd.buffer.registers[1].value = CPIA2_VC_ST_CTRL_SRC_VC |
252 CPIA2_VC_ST_CTRL_DST_USB |
253 CPIA2_VC_ST_CTRL_EOF_DETECT |
254 CPIA2_VC_ST_CTRL_FIFO_ENABLE;
255 break;
256 case CPIA2_CMD_SET_HI_POWER:
257 cmd.req_mode =
258 CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_SYSTEM;
259 cmd.reg_count = 2;
260 cmd.buffer.registers[0].index =
261 CPIA2_SYSTEM_SYSTEM_CONTROL;
262 cmd.buffer.registers[1].index =
263 CPIA2_SYSTEM_SYSTEM_CONTROL;
264 cmd.buffer.registers[0].value = CPIA2_SYSTEM_CONTROL_CLEAR_ERR;
265 cmd.buffer.registers[1].value =
266 CPIA2_SYSTEM_CONTROL_HIGH_POWER;
267 break;
268 case CPIA2_CMD_SET_LOW_POWER:
269 cmd.req_mode =
270 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
271 cmd.reg_count = 1;
272 cmd.start = CPIA2_SYSTEM_SYSTEM_CONTROL;
273 cmd.buffer.block_data[0] = 0;
274 break;
275 case CPIA2_CMD_CLEAR_V2W_ERR:
276 cmd.req_mode =
277 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
278 cmd.reg_count = 1;
279 cmd.start = CPIA2_SYSTEM_SYSTEM_CONTROL;
280 cmd.buffer.block_data[0] = CPIA2_SYSTEM_CONTROL_CLEAR_ERR;
281 break;
282 case CPIA2_CMD_SET_USER_MODE:
283 cmd.buffer.block_data[0] = param;
284 /* fall through */
285 case CPIA2_CMD_GET_USER_MODE:
286 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
287 cmd.reg_count = 1;
288 if (device == DEVICE_STV_672)
289 cmd.start = CPIA2_VP4_USER_MODE;
290 else
291 cmd.start = CPIA2_VP5_USER_MODE;
292 break;
293 case CPIA2_CMD_FRAMERATE_REQ:
294 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
295 cmd.reg_count = 1;
296 if (device == DEVICE_STV_672)
297 cmd.start = CPIA2_VP4_FRAMERATE_REQUEST;
298 else
299 cmd.start = CPIA2_VP5_FRAMERATE_REQUEST;
300 cmd.buffer.block_data[0] = param;
301 break;
302 case CPIA2_CMD_SET_WAKEUP:
303 cmd.buffer.block_data[0] = param;
304 /* fall through */
305 case CPIA2_CMD_GET_WAKEUP:
306 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
307 cmd.reg_count = 1;
308 cmd.start = CPIA2_VC_WAKEUP;
309 break;
310 case CPIA2_CMD_SET_PW_CONTROL:
311 cmd.buffer.block_data[0] = param;
312 /* fall through */
313 case CPIA2_CMD_GET_PW_CONTROL:
314 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
315 cmd.reg_count = 1;
316 cmd.start = CPIA2_VC_PW_CTRL;
317 break;
318 case CPIA2_CMD_GET_VP_SYSTEM_STATE:
319 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
320 cmd.reg_count = 1;
321 cmd.start = CPIA2_VP_SYSTEMSTATE;
322 break;
323 case CPIA2_CMD_SET_SYSTEM_CTRL:
324 cmd.buffer.block_data[0] = param;
325 /* fall through */
326 case CPIA2_CMD_GET_SYSTEM_CTRL:
327 cmd.req_mode =
328 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
329 cmd.reg_count = 1;
330 cmd.start = CPIA2_SYSTEM_SYSTEM_CONTROL;
331 break;
332 case CPIA2_CMD_SET_VP_SYSTEM_CTRL:
333 cmd.buffer.block_data[0] = param;
334 /* fall through */
335 case CPIA2_CMD_GET_VP_SYSTEM_CTRL:
336 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
337 cmd.reg_count = 1;
338 cmd.start = CPIA2_VP_SYSTEMCTRL;
339 break;
340 case CPIA2_CMD_SET_VP_EXP_MODES:
341 cmd.buffer.block_data[0] = param;
342 /* fall through */
343 case CPIA2_CMD_GET_VP_EXP_MODES:
344 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
345 cmd.reg_count = 1;
346 cmd.start = CPIA2_VP_EXPOSURE_MODES;
347 break;
348 case CPIA2_CMD_SET_DEVICE_CONFIG:
349 cmd.buffer.block_data[0] = param;
350 /* fall through */
351 case CPIA2_CMD_GET_DEVICE_CONFIG:
352 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
353 cmd.reg_count = 1;
354 cmd.start = CPIA2_VP_DEVICE_CONFIG;
355 break;
356 case CPIA2_CMD_SET_SERIAL_ADDR:
357 cmd.buffer.block_data[0] = param;
358 cmd.req_mode =
359 CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
360 cmd.reg_count = 1;
361 cmd.start = CPIA2_SYSTEM_VP_SERIAL_ADDR;
362 break;
363 case CPIA2_CMD_SET_SENSOR_CR1:
364 cmd.buffer.block_data[0] = param;
365 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
366 cmd.reg_count = 1;
367 cmd.start = CPIA2_SENSOR_CR1;
368 break;
369 case CPIA2_CMD_SET_VC_CONTROL:
370 cmd.buffer.block_data[0] = param;
371 /* fall through */
372 case CPIA2_CMD_GET_VC_CONTROL:
373 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
374 cmd.reg_count = 1;
375 cmd.start = CPIA2_VC_VC_CTRL;
376 break;
377 case CPIA2_CMD_SET_TARGET_KB:
378 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VC;
379 cmd.reg_count = 1;
380 cmd.buffer.registers[0].index = CPIA2_VC_VC_TARGET_KB;
381 cmd.buffer.registers[0].value = param;
382 break;
383 case CPIA2_CMD_SET_DEF_JPEG_OPT:
384 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VC;
385 cmd.reg_count = 4;
386 cmd.buffer.registers[0].index = CPIA2_VC_VC_JPEG_OPT;
387 cmd.buffer.registers[0].value =
388 CPIA2_VC_VC_JPEG_OPT_DOUBLE_SQUEEZE;
389 cmd.buffer.registers[1].index = CPIA2_VC_VC_USER_SQUEEZE;
390 cmd.buffer.registers[1].value = 20;
391 cmd.buffer.registers[2].index = CPIA2_VC_VC_CREEP_PERIOD;
392 cmd.buffer.registers[2].value = 2;
393 cmd.buffer.registers[3].index = CPIA2_VC_VC_JPEG_OPT;
394 cmd.buffer.registers[3].value = CPIA2_VC_VC_JPEG_OPT_DEFAULT;
395 break;
396 case CPIA2_CMD_REHASH_VP4:
397 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
398 cmd.reg_count = 1;
399 cmd.start = CPIA2_VP_REHASH_VALUES;
400 cmd.buffer.block_data[0] = param;
401 break;
402 case CPIA2_CMD_SET_USER_EFFECTS: /* Note: Be careful with this as
403 this register can also affect
404 flicker modes */
405 cmd.buffer.block_data[0] = param;
406 /* fall through */
407 case CPIA2_CMD_GET_USER_EFFECTS:
408 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
409 cmd.reg_count = 1;
410 if (device == DEVICE_STV_672)
411 cmd.start = CPIA2_VP4_USER_EFFECTS;
412 else
413 cmd.start = CPIA2_VP5_USER_EFFECTS;
414 break;
415 default:
416 LOG("DoCommand received invalid command\n");
417 return -EINVAL;
418 }
419
420 retval = cpia2_send_command(cam, &cmd);
421 if (retval) {
422 return retval;
423 }
424
425 /***
426 * Now copy any results from a read into the appropriate param struct.
427 ***/
428 switch (command) {
429 case CPIA2_CMD_GET_VERSION:
430 cam->params.version.firmware_revision_hi =
431 cmd.buffer.block_data[0];
432 cam->params.version.firmware_revision_lo =
433 cmd.buffer.block_data[1];
434 break;
435 case CPIA2_CMD_GET_PNP_ID:
436 cam->params.pnp_id.vendor = (cmd.buffer.block_data[0] << 8) |
437 cmd.buffer.block_data[1];
438 cam->params.pnp_id.product = (cmd.buffer.block_data[2] << 8) |
439 cmd.buffer.block_data[3];
440 cam->params.pnp_id.device_revision =
441 (cmd.buffer.block_data[4] << 8) |
442 cmd.buffer.block_data[5];
443 if (cam->params.pnp_id.vendor == 0x553) {
444 if (cam->params.pnp_id.product == 0x100) {
445 cam->params.pnp_id.device_type = DEVICE_STV_672;
446 } else if (cam->params.pnp_id.product == 0x140 ||
447 cam->params.pnp_id.product == 0x151) {
448 cam->params.pnp_id.device_type = DEVICE_STV_676;
449 }
450 }
451 break;
452 case CPIA2_CMD_GET_ASIC_TYPE:
453 cam->params.version.asic_id = cmd.buffer.block_data[0];
454 cam->params.version.asic_rev = cmd.buffer.block_data[1];
455 break;
456 case CPIA2_CMD_GET_SENSOR:
457 cam->params.version.sensor_flags = cmd.buffer.block_data[0];
458 cam->params.version.sensor_rev = cmd.buffer.block_data[1];
459 break;
460 case CPIA2_CMD_GET_VP_DEVICE:
461 cam->params.version.vp_device_hi = cmd.buffer.block_data[0];
462 cam->params.version.vp_device_lo = cmd.buffer.block_data[1];
463 break;
464 case CPIA2_CMD_GET_VP_GPIO_DATA:
465 cam->params.vp_params.gpio_data = cmd.buffer.block_data[0];
466 break;
467 case CPIA2_CMD_GET_VP_GPIO_DIRECTION:
468 cam->params.vp_params.gpio_direction = cmd.buffer.block_data[0];
469 break;
470 case CPIA2_CMD_GET_VC_MP_GPIO_DIRECTION:
471 cam->params.vc_params.vc_mp_direction =cmd.buffer.block_data[0];
472 break;
473 case CPIA2_CMD_GET_VC_MP_GPIO_DATA:
474 cam->params.vc_params.vc_mp_data = cmd.buffer.block_data[0];
475 break;
476 case CPIA2_CMD_GET_FLICKER_MODES:
477 cam->params.flicker_control.cam_register =
478 cmd.buffer.block_data[0];
479 break;
480 case CPIA2_CMD_GET_WAKEUP:
481 cam->params.vc_params.wakeup = cmd.buffer.block_data[0];
482 break;
483 case CPIA2_CMD_GET_PW_CONTROL:
484 cam->params.vc_params.pw_control = cmd.buffer.block_data[0];
485 break;
486 case CPIA2_CMD_GET_SYSTEM_CTRL:
487 cam->params.camera_state.system_ctrl = cmd.buffer.block_data[0];
488 break;
489 case CPIA2_CMD_GET_VP_SYSTEM_STATE:
490 cam->params.vp_params.system_state = cmd.buffer.block_data[0];
491 break;
492 case CPIA2_CMD_GET_VP_SYSTEM_CTRL:
493 cam->params.vp_params.system_ctrl = cmd.buffer.block_data[0];
494 break;
495 case CPIA2_CMD_GET_VP_EXP_MODES:
496 cam->params.vp_params.exposure_modes = cmd.buffer.block_data[0];
497 break;
498 case CPIA2_CMD_GET_DEVICE_CONFIG:
499 cam->params.vp_params.device_config = cmd.buffer.block_data[0];
500 break;
501 case CPIA2_CMD_GET_VC_CONTROL:
502 cam->params.vc_params.vc_control = cmd.buffer.block_data[0];
503 break;
504 case CPIA2_CMD_GET_USER_MODE:
505 cam->params.vp_params.video_mode = cmd.buffer.block_data[0];
506 break;
507 case CPIA2_CMD_GET_USER_EFFECTS:
508 cam->params.vp_params.user_effects = cmd.buffer.block_data[0];
509 break;
510 default:
511 break;
512 }
513 return retval;
514 }
515
516 /******************************************************************************
517 *
518 * cpia2_send_command
519 *
520 *****************************************************************************/
521
522 #define DIR(cmd) ((cmd->direction == TRANSFER_WRITE) ? "Write" : "Read")
523 #define BINDEX(cmd) (cmd->req_mode & 0x03)
524
525 int cpia2_send_command(struct camera_data *cam, struct cpia2_command *cmd)
526 {
527 u8 count;
528 u8 start;
529 u8 *buffer;
530 int retval;
531
532 switch (cmd->req_mode & 0x0c) {
533 case CAMERAACCESS_TYPE_RANDOM:
534 count = cmd->reg_count * sizeof(struct cpia2_register);
535 start = 0;
536 buffer = (u8 *) & cmd->buffer;
537 if (debugs_on & DEBUG_REG)
538 DBG("%s Random: Register block %s\n", DIR(cmd),
539 block_name[BINDEX(cmd)]);
540 break;
541 case CAMERAACCESS_TYPE_BLOCK:
542 count = cmd->reg_count;
543 start = cmd->start;
544 buffer = cmd->buffer.block_data;
545 if (debugs_on & DEBUG_REG)
546 DBG("%s Block: Register block %s\n", DIR(cmd),
547 block_name[BINDEX(cmd)]);
548 break;
549 case CAMERAACCESS_TYPE_MASK:
550 count = cmd->reg_count * sizeof(struct cpia2_reg_mask);
551 start = 0;
552 buffer = (u8 *) & cmd->buffer;
553 if (debugs_on & DEBUG_REG)
554 DBG("%s Mask: Register block %s\n", DIR(cmd),
555 block_name[BINDEX(cmd)]);
556 break;
557 case CAMERAACCESS_TYPE_REPEAT: /* For patch blocks only */
558 count = cmd->reg_count;
559 start = cmd->start;
560 buffer = cmd->buffer.block_data;
561 if (debugs_on & DEBUG_REG)
562 DBG("%s Repeat: Register block %s\n", DIR(cmd),
563 block_name[BINDEX(cmd)]);
564 break;
565 default:
566 LOG("%s: invalid request mode\n",__func__);
567 return -EINVAL;
568 }
569
570 retval = cpia2_usb_transfer_cmd(cam,
571 buffer,
572 cmd->req_mode,
573 start, count, cmd->direction);
574 #ifdef _CPIA2_DEBUG_
575 if (debugs_on & DEBUG_REG) {
576 int i;
577 for (i = 0; i < cmd->reg_count; i++) {
578 if((cmd->req_mode & 0x0c) == CAMERAACCESS_TYPE_BLOCK)
579 KINFO("%s Block: [0x%02X] = 0x%02X\n",
580 DIR(cmd), start + i, buffer[i]);
581 if((cmd->req_mode & 0x0c) == CAMERAACCESS_TYPE_RANDOM)
582 KINFO("%s Random: [0x%02X] = 0x%02X\n",
583 DIR(cmd), cmd->buffer.registers[i].index,
584 cmd->buffer.registers[i].value);
585 }
586 }
587 #endif
588
589 return retval;
590 };
591
592 /*************
593 * Functions to implement camera functionality
594 *************/
595 /******************************************************************************
596 *
597 * cpia2_get_version_info
598 *
599 *****************************************************************************/
600 static void cpia2_get_version_info(struct camera_data *cam)
601 {
602 cpia2_do_command(cam, CPIA2_CMD_GET_VERSION, TRANSFER_READ, 0);
603 cpia2_do_command(cam, CPIA2_CMD_GET_PNP_ID, TRANSFER_READ, 0);
604 cpia2_do_command(cam, CPIA2_CMD_GET_ASIC_TYPE, TRANSFER_READ, 0);
605 cpia2_do_command(cam, CPIA2_CMD_GET_SENSOR, TRANSFER_READ, 0);
606 cpia2_do_command(cam, CPIA2_CMD_GET_VP_DEVICE, TRANSFER_READ, 0);
607 }
608
609 /******************************************************************************
610 *
611 * cpia2_reset_camera
612 *
613 * Called at least during the open process, sets up initial params.
614 *****************************************************************************/
615 int cpia2_reset_camera(struct camera_data *cam)
616 {
617 u8 tmp_reg;
618 int retval = 0;
619 int target_kb;
620 int i;
621 struct cpia2_command cmd;
622
623 /***
624 * VC setup
625 ***/
626 retval = configure_sensor(cam,
627 cam->params.roi.width,
628 cam->params.roi.height);
629 if (retval < 0) {
630 ERR("Couldn't configure sensor, error=%d\n", retval);
631 return retval;
632 }
633
634 /* Clear FIFO and route/enable stream block */
635 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VC;
636 cmd.direction = TRANSFER_WRITE;
637 cmd.reg_count = 2;
638 cmd.buffer.registers[0].index = CPIA2_VC_ST_CTRL;
639 cmd.buffer.registers[0].value = CPIA2_VC_ST_CTRL_SRC_VC |
640 CPIA2_VC_ST_CTRL_DST_USB | CPIA2_VC_ST_CTRL_EOF_DETECT;
641 cmd.buffer.registers[1].index = CPIA2_VC_ST_CTRL;
642 cmd.buffer.registers[1].value = CPIA2_VC_ST_CTRL_SRC_VC |
643 CPIA2_VC_ST_CTRL_DST_USB |
644 CPIA2_VC_ST_CTRL_EOF_DETECT | CPIA2_VC_ST_CTRL_FIFO_ENABLE;
645
646 cpia2_send_command(cam, &cmd);
647
648 cpia2_set_high_power(cam);
649
650 if (cam->params.pnp_id.device_type == DEVICE_STV_672) {
651 /* Enable button notification */
652 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_SYSTEM;
653 cmd.buffer.registers[0].index = CPIA2_SYSTEM_INT_PACKET_CTRL;
654 cmd.buffer.registers[0].value =
655 CPIA2_SYSTEM_INT_PACKET_CTRL_ENABLE_SW_XX;
656 cmd.reg_count = 1;
657 cpia2_send_command(cam, &cmd);
658 }
659
660 schedule_timeout_interruptible(msecs_to_jiffies(100));
661
662 if (cam->params.pnp_id.device_type == DEVICE_STV_672)
663 retval = apply_vp_patch(cam);
664
665 /* wait for vp to go to sleep */
666 schedule_timeout_interruptible(msecs_to_jiffies(100));
667
668 /***
669 * If this is a 676, apply VP5 fixes before we start streaming
670 ***/
671 if (cam->params.pnp_id.device_type == DEVICE_STV_676) {
672 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VP;
673
674 /* The following writes improve the picture */
675 cmd.buffer.registers[0].index = CPIA2_VP5_MYBLACK_LEVEL;
676 cmd.buffer.registers[0].value = 0; /* reduce from the default
677 * rec 601 pedestal of 16 */
678 cmd.buffer.registers[1].index = CPIA2_VP5_MCYRANGE;
679 cmd.buffer.registers[1].value = 0x92; /* increase from 100% to
680 * (256/256 - 31) to fill
681 * available range */
682 cmd.buffer.registers[2].index = CPIA2_VP5_MYCEILING;
683 cmd.buffer.registers[2].value = 0xFF; /* Increase from the
684 * default rec 601 ceiling
685 * of 240 */
686 cmd.buffer.registers[3].index = CPIA2_VP5_MCUVSATURATION;
687 cmd.buffer.registers[3].value = 0xFF; /* Increase from the rec
688 * 601 100% level (128)
689 * to 145-192 */
690 cmd.buffer.registers[4].index = CPIA2_VP5_ANTIFLKRSETUP;
691 cmd.buffer.registers[4].value = 0x80; /* Inhibit the
692 * anti-flicker */
693
694 /* The following 4 writes are a fix to allow QVGA to work at 30 fps */
695 cmd.buffer.registers[5].index = CPIA2_VP_RAM_ADDR_H;
696 cmd.buffer.registers[5].value = 0x01;
697 cmd.buffer.registers[6].index = CPIA2_VP_RAM_ADDR_L;
698 cmd.buffer.registers[6].value = 0xE3;
699 cmd.buffer.registers[7].index = CPIA2_VP_RAM_DATA;
700 cmd.buffer.registers[7].value = 0x02;
701 cmd.buffer.registers[8].index = CPIA2_VP_RAM_DATA;
702 cmd.buffer.registers[8].value = 0xFC;
703
704 cmd.direction = TRANSFER_WRITE;
705 cmd.reg_count = 9;
706
707 cpia2_send_command(cam, &cmd);
708 }
709
710 /* Activate all settings and start the data stream */
711 /* Set user mode */
712 set_default_user_mode(cam);
713
714 /* Give VP time to wake up */
715 schedule_timeout_interruptible(msecs_to_jiffies(100));
716
717 set_all_properties(cam);
718
719 cpia2_do_command(cam, CPIA2_CMD_GET_USER_MODE, TRANSFER_READ, 0);
720 DBG("After SetAllProperties(cam), user mode is 0x%0X\n",
721 cam->params.vp_params.video_mode);
722
723 /***
724 * Set audio regulator off. This and the code to set the compresison
725 * state are too complex to form a CPIA2_CMD_, and seem to be somewhat
726 * intertwined. This stuff came straight from the windows driver.
727 ***/
728 /* Turn AutoExposure off in VP and enable the serial bridge to the sensor */
729 cpia2_do_command(cam, CPIA2_CMD_GET_VP_SYSTEM_CTRL, TRANSFER_READ, 0);
730 tmp_reg = cam->params.vp_params.system_ctrl;
731 cmd.buffer.registers[0].value = tmp_reg &
732 (tmp_reg & (CPIA2_VP_SYSTEMCTRL_HK_CONTROL ^ 0xFF));
733
734 cpia2_do_command(cam, CPIA2_CMD_GET_DEVICE_CONFIG, TRANSFER_READ, 0);
735 cmd.buffer.registers[1].value = cam->params.vp_params.device_config |
736 CPIA2_VP_DEVICE_CONFIG_SERIAL_BRIDGE;
737 cmd.buffer.registers[0].index = CPIA2_VP_SYSTEMCTRL;
738 cmd.buffer.registers[1].index = CPIA2_VP_DEVICE_CONFIG;
739 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VP;
740 cmd.reg_count = 2;
741 cmd.direction = TRANSFER_WRITE;
742 cmd.start = 0;
743 cpia2_send_command(cam, &cmd);
744
745 /* Set the correct I2C address in the CPiA-2 system register */
746 cpia2_do_command(cam,
747 CPIA2_CMD_SET_SERIAL_ADDR,
748 TRANSFER_WRITE,
749 CPIA2_SYSTEM_VP_SERIAL_ADDR_SENSOR);
750
751 /* Now have sensor access - set bit to turn the audio regulator off */
752 cpia2_do_command(cam,
753 CPIA2_CMD_SET_SENSOR_CR1,
754 TRANSFER_WRITE, CPIA2_SENSOR_CR1_DOWN_AUDIO_REGULATOR);
755
756 /* Set the correct I2C address in the CPiA-2 system register */
757 if (cam->params.pnp_id.device_type == DEVICE_STV_672)
758 cpia2_do_command(cam,
759 CPIA2_CMD_SET_SERIAL_ADDR,
760 TRANSFER_WRITE,
761 CPIA2_SYSTEM_VP_SERIAL_ADDR_VP); // 0x88
762 else
763 cpia2_do_command(cam,
764 CPIA2_CMD_SET_SERIAL_ADDR,
765 TRANSFER_WRITE,
766 CPIA2_SYSTEM_VP_SERIAL_ADDR_676_VP); // 0x8a
767
768 /* increase signal drive strength */
769 if (cam->params.pnp_id.device_type == DEVICE_STV_676)
770 cpia2_do_command(cam,
771 CPIA2_CMD_SET_VP_EXP_MODES,
772 TRANSFER_WRITE,
773 CPIA2_VP_EXPOSURE_MODES_COMPILE_EXP);
774
775 /* Start autoexposure */
776 cpia2_do_command(cam, CPIA2_CMD_GET_DEVICE_CONFIG, TRANSFER_READ, 0);
777 cmd.buffer.registers[0].value = cam->params.vp_params.device_config &
778 (CPIA2_VP_DEVICE_CONFIG_SERIAL_BRIDGE ^ 0xFF);
779
780 cpia2_do_command(cam, CPIA2_CMD_GET_VP_SYSTEM_CTRL, TRANSFER_READ, 0);
781 cmd.buffer.registers[1].value =
782 cam->params.vp_params.system_ctrl | CPIA2_VP_SYSTEMCTRL_HK_CONTROL;
783
784 cmd.buffer.registers[0].index = CPIA2_VP_DEVICE_CONFIG;
785 cmd.buffer.registers[1].index = CPIA2_VP_SYSTEMCTRL;
786 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VP;
787 cmd.reg_count = 2;
788 cmd.direction = TRANSFER_WRITE;
789
790 cpia2_send_command(cam, &cmd);
791
792 /* Set compression state */
793 cpia2_do_command(cam, CPIA2_CMD_GET_VC_CONTROL, TRANSFER_READ, 0);
794 if (cam->params.compression.inhibit_htables) {
795 tmp_reg = cam->params.vc_params.vc_control |
796 CPIA2_VC_VC_CTRL_INHIBIT_H_TABLES;
797 } else {
798 tmp_reg = cam->params.vc_params.vc_control &
799 ~CPIA2_VC_VC_CTRL_INHIBIT_H_TABLES;
800 }
801 cpia2_do_command(cam, CPIA2_CMD_SET_VC_CONTROL, TRANSFER_WRITE,tmp_reg);
802
803 /* Set target size (kb) on vc
804 This is a heuristic based on the quality parameter and the raw
805 framesize in kB divided by 16 (the compression factor when the
806 quality is 100%) */
807 target_kb = (cam->width * cam->height * 2 / 16384) *
808 cam->params.vc_params.quality / 100;
809 if (target_kb < 1)
810 target_kb = 1;
811 cpia2_do_command(cam, CPIA2_CMD_SET_TARGET_KB,
812 TRANSFER_WRITE, target_kb);
813
814 /* Wiggle VC Reset */
815 /***
816 * First read and wait a bit.
817 ***/
818 for (i = 0; i < 50; i++) {
819 cpia2_do_command(cam, CPIA2_CMD_GET_PW_CONTROL,
820 TRANSFER_READ, 0);
821 }
822
823 tmp_reg = cam->params.vc_params.pw_control;
824 tmp_reg &= ~CPIA2_VC_PW_CTRL_VC_RESET_N;
825
826 cpia2_do_command(cam, CPIA2_CMD_SET_PW_CONTROL, TRANSFER_WRITE,tmp_reg);
827
828 tmp_reg |= CPIA2_VC_PW_CTRL_VC_RESET_N;
829 cpia2_do_command(cam, CPIA2_CMD_SET_PW_CONTROL, TRANSFER_WRITE,tmp_reg);
830
831 cpia2_do_command(cam, CPIA2_CMD_SET_DEF_JPEG_OPT, TRANSFER_WRITE, 0);
832
833 cpia2_do_command(cam, CPIA2_CMD_GET_USER_MODE, TRANSFER_READ, 0);
834 DBG("After VC RESET, user mode is 0x%0X\n",
835 cam->params.vp_params.video_mode);
836
837 return retval;
838 }
839
840 /******************************************************************************
841 *
842 * cpia2_set_high_power
843 *
844 *****************************************************************************/
845 static int cpia2_set_high_power(struct camera_data *cam)
846 {
847 int i;
848 for (i = 0; i <= 50; i++) {
849 /* Read system status */
850 cpia2_do_command(cam,CPIA2_CMD_GET_SYSTEM_CTRL,TRANSFER_READ,0);
851
852 /* If there is an error, clear it */
853 if(cam->params.camera_state.system_ctrl &
854 CPIA2_SYSTEM_CONTROL_V2W_ERR)
855 cpia2_do_command(cam, CPIA2_CMD_CLEAR_V2W_ERR,
856 TRANSFER_WRITE, 0);
857
858 /* Try to set high power mode */
859 cpia2_do_command(cam, CPIA2_CMD_SET_SYSTEM_CTRL,
860 TRANSFER_WRITE, 1);
861
862 /* Try to read something in VP to check if everything is awake */
863 cpia2_do_command(cam, CPIA2_CMD_GET_VP_SYSTEM_STATE,
864 TRANSFER_READ, 0);
865 if (cam->params.vp_params.system_state &
866 CPIA2_VP_SYSTEMSTATE_HK_ALIVE) {
867 break;
868 } else if (i == 50) {
869 cam->params.camera_state.power_mode = LO_POWER_MODE;
870 ERR("Camera did not wake up\n");
871 return -EIO;
872 }
873 }
874
875 DBG("System now in high power state\n");
876 cam->params.camera_state.power_mode = HI_POWER_MODE;
877 return 0;
878 }
879
880 /******************************************************************************
881 *
882 * cpia2_set_low_power
883 *
884 *****************************************************************************/
885 int cpia2_set_low_power(struct camera_data *cam)
886 {
887 cam->params.camera_state.power_mode = LO_POWER_MODE;
888 cpia2_do_command(cam, CPIA2_CMD_SET_SYSTEM_CTRL, TRANSFER_WRITE, 0);
889 return 0;
890 }
891
892 /******************************************************************************
893 *
894 * apply_vp_patch
895 *
896 *****************************************************************************/
897 static int cpia2_send_onebyte_command(struct camera_data *cam,
898 struct cpia2_command *cmd,
899 u8 start, u8 datum)
900 {
901 cmd->buffer.block_data[0] = datum;
902 cmd->start = start;
903 cmd->reg_count = 1;
904 return cpia2_send_command(cam, cmd);
905 }
906
907 static int apply_vp_patch(struct camera_data *cam)
908 {
909 const struct firmware *fw;
910 const char fw_name[] = FIRMWARE;
911 int i, ret;
912 struct cpia2_command cmd;
913
914 ret = request_firmware(&fw, fw_name, &cam->dev->dev);
915 if (ret) {
916 printk(KERN_ERR "cpia2: failed to load VP patch \"%s\"\n",
917 fw_name);
918 return ret;
919 }
920
921 cmd.req_mode = CAMERAACCESS_TYPE_REPEAT | CAMERAACCESS_VP;
922 cmd.direction = TRANSFER_WRITE;
923
924 /* First send the start address... */
925 cpia2_send_onebyte_command(cam, &cmd, 0x0A, fw->data[0]); /* hi */
926 cpia2_send_onebyte_command(cam, &cmd, 0x0B, fw->data[1]); /* lo */
927
928 /* ... followed by the data payload */
929 for (i = 2; i < fw->size; i += 64) {
930 cmd.start = 0x0C; /* Data */
931 cmd.reg_count = min_t(uint, 64, fw->size - i);
932 memcpy(cmd.buffer.block_data, &fw->data[i], cmd.reg_count);
933 cpia2_send_command(cam, &cmd);
934 }
935
936 /* Next send the start address... */
937 cpia2_send_onebyte_command(cam, &cmd, 0x0A, fw->data[0]); /* hi */
938 cpia2_send_onebyte_command(cam, &cmd, 0x0B, fw->data[1]); /* lo */
939
940 /* ... followed by the 'goto' command */
941 cpia2_send_onebyte_command(cam, &cmd, 0x0D, 1);
942
943 release_firmware(fw);
944 return 0;
945 }
946
947 /******************************************************************************
948 *
949 * set_default_user_mode
950 *
951 *****************************************************************************/
952 static int set_default_user_mode(struct camera_data *cam)
953 {
954 unsigned char user_mode;
955 unsigned char frame_rate;
956 int width = cam->params.roi.width;
957 int height = cam->params.roi.height;
958
959 switch (cam->params.version.sensor_flags) {
960 case CPIA2_VP_SENSOR_FLAGS_404:
961 case CPIA2_VP_SENSOR_FLAGS_407:
962 case CPIA2_VP_SENSOR_FLAGS_409:
963 case CPIA2_VP_SENSOR_FLAGS_410:
964 if ((width > STV_IMAGE_QCIF_COLS)
965 || (height > STV_IMAGE_QCIF_ROWS)) {
966 user_mode = CPIA2_VP_USER_MODE_CIF;
967 } else {
968 user_mode = CPIA2_VP_USER_MODE_QCIFDS;
969 }
970 frame_rate = CPIA2_VP_FRAMERATE_30;
971 break;
972 case CPIA2_VP_SENSOR_FLAGS_500:
973 if ((width > STV_IMAGE_CIF_COLS)
974 || (height > STV_IMAGE_CIF_ROWS)) {
975 user_mode = CPIA2_VP_USER_MODE_VGA;
976 } else {
977 user_mode = CPIA2_VP_USER_MODE_QVGADS;
978 }
979 if (cam->params.pnp_id.device_type == DEVICE_STV_672)
980 frame_rate = CPIA2_VP_FRAMERATE_15;
981 else
982 frame_rate = CPIA2_VP_FRAMERATE_30;
983 break;
984 default:
985 LOG("%s: Invalid sensor flag value 0x%0X\n",__func__,
986 cam->params.version.sensor_flags);
987 return -EINVAL;
988 }
989
990 DBG("Sensor flag = 0x%0x, user mode = 0x%0x, frame rate = 0x%X\n",
991 cam->params.version.sensor_flags, user_mode, frame_rate);
992 cpia2_do_command(cam, CPIA2_CMD_SET_USER_MODE, TRANSFER_WRITE,
993 user_mode);
994 if(cam->params.vp_params.frame_rate > 0 &&
995 frame_rate > cam->params.vp_params.frame_rate)
996 frame_rate = cam->params.vp_params.frame_rate;
997
998 cpia2_set_fps(cam, frame_rate);
999
1000 // if (cam->params.pnp_id.device_type == DEVICE_STV_676)
1001 // cpia2_do_command(cam,
1002 // CPIA2_CMD_SET_VP_SYSTEM_CTRL,
1003 // TRANSFER_WRITE,
1004 // CPIA2_VP_SYSTEMCTRL_HK_CONTROL |
1005 // CPIA2_VP_SYSTEMCTRL_POWER_CONTROL);
1006
1007 return 0;
1008 }
1009
1010 /******************************************************************************
1011 *
1012 * cpia2_match_video_size
1013 *
1014 * return the best match, where 'best' is as always
1015 * the largest that is not bigger than what is requested.
1016 *****************************************************************************/
1017 int cpia2_match_video_size(int width, int height)
1018 {
1019 if (width >= STV_IMAGE_VGA_COLS && height >= STV_IMAGE_VGA_ROWS)
1020 return VIDEOSIZE_VGA;
1021
1022 if (width >= STV_IMAGE_CIF_COLS && height >= STV_IMAGE_CIF_ROWS)
1023 return VIDEOSIZE_CIF;
1024
1025 if (width >= STV_IMAGE_QVGA_COLS && height >= STV_IMAGE_QVGA_ROWS)
1026 return VIDEOSIZE_QVGA;
1027
1028 if (width >= 288 && height >= 216)
1029 return VIDEOSIZE_288_216;
1030
1031 if (width >= 256 && height >= 192)
1032 return VIDEOSIZE_256_192;
1033
1034 if (width >= 224 && height >= 168)
1035 return VIDEOSIZE_224_168;
1036
1037 if (width >= 192 && height >= 144)
1038 return VIDEOSIZE_192_144;
1039
1040 if (width >= STV_IMAGE_QCIF_COLS && height >= STV_IMAGE_QCIF_ROWS)
1041 return VIDEOSIZE_QCIF;
1042
1043 return -1;
1044 }
1045
1046 /******************************************************************************
1047 *
1048 * SetVideoSize
1049 *
1050 *****************************************************************************/
1051 static int set_vw_size(struct camera_data *cam, int size)
1052 {
1053 int retval = 0;
1054
1055 cam->params.vp_params.video_size = size;
1056
1057 switch (size) {
1058 case VIDEOSIZE_VGA:
1059 DBG("Setting size to VGA\n");
1060 cam->params.roi.width = STV_IMAGE_VGA_COLS;
1061 cam->params.roi.height = STV_IMAGE_VGA_ROWS;
1062 cam->width = STV_IMAGE_VGA_COLS;
1063 cam->height = STV_IMAGE_VGA_ROWS;
1064 break;
1065 case VIDEOSIZE_CIF:
1066 DBG("Setting size to CIF\n");
1067 cam->params.roi.width = STV_IMAGE_CIF_COLS;
1068 cam->params.roi.height = STV_IMAGE_CIF_ROWS;
1069 cam->width = STV_IMAGE_CIF_COLS;
1070 cam->height = STV_IMAGE_CIF_ROWS;
1071 break;
1072 case VIDEOSIZE_QVGA:
1073 DBG("Setting size to QVGA\n");
1074 cam->params.roi.width = STV_IMAGE_QVGA_COLS;
1075 cam->params.roi.height = STV_IMAGE_QVGA_ROWS;
1076 cam->width = STV_IMAGE_QVGA_COLS;
1077 cam->height = STV_IMAGE_QVGA_ROWS;
1078 break;
1079 case VIDEOSIZE_288_216:
1080 cam->params.roi.width = 288;
1081 cam->params.roi.height = 216;
1082 cam->width = 288;
1083 cam->height = 216;
1084 break;
1085 case VIDEOSIZE_256_192:
1086 cam->width = 256;
1087 cam->height = 192;
1088 cam->params.roi.width = 256;
1089 cam->params.roi.height = 192;
1090 break;
1091 case VIDEOSIZE_224_168:
1092 cam->width = 224;
1093 cam->height = 168;
1094 cam->params.roi.width = 224;
1095 cam->params.roi.height = 168;
1096 break;
1097 case VIDEOSIZE_192_144:
1098 cam->width = 192;
1099 cam->height = 144;
1100 cam->params.roi.width = 192;
1101 cam->params.roi.height = 144;
1102 break;
1103 case VIDEOSIZE_QCIF:
1104 DBG("Setting size to QCIF\n");
1105 cam->params.roi.width = STV_IMAGE_QCIF_COLS;
1106 cam->params.roi.height = STV_IMAGE_QCIF_ROWS;
1107 cam->width = STV_IMAGE_QCIF_COLS;
1108 cam->height = STV_IMAGE_QCIF_ROWS;
1109 break;
1110 default:
1111 retval = -EINVAL;
1112 }
1113 return retval;
1114 }
1115
1116 /******************************************************************************
1117 *
1118 * configure_sensor
1119 *
1120 *****************************************************************************/
1121 static int configure_sensor(struct camera_data *cam,
1122 int req_width, int req_height)
1123 {
1124 int retval;
1125
1126 switch (cam->params.version.sensor_flags) {
1127 case CPIA2_VP_SENSOR_FLAGS_404:
1128 case CPIA2_VP_SENSOR_FLAGS_407:
1129 case CPIA2_VP_SENSOR_FLAGS_409:
1130 case CPIA2_VP_SENSOR_FLAGS_410:
1131 retval = config_sensor_410(cam, req_width, req_height);
1132 break;
1133 case CPIA2_VP_SENSOR_FLAGS_500:
1134 retval = config_sensor_500(cam, req_width, req_height);
1135 break;
1136 default:
1137 return -EINVAL;
1138 }
1139
1140 return retval;
1141 }
1142
1143 /******************************************************************************
1144 *
1145 * config_sensor_410
1146 *
1147 *****************************************************************************/
1148 static int config_sensor_410(struct camera_data *cam,
1149 int req_width, int req_height)
1150 {
1151 struct cpia2_command cmd;
1152 int i = 0;
1153 int image_size;
1154 int image_type;
1155 int width = req_width;
1156 int height = req_height;
1157
1158 /***
1159 * Make sure size doesn't exceed CIF.
1160 ***/
1161 if (width > STV_IMAGE_CIF_COLS)
1162 width = STV_IMAGE_CIF_COLS;
1163 if (height > STV_IMAGE_CIF_ROWS)
1164 height = STV_IMAGE_CIF_ROWS;
1165
1166 image_size = cpia2_match_video_size(width, height);
1167
1168 DBG("Config 410: width = %d, height = %d\n", width, height);
1169 DBG("Image size returned is %d\n", image_size);
1170 if (image_size >= 0) {
1171 set_vw_size(cam, image_size);
1172 width = cam->params.roi.width;
1173 height = cam->params.roi.height;
1174
1175 DBG("After set_vw_size(), width = %d, height = %d\n",
1176 width, height);
1177 if (width <= 176 && height <= 144) {
1178 DBG("image type = VIDEOSIZE_QCIF\n");
1179 image_type = VIDEOSIZE_QCIF;
1180 }
1181 else if (width <= 320 && height <= 240) {
1182 DBG("image type = VIDEOSIZE_QVGA\n");
1183 image_type = VIDEOSIZE_QVGA;
1184 }
1185 else {
1186 DBG("image type = VIDEOSIZE_CIF\n");
1187 image_type = VIDEOSIZE_CIF;
1188 }
1189 } else {
1190 ERR("ConfigSensor410 failed\n");
1191 return -EINVAL;
1192 }
1193
1194 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VC;
1195 cmd.direction = TRANSFER_WRITE;
1196
1197 /* VC Format */
1198 cmd.buffer.registers[i].index = CPIA2_VC_VC_FORMAT;
1199 if (image_type == VIDEOSIZE_CIF) {
1200 cmd.buffer.registers[i++].value =
1201 (u8) (CPIA2_VC_VC_FORMAT_UFIRST |
1202 CPIA2_VC_VC_FORMAT_SHORTLINE);
1203 } else {
1204 cmd.buffer.registers[i++].value =
1205 (u8) CPIA2_VC_VC_FORMAT_UFIRST;
1206 }
1207
1208 /* VC Clocks */
1209 cmd.buffer.registers[i].index = CPIA2_VC_VC_CLOCKS;
1210 if (image_type == VIDEOSIZE_QCIF) {
1211 if (cam->params.pnp_id.device_type == DEVICE_STV_672) {
1212 cmd.buffer.registers[i++].value=
1213 (u8)(CPIA2_VC_VC_672_CLOCKS_CIF_DIV_BY_3 |
1214 CPIA2_VC_VC_672_CLOCKS_SCALING |
1215 CPIA2_VC_VC_CLOCKS_LOGDIV2);
1216 DBG("VC_Clocks (0xc4) should be B\n");
1217 }
1218 else {
1219 cmd.buffer.registers[i++].value=
1220 (u8)(CPIA2_VC_VC_676_CLOCKS_CIF_DIV_BY_3 |
1221 CPIA2_VC_VC_CLOCKS_LOGDIV2);
1222 }
1223 } else {
1224 if (cam->params.pnp_id.device_type == DEVICE_STV_672) {
1225 cmd.buffer.registers[i++].value =
1226 (u8) (CPIA2_VC_VC_672_CLOCKS_CIF_DIV_BY_3 |
1227 CPIA2_VC_VC_CLOCKS_LOGDIV0);
1228 }
1229 else {
1230 cmd.buffer.registers[i++].value =
1231 (u8) (CPIA2_VC_VC_676_CLOCKS_CIF_DIV_BY_3 |
1232 CPIA2_VC_VC_676_CLOCKS_SCALING |
1233 CPIA2_VC_VC_CLOCKS_LOGDIV0);
1234 }
1235 }
1236 DBG("VC_Clocks (0xc4) = 0x%0X\n", cmd.buffer.registers[i-1].value);
1237
1238 /* Input reqWidth from VC */
1239 cmd.buffer.registers[i].index = CPIA2_VC_VC_IHSIZE_LO;
1240 if (image_type == VIDEOSIZE_QCIF)
1241 cmd.buffer.registers[i++].value =
1242 (u8) (STV_IMAGE_QCIF_COLS / 4);
1243 else
1244 cmd.buffer.registers[i++].value =
1245 (u8) (STV_IMAGE_CIF_COLS / 4);
1246
1247 /* Timings */
1248 cmd.buffer.registers[i].index = CPIA2_VC_VC_XLIM_HI;
1249 if (image_type == VIDEOSIZE_QCIF)
1250 cmd.buffer.registers[i++].value = (u8) 0;
1251 else
1252 cmd.buffer.registers[i++].value = (u8) 1;
1253
1254 cmd.buffer.registers[i].index = CPIA2_VC_VC_XLIM_LO;
1255 if (image_type == VIDEOSIZE_QCIF)
1256 cmd.buffer.registers[i++].value = (u8) 208;
1257 else
1258 cmd.buffer.registers[i++].value = (u8) 160;
1259
1260 cmd.buffer.registers[i].index = CPIA2_VC_VC_YLIM_HI;
1261 if (image_type == VIDEOSIZE_QCIF)
1262 cmd.buffer.registers[i++].value = (u8) 0;
1263 else
1264 cmd.buffer.registers[i++].value = (u8) 1;
1265
1266 cmd.buffer.registers[i].index = CPIA2_VC_VC_YLIM_LO;
1267 if (image_type == VIDEOSIZE_QCIF)
1268 cmd.buffer.registers[i++].value = (u8) 160;
1269 else
1270 cmd.buffer.registers[i++].value = (u8) 64;
1271
1272 /* Output Image Size */
1273 cmd.buffer.registers[i].index = CPIA2_VC_VC_OHSIZE;
1274 cmd.buffer.registers[i++].value = cam->params.roi.width / 4;
1275
1276 cmd.buffer.registers[i].index = CPIA2_VC_VC_OVSIZE;
1277 cmd.buffer.registers[i++].value = cam->params.roi.height / 4;
1278
1279 /* Cropping */
1280 cmd.buffer.registers[i].index = CPIA2_VC_VC_HCROP;
1281 if (image_type == VIDEOSIZE_QCIF)
1282 cmd.buffer.registers[i++].value =
1283 (u8) (((STV_IMAGE_QCIF_COLS / 4) - (width / 4)) / 2);
1284 else
1285 cmd.buffer.registers[i++].value =
1286 (u8) (((STV_IMAGE_CIF_COLS / 4) - (width / 4)) / 2);
1287
1288 cmd.buffer.registers[i].index = CPIA2_VC_VC_VCROP;
1289 if (image_type == VIDEOSIZE_QCIF)
1290 cmd.buffer.registers[i++].value =
1291 (u8) (((STV_IMAGE_QCIF_ROWS / 4) - (height / 4)) / 2);
1292 else
1293 cmd.buffer.registers[i++].value =
1294 (u8) (((STV_IMAGE_CIF_ROWS / 4) - (height / 4)) / 2);
1295
1296 /* Scaling registers (defaults) */
1297 cmd.buffer.registers[i].index = CPIA2_VC_VC_HPHASE;
1298 cmd.buffer.registers[i++].value = (u8) 0;
1299
1300 cmd.buffer.registers[i].index = CPIA2_VC_VC_VPHASE;
1301 cmd.buffer.registers[i++].value = (u8) 0;
1302
1303 cmd.buffer.registers[i].index = CPIA2_VC_VC_HISPAN;
1304 cmd.buffer.registers[i++].value = (u8) 31;
1305
1306 cmd.buffer.registers[i].index = CPIA2_VC_VC_VISPAN;
1307 cmd.buffer.registers[i++].value = (u8) 31;
1308
1309 cmd.buffer.registers[i].index = CPIA2_VC_VC_HICROP;
1310 cmd.buffer.registers[i++].value = (u8) 0;
1311
1312 cmd.buffer.registers[i].index = CPIA2_VC_VC_VICROP;
1313 cmd.buffer.registers[i++].value = (u8) 0;
1314
1315 cmd.buffer.registers[i].index = CPIA2_VC_VC_HFRACT;
1316 cmd.buffer.registers[i++].value = (u8) 0x81; /* = 8/1 = 8 (HIBYTE/LOBYTE) */
1317
1318 cmd.buffer.registers[i].index = CPIA2_VC_VC_VFRACT;
1319 cmd.buffer.registers[i++].value = (u8) 0x81; /* = 8/1 = 8 (HIBYTE/LOBYTE) */
1320
1321 cmd.reg_count = i;
1322
1323 cpia2_send_command(cam, &cmd);
1324
1325 return i;
1326 }
1327
1328
1329 /******************************************************************************
1330 *
1331 * config_sensor_500(cam)
1332 *
1333 *****************************************************************************/
1334 static int config_sensor_500(struct camera_data *cam,
1335 int req_width, int req_height)
1336 {
1337 struct cpia2_command cmd;
1338 int i = 0;
1339 int image_size = VIDEOSIZE_CIF;
1340 int image_type = VIDEOSIZE_VGA;
1341 int width = req_width;
1342 int height = req_height;
1343 unsigned int device = cam->params.pnp_id.device_type;
1344
1345 image_size = cpia2_match_video_size(width, height);
1346
1347 if (width > STV_IMAGE_CIF_COLS || height > STV_IMAGE_CIF_ROWS)
1348 image_type = VIDEOSIZE_VGA;
1349 else if (width > STV_IMAGE_QVGA_COLS || height > STV_IMAGE_QVGA_ROWS)
1350 image_type = VIDEOSIZE_CIF;
1351 else if (width > STV_IMAGE_QCIF_COLS || height > STV_IMAGE_QCIF_ROWS)
1352 image_type = VIDEOSIZE_QVGA;
1353 else
1354 image_type = VIDEOSIZE_QCIF;
1355
1356 if (image_size >= 0) {
1357 set_vw_size(cam, image_size);
1358 width = cam->params.roi.width;
1359 height = cam->params.roi.height;
1360 } else {
1361 ERR("ConfigSensor500 failed\n");
1362 return -EINVAL;
1363 }
1364
1365 DBG("image_size = %d, width = %d, height = %d, type = %d\n",
1366 image_size, width, height, image_type);
1367
1368 cmd.req_mode = CAMERAACCESS_TYPE_RANDOM | CAMERAACCESS_VC;
1369 cmd.direction = TRANSFER_WRITE;
1370 i = 0;
1371
1372 /* VC Format */
1373 cmd.buffer.registers[i].index = CPIA2_VC_VC_FORMAT;
1374 cmd.buffer.registers[i].value = (u8) CPIA2_VC_VC_FORMAT_UFIRST;
1375 if (image_type == VIDEOSIZE_QCIF)
1376 cmd.buffer.registers[i].value |= (u8) CPIA2_VC_VC_FORMAT_DECIMATING;
1377 i++;
1378
1379 /* VC Clocks */
1380 cmd.buffer.registers[i].index = CPIA2_VC_VC_CLOCKS;
1381 if (device == DEVICE_STV_672) {
1382 if (image_type == VIDEOSIZE_VGA)
1383 cmd.buffer.registers[i].value =
1384 (u8)CPIA2_VC_VC_CLOCKS_LOGDIV1;
1385 else
1386 cmd.buffer.registers[i].value =
1387 (u8)(CPIA2_VC_VC_672_CLOCKS_SCALING |
1388 CPIA2_VC_VC_CLOCKS_LOGDIV3);
1389 } else {
1390 if (image_type == VIDEOSIZE_VGA)
1391 cmd.buffer.registers[i].value =
1392 (u8)CPIA2_VC_VC_CLOCKS_LOGDIV0;
1393 else
1394 cmd.buffer.registers[i].value =
1395 (u8)(CPIA2_VC_VC_676_CLOCKS_SCALING |
1396 CPIA2_VC_VC_CLOCKS_LOGDIV2);
1397 }
1398 i++;
1399
1400 DBG("VC_CLOCKS = 0x%X\n", cmd.buffer.registers[i-1].value);
1401
1402 /* Input width from VP */
1403 cmd.buffer.registers[i].index = CPIA2_VC_VC_IHSIZE_LO;
1404 if (image_type == VIDEOSIZE_VGA)
1405 cmd.buffer.registers[i].value =
1406 (u8) (STV_IMAGE_VGA_COLS / 4);
1407 else
1408 cmd.buffer.registers[i].value =
1409 (u8) (STV_IMAGE_QVGA_COLS / 4);
1410 i++;
1411 DBG("Input width = %d\n", cmd.buffer.registers[i-1].value);
1412
1413 /* Timings */
1414 cmd.buffer.registers[i].index = CPIA2_VC_VC_XLIM_HI;
1415 if (image_type == VIDEOSIZE_VGA)
1416 cmd.buffer.registers[i++].value = (u8) 2;
1417 else
1418 cmd.buffer.registers[i++].value = (u8) 1;
1419
1420 cmd.buffer.registers[i].index = CPIA2_VC_VC_XLIM_LO;
1421 if (image_type == VIDEOSIZE_VGA)
1422 cmd.buffer.registers[i++].value = (u8) 250;
1423 else if (image_type == VIDEOSIZE_QVGA)
1424 cmd.buffer.registers[i++].value = (u8) 125;
1425 else
1426 cmd.buffer.registers[i++].value = (u8) 160;
1427
1428 cmd.buffer.registers[i].index = CPIA2_VC_VC_YLIM_HI;
1429 if (image_type == VIDEOSIZE_VGA)
1430 cmd.buffer.registers[i++].value = (u8) 2;
1431 else
1432 cmd.buffer.registers[i++].value = (u8) 1;
1433
1434 cmd.buffer.registers[i].index = CPIA2_VC_VC_YLIM_LO;
1435 if (image_type == VIDEOSIZE_VGA)
1436 cmd.buffer.registers[i++].value = (u8) 12;
1437 else if (image_type == VIDEOSIZE_QVGA)
1438 cmd.buffer.registers[i++].value = (u8) 64;
1439 else
1440 cmd.buffer.registers[i++].value = (u8) 6;
1441
1442 /* Output Image Size */
1443 cmd.buffer.registers[i].index = CPIA2_VC_VC_OHSIZE;
1444 if (image_type == VIDEOSIZE_QCIF)
1445 cmd.buffer.registers[i++].value = STV_IMAGE_CIF_COLS / 4;
1446 else
1447 cmd.buffer.registers[i++].value = width / 4;
1448
1449 cmd.buffer.registers[i].index = CPIA2_VC_VC_OVSIZE;
1450 if (image_type == VIDEOSIZE_QCIF)
1451 cmd.buffer.registers[i++].value = STV_IMAGE_CIF_ROWS / 4;
1452 else
1453 cmd.buffer.registers[i++].value = height / 4;
1454
1455 /* Cropping */
1456 cmd.buffer.registers[i].index = CPIA2_VC_VC_HCROP;
1457 if (image_type == VIDEOSIZE_VGA)
1458 cmd.buffer.registers[i++].value =
1459 (u8) (((STV_IMAGE_VGA_COLS / 4) - (width / 4)) / 2);
1460 else if (image_type == VIDEOSIZE_QVGA)
1461 cmd.buffer.registers[i++].value =
1462 (u8) (((STV_IMAGE_QVGA_COLS / 4) - (width / 4)) / 2);
1463 else if (image_type == VIDEOSIZE_CIF)
1464 cmd.buffer.registers[i++].value =
1465 (u8) (((STV_IMAGE_CIF_COLS / 4) - (width / 4)) / 2);
1466 else /*if (image_type == VIDEOSIZE_QCIF)*/
1467 cmd.buffer.registers[i++].value =
1468 (u8) (((STV_IMAGE_QCIF_COLS / 4) - (width / 4)) / 2);
1469
1470 cmd.buffer.registers[i].index = CPIA2_VC_VC_VCROP;
1471 if (image_type == VIDEOSIZE_VGA)
1472 cmd.buffer.registers[i++].value =
1473 (u8) (((STV_IMAGE_VGA_ROWS / 4) - (height / 4)) / 2);
1474 else if (image_type == VIDEOSIZE_QVGA)
1475 cmd.buffer.registers[i++].value =
1476 (u8) (((STV_IMAGE_QVGA_ROWS / 4) - (height / 4)) / 2);
1477 else if (image_type == VIDEOSIZE_CIF)
1478 cmd.buffer.registers[i++].value =
1479 (u8) (((STV_IMAGE_CIF_ROWS / 4) - (height / 4)) / 2);
1480 else /*if (image_type == VIDEOSIZE_QCIF)*/
1481 cmd.buffer.registers[i++].value =
1482 (u8) (((STV_IMAGE_QCIF_ROWS / 4) - (height / 4)) / 2);
1483
1484 /* Scaling registers (defaults) */
1485 cmd.buffer.registers[i].index = CPIA2_VC_VC_HPHASE;
1486 if (image_type == VIDEOSIZE_CIF || image_type == VIDEOSIZE_QCIF)
1487 cmd.buffer.registers[i++].value = (u8) 36;
1488 else
1489 cmd.buffer.registers[i++].value = (u8) 0;
1490
1491 cmd.buffer.registers[i].index = CPIA2_VC_VC_VPHASE;
1492 if (image_type == VIDEOSIZE_CIF || image_type == VIDEOSIZE_QCIF)
1493 cmd.buffer.registers[i++].value = (u8) 32;
1494 else
1495 cmd.buffer.registers[i++].value = (u8) 0;
1496
1497 cmd.buffer.registers[i].index = CPIA2_VC_VC_HISPAN;
1498 if (image_type == VIDEOSIZE_CIF || image_type == VIDEOSIZE_QCIF)
1499 cmd.buffer.registers[i++].value = (u8) 26;
1500 else
1501 cmd.buffer.registers[i++].value = (u8) 31;
1502
1503 cmd.buffer.registers[i].index = CPIA2_VC_VC_VISPAN;
1504 if (image_type == VIDEOSIZE_CIF || image_type == VIDEOSIZE_QCIF)
1505 cmd.buffer.registers[i++].value = (u8) 21;
1506 else
1507 cmd.buffer.registers[i++].value = (u8) 31;
1508
1509 cmd.buffer.registers[i].index = CPIA2_VC_VC_HICROP;
1510 cmd.buffer.registers[i++].value = (u8) 0;
1511
1512 cmd.buffer.registers[i].index = CPIA2_VC_VC_VICROP;
1513 cmd.buffer.registers[i++].value = (u8) 0;
1514
1515 cmd.buffer.registers[i].index = CPIA2_VC_VC_HFRACT;
1516 if (image_type == VIDEOSIZE_CIF || image_type == VIDEOSIZE_QCIF)
1517 cmd.buffer.registers[i++].value = (u8) 0x2B; /* 2/11 */
1518 else
1519 cmd.buffer.registers[i++].value = (u8) 0x81; /* 8/1 */
1520
1521 cmd.buffer.registers[i].index = CPIA2_VC_VC_VFRACT;
1522 if (image_type == VIDEOSIZE_CIF || image_type == VIDEOSIZE_QCIF)
1523 cmd.buffer.registers[i++].value = (u8) 0x13; /* 1/3 */
1524 else
1525 cmd.buffer.registers[i++].value = (u8) 0x81; /* 8/1 */
1526
1527 cmd.reg_count = i;
1528
1529 cpia2_send_command(cam, &cmd);
1530
1531 return i;
1532 }
1533
1534
1535 /******************************************************************************
1536 *
1537 * setallproperties
1538 *
1539 * This sets all user changeable properties to the values in cam->params.
1540 *****************************************************************************/
1541 static int set_all_properties(struct camera_data *cam)
1542 {
1543 /**
1544 * Don't set target_kb here, it will be set later.
1545 * framerate and user_mode were already set (set_default_user_mode).
1546 **/
1547
1548 cpia2_usb_change_streaming_alternate(cam,
1549 cam->params.camera_state.stream_mode);
1550
1551 cpia2_do_command(cam,
1552 CPIA2_CMD_SET_VC_MP_GPIO_DIRECTION,
1553 TRANSFER_WRITE, cam->params.vp_params.gpio_direction);
1554 cpia2_do_command(cam, CPIA2_CMD_SET_VC_MP_GPIO_DATA, TRANSFER_WRITE,
1555 cam->params.vp_params.gpio_data);
1556
1557 v4l2_ctrl_handler_setup(&cam->hdl);
1558
1559 wake_system(cam);
1560
1561 set_lowlight_boost(cam);
1562
1563 return 0;
1564 }
1565
1566 /******************************************************************************
1567 *
1568 * cpia2_save_camera_state
1569 *
1570 *****************************************************************************/
1571 void cpia2_save_camera_state(struct camera_data *cam)
1572 {
1573 cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS, TRANSFER_READ, 0);
1574 cpia2_do_command(cam, CPIA2_CMD_GET_VC_MP_GPIO_DIRECTION, TRANSFER_READ,
1575 0);
1576 cpia2_do_command(cam, CPIA2_CMD_GET_VC_MP_GPIO_DATA, TRANSFER_READ, 0);
1577 /* Don't get framerate or target_kb. Trust the values we already have */
1578 }
1579
1580
1581 /******************************************************************************
1582 *
1583 * cpia2_set_flicker_mode
1584 *
1585 *****************************************************************************/
1586 int cpia2_set_flicker_mode(struct camera_data *cam, int mode)
1587 {
1588 unsigned char cam_reg;
1589 int err = 0;
1590
1591 if(cam->params.pnp_id.device_type != DEVICE_STV_672)
1592 return -EINVAL;
1593
1594 /* Set the appropriate bits in FLICKER_MODES, preserving the rest */
1595 if((err = cpia2_do_command(cam, CPIA2_CMD_GET_FLICKER_MODES,
1596 TRANSFER_READ, 0)))
1597 return err;
1598 cam_reg = cam->params.flicker_control.cam_register;
1599
1600 switch(mode) {
1601 case NEVER_FLICKER:
1602 cam_reg |= CPIA2_VP_FLICKER_MODES_NEVER_FLICKER;
1603 cam_reg &= ~CPIA2_VP_FLICKER_MODES_50HZ;
1604 break;
1605 case FLICKER_60:
1606 cam_reg &= ~CPIA2_VP_FLICKER_MODES_NEVER_FLICKER;
1607 cam_reg &= ~CPIA2_VP_FLICKER_MODES_50HZ;
1608 break;
1609 case FLICKER_50:
1610 cam_reg &= ~CPIA2_VP_FLICKER_MODES_NEVER_FLICKER;
1611 cam_reg |= CPIA2_VP_FLICKER_MODES_50HZ;
1612 break;
1613 default:
1614 return -EINVAL;
1615 }
1616
1617 if((err = cpia2_do_command(cam, CPIA2_CMD_SET_FLICKER_MODES,
1618 TRANSFER_WRITE, cam_reg)))
1619 return err;
1620
1621 /* Set the appropriate bits in EXP_MODES, preserving the rest */
1622 if((err = cpia2_do_command(cam, CPIA2_CMD_GET_VP_EXP_MODES,
1623 TRANSFER_READ, 0)))
1624 return err;
1625 cam_reg = cam->params.vp_params.exposure_modes;
1626
1627 if (mode == NEVER_FLICKER) {
1628 cam_reg |= CPIA2_VP_EXPOSURE_MODES_INHIBIT_FLICKER;
1629 } else {
1630 cam_reg &= ~CPIA2_VP_EXPOSURE_MODES_INHIBIT_FLICKER;
1631 }
1632
1633 if((err = cpia2_do_command(cam, CPIA2_CMD_SET_VP_EXP_MODES,
1634 TRANSFER_WRITE, cam_reg)))
1635 return err;
1636
1637 if((err = cpia2_do_command(cam, CPIA2_CMD_REHASH_VP4,
1638 TRANSFER_WRITE, 1)))
1639 return err;
1640
1641 switch(mode) {
1642 case NEVER_FLICKER:
1643 case FLICKER_60:
1644 case FLICKER_50:
1645 cam->params.flicker_control.flicker_mode_req = mode;
1646 break;
1647 default:
1648 err = -EINVAL;
1649 }
1650
1651 return err;
1652 }
1653
1654 /******************************************************************************
1655 *
1656 * cpia2_set_property_flip
1657 *
1658 *****************************************************************************/
1659 void cpia2_set_property_flip(struct camera_data *cam, int prop_val)
1660 {
1661 unsigned char cam_reg;
1662
1663 cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS, TRANSFER_READ, 0);
1664 cam_reg = cam->params.vp_params.user_effects;
1665
1666 if (prop_val)
1667 {
1668 cam_reg |= CPIA2_VP_USER_EFFECTS_FLIP;
1669 }
1670 else
1671 {
1672 cam_reg &= ~CPIA2_VP_USER_EFFECTS_FLIP;
1673 }
1674 cam->params.vp_params.user_effects = cam_reg;
1675 cpia2_do_command(cam, CPIA2_CMD_SET_USER_EFFECTS, TRANSFER_WRITE,
1676 cam_reg);
1677 }
1678
1679 /******************************************************************************
1680 *
1681 * cpia2_set_property_mirror
1682 *
1683 *****************************************************************************/
1684 void cpia2_set_property_mirror(struct camera_data *cam, int prop_val)
1685 {
1686 unsigned char cam_reg;
1687
1688 cpia2_do_command(cam, CPIA2_CMD_GET_USER_EFFECTS, TRANSFER_READ, 0);
1689 cam_reg = cam->params.vp_params.user_effects;
1690
1691 if (prop_val)
1692 {
1693 cam_reg |= CPIA2_VP_USER_EFFECTS_MIRROR;
1694 }
1695 else
1696 {
1697 cam_reg &= ~CPIA2_VP_USER_EFFECTS_MIRROR;
1698 }
1699 cam->params.vp_params.user_effects = cam_reg;
1700 cpia2_do_command(cam, CPIA2_CMD_SET_USER_EFFECTS, TRANSFER_WRITE,
1701 cam_reg);
1702 }
1703
1704 /******************************************************************************
1705 *
1706 * cpia2_set_gpio
1707 *
1708 *****************************************************************************/
1709 int cpia2_set_gpio(struct camera_data *cam, unsigned char setting)
1710 {
1711 int ret;
1712
1713 /* Set the microport direction (register 0x90, should be defined
1714 * already) to 1 (user output), and set the microport data (0x91) to
1715 * the value in the ioctl argument.
1716 */
1717
1718 ret = cpia2_do_command(cam,
1719 CPIA2_CMD_SET_VC_MP_GPIO_DIRECTION,
1720 CPIA2_VC_MP_DIR_OUTPUT,
1721 255);
1722 if (ret < 0)
1723 return ret;
1724 cam->params.vp_params.gpio_direction = 255;
1725
1726 ret = cpia2_do_command(cam,
1727 CPIA2_CMD_SET_VC_MP_GPIO_DATA,
1728 CPIA2_VC_MP_DIR_OUTPUT,
1729 setting);
1730 if (ret < 0)
1731 return ret;
1732 cam->params.vp_params.gpio_data = setting;
1733
1734 return 0;
1735 }
1736
1737 /******************************************************************************
1738 *
1739 * cpia2_set_fps
1740 *
1741 *****************************************************************************/
1742 int cpia2_set_fps(struct camera_data *cam, int framerate)
1743 {
1744 int retval;
1745
1746 switch(framerate) {
1747 case CPIA2_VP_FRAMERATE_30:
1748 case CPIA2_VP_FRAMERATE_25:
1749 if(cam->params.pnp_id.device_type == DEVICE_STV_672 &&
1750 cam->params.version.sensor_flags ==
1751 CPIA2_VP_SENSOR_FLAGS_500) {
1752 return -EINVAL;
1753 }
1754 /* Fall through */
1755 case CPIA2_VP_FRAMERATE_15:
1756 case CPIA2_VP_FRAMERATE_12_5:
1757 case CPIA2_VP_FRAMERATE_7_5:
1758 case CPIA2_VP_FRAMERATE_6_25:
1759 break;
1760 default:
1761 return -EINVAL;
1762 }
1763
1764 if (cam->params.pnp_id.device_type == DEVICE_STV_672 &&
1765 framerate == CPIA2_VP_FRAMERATE_15)
1766 framerate = 0; /* Work around bug in VP4 */
1767
1768 retval = cpia2_do_command(cam,
1769 CPIA2_CMD_FRAMERATE_REQ,
1770 TRANSFER_WRITE,
1771 framerate);
1772
1773 if(retval == 0)
1774 cam->params.vp_params.frame_rate = framerate;
1775
1776 return retval;
1777 }
1778
1779 /******************************************************************************
1780 *
1781 * cpia2_set_brightness
1782 *
1783 *****************************************************************************/
1784 void cpia2_set_brightness(struct camera_data *cam, unsigned char value)
1785 {
1786 /***
1787 * Don't let the register be set to zero - bug in VP4 - flash of full
1788 * brightness
1789 ***/
1790 if (cam->params.pnp_id.device_type == DEVICE_STV_672 && value == 0)
1791 value++;
1792 DBG("Setting brightness to %d (0x%0x)\n", value, value);
1793 cpia2_do_command(cam, CPIA2_CMD_SET_VP_BRIGHTNESS, TRANSFER_WRITE, value);
1794 }
1795
1796 /******************************************************************************
1797 *
1798 * cpia2_set_contrast
1799 *
1800 *****************************************************************************/
1801 void cpia2_set_contrast(struct camera_data *cam, unsigned char value)
1802 {
1803 DBG("Setting contrast to %d (0x%0x)\n", value, value);
1804 cpia2_do_command(cam, CPIA2_CMD_SET_CONTRAST, TRANSFER_WRITE, value);
1805 }
1806
1807 /******************************************************************************
1808 *
1809 * cpia2_set_saturation
1810 *
1811 *****************************************************************************/
1812 void cpia2_set_saturation(struct camera_data *cam, unsigned char value)
1813 {
1814 DBG("Setting saturation to %d (0x%0x)\n", value, value);
1815 cpia2_do_command(cam,CPIA2_CMD_SET_VP_SATURATION, TRANSFER_WRITE,value);
1816 }
1817
1818 /******************************************************************************
1819 *
1820 * wake_system
1821 *
1822 *****************************************************************************/
1823 static void wake_system(struct camera_data *cam)
1824 {
1825 cpia2_do_command(cam, CPIA2_CMD_SET_WAKEUP, TRANSFER_WRITE, 0);
1826 }
1827
1828 /******************************************************************************
1829 *
1830 * set_lowlight_boost
1831 *
1832 * Valid for STV500 sensor only
1833 *****************************************************************************/
1834 static void set_lowlight_boost(struct camera_data *cam)
1835 {
1836 struct cpia2_command cmd;
1837
1838 if (cam->params.pnp_id.device_type != DEVICE_STV_672 ||
1839 cam->params.version.sensor_flags != CPIA2_VP_SENSOR_FLAGS_500)
1840 return;
1841
1842 cmd.direction = TRANSFER_WRITE;
1843 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
1844 cmd.reg_count = 3;
1845 cmd.start = CPIA2_VP_RAM_ADDR_H;
1846
1847 cmd.buffer.block_data[0] = 0; /* High byte of address to write to */
1848 cmd.buffer.block_data[1] = 0x59; /* Low byte of address to write to */
1849 cmd.buffer.block_data[2] = 0; /* High byte of data to write */
1850
1851 cpia2_send_command(cam, &cmd);
1852
1853 if (cam->params.vp_params.lowlight_boost) {
1854 cmd.buffer.block_data[0] = 0x02; /* Low byte data to write */
1855 } else {
1856 cmd.buffer.block_data[0] = 0x06;
1857 }
1858 cmd.start = CPIA2_VP_RAM_DATA;
1859 cmd.reg_count = 1;
1860 cpia2_send_command(cam, &cmd);
1861
1862 /* Rehash the VP4 values */
1863 cpia2_do_command(cam, CPIA2_CMD_REHASH_VP4, TRANSFER_WRITE, 1);
1864 }
1865
1866 /******************************************************************************
1867 *
1868 * cpia2_set_format
1869 *
1870 * Assumes that new size is already set in param struct.
1871 *****************************************************************************/
1872 void cpia2_set_format(struct camera_data *cam)
1873 {
1874 cam->flush = true;
1875
1876 cpia2_usb_stream_pause(cam);
1877
1878 /* reset camera to new size */
1879 cpia2_set_low_power(cam);
1880 cpia2_reset_camera(cam);
1881 cam->flush = false;
1882
1883 cpia2_dbg_dump_registers(cam);
1884
1885 cpia2_usb_stream_resume(cam);
1886 }
1887
1888 /******************************************************************************
1889 *
1890 * cpia2_dbg_dump_registers
1891 *
1892 *****************************************************************************/
1893 void cpia2_dbg_dump_registers(struct camera_data *cam)
1894 {
1895 #ifdef _CPIA2_DEBUG_
1896 struct cpia2_command cmd;
1897
1898 if (!(debugs_on & DEBUG_DUMP_REGS))
1899 return;
1900
1901 cmd.direction = TRANSFER_READ;
1902
1903 /* Start with bank 0 (SYSTEM) */
1904 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_SYSTEM;
1905 cmd.reg_count = 3;
1906 cmd.start = 0;
1907 cpia2_send_command(cam, &cmd);
1908 printk(KERN_DEBUG "System Device Hi = 0x%X\n",
1909 cmd.buffer.block_data[0]);
1910 printk(KERN_DEBUG "System Device Lo = 0x%X\n",
1911 cmd.buffer.block_data[1]);
1912 printk(KERN_DEBUG "System_system control = 0x%X\n",
1913 cmd.buffer.block_data[2]);
1914
1915 /* Bank 1 (VC) */
1916 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VC;
1917 cmd.reg_count = 4;
1918 cmd.start = 0x80;
1919 cpia2_send_command(cam, &cmd);
1920 printk(KERN_DEBUG "ASIC_ID = 0x%X\n",
1921 cmd.buffer.block_data[0]);
1922 printk(KERN_DEBUG "ASIC_REV = 0x%X\n",
1923 cmd.buffer.block_data[1]);
1924 printk(KERN_DEBUG "PW_CONTRL = 0x%X\n",
1925 cmd.buffer.block_data[2]);
1926 printk(KERN_DEBUG "WAKEUP = 0x%X\n",
1927 cmd.buffer.block_data[3]);
1928
1929 cmd.start = 0xA0; /* ST_CTRL */
1930 cmd.reg_count = 1;
1931 cpia2_send_command(cam, &cmd);
1932 printk(KERN_DEBUG "Stream ctrl = 0x%X\n",
1933 cmd.buffer.block_data[0]);
1934
1935 cmd.start = 0xA4; /* Stream status */
1936 cpia2_send_command(cam, &cmd);
1937 printk(KERN_DEBUG "Stream status = 0x%X\n",
1938 cmd.buffer.block_data[0]);
1939
1940 cmd.start = 0xA8; /* USB status */
1941 cmd.reg_count = 3;
1942 cpia2_send_command(cam, &cmd);
1943 printk(KERN_DEBUG "USB_CTRL = 0x%X\n",
1944 cmd.buffer.block_data[0]);
1945 printk(KERN_DEBUG "USB_STRM = 0x%X\n",
1946 cmd.buffer.block_data[1]);
1947 printk(KERN_DEBUG "USB_STATUS = 0x%X\n",
1948 cmd.buffer.block_data[2]);
1949
1950 cmd.start = 0xAF; /* USB settings */
1951 cmd.reg_count = 1;
1952 cpia2_send_command(cam, &cmd);
1953 printk(KERN_DEBUG "USB settings = 0x%X\n",
1954 cmd.buffer.block_data[0]);
1955
1956 cmd.start = 0xC0; /* VC stuff */
1957 cmd.reg_count = 26;
1958 cpia2_send_command(cam, &cmd);
1959 printk(KERN_DEBUG "VC Control = 0x%0X\n",
1960 cmd.buffer.block_data[0]);
1961 printk(KERN_DEBUG "VC Format = 0x%0X\n",
1962 cmd.buffer.block_data[3]);
1963 printk(KERN_DEBUG "VC Clocks = 0x%0X\n",
1964 cmd.buffer.block_data[4]);
1965 printk(KERN_DEBUG "VC IHSize = 0x%0X\n",
1966 cmd.buffer.block_data[5]);
1967 printk(KERN_DEBUG "VC Xlim Hi = 0x%0X\n",
1968 cmd.buffer.block_data[6]);
1969 printk(KERN_DEBUG "VC XLim Lo = 0x%0X\n",
1970 cmd.buffer.block_data[7]);
1971 printk(KERN_DEBUG "VC YLim Hi = 0x%0X\n",
1972 cmd.buffer.block_data[8]);
1973 printk(KERN_DEBUG "VC YLim Lo = 0x%0X\n",
1974 cmd.buffer.block_data[9]);
1975 printk(KERN_DEBUG "VC OHSize = 0x%0X\n",
1976 cmd.buffer.block_data[10]);
1977 printk(KERN_DEBUG "VC OVSize = 0x%0X\n",
1978 cmd.buffer.block_data[11]);
1979 printk(KERN_DEBUG "VC HCrop = 0x%0X\n",
1980 cmd.buffer.block_data[12]);
1981 printk(KERN_DEBUG "VC VCrop = 0x%0X\n",
1982 cmd.buffer.block_data[13]);
1983 printk(KERN_DEBUG "VC HPhase = 0x%0X\n",
1984 cmd.buffer.block_data[14]);
1985 printk(KERN_DEBUG "VC VPhase = 0x%0X\n",
1986 cmd.buffer.block_data[15]);
1987 printk(KERN_DEBUG "VC HIspan = 0x%0X\n",
1988 cmd.buffer.block_data[16]);
1989 printk(KERN_DEBUG "VC VIspan = 0x%0X\n",
1990 cmd.buffer.block_data[17]);
1991 printk(KERN_DEBUG "VC HiCrop = 0x%0X\n",
1992 cmd.buffer.block_data[18]);
1993 printk(KERN_DEBUG "VC ViCrop = 0x%0X\n",
1994 cmd.buffer.block_data[19]);
1995 printk(KERN_DEBUG "VC HiFract = 0x%0X\n",
1996 cmd.buffer.block_data[20]);
1997 printk(KERN_DEBUG "VC ViFract = 0x%0X\n",
1998 cmd.buffer.block_data[21]);
1999 printk(KERN_DEBUG "VC JPeg Opt = 0x%0X\n",
2000 cmd.buffer.block_data[22]);
2001 printk(KERN_DEBUG "VC Creep Per = 0x%0X\n",
2002 cmd.buffer.block_data[23]);
2003 printk(KERN_DEBUG "VC User Sq. = 0x%0X\n",
2004 cmd.buffer.block_data[24]);
2005 printk(KERN_DEBUG "VC Target KB = 0x%0X\n",
2006 cmd.buffer.block_data[25]);
2007
2008 /*** VP ***/
2009 cmd.req_mode = CAMERAACCESS_TYPE_BLOCK | CAMERAACCESS_VP;
2010 cmd.reg_count = 14;
2011 cmd.start = 0;
2012 cpia2_send_command(cam, &cmd);
2013
2014 printk(KERN_DEBUG "VP Dev Hi = 0x%0X\n",
2015 cmd.buffer.block_data[0]);
2016 printk(KERN_DEBUG "VP Dev Lo = 0x%0X\n",
2017 cmd.buffer.block_data[1]);
2018 printk(KERN_DEBUG "VP Sys State = 0x%0X\n",
2019 cmd.buffer.block_data[2]);
2020 printk(KERN_DEBUG "VP Sys Ctrl = 0x%0X\n",
2021 cmd.buffer.block_data[3]);
2022 printk(KERN_DEBUG "VP Sensor flg = 0x%0X\n",
2023 cmd.buffer.block_data[5]);
2024 printk(KERN_DEBUG "VP Sensor Rev = 0x%0X\n",
2025 cmd.buffer.block_data[6]);
2026 printk(KERN_DEBUG "VP Dev Config = 0x%0X\n",
2027 cmd.buffer.block_data[7]);
2028 printk(KERN_DEBUG "VP GPIO_DIR = 0x%0X\n",
2029 cmd.buffer.block_data[8]);
2030 printk(KERN_DEBUG "VP GPIO_DATA = 0x%0X\n",
2031 cmd.buffer.block_data[9]);
2032 printk(KERN_DEBUG "VP Ram ADDR H = 0x%0X\n",
2033 cmd.buffer.block_data[10]);
2034 printk(KERN_DEBUG "VP Ram ADDR L = 0x%0X\n",
2035 cmd.buffer.block_data[11]);
2036 printk(KERN_DEBUG "VP RAM Data = 0x%0X\n",
2037 cmd.buffer.block_data[12]);
2038 printk(KERN_DEBUG "Do Call = 0x%0X\n",
2039 cmd.buffer.block_data[13]);
2040
2041 if (cam->params.pnp_id.device_type == DEVICE_STV_672) {
2042 cmd.reg_count = 9;
2043 cmd.start = 0x0E;
2044 cpia2_send_command(cam, &cmd);
2045 printk(KERN_DEBUG "VP Clock Ctrl = 0x%0X\n",
2046 cmd.buffer.block_data[0]);
2047 printk(KERN_DEBUG "VP Patch Rev = 0x%0X\n",
2048 cmd.buffer.block_data[1]);
2049 printk(KERN_DEBUG "VP Vid Mode = 0x%0X\n",
2050 cmd.buffer.block_data[2]);
2051 printk(KERN_DEBUG "VP Framerate = 0x%0X\n",
2052 cmd.buffer.block_data[3]);
2053 printk(KERN_DEBUG "VP UserEffect = 0x%0X\n",
2054 cmd.buffer.block_data[4]);
2055 printk(KERN_DEBUG "VP White Bal = 0x%0X\n",
2056 cmd.buffer.block_data[5]);
2057 printk(KERN_DEBUG "VP WB thresh = 0x%0X\n",
2058 cmd.buffer.block_data[6]);
2059 printk(KERN_DEBUG "VP Exp Modes = 0x%0X\n",
2060 cmd.buffer.block_data[7]);
2061 printk(KERN_DEBUG "VP Exp Target = 0x%0X\n",
2062 cmd.buffer.block_data[8]);
2063
2064 cmd.reg_count = 1;
2065 cmd.start = 0x1B;
2066 cpia2_send_command(cam, &cmd);
2067 printk(KERN_DEBUG "VP FlickerMds = 0x%0X\n",
2068 cmd.buffer.block_data[0]);
2069 } else {
2070 cmd.reg_count = 8 ;
2071 cmd.start = 0x0E;
2072 cpia2_send_command(cam, &cmd);
2073 printk(KERN_DEBUG "VP Clock Ctrl = 0x%0X\n",
2074 cmd.buffer.block_data[0]);
2075 printk(KERN_DEBUG "VP Patch Rev = 0x%0X\n",
2076 cmd.buffer.block_data[1]);
2077 printk(KERN_DEBUG "VP Vid Mode = 0x%0X\n",
2078 cmd.buffer.block_data[5]);
2079 printk(KERN_DEBUG "VP Framerate = 0x%0X\n",
2080 cmd.buffer.block_data[6]);
2081 printk(KERN_DEBUG "VP UserEffect = 0x%0X\n",
2082 cmd.buffer.block_data[7]);
2083
2084 cmd.reg_count = 1;
2085 cmd.start = CPIA2_VP5_EXPOSURE_TARGET;
2086 cpia2_send_command(cam, &cmd);
2087 printk(KERN_DEBUG "VP5 Exp Target= 0x%0X\n",
2088 cmd.buffer.block_data[0]);
2089
2090 cmd.reg_count = 4;
2091 cmd.start = 0x3A;
2092 cpia2_send_command(cam, &cmd);
2093 printk(KERN_DEBUG "VP5 MY Black = 0x%0X\n",
2094 cmd.buffer.block_data[0]);
2095 printk(KERN_DEBUG "VP5 MCY Range = 0x%0X\n",
2096 cmd.buffer.block_data[1]);
2097 printk(KERN_DEBUG "VP5 MYCEILING = 0x%0X\n",
2098 cmd.buffer.block_data[2]);
2099 printk(KERN_DEBUG "VP5 MCUV Sat = 0x%0X\n",
2100 cmd.buffer.block_data[3]);
2101 }
2102 #endif
2103 }
2104
2105 /******************************************************************************
2106 *
2107 * reset_camera_struct
2108 *
2109 * Sets all values to the defaults
2110 *****************************************************************************/
2111 static void reset_camera_struct(struct camera_data *cam)
2112 {
2113 /***
2114 * The following parameter values are the defaults from the register map.
2115 ***/
2116 cam->params.vp_params.lowlight_boost = 0;
2117
2118 /* FlickerModes */
2119 cam->params.flicker_control.flicker_mode_req = NEVER_FLICKER;
2120
2121 /* jpeg params */
2122 cam->params.compression.jpeg_options = CPIA2_VC_VC_JPEG_OPT_DEFAULT;
2123 cam->params.compression.creep_period = 2;
2124 cam->params.compression.user_squeeze = 20;
2125 cam->params.compression.inhibit_htables = false;
2126
2127 /* gpio params */
2128 cam->params.vp_params.gpio_direction = 0; /* write, the default safe mode */
2129 cam->params.vp_params.gpio_data = 0;
2130
2131 /* Target kb params */
2132 cam->params.vc_params.quality = 100;
2133
2134 /***
2135 * Set Sensor FPS as fast as possible.
2136 ***/
2137 if(cam->params.pnp_id.device_type == DEVICE_STV_672) {
2138 if(cam->params.version.sensor_flags == CPIA2_VP_SENSOR_FLAGS_500)
2139 cam->params.vp_params.frame_rate = CPIA2_VP_FRAMERATE_15;
2140 else
2141 cam->params.vp_params.frame_rate = CPIA2_VP_FRAMERATE_30;
2142 } else {
2143 cam->params.vp_params.frame_rate = CPIA2_VP_FRAMERATE_30;
2144 }
2145
2146 /***
2147 * Set default video mode as large as possible :
2148 * for vga sensor set to vga, for cif sensor set to CIF.
2149 ***/
2150 if (cam->params.version.sensor_flags == CPIA2_VP_SENSOR_FLAGS_500) {
2151 cam->sensor_type = CPIA2_SENSOR_500;
2152 cam->video_size = VIDEOSIZE_VGA;
2153 cam->params.roi.width = STV_IMAGE_VGA_COLS;
2154 cam->params.roi.height = STV_IMAGE_VGA_ROWS;
2155 } else {
2156 cam->sensor_type = CPIA2_SENSOR_410;
2157 cam->video_size = VIDEOSIZE_CIF;
2158 cam->params.roi.width = STV_IMAGE_CIF_COLS;
2159 cam->params.roi.height = STV_IMAGE_CIF_ROWS;
2160 }
2161
2162 cam->width = cam->params.roi.width;
2163 cam->height = cam->params.roi.height;
2164 }
2165
2166 /******************************************************************************
2167 *
2168 * cpia2_init_camera_struct
2169 *
2170 * Initializes camera struct, does not call reset to fill in defaults.
2171 *****************************************************************************/
2172 struct camera_data *cpia2_init_camera_struct(struct usb_interface *intf)
2173 {
2174 struct camera_data *cam;
2175
2176 cam = kzalloc(sizeof(*cam), GFP_KERNEL);
2177
2178 if (!cam) {
2179 ERR("couldn't kmalloc cpia2 struct\n");
2180 return NULL;
2181 }
2182
2183 cam->v4l2_dev.release = cpia2_camera_release;
2184 if (v4l2_device_register(&intf->dev, &cam->v4l2_dev) < 0) {
2185 v4l2_err(&cam->v4l2_dev, "couldn't register v4l2_device\n");
2186 kfree(cam);
2187 return NULL;
2188 }
2189
2190 mutex_init(&cam->v4l2_lock);
2191 init_waitqueue_head(&cam->wq_stream);
2192
2193 return cam;
2194 }
2195
2196 /******************************************************************************
2197 *
2198 * cpia2_init_camera
2199 *
2200 * Initializes camera.
2201 *****************************************************************************/
2202 int cpia2_init_camera(struct camera_data *cam)
2203 {
2204 DBG("Start\n");
2205
2206 cam->mmapped = false;
2207
2208 /* Get sensor and asic types before reset. */
2209 cpia2_set_high_power(cam);
2210 cpia2_get_version_info(cam);
2211 if (cam->params.version.asic_id != CPIA2_ASIC_672) {
2212 ERR("Device IO error (asicID has incorrect value of 0x%X\n",
2213 cam->params.version.asic_id);
2214 return -ENODEV;
2215 }
2216
2217 /* Set GPIO direction and data to a safe state. */
2218 cpia2_do_command(cam, CPIA2_CMD_SET_VC_MP_GPIO_DIRECTION,
2219 TRANSFER_WRITE, 0);
2220 cpia2_do_command(cam, CPIA2_CMD_SET_VC_MP_GPIO_DATA,
2221 TRANSFER_WRITE, 0);
2222
2223 /* resetting struct requires version info for sensor and asic types */
2224 reset_camera_struct(cam);
2225
2226 cpia2_set_low_power(cam);
2227
2228 DBG("End\n");
2229
2230 return 0;
2231 }
2232
2233 /******************************************************************************
2234 *
2235 * cpia2_allocate_buffers
2236 *
2237 *****************************************************************************/
2238 int cpia2_allocate_buffers(struct camera_data *cam)
2239 {
2240 int i;
2241
2242 if(!cam->buffers) {
2243 u32 size = cam->num_frames*sizeof(struct framebuf);
2244 cam->buffers = kmalloc(size, GFP_KERNEL);
2245 if(!cam->buffers) {
2246 ERR("couldn't kmalloc frame buffer structures\n");
2247 return -ENOMEM;
2248 }
2249 }
2250
2251 if(!cam->frame_buffer) {
2252 cam->frame_buffer = rvmalloc(cam->frame_size*cam->num_frames);
2253 if (!cam->frame_buffer) {
2254 ERR("couldn't vmalloc frame buffer data area\n");
2255 kfree(cam->buffers);
2256 cam->buffers = NULL;
2257 return -ENOMEM;
2258 }
2259 }
2260
2261 for(i=0; i<cam->num_frames-1; ++i) {
2262 cam->buffers[i].next = &cam->buffers[i+1];
2263 cam->buffers[i].data = cam->frame_buffer +i*cam->frame_size;
2264 cam->buffers[i].status = FRAME_EMPTY;
2265 cam->buffers[i].length = 0;
2266 cam->buffers[i].max_length = 0;
2267 cam->buffers[i].num = i;
2268 }
2269 cam->buffers[i].next = cam->buffers;
2270 cam->buffers[i].data = cam->frame_buffer +i*cam->frame_size;
2271 cam->buffers[i].status = FRAME_EMPTY;
2272 cam->buffers[i].length = 0;
2273 cam->buffers[i].max_length = 0;
2274 cam->buffers[i].num = i;
2275 cam->curbuff = cam->buffers;
2276 cam->workbuff = cam->curbuff->next;
2277 DBG("buffers=%p, curbuff=%p, workbuff=%p\n", cam->buffers, cam->curbuff,
2278 cam->workbuff);
2279 return 0;
2280 }
2281
2282 /******************************************************************************
2283 *
2284 * cpia2_free_buffers
2285 *
2286 *****************************************************************************/
2287 void cpia2_free_buffers(struct camera_data *cam)
2288 {
2289 if(cam->buffers) {
2290 kfree(cam->buffers);
2291 cam->buffers = NULL;
2292 }
2293 if(cam->frame_buffer) {
2294 rvfree(cam->frame_buffer, cam->frame_size*cam->num_frames);
2295 cam->frame_buffer = NULL;
2296 }
2297 }
2298
2299 /******************************************************************************
2300 *
2301 * cpia2_read
2302 *
2303 *****************************************************************************/
2304 long cpia2_read(struct camera_data *cam,
2305 char __user *buf, unsigned long count, int noblock)
2306 {
2307 struct framebuf *frame;
2308
2309 if (!count)
2310 return 0;
2311
2312 if (!buf) {
2313 ERR("%s: buffer NULL\n",__func__);
2314 return -EINVAL;
2315 }
2316
2317 if (!cam) {
2318 ERR("%s: Internal error, camera_data NULL!\n",__func__);
2319 return -EINVAL;
2320 }
2321
2322 if (!cam->streaming) {
2323 /* Start streaming */
2324 cpia2_usb_stream_start(cam,
2325 cam->params.camera_state.stream_mode);
2326 }
2327
2328 /* Copy cam->curbuff in case it changes while we're processing */
2329 frame = cam->curbuff;
2330 if (noblock && frame->status != FRAME_READY) {
2331 return -EAGAIN;
2332 }
2333
2334 if (frame->status != FRAME_READY) {
2335 mutex_unlock(&cam->v4l2_lock);
2336 wait_event_interruptible(cam->wq_stream,
2337 !video_is_registered(&cam->vdev) ||
2338 (frame = cam->curbuff)->status == FRAME_READY);
2339 mutex_lock(&cam->v4l2_lock);
2340 if (signal_pending(current))
2341 return -ERESTARTSYS;
2342 if (!video_is_registered(&cam->vdev))
2343 return 0;
2344 }
2345
2346 /* copy data to user space */
2347 if (frame->length > count)
2348 return -EFAULT;
2349 if (copy_to_user(buf, frame->data, frame->length))
2350 return -EFAULT;
2351
2352 count = frame->length;
2353
2354 frame->status = FRAME_EMPTY;
2355
2356 return count;
2357 }
2358
2359 /******************************************************************************
2360 *
2361 * cpia2_poll
2362 *
2363 *****************************************************************************/
2364 __poll_t cpia2_poll(struct camera_data *cam, struct file *filp,
2365 poll_table *wait)
2366 {
2367 __poll_t status = v4l2_ctrl_poll(filp, wait);
2368
2369 if ((poll_requested_events(wait) & (EPOLLIN | EPOLLRDNORM)) &&
2370 !cam->streaming) {
2371 /* Start streaming */
2372 cpia2_usb_stream_start(cam,
2373 cam->params.camera_state.stream_mode);
2374 }
2375
2376 poll_wait(filp, &cam->wq_stream, wait);
2377
2378 if (cam->curbuff->status == FRAME_READY)
2379 status |= EPOLLIN | EPOLLRDNORM;
2380
2381 return status;
2382 }
2383
2384 /******************************************************************************
2385 *
2386 * cpia2_remap_buffer
2387 *
2388 *****************************************************************************/
2389 int cpia2_remap_buffer(struct camera_data *cam, struct vm_area_struct *vma)
2390 {
2391 const char *adr = (const char *)vma->vm_start;
2392 unsigned long size = vma->vm_end-vma->vm_start;
2393 unsigned long start_offset = vma->vm_pgoff << PAGE_SHIFT;
2394 unsigned long start = (unsigned long) adr;
2395 unsigned long page, pos;
2396
2397 DBG("mmap offset:%ld size:%ld\n", start_offset, size);
2398
2399 if (!video_is_registered(&cam->vdev))
2400 return -ENODEV;
2401
2402 if (size > cam->frame_size*cam->num_frames ||
2403 (start_offset % cam->frame_size) != 0 ||
2404 (start_offset+size > cam->frame_size*cam->num_frames))
2405 return -EINVAL;
2406
2407 pos = ((unsigned long) (cam->frame_buffer)) + start_offset;
2408 while (size > 0) {
2409 page = kvirt_to_pa(pos);
2410 if (remap_pfn_range(vma, start, page >> PAGE_SHIFT, PAGE_SIZE, PAGE_SHARED))
2411 return -EAGAIN;
2412 start += PAGE_SIZE;
2413 pos += PAGE_SIZE;
2414 if (size > PAGE_SIZE)
2415 size -= PAGE_SIZE;
2416 else
2417 size = 0;
2418 }
2419
2420 cam->mmapped = true;
2421 return 0;
2422 }
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git