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