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