1 #ifndef __ASM_ARCH_GENERIC_SENSOR_RK_H_
\r
2 #include <linux/videodev2.h>
\r
3 #include <linux/slab.h>
\r
4 #include <linux/i2c.h>
\r
5 #include <linux/stat.h>
\r
6 #include <linux/log2.h>
\r
7 #include <linux/platform_device.h>
\r
8 #include <linux/delay.h>
\r
9 #include <linux/circ_buf.h>
\r
10 #include <linux/miscdevice.h>
\r
11 #include <media/v4l2-common.h>
\r
12 #include <media/v4l2-chip-ident.h>
\r
13 #include <media/soc_camera.h>
\r
14 #include <linux/vmalloc.h>
\r
15 #include <plat/rk_camera.h>
\r
17 /* Camera Sensor driver */
\r
19 #define MIN(x,y) ((x<y) ? x: y)
\r
20 #define MAX(x,y) ((x>y) ? x: y)
\r
22 #define SENSOR_TR(format, ...) printk(KERN_ERR "%s(%d): " format"\n", SENSOR_NAME_STRING(),__LINE__, ## __VA_ARGS__)
\r
23 #define SENSOR_DG(format, ...) dprintk(1, "%s(%d): "format"\n", SENSOR_NAME_STRING(),__LINE__,## __VA_ARGS__)
\r
26 //a represents a i2c_client type point
\r
27 #define to_generic_sensor(a) (container_of(i2c_get_clientdata(a), struct generic_sensor, subdev))
\r
29 //to specific sensor
\r
30 //a represents a generic_sensor type point
\r
31 #define to_specific_sensor(a) (container_of(a, struct specific_sensor, common_sensor))
\r
33 #define SENSOR_INIT_IS_ERR (0x00<<28)
\r
34 #define SENSOR_INIT_IS_OK (0x01<<28)
\r
36 #define SEQCMD_STREAMCHK 0xFA000000
\r
37 #define SEQCMD_INVALIDATE 0xFB000000
\r
38 #define SEQCMD_INTERPOLATION 0xFC000000
\r
39 #define SEQCMD_WAIT_MS 0xFD000000
\r
40 #define SEQCMD_WAIT_US 0xFE000000
\r
41 #define SEQCMD_END 0xFF000000
\r
43 #define SensorReg0Val0(a,b) {SEQCMD_INVALIDATE,0,0,0}
\r
44 #define SensorReg1Val1(a,b) {a,b,0xff,0xff}
\r
45 #define SensorReg2Val1(a,b) {a,b,0xffff,0xff}
\r
46 #define SensorReg2Val2(a,b) {a,b,0xffff,0xffff}
\r
48 #define SensorStreamChk {SEQCMD_STREAMCHK,0,0,0}
\r
49 #define SensorWaitMs(a) {SEQCMD_WAIT_MS,a,0x00,0x00}
\r
50 #define SensorWaitUs(a) {SEQCMD_WAIT_US,a,0x00,0x00}
\r
51 #define SensorEnd {SEQCMD_END,0x00,0x00,0x00}
\r
53 #define CFG_WhiteBalance (1<<0)
\r
54 #define CFG_Brightness (1<<1)
\r
55 #define CFG_Contrast (1<<2)
\r
56 #define CFG_Saturation (1<<3)
\r
57 #define CFG_Effect (1<<4)
\r
58 #define CFG_Scene (1<<5)
\r
59 #define CFG_DigitalZoom (1<<6)
\r
60 #define CFG_Focus (1<<7)
\r
61 #define CFG_FocusContinues (1<<8)
\r
62 #define CFG_FocusZone (1<<9)
\r
63 #define CFG_FocusRelative (1<<10)
\r
64 #define CFG_FocusAbsolute (1<<11)
\r
65 #define CFG_FACE_DETECT (1<<12)
\r
66 #define CFG_Exposure (1<<13)
\r
67 #define CFG_Flash (1<<14)
\r
68 #define CFG_Mirror (1<<15)
\r
69 #define CFG_Flip (1<<16)
\r
71 #define CFG_FunChk(a,b) ((a&b)==b)
\r
72 #define CFG_FunDis(a,b) (a &= (~b))
\r
74 enum rk_sensor_sequence_property {
\r
80 struct rk_sensor_reg {
\r
83 unsigned int reg_mask;
\r
84 unsigned int val_mask;
\r
87 struct rk_sensor_seq_info {
\r
92 struct rk_sensor_sequence {
\r
93 struct rk_sensor_seq_info gSeq_info;
\r
94 enum rk_sensor_sequence_property property;
\r
95 struct rk_sensor_reg *data;
\r
98 /* only one fixed colorspace per pixelcode */
\r
99 struct rk_sensor_datafmt {
\r
100 enum v4l2_mbus_pixelcode code;
\r
101 enum v4l2_colorspace colorspace;
\r
106 enum rk_sensor_focus_wq_cmd
\r
108 WqCmd_af_invalid = -1,
\r
111 WqCmd_af_continues,
\r
112 WqCmd_af_continues_pause, /* ddl@rock-chips.com: v0.1.1 */
\r
113 WqCmd_af_update_zone,
\r
115 WqCmd_af_special_pos,
\r
120 enum rk_sensor_focus_sensor_wq_result
\r
127 enum rk_sensor_focus_state
\r
133 struct rk_sensor_focus_work
\r
135 struct i2c_client *client;
\r
136 struct delayed_work dwork;
\r
137 enum rk_sensor_focus_wq_cmd cmd;
\r
138 wait_queue_head_t done;
\r
139 enum rk_sensor_focus_sensor_wq_result result;
\r
145 struct rk_sensor_focus_cb{
\r
146 int (*sensor_focus_init_cb)(struct i2c_client *client);
\r
147 int (*sensor_af_single_cb)(struct i2c_client *client);
\r
148 int (*sensor_af_const_cb)(struct i2c_client *client);
\r
149 int (*sensor_af_const_pause_cb)(struct i2c_client *client);
\r
150 int (*sensor_af_zoneupdate_cb)(struct i2c_client *client, int *zone_tm_pos);
\r
151 int (*sensor_af_close_cb)(struct i2c_client *client);
\r
152 int (*sensor_af_near_cb)(struct i2c_client *client);
\r
153 int (*sensor_af_far_cb)(struct i2c_client *client);
\r
154 int (*sensor_af_specialpos_cb)(struct i2c_client *client,int pos);
\r
157 //zone from hal is [-1000,-1000,1000,1000],must map to sensor's zone.
\r
158 struct rk_sensor_focus_zone{
\r
164 struct rk_sensor_focus_op_s{
\r
165 struct rk_sensor_focus_cb focus_cb;
\r
166 struct workqueue_struct *sensor_wq;
\r
167 struct mutex focus_lock;
\r
168 unsigned int focus_state;
\r
169 unsigned int focus_mode; //show the focus mode
\r
170 struct rk_sensor_focus_zone focus_zone;
\r
171 enum rk_sensor_focus_wq_cmd focus_delay;
\r
175 typedef struct rk_sensor_priv_s
\r
179 bool video2preview;
\r
180 struct rk_sensor_sequence* winseqe_cur_addr;
\r
181 struct rk_sensor_datafmt* datafmt;
\r
183 struct rk_sensor_datafmt curfmt;
\r
184 unsigned int funmodule_state;
\r
186 struct rk_sensor_sequence* sensor_series;
\r
189 struct rk_sensor_reg* sensor_SfRstSeqe;
\r
190 struct rk_sensor_reg* sensor_CkIdSeqe;
\r
192 struct rk_sensor_seq_info max_res;//maybe interploted
\r
193 struct rk_sensor_seq_info max_real_res;
\r
194 struct rk_sensor_seq_info min_res;
\r
195 unsigned long bus_parameter;
\r
196 unsigned int *chip_id;
\r
197 unsigned int chip_id_num;
\r
199 unsigned int gReg_mask;
\r
200 unsigned int gVal_mask;
\r
201 unsigned int gI2c_speed;
\r
205 } rk_sensor_info_priv_t;
\r
207 struct sensor_v4l2ctrl_info_s {
\r
208 struct v4l2_queryctrl *qctrl;
\r
209 int (*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
210 struct v4l2_ext_control *ext_ctrl);
\r
211 struct rk_sensor_reg **sensor_Seqe;
\r
216 struct sensor_v4l2ctrl_usr_s {
\r
217 struct v4l2_queryctrl qctrl;
\r
218 int (*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
219 struct v4l2_ext_control *ext_ctrl);
\r
220 struct rk_sensor_reg **sensor_Seqe;
\r
223 struct sensor_ops_cb_s{
\r
224 int (*sensor_softreset_cb)(struct i2c_client *client,struct rk_sensor_reg *series);
\r
225 int (*sensor_check_id_cb)(struct i2c_client *client,struct rk_sensor_reg *series);
\r
226 int (*sensor_activate_cb)(struct i2c_client *client);
\r
227 int (*sensor_deactivate_cb)(struct i2c_client *client);
\r
228 int (*sensor_mirror_cb)(struct i2c_client *client, int mirror);
\r
229 int (*sensor_flip_cb)(struct i2c_client *client, int flip);
\r
230 int (*sensor_face_detect_cb)(struct i2c_client *client, int on);
\r
232 int (*sensor_s_fmt_cb_th)(struct i2c_client *client,struct v4l2_mbus_framefmt *mf, bool capture);
\r
233 int (*sensor_s_fmt_cb_bh)(struct i2c_client *client,struct v4l2_mbus_framefmt *mf, bool capture);
\r
234 int (*sensor_try_fmt_cb_th)(struct i2c_client *client,struct v4l2_mbus_framefmt *mf);
\r
236 //flash off in fixed time to prevent from too hot , zyc
\r
237 struct rk_flash_timer{
\r
238 struct soc_camera_device *icd;
\r
239 struct hrtimer timer;
\r
242 struct generic_sensor
\r
245 struct v4l2_subdev subdev;
\r
246 struct i2c_client *client;
\r
247 rk_sensor_info_priv_t info_priv;
\r
248 int model; /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */
\r
250 bool is_need_tasklock;
\r
251 atomic_t tasklock_cnt;
\r
252 struct soc_camera_ops *sensor_ops;
\r
253 struct v4l2_queryctrl* sensor_controls;
\r
254 struct sensor_v4l2ctrl_info_s *ctrls;
\r
255 struct rk_flash_timer flash_off_timer;
\r
256 struct sensor_ops_cb_s sensor_cb;
\r
257 struct rk_sensor_focus_op_s sensor_focus;
\r
258 struct rk29camera_platform_data *sensor_io_request;
\r
259 struct rk29camera_gpio_res *sensor_gpio_res;
\r
263 extern int generic_sensor_softreset(struct i2c_client *client, struct rk_sensor_reg *series);
\r
264 extern int generic_sensor_check_id(struct i2c_client *client, struct rk_sensor_reg *series);
\r
265 extern int sensor_write_reg2val1(struct i2c_client *client, u16 reg,u8 val);
\r
266 extern int sensor_write_reg2val2(struct i2c_client *client, u16 reg,u16 val);
\r
267 extern int sensor_write_reg1val1(struct i2c_client *client, u8 reg,u8 val);
\r
268 extern int sensor_write_reg1val2(struct i2c_client *client, u8 reg,u16 val);
\r
269 extern int sensor_read_reg1val1(struct i2c_client *client, u8 reg,u8* val);
\r
270 extern int sensor_read_reg2val1(struct i2c_client *client, u16 reg,u8* val);
\r
271 extern int sensor_read_reg1val2(struct i2c_client *client, u8 reg,u16* val);
\r
272 extern int sensor_read_reg2val2(struct i2c_client *client, u16 reg,u16* val);
\r
273 extern int generic_sensor_write(struct i2c_client *client,struct rk_sensor_reg* sensor_reg);
\r
274 extern int generic_sensor_read(struct i2c_client *client, struct rk_sensor_reg* sensor_reg);
\r
275 extern int generic_sensor_write_array(struct i2c_client *client, struct rk_sensor_reg *regarray);
\r
276 extern int generic_sensor_get_max_min_res(struct rk_sensor_sequence* res_array,int num,struct rk_sensor_seq_info * max_real_res
\r
277 ,struct rk_sensor_seq_info * max_res,struct rk_sensor_seq_info *min_res);
\r
278 extern int generic_sensor_init(struct v4l2_subdev *sd, u32 val);
\r
279 extern int generic_sensor_enum_frameintervals(struct v4l2_subdev *sd, struct v4l2_frmivalenum *fival);
\r
280 extern int generic_sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
281 extern int generic_sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on);
\r
282 extern unsigned long generic_sensor_query_bus_param(struct soc_camera_device *icd);
\r
283 extern int generic_sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
284 extern int generic_sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);
\r
285 extern int generic_sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
\r
286 extern int generic_sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
\r
287 extern int generic_sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl);
\r
288 extern int generic_sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl);
\r
289 extern int generic_sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl);
\r
290 extern int generic_sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl);
\r
291 extern long generic_sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
\r
292 extern int generic_sensor_enum_fmt(struct v4l2_subdev *sd, unsigned int index,enum v4l2_mbus_pixelcode *code);
\r
293 extern int generic_sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
294 extern int generic_sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id);
\r
295 extern int generic_sensor_af_workqueue_set(struct soc_camera_device *icd, enum rk_sensor_focus_wq_cmd cmd, int var, bool wait);
\r
296 extern int generic_sensor_s_stream(struct v4l2_subdev *sd, int enable);
\r
297 extern int generic_sensor_writebuf(struct i2c_client *client, char *buf, int buf_size);
\r
299 static inline int sensor_get_full_width_height(int full_resolution, unsigned short *w, unsigned short *h)
\r
301 switch (full_resolution)
\r
358 static inline int sensor_video_probe(struct soc_camera_device *icd,
\r
359 struct i2c_client *client)
\r
362 struct generic_sensor *sensor = to_generic_sensor(client);
\r
364 /* We must have a parent by now. And it cannot be a wrong one.
\r
365 * So this entire test is completely redundant. */
\r
366 if (!icd->dev.parent ||
\r
367 to_soc_camera_host(icd->dev.parent)->nr != icd->iface) {
\r
369 goto sensor_video_probe_end;
\r
372 generic_sensor_softreset(client,sensor->info_priv.sensor_SfRstSeqe);
\r
373 ret = generic_sensor_check_id(client,sensor->info_priv.sensor_CkIdSeqe);
\r
375 sensor_video_probe_end:
\r
379 static inline int sensor_regarray_check(struct rk_sensor_reg *data, int reg_num)
\r
381 struct rk_sensor_reg *data_ptr;
\r
383 data_ptr = data+reg_num-1;
\r
384 if (data_ptr->reg == SEQCMD_END) {
\r
387 printk(KERN_ERR "%s(%d): data[%d].reg = 0x%x\n",__FUNCTION__,__LINE__,reg_num-1,data_ptr->reg);
\r
393 static inline void sensor_v4l2ctrl_info_init (struct sensor_v4l2ctrl_info_s *ptr,
\r
395 enum v4l2_ctrl_type type,
\r
401 int(*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
402 struct v4l2_ext_control *ext_ctrl),
\r
403 struct rk_sensor_reg ** sensor_seqe
\r
406 ptr->qctrl->id = id;
\r
407 ptr->qctrl->type = type;
\r
408 strcat(ptr->qctrl->name,name);
\r
409 ptr->qctrl->minimum = min;
\r
410 ptr->qctrl->maximum = max;
\r
411 ptr->qctrl->step = step;
\r
412 ptr->qctrl->default_value = default_val;
\r
413 ptr->cur_value = default_val;
\r
415 ptr->sensor_Seqe = sensor_seqe;
\r
419 static inline struct sensor_v4l2ctrl_info_s* sensor_find_ctrl(
\r
420 struct sensor_v4l2ctrl_info_s *ops, int id)
\r
424 for (i = 0; i < ops[i].num_ctrls; i++)
\r
425 if (ops[i].qctrl->id == id)
\r
431 static inline void v4l2_querymenu_init (struct v4l2_querymenu *ptr,
\r
433 unsigned int index,
\r
435 unsigned int reserved)
\r
438 ptr->index = index;
\r
439 strcat(ptr->name,name);
\r
440 ptr->reserved = reserved;
\r
445 static inline int sensor_v4l2ctrl_replace_cb(struct generic_sensor *sensor, int id, void *cb)
\r
448 struct sensor_v4l2ctrl_info_s* ctrls;
\r
450 ctrls = sensor->ctrls;
\r
451 num = ctrls->num_ctrls;
\r
452 for (i=0; i<num; i++,ctrls++) {
\r
453 if (ctrls->qctrl->id == id) {
\r
460 printk(KERN_ERR "%s(%d): v4l2_control id(0x%x) isn't exist\n",__FUNCTION__,__LINE__,id);
\r
466 static inline int sensor_v4l2ctrl_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
467 struct v4l2_ext_control *ext_ctrl)
\r
469 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
470 int value = ext_ctrl->value;
\r
473 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
474 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
475 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
479 index = value - ctrl_info->qctrl->minimum;
\r
480 if (ctrl_info->sensor_Seqe && (ctrl_info->sensor_Seqe[index] != NULL)) {
\r
481 if (generic_sensor_write_array(client, ctrl_info->sensor_Seqe[index]) != 0) {
\r
482 printk(KERN_ERR "%s(%d): sensor write array sensor_Seqe failed\n",__FUNCTION__,__LINE__);
\r
486 ctrl_info->cur_value = value;
\r
489 printk(KERN_ERR "%s(%d): ctrl_info(id=0x%x)'s sensor_Seqe is invalidate\n",__FUNCTION__,__LINE__,ctrl_info->qctrl->id);
\r
493 static inline int sensor_v4l2ctrl_flash_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
494 struct v4l2_ext_control *ext_ctrl)
\r
496 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
497 int value = ext_ctrl->value;
\r
499 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
500 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
501 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
505 if (value == 3) { /* ddl@rock-chips.com: torch */
\r
506 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Torch); /* Flash On */
\r
508 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
\r
511 ctrl_info->cur_value = value; /* ddl@rock-chips.com : v0.1.3 */
\r
515 static inline int sensor_focus_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
516 struct v4l2_ext_control *ext_ctrl)
\r
518 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
519 int value = ext_ctrl->value;
\r
521 struct generic_sensor* sensor = to_generic_sensor(client);
\r
523 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
524 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
525 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
529 if(sensor->sensor_focus.focus_state == FocusState_Inval){
\r
530 printk(KERN_ERR "%s(%d): focus have not been init success yet\n",__FUNCTION__,__LINE__);
\r
533 switch (ext_ctrl->id)
\r
535 case V4L2_CID_FOCUS_ABSOLUTE:
\r
536 sensor->sensor_focus.focus_delay = WqCmd_af_special_pos;
\r
538 case V4L2_CID_FOCUS_RELATIVE:
\r
539 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
540 sensor->sensor_focus.focus_delay = WqCmd_af_near_pos;
\r
542 sensor->sensor_focus.focus_delay = WqCmd_af_far_pos;
\r
545 case V4L2_CID_FOCUS_AUTO:
\r
546 sensor->sensor_focus.focus_delay = WqCmd_af_single;
\r
548 case V4L2_CID_FOCUS_CONTINUOUS:
\r
549 sensor->sensor_focus.focus_delay = WqCmd_af_continues;
\r
552 printk(KERN_ERR "%s(%d):not support this focus mode",__FUNCTION__,__LINE__ );
\r
556 switch (ext_ctrl->id)
\r
558 case V4L2_CID_FOCUS_ABSOLUTE:
\r
560 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
561 //need do something?
\r
564 if (ctrl_info->cur_value != value) {
\r
565 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
566 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
567 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
568 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
570 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_special_pos, value, true);
\r
572 ctrl_info->cur_value = value;
\r
575 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
580 case V4L2_CID_FOCUS_RELATIVE:
\r
582 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
583 //need do something?
\r
586 if (ctrl_info->cur_value != value) {
\r
587 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
588 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
589 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
590 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
592 ctrl_info->cur_value = value;
\r
595 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
600 case V4L2_CID_FOCUS_AUTO:
\r
602 mutex_lock(&sensor->sensor_focus.focus_lock);
\r
604 sensor->sensor_focus.focus_zone.lx = ext_ctrl->rect[0];
\r
605 sensor->sensor_focus.focus_zone.ty = ext_ctrl->rect[1];
\r
606 sensor->sensor_focus.focus_zone.rx = ext_ctrl->rect[2];
\r
607 sensor->sensor_focus.focus_zone.dy = ext_ctrl->rect[3];
\r
608 mutex_unlock(&sensor->sensor_focus.focus_lock);
\r
610 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
611 //need do something?
\r
612 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
614 if((value==1) || (sensor->sensor_focus.focus_mode==V4L2_CID_FOCUS_AUTO)){
\r
615 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_update_zone, value, true);
\r
616 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_single, value, true);
\r
617 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_AUTO;
\r
618 }else if(value == 0){
\r
619 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
623 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
628 case V4L2_CID_FOCUS_CONTINUOUS:
\r
630 if((value==1) && (sensor->sensor_focus.focus_mode!=V4L2_CID_FOCUS_CONTINUOUS)){
\r
631 //have to close focus firstly?
\r
632 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
633 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_continues, value, true);
\r
635 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_CONTINUOUS;
\r
636 }else if(value ==0){
\r
637 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
641 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
650 static inline int sensor_face_detect_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
651 struct v4l2_ext_control *ext_ctrl)
\r
653 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
654 int value = ext_ctrl->value;
\r
656 struct generic_sensor* sensor = to_generic_sensor(client);
\r
657 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
658 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
659 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
662 if(ctrl_info->cur_value != value){
\r
663 if(sensor->sensor_cb.sensor_face_detect_cb)
\r
664 ret = (sensor->sensor_cb.sensor_face_detect_cb)(client,value);
\r
666 ctrl_info->cur_value = value;
\r
670 #define new_user_v4l2ctrl(ctl_id,ctl_type,ctl_name,ctl_min,ctl_max,ctl_step,default_val,callback,seqe)\
\r
676 .minimum = ctl_min,\
\r
677 .maximum = ctl_max,\
\r
679 .default_value = default_val,\
\r
682 .sensor_Seqe = seqe,\
\r
686 #define new_usr_v4l2menu(menu_id,menu_idx,menu_name,menu_rev)\
\r
689 .index = menu_idx,\
\r
690 .name = menu_name,\
\r
691 .reserved = menu_rev,\
\r
694 #define sensor_init_parameters_default_code() static void sensor_init_parameters(struct specific_sensor* spsensor,struct soc_camera_device *icd)\
\r
697 struct rk_sensor_sequence *sensor_series; \
\r
698 struct v4l2_queryctrl *controls, *control; \
\r
699 struct sensor_v4l2ctrl_info_s *ctrls; \
\r
700 struct v4l2_querymenu *menus,*menu; \
\r
701 struct soc_camera_link *icl = to_soc_camera_link(icd); \
\r
702 struct rk29camera_platform_data *pdata = icl->priv_usr; \
\r
703 struct rkcamera_platform_data *sensor_device=NULL,*new_camera; \
\r
704 struct rk_sensor_reg *reg_data; \
\r
705 int config_flash = 0;\
\r
706 int sensor_config;\
\r
708 if (pdata == NULL) {\
\r
709 printk("WARNING: Camera sensor device is registered in board by CONFIG_SENSOR_XX,\n"\
\r
710 "Please register camera sesnor deivce in struct rkcamera_platform_data new_camera[]\n");\
\r
713 sensor_config = SensorConfiguration;\
\r
714 new_camera = pdata->register_dev_new; \
\r
715 while (strstr(new_camera->dev_name,"end")==NULL) { \
\r
716 if (strcmp(dev_name(icd->pdev), new_camera->dev_name) == 0) { \
\r
717 sensor_device = new_camera; \
\r
723 if(sensor_device && sensor_device->flash)\
\r
725 spsensor->common_sensor.info_priv.gReg_mask = 0x00; \
\r
726 spsensor->common_sensor.info_priv.gVal_mask = 0x00; \
\r
727 for (i=0; i<SENSOR_REGISTER_LEN; i++) \
\r
728 spsensor->common_sensor.info_priv.gReg_mask |= (0xff<<(i*8)); \
\r
729 for (i=0; i<SENSOR_VALUE_LEN; i++) \
\r
730 spsensor->common_sensor.info_priv.gVal_mask |= (0xff<<(i*8)); \
\r
731 spsensor->common_sensor.info_priv.gI2c_speed = 100000; \
\r
732 if (sensor_regarray_check(sensor_softreset_data, sizeof(sensor_softreset_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
733 spsensor->common_sensor.info_priv.sensor_SfRstSeqe = sensor_softreset_data; \
\r
735 SENSOR_TR("sensor_softreset_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_softreset_data"); \
\r
738 if (sensor_regarray_check(sensor_check_id_data, sizeof(sensor_check_id_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
739 spsensor->common_sensor.info_priv.sensor_CkIdSeqe= sensor_check_id_data; \
\r
741 SENSOR_TR("sensor_check_id_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_check_id_data"); \
\r
744 spsensor->common_sensor.sensor_cb.sensor_activate_cb = sensor_activate_cb; \
\r
745 spsensor->common_sensor.sensor_cb.sensor_deactivate_cb = sensor_deactivate_cb; \
\r
746 spsensor->common_sensor.sensor_cb.sensor_mirror_cb = sensor_mirror_cb; \
\r
747 spsensor->common_sensor.sensor_cb.sensor_flip_cb = sensor_flip_cb; \
\r
748 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_th = sensor_s_fmt_cb_th; \
\r
749 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_bh = sensor_s_fmt_cb_bh; \
\r
750 spsensor->common_sensor.sensor_cb.sensor_try_fmt_cb_th = sensor_try_fmt_cb_th;\
\r
751 spsensor->common_sensor.sensor_cb.sensor_softreset_cb = sensor_softrest_usr_cb;\
\r
752 spsensor->common_sensor.sensor_cb.sensor_check_id_cb = sensor_check_id_usr_cb;\
\r
753 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) \
\r
754 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = sensor_face_detect_usr_cb; \
\r
756 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = NULL; \
\r
759 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
762 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
766 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) \
\r
769 sensor_series = (struct rk_sensor_sequence*)kzalloc(sizeof(struct rk_sensor_sequence)*num,GFP_KERNEL); \
\r
770 if (sensor_series == NULL) { \
\r
771 SENSOR_TR("malloc sensor_series failed! n"); \
\r
774 spsensor->common_sensor.info_priv.sensor_series = sensor_series; \
\r
775 spsensor->common_sensor.info_priv.num_series = num; \
\r
777 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
778 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
779 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
780 sensor_series->property = SEQUENCE_INIT; \
\r
781 if (sensor_regarray_check(sensor_init_data, sizeof(sensor_init_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
782 sensor_series->data = sensor_init_data; \
\r
784 SENSOR_TR("sensor_init_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_int_data"); \
\r
789 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
790 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
791 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
792 sensor_series->property = SEQUENCE_PREVIEW; \
\r
793 if (sensor_regarray_check(sensor_preview_data, sizeof(sensor_preview_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
794 sensor_series->data = sensor_preview_data; \
\r
796 SENSOR_TR("sensor_preview_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_preview_data"); \
\r
801 if (sensor_get_full_width_height(CONS(SENSOR_NAME,_FULL_RESOLUTION),&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
802 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
803 sensor_series->property = SEQUENCE_CAPTURE; \
\r
804 if (sensor_regarray_check(sensor_fullres_lowfps_data, sizeof(sensor_fullres_lowfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
805 sensor_series->data = sensor_fullres_lowfps_data; \
\r
807 SENSOR_TR("sensor_fullres_lowfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_lowfps_data"); \
\r
811 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
816 sensor_series->gSeq_info.w = (sensor_series-1)->gSeq_info.w; \
\r
817 sensor_series->gSeq_info.h = (sensor_series-1)->gSeq_info.h; \
\r
818 sensor_series->gSeq_info.fps = SENSOR_FULLRES_H_FPS; \
\r
819 sensor_series->property = SEQUENCE_PREVIEW; \
\r
820 if (sensor_regarray_check(sensor_fullres_highfps_data, sizeof(sensor_fullres_highfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
821 sensor_series->data = sensor_fullres_highfps_data; \
\r
823 SENSOR_TR("sensor_fullres_highfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_highfps_data"); \
\r
827 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) { \
\r
829 if (sensor_get_full_width_height(sensor_device->resolution,&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
830 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
831 sensor_series->property = SEQUENCE_CAPTURE; \
\r
832 reg_data = kzalloc(sizeof(struct rk_sensor_reg)*2,GFP_KERNEL); \
\r
833 if (reg_data == NULL) { \
\r
834 SENSOR_TR("kzalloc interpolate reg_data failed"); \
\r
836 sensor_series->data = reg_data; \
\r
837 reg_data->reg = SEQCMD_INTERPOLATION; \
\r
839 reg_data->reg = SEQCMD_END; \
\r
842 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
847 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
849 sensor_series->gSeq_info.w = 1280; \
\r
850 sensor_series->gSeq_info.h = 720; \
\r
851 sensor_series->gSeq_info.fps = SENSOR_720P_FPS; \
\r
852 sensor_series->property = SEQUENCE_PREVIEW; \
\r
853 if (sensor_regarray_check(sensor_720p, sizeof(sensor_720p)/sizeof(struct rk_sensor_reg))==0) { \
\r
854 sensor_series->data = sensor_720p; \
\r
856 SENSOR_TR("sensor_720p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_720p"); \
\r
861 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
863 sensor_series->gSeq_info.w = 1920; \
\r
864 sensor_series->gSeq_info.h = 1080; \
\r
865 sensor_series->gSeq_info.fps = SENSOR_1080P_FPS; \
\r
866 sensor_series->property = SEQUENCE_PREVIEW; \
\r
867 if (sensor_regarray_check(sensor_1080p, sizeof(sensor_1080p)/sizeof(struct rk_sensor_reg))==0) { \
\r
868 sensor_series->data = sensor_1080p; \
\r
870 SENSOR_TR("sensor_1080p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_1080p"); \
\r
876 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
877 spsensor->common_sensor.sensor_focus.sensor_wq = create_workqueue(SENSOR_NAME_STRING(_af_workqueue)); \
\r
878 if (spsensor->common_sensor.sensor_focus.sensor_wq == NULL) {\
\r
879 SENSOR_TR("%s create fail, so auto focus is disable!", SENSOR_NAME_STRING(_af_workqueue));\
\r
880 CFG_FunDis(sensor_config,CFG_Focus);\
\r
881 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
882 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
883 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
884 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
887 spsensor->common_sensor.sensor_focus.sensor_wq = NULL;\
\r
888 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
889 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
890 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
891 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
894 spsensor->common_sensor.info_priv.bus_parameter = SENSOR_BUS_PARAM; \
\r
895 spsensor->common_sensor.info_priv.chip_ident = SENSOR_V4L2_IDENT; \
\r
896 spsensor->common_sensor.info_priv.chip_id = SensorChipID;\
\r
897 spsensor->common_sensor.info_priv.chip_id_num = sizeof(SensorChipID)/sizeof(SensorChipID[0]);\
\r
899 generic_sensor_get_max_min_res(spsensor->common_sensor.info_priv.sensor_series , \
\r
900 spsensor->common_sensor.info_priv.num_series, \
\r
901 &(spsensor->common_sensor.info_priv.max_real_res), \
\r
902 &(spsensor->common_sensor.info_priv.max_res), \
\r
903 &(spsensor->common_sensor.info_priv.min_res)); \
\r
906 for (i=0; i<32; i++)\
\r
907 if (SensorConfiguration & (1<<i))\
\r
909 num += sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s); \
\r
910 num += config_flash;\
\r
911 controls = (struct v4l2_queryctrl*)kzalloc(sizeof(struct v4l2_queryctrl)*num,GFP_KERNEL); \
\r
912 if (controls == NULL) { \
\r
913 SENSOR_TR("kzalloc struct v4l2_queryctrl(%d) failed",num); \
\r
916 spsensor->common_sensor.sensor_controls = controls; \
\r
917 sensor_ops.controls = controls; \
\r
918 sensor_ops.num_controls = num; \
\r
920 ctrls = (struct sensor_v4l2ctrl_info_s*)kzalloc(sizeof(struct sensor_v4l2ctrl_info_s)*num,GFP_KERNEL); \
\r
921 if (ctrls == NULL) { \
\r
922 SENSOR_TR("kzalloc struct sensor_v4l2ctrl_info_s(%d) failed",num); \
\r
925 spsensor->common_sensor.ctrls = ctrls; \
\r
926 for (i=0; i<num; i++) { \
\r
927 ctrls->qctrl = controls; \
\r
928 ctrls->num_ctrls = num; \
\r
932 controls = spsensor->common_sensor.sensor_controls; \
\r
933 ctrls = spsensor->common_sensor.ctrls; \
\r
936 num += (CFG_FunChk(sensor_config,CFG_WhiteBalance)*5 + CFG_FunChk(sensor_config,CFG_Effect)*6 + CFG_FunChk(sensor_config,CFG_Scene)*2 + config_flash*4); \
\r
937 num += sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
938 menus = (struct v4l2_querymenu*)kzalloc(sizeof(struct v4l2_querymenu)*num,GFP_KERNEL); \
\r
939 if (menus == NULL) { \
\r
940 SENSOR_TR("kzalloc struct v4l2_querymenu(%d) failed",num); \
\r
943 sensor_ops.menus = menus; \
\r
944 sensor_ops.num_menus = num; \
\r
946 sensor_ops.suspend = sensor_suspend; \
\r
947 sensor_ops.resume = sensor_resume; \
\r
948 sensor_ops.set_bus_param = generic_sensor_set_bus_param; \
\r
949 sensor_ops.query_bus_param = generic_sensor_query_bus_param; \
\r
951 if (CFG_FunChk(sensor_config,CFG_WhiteBalance)) { \
\r
952 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_DO_WHITE_BALANCE,V4L2_CTRL_TYPE_MENU, \
\r
953 "White Balance Control",0,4,1,0,sensor_v4l2ctrl_default_cb,sensor_WhiteBalanceSeqe); \
\r
957 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,0,"auto",0); \
\r
959 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,1,"incandescent",0); \
\r
961 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,2,"fluorescent",0); \
\r
963 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,3,"daylight",0); \
\r
965 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,4,"cloudy-daylight",0); \
\r
969 if (CFG_FunChk(sensor_config,CFG_Brightness)) { \
\r
970 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_BRIGHTNESS,V4L2_CTRL_TYPE_INTEGER, \
\r
971 "Brightness Control",-3,2,1,0,sensor_v4l2ctrl_default_cb,sensor_BrightnessSeqe); \
\r
975 if (CFG_FunChk(sensor_config,CFG_Effect)) { \
\r
976 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EFFECT,V4L2_CTRL_TYPE_MENU, \
\r
977 "Effect Control",0,5,1,0,sensor_v4l2ctrl_default_cb,sensor_EffectSeqe); \
\r
981 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,0,"none",0); \
\r
983 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,1,"mono",0); \
\r
985 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,2,"negative",0); \
\r
987 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,3,"sepia",0); \
\r
989 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,4,"posterize",0); \
\r
991 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,5,"aqua",0); \
\r
994 if (CFG_FunChk(sensor_config,CFG_Exposure)) { \
\r
995 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EXPOSURE,V4L2_CTRL_TYPE_INTEGER, \
\r
996 "Exposure Control",0,6,1,0,sensor_v4l2ctrl_default_cb,sensor_ExposureSeqe); \
\r
1000 if (CFG_FunChk(sensor_config,CFG_Saturation)) { \
\r
1001 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SATURATION,V4L2_CTRL_TYPE_INTEGER, \
\r
1002 "Saturation Control",0,2,1,0,sensor_v4l2ctrl_default_cb,sensor_SaturationSeqe); \
\r
1006 if (CFG_FunChk(sensor_config,CFG_Contrast)) { \
\r
1007 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_CONTRAST,V4L2_CTRL_TYPE_INTEGER, \
\r
1008 "Contrast Control",-3,3,1,0,sensor_v4l2ctrl_default_cb,sensor_ContrastSeqe); \
\r
1012 if (CFG_FunChk(sensor_config,CFG_Mirror)) { \
\r
1013 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_HFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1014 "Mirror Control",0,1,1,0,sensor_v4l2ctrl_mirror_cb,NULL); \
\r
1018 if (CFG_FunChk(sensor_config,CFG_Flip)) { \
\r
1019 ctrls->qctrl = controls; \
\r
1020 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_VFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1021 "Flip Control",0,1,1,0,sensor_v4l2ctrl_flip_cb,NULL); \
\r
1025 if (CFG_FunChk(sensor_config,CFG_Scene)) { \
\r
1026 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SCENE,V4L2_CTRL_TYPE_MENU, \
\r
1027 "Scene Control",0,1,1,0,sensor_v4l2ctrl_default_cb,sensor_SceneSeqe); \
\r
1031 v4l2_querymenu_init(menus,V4L2_CID_SCENE,0,"auto",0); \
\r
1033 v4l2_querymenu_init(menus,V4L2_CID_SCENE,1,"night",0); \
\r
1036 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1037 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_AUTO,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1038 "Focus Control",0,2,1,0,sensor_focus_default_cb,NULL); \
\r
1043 if (CFG_FunChk(sensor_config,CFG_FocusRelative)) { \
\r
1044 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_RELATIVE,V4L2_CTRL_TYPE_INTEGER, \
\r
1045 "Focus Control",-1,1,1,0,sensor_focus_default_cb,NULL); \
\r
1050 if (CFG_FunChk(sensor_config,CFG_FocusAbsolute)) { \
\r
1051 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_ABSOLUTE,V4L2_CTRL_TYPE_INTEGER, \
\r
1052 "Focus Control",0,255,1,125,sensor_focus_default_cb,NULL); \
\r
1056 if (CFG_FunChk(sensor_config,CFG_FocusZone)) { \
\r
1057 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUSZONE,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1058 "Focus Control",0,1,1,0,NULL,NULL); \
\r
1062 if (CFG_FunChk(sensor_config,CFG_FocusContinues)) { \
\r
1063 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_CONTINUOUS,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1064 "Focus Control",0,1,1,0,sensor_focus_default_cb,NULL); \
\r
1068 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) { \
\r
1069 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FACEDETECT,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1070 "FaceDEt Control",0,1,1,0,sensor_face_detect_default_cb,NULL); \
\r
1074 if (config_flash) { \
\r
1075 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FLASH,V4L2_CTRL_TYPE_MENU, \
\r
1076 "Flash Control",0,3,1,0,sensor_v4l2ctrl_flash_cb,NULL); \
\r
1080 v4l2_querymenu_init(menus,V4L2_CID_FLASH,0,"off",0); \
\r
1082 v4l2_querymenu_init(menus,V4L2_CID_FLASH,1,"auto",0); \
\r
1084 v4l2_querymenu_init(menus,V4L2_CID_FLASH,2,"on",0); \
\r
1086 v4l2_querymenu_init(menus,V4L2_CID_FLASH,3,"torch",0); \
\r
1090 for (i=0; i<(sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s)); i++) { \
\r
1092 control = spsensor->common_sensor.sensor_controls; \
\r
1093 while (control < controls) \
\r
1095 if (control->id == sensor_controls[i].qctrl.id) { \
\r
1096 control->id = 0xffffffff; \
\r
1101 memcpy(controls, &sensor_controls[i].qctrl,sizeof(struct v4l2_queryctrl)); \
\r
1104 ctrls->sensor_Seqe = sensor_controls[i].sensor_Seqe; \
\r
1105 ctrls->cur_value = sensor_controls[i].qctrl.default_value; \
\r
1106 ctrls->cb = sensor_controls[i].cb; \
\r
1110 for (i=0; i<(sizeof(sensor_menus)/sizeof(struct v4l2_querymenu)); i++) { \
\r
1111 num = sensor_ops.num_menus - sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
1112 menu = sensor_ops.menus; \
\r
1114 if (menu->id == sensor_menus[i].id) { \
\r
1115 menu->id = 0xffffffff; \
\r
1120 memcpy(menus, &sensor_menus[i],sizeof(struct v4l2_querymenu)); \
\r
1124 spsensor->common_sensor.info_priv.datafmt = sensor_colour_fmts; \
\r
1125 spsensor->common_sensor.info_priv.num_datafmt = ARRAY_SIZE(sensor_colour_fmts); \
\r
1126 spsensor->common_sensor.sensor_ops = &sensor_ops; \
\r
1127 icd->ops = &sensor_ops; \
\r
1128 spsensor->common_sensor.info_priv.curfmt= sensor_colour_fmts[0]; \
\r
1130 if (config_flash) { \
\r
1131 hrtimer_init(&(spsensor->common_sensor.flash_off_timer.timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL); \
\r
1132 spsensor->common_sensor.flash_off_timer.icd = icd; \
\r
1134 if(CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1135 mutex_init(&spsensor->common_sensor.sensor_focus.focus_lock); \
\r
1136 spsensor->common_sensor.sensor_focus.focus_mode = WqCmd_af_invalid; \
\r
1137 spsensor->common_sensor.sensor_focus.focus_state = FocusState_Inval;\
\r
1138 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = sensor_focus_init_usr_cb; \
\r
1139 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = sensor_focus_af_single_usr_cb; \
\r
1140 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = sensor_focus_af_near_usr_cb; \
\r
1141 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb = sensor_focus_af_far_usr_cb; \
\r
1142 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb = sensor_focus_af_specialpos_usr_cb; \
\r
1143 if(CFG_FunChk(sensor_config,CFG_FocusContinues)) {\
\r
1144 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb = sensor_focus_af_const_usr_cb; \
\r
1145 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_pause_cb = sensor_focus_af_const_pause_usr_cb; \
\r
1147 if(CFG_FunChk(sensor_config,CFG_FocusZone)) \
\r
1148 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb = sensor_focus_af_zoneupdate_usr_cb; \
\r
1149 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb = sensor_focus_af_close_usr_cb; \
\r
1151 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = NULL; \
\r
1152 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = NULL; \
\r
1153 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = NULL; \
\r
1154 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb =NULL; \
\r
1155 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb =NULL; \
\r
1156 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb =NULL; \
\r
1157 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb =NULL; \
\r
1158 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb =NULL; \
\r
1161 memcpy(spsensor->common_sensor.dev_name,dev_name(icd->pdev), sizeof(spsensor->common_sensor.dev_name)-1); \
\r
1162 sensor_init_parameters_user(spsensor,icd); \
\r
1166 #define sensor_v4l2_struct_initialization() static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {\
\r
1167 .init = generic_sensor_init,\
\r
1168 .g_ctrl = generic_sensor_g_control,\
\r
1169 .s_ctrl = generic_sensor_s_control,\
\r
1170 .g_ext_ctrls = generic_sensor_g_ext_controls,\
\r
1171 .s_ext_ctrls = generic_sensor_s_ext_controls,\
\r
1172 .g_chip_ident = generic_sensor_g_chip_ident,\
\r
1173 .ioctl = generic_sensor_ioctl,\
\r
1176 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {\
\r
1177 .s_mbus_fmt = generic_sensor_s_fmt,\
\r
1178 .g_mbus_fmt = generic_sensor_g_fmt,\
\r
1179 .try_mbus_fmt = generic_sensor_try_fmt,\
\r
1180 .enum_mbus_fmt = generic_sensor_enum_fmt,\
\r
1181 .enum_frameintervals = generic_sensor_enum_frameintervals,\
\r
1182 .s_stream = generic_sensor_s_stream,\
\r
1184 static struct v4l2_subdev_ops sensor_subdev_ops = {\
\r
1185 .core = &sensor_subdev_core_ops,\
\r
1186 .video = &sensor_subdev_video_ops,\
\r
1189 static const struct i2c_device_id sensor_id[] = {\
\r
1190 {SENSOR_NAME_STRING(), 0 },\
\r
1194 MODULE_DEVICE_TABLE(i2c, sensor_id);
\r
1197 #define sensor_probe_default_code() static int sensor_probe(struct i2c_client *client,\
\r
1198 const struct i2c_device_id *did)\
\r
1200 struct specific_sensor *spsensor=NULL;\
\r
1201 struct soc_camera_device *icd = client->dev.platform_data;\
\r
1202 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);\
\r
1203 struct soc_camera_link *icl;\
\r
1207 dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\
\r
1209 goto sensor_probe_end;\
\r
1212 icl = to_soc_camera_link(icd);\
\r
1214 SENSOR_TR("driver needs platform data! But it is failed\n");\
\r
1216 goto sensor_probe_end;\
\r
1219 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\
\r
1220 SENSOR_TR("I2C-Adapter doesn't support I2C_FUNC_I2C\n");\
\r
1222 goto sensor_probe_end;\
\r
1225 spsensor = kzalloc(sizeof(struct specific_sensor), GFP_KERNEL);\
\r
1228 SENSOR_TR("kzalloc failed\n");\
\r
1229 goto sensor_probe_end;\
\r
1232 v4l2_i2c_subdev_init(&spsensor->common_sensor.subdev, client, &sensor_subdev_ops);\
\r
1233 sensor_init_parameters(spsensor,icd);\
\r
1235 ret = sensor_video_probe(icd, client);\
\r
1237 sensor_probe_end:\
\r
1240 if (icd->ops->controls) {\
\r
1241 kfree(icd->ops->controls);\
\r
1242 icd->ops->controls = NULL;\
\r
1244 if (icd->ops->menus) {\
\r
1245 kfree(icd->ops->menus);\
\r
1246 icd->ops->menus = NULL;\
\r
1250 i2c_set_clientdata(client, NULL);\
\r
1251 client->driver = NULL;\
\r
1260 #define sensor_remove_default_code() static int sensor_remove(struct i2c_client *client)\
\r
1262 struct generic_sensor*sensor = to_generic_sensor(client);\
\r
1263 struct soc_camera_device *icd = client->dev.platform_data;\
\r
1264 struct specific_sensor *spsensor = to_specific_sensor(sensor);\
\r
1265 int sensor_config;\
\r
1267 sensor_config = SensorConfiguration;\
\r
1268 if(CFG_FunChk(sensor_config,CFG_Focus)){ \
\r
1269 if (sensor->sensor_focus.sensor_wq) {\
\r
1270 destroy_workqueue(sensor->sensor_focus.sensor_wq);\
\r
1271 sensor->sensor_focus.sensor_wq = NULL;\
\r
1275 if (icd->ops->controls) {\
\r
1276 kfree(icd->ops->controls);\
\r
1277 icd->ops->controls = NULL;\
\r
1279 if (icd->ops->menus) {\
\r
1280 kfree(icd->ops->menus);\
\r
1281 icd->ops->menus = NULL;\
\r
1285 i2c_set_clientdata(client, NULL);\
\r
1286 client->driver = NULL;\
\r
1295 #define sensor_driver_default_module_code() static struct i2c_driver sensor_i2c_driver = {\
\r
1297 .name = SENSOR_NAME_STRING(),\
\r
1299 .probe = sensor_probe,\
\r
1300 .remove = sensor_remove,\
\r
1301 .id_table = sensor_id,\
\r
1304 static int __init sensor_mod_init(void)\
\r
1306 return i2c_add_driver(&sensor_i2c_driver);\
\r
1309 static void __exit sensor_mod_exit(void)\
\r
1311 i2c_del_driver(&sensor_i2c_driver);\
\r
1314 device_initcall_sync(sensor_mod_init);\
\r
1315 module_exit(sensor_mod_exit);\
\r
1317 MODULE_DESCRIPTION(SENSOR_NAME_STRING(sensor driver));\
\r
1318 MODULE_AUTHOR("<ddl@rock-chips.com,zyc@rock-chips.com>");\
\r
1319 MODULE_LICENSE("GPL");
\r