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 long generic_sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
\r
293 extern int generic_sensor_enum_fmt(struct v4l2_subdev *sd, unsigned int index,enum v4l2_mbus_pixelcode *code);
\r
294 extern int generic_sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
295 extern int generic_sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id);
\r
296 extern int sensor_v4l2ctrl_flash_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
297 struct v4l2_ext_control *ext_ctrl);
\r
298 extern int generic_sensor_af_workqueue_set(struct soc_camera_device *icd, enum rk_sensor_focus_wq_cmd cmd, int var, bool wait);
\r
299 extern int generic_sensor_s_stream(struct v4l2_subdev *sd, int enable);
\r
300 extern int generic_sensor_writebuf(struct i2c_client *client, char *buf, int buf_size);
\r
302 static inline int sensor_get_full_width_height(int full_resolution, unsigned short *w, unsigned short *h)
\r
304 switch (full_resolution)
\r
361 static inline int sensor_video_probe(struct soc_camera_device *icd,
\r
362 struct i2c_client *client)
\r
365 struct generic_sensor *sensor = to_generic_sensor(client);
\r
367 /* We must have a parent by now. And it cannot be a wrong one.
\r
368 * So this entire test is completely redundant. */
\r
369 if (!icd->dev.parent ||
\r
370 to_soc_camera_host(icd->dev.parent)->nr != icd->iface) {
\r
372 goto sensor_video_probe_end;
\r
375 generic_sensor_softreset(client,sensor->info_priv.sensor_SfRstSeqe);
\r
376 ret = generic_sensor_check_id(client,sensor->info_priv.sensor_CkIdSeqe);
\r
378 sensor_video_probe_end:
\r
382 static inline int sensor_regarray_check(struct rk_sensor_reg *data, int reg_num)
\r
384 struct rk_sensor_reg *data_ptr;
\r
386 data_ptr = data+reg_num-1;
\r
387 if (data_ptr->reg == SEQCMD_END) {
\r
390 printk(KERN_ERR "%s(%d): data[%d].reg = 0x%x\n",__FUNCTION__,__LINE__,reg_num-1,data_ptr->reg);
\r
396 static inline void sensor_v4l2ctrl_info_init (struct sensor_v4l2ctrl_info_s *ptr,
\r
398 enum v4l2_ctrl_type type,
\r
404 int(*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
405 struct v4l2_ext_control *ext_ctrl),
\r
406 struct rk_sensor_reg ** sensor_seqe
\r
409 ptr->qctrl->id = id;
\r
410 ptr->qctrl->type = type;
\r
411 strcat(ptr->qctrl->name,name);
\r
412 ptr->qctrl->minimum = min;
\r
413 ptr->qctrl->maximum = max;
\r
414 ptr->qctrl->step = step;
\r
415 ptr->qctrl->default_value = default_val;
\r
416 ptr->cur_value = default_val;
\r
418 ptr->sensor_Seqe = sensor_seqe;
\r
422 static inline struct sensor_v4l2ctrl_info_s* sensor_find_ctrl(
\r
423 struct sensor_v4l2ctrl_info_s *ops, int id)
\r
427 for (i = 0; i < ops[i].num_ctrls; i++)
\r
428 if (ops[i].qctrl->id == id)
\r
434 static inline void v4l2_querymenu_init (struct v4l2_querymenu *ptr,
\r
436 unsigned int index,
\r
438 unsigned int reserved)
\r
441 ptr->index = index;
\r
442 strcat(ptr->name,name);
\r
443 ptr->reserved = reserved;
\r
448 static inline int sensor_v4l2ctrl_replace_cb(struct generic_sensor *sensor, int id, void *cb)
\r
451 struct sensor_v4l2ctrl_info_s* ctrls;
\r
453 ctrls = sensor->ctrls;
\r
454 num = ctrls->num_ctrls;
\r
455 for (i=0; i<num; i++,ctrls++) {
\r
456 if (ctrls->qctrl->id == id) {
\r
463 printk(KERN_ERR "%s(%d): v4l2_control id(0x%x) isn't exist\n",__FUNCTION__,__LINE__,id);
\r
469 static inline int sensor_v4l2ctrl_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
470 struct v4l2_ext_control *ext_ctrl)
\r
472 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
473 int value = ext_ctrl->value;
\r
476 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
477 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
478 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
482 index = value - ctrl_info->qctrl->minimum;
\r
483 if (ctrl_info->sensor_Seqe && (ctrl_info->sensor_Seqe[index] != NULL)) {
\r
484 if (generic_sensor_write_array(client, ctrl_info->sensor_Seqe[index]) != 0) {
\r
485 printk(KERN_ERR "%s(%d): sensor write array sensor_Seqe failed\n",__FUNCTION__,__LINE__);
\r
489 ctrl_info->cur_value = value;
\r
492 printk(KERN_ERR "%s(%d): ctrl_info(id=0x%x)'s sensor_Seqe is invalidate\n",__FUNCTION__,__LINE__,ctrl_info->qctrl->id);
\r
496 static inline int sensor_focus_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
497 struct v4l2_ext_control *ext_ctrl)
\r
499 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
500 int value = ext_ctrl->value;
\r
502 struct generic_sensor* sensor = to_generic_sensor(client);
\r
504 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
505 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
506 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
510 if(sensor->sensor_focus.focus_state == FocusState_Inval){
\r
511 printk(KERN_ERR "%s(%d): focus have not been init success yet\n",__FUNCTION__,__LINE__);
\r
514 switch (ext_ctrl->id)
\r
516 case V4L2_CID_FOCUS_ABSOLUTE:
\r
517 sensor->sensor_focus.focus_delay = WqCmd_af_special_pos;
\r
519 case V4L2_CID_FOCUS_RELATIVE:
\r
520 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
521 sensor->sensor_focus.focus_delay = WqCmd_af_near_pos;
\r
523 sensor->sensor_focus.focus_delay = WqCmd_af_far_pos;
\r
526 case V4L2_CID_FOCUS_AUTO:
\r
527 sensor->sensor_focus.focus_delay = WqCmd_af_single;
\r
529 case V4L2_CID_FOCUS_CONTINUOUS:
\r
530 sensor->sensor_focus.focus_delay = WqCmd_af_continues;
\r
533 printk(KERN_ERR "%s(%d):not support this focus mode",__FUNCTION__,__LINE__ );
\r
537 switch (ext_ctrl->id)
\r
539 case V4L2_CID_FOCUS_ABSOLUTE:
\r
541 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
542 //need do something?
\r
545 if (ctrl_info->cur_value != value) {
\r
546 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
547 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
548 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
549 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
551 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_special_pos, value, true);
\r
553 ctrl_info->cur_value = value;
\r
556 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
561 case V4L2_CID_FOCUS_RELATIVE:
\r
563 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
564 //need do something?
\r
567 if (ctrl_info->cur_value != value) {
\r
568 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
569 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
570 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
571 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
573 ctrl_info->cur_value = value;
\r
576 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
581 case V4L2_CID_FOCUS_AUTO:
\r
583 mutex_lock(&sensor->sensor_focus.focus_lock);
\r
585 sensor->sensor_focus.focus_zone.lx = ext_ctrl->rect[0];
\r
586 sensor->sensor_focus.focus_zone.ty = ext_ctrl->rect[1];
\r
587 sensor->sensor_focus.focus_zone.rx = ext_ctrl->rect[2];
\r
588 sensor->sensor_focus.focus_zone.dy = ext_ctrl->rect[3];
\r
589 mutex_unlock(&sensor->sensor_focus.focus_lock);
\r
591 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
592 //need do something?
\r
593 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
595 if((value==1) || (sensor->sensor_focus.focus_mode==V4L2_CID_FOCUS_AUTO)){
\r
596 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_update_zone, value, true);
\r
597 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_single, value, true);
\r
598 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_AUTO;
\r
599 }else if(value == 0){
\r
600 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
604 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
609 case V4L2_CID_FOCUS_CONTINUOUS:
\r
611 if((value==1) && (sensor->sensor_focus.focus_mode!=V4L2_CID_FOCUS_CONTINUOUS)){
\r
612 //have to close focus firstly?
\r
613 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
614 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_continues, value, true);
\r
616 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_CONTINUOUS;
\r
617 }else if(value ==0){
\r
618 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
622 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
631 static inline int sensor_face_detect_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
632 struct v4l2_ext_control *ext_ctrl)
\r
634 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
635 int value = ext_ctrl->value;
\r
637 struct generic_sensor* sensor = to_generic_sensor(client);
\r
638 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
639 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
640 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
643 if(ctrl_info->cur_value != value){
\r
644 if(sensor->sensor_cb.sensor_face_detect_cb)
\r
645 ret = (sensor->sensor_cb.sensor_face_detect_cb)(client,value);
\r
647 ctrl_info->cur_value = value;
\r
651 #define new_user_v4l2ctrl(ctl_id,ctl_type,ctl_name,ctl_min,ctl_max,ctl_step,default_val,callback,seqe)\
\r
657 .minimum = ctl_min,\
\r
658 .maximum = ctl_max,\
\r
660 .default_value = default_val,\
\r
663 .sensor_Seqe = seqe,\
\r
667 #define new_usr_v4l2menu(menu_id,menu_idx,menu_name,menu_rev)\
\r
670 .index = menu_idx,\
\r
671 .name = menu_name,\
\r
672 .reserved = menu_rev,\
\r
675 #define sensor_init_parameters_default_code() static void sensor_init_parameters(struct specific_sensor* spsensor,struct soc_camera_device *icd)\
\r
678 struct rk_sensor_sequence *sensor_series; \
\r
679 struct v4l2_queryctrl *controls, *control; \
\r
680 struct sensor_v4l2ctrl_info_s *ctrls; \
\r
681 struct v4l2_querymenu *menus,*menu; \
\r
682 struct soc_camera_link *icl = to_soc_camera_link(icd); \
\r
683 struct rk29camera_platform_data *pdata = icl->priv_usr; \
\r
684 struct rkcamera_platform_data *sensor_device=NULL,*new_camera; \
\r
685 struct rk_sensor_reg *reg_data; \
\r
686 int config_flash = 0;\
\r
687 int sensor_config;\
\r
689 if (pdata == NULL) {\
\r
690 printk("WARNING: Camera sensor device is registered in board by CONFIG_SENSOR_XX,\n"\
\r
691 "Please register camera sesnor deivce in struct rkcamera_platform_data new_camera[]\n");\
\r
694 sensor_config = SensorConfiguration;\
\r
695 new_camera = pdata->register_dev_new; \
\r
696 while (strstr(new_camera->dev_name,"end")==NULL) { \
\r
697 if (strcmp(dev_name(icd->pdev), new_camera->dev_name) == 0) { \
\r
698 sensor_device = new_camera; \
\r
704 if(sensor_device && sensor_device->flash)\
\r
706 spsensor->common_sensor.info_priv.gReg_mask = 0x00; \
\r
707 spsensor->common_sensor.info_priv.gVal_mask = 0x00; \
\r
708 for (i=0; i<SENSOR_REGISTER_LEN; i++) \
\r
709 spsensor->common_sensor.info_priv.gReg_mask |= (0xff<<(i*8)); \
\r
710 for (i=0; i<SENSOR_VALUE_LEN; i++) \
\r
711 spsensor->common_sensor.info_priv.gVal_mask |= (0xff<<(i*8)); \
\r
712 spsensor->common_sensor.info_priv.gI2c_speed = 100000; \
\r
713 if (sensor_regarray_check(sensor_softreset_data, sizeof(sensor_softreset_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
714 spsensor->common_sensor.info_priv.sensor_SfRstSeqe = sensor_softreset_data; \
\r
716 SENSOR_TR("sensor_softreset_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_softreset_data"); \
\r
719 if (sensor_regarray_check(sensor_check_id_data, sizeof(sensor_check_id_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
720 spsensor->common_sensor.info_priv.sensor_CkIdSeqe= sensor_check_id_data; \
\r
722 SENSOR_TR("sensor_check_id_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_check_id_data"); \
\r
725 spsensor->common_sensor.sensor_cb.sensor_activate_cb = sensor_activate_cb; \
\r
726 spsensor->common_sensor.sensor_cb.sensor_deactivate_cb = sensor_deactivate_cb; \
\r
727 spsensor->common_sensor.sensor_cb.sensor_mirror_cb = sensor_mirror_cb; \
\r
728 spsensor->common_sensor.sensor_cb.sensor_flip_cb = sensor_flip_cb; \
\r
729 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_th = sensor_s_fmt_cb_th; \
\r
730 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_bh = sensor_s_fmt_cb_bh; \
\r
731 spsensor->common_sensor.sensor_cb.sensor_try_fmt_cb_th = sensor_try_fmt_cb_th;\
\r
732 spsensor->common_sensor.sensor_cb.sensor_softreset_cb = sensor_softrest_usr_cb;\
\r
733 spsensor->common_sensor.sensor_cb.sensor_check_id_cb = sensor_check_id_usr_cb;\
\r
734 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) \
\r
735 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = sensor_face_detect_usr_cb; \
\r
737 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = NULL; \
\r
740 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
743 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
747 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) \
\r
750 sensor_series = (struct rk_sensor_sequence*)kzalloc(sizeof(struct rk_sensor_sequence)*num,GFP_KERNEL); \
\r
751 if (sensor_series == NULL) { \
\r
752 SENSOR_TR("malloc sensor_series failed! n"); \
\r
755 spsensor->common_sensor.info_priv.sensor_series = sensor_series; \
\r
756 spsensor->common_sensor.info_priv.num_series = num; \
\r
758 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
759 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
760 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
761 sensor_series->property = SEQUENCE_INIT; \
\r
762 if (sensor_regarray_check(sensor_init_data, sizeof(sensor_init_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
763 sensor_series->data = sensor_init_data; \
\r
765 SENSOR_TR("sensor_init_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_int_data"); \
\r
770 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
771 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
772 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
773 sensor_series->property = SEQUENCE_PREVIEW; \
\r
774 if (sensor_regarray_check(sensor_preview_data, sizeof(sensor_preview_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
775 sensor_series->data = sensor_preview_data; \
\r
777 SENSOR_TR("sensor_preview_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_preview_data"); \
\r
782 if (sensor_get_full_width_height(CONS(SENSOR_NAME,_FULL_RESOLUTION),&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
783 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
784 sensor_series->property = SEQUENCE_CAPTURE; \
\r
785 if (sensor_regarray_check(sensor_fullres_lowfps_data, sizeof(sensor_fullres_lowfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
786 sensor_series->data = sensor_fullres_lowfps_data; \
\r
788 SENSOR_TR("sensor_fullres_lowfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_lowfps_data"); \
\r
792 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
797 sensor_series->gSeq_info.w = (sensor_series-1)->gSeq_info.w; \
\r
798 sensor_series->gSeq_info.h = (sensor_series-1)->gSeq_info.h; \
\r
799 sensor_series->gSeq_info.fps = SENSOR_FULLRES_H_FPS; \
\r
800 sensor_series->property = SEQUENCE_PREVIEW; \
\r
801 if (sensor_regarray_check(sensor_fullres_highfps_data, sizeof(sensor_fullres_highfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
802 sensor_series->data = sensor_fullres_highfps_data; \
\r
804 SENSOR_TR("sensor_fullres_highfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_highfps_data"); \
\r
808 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) { \
\r
810 if (sensor_get_full_width_height(sensor_device->resolution,&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
811 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
812 sensor_series->property = SEQUENCE_CAPTURE; \
\r
813 reg_data = kzalloc(sizeof(struct rk_sensor_reg)*2,GFP_KERNEL); \
\r
814 if (reg_data == NULL) { \
\r
815 SENSOR_TR("kzalloc interpolate reg_data failed"); \
\r
817 sensor_series->data = reg_data; \
\r
818 reg_data->reg = SEQCMD_INTERPOLATION; \
\r
820 reg_data->reg = SEQCMD_END; \
\r
823 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
828 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
830 sensor_series->gSeq_info.w = 1280; \
\r
831 sensor_series->gSeq_info.h = 720; \
\r
832 sensor_series->gSeq_info.fps = SENSOR_720P_FPS; \
\r
833 sensor_series->property = SEQUENCE_PREVIEW; \
\r
834 if (sensor_regarray_check(sensor_720p, sizeof(sensor_720p)/sizeof(struct rk_sensor_reg))==0) { \
\r
835 sensor_series->data = sensor_720p; \
\r
837 SENSOR_TR("sensor_720p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_720p"); \
\r
842 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
844 sensor_series->gSeq_info.w = 1920; \
\r
845 sensor_series->gSeq_info.h = 1080; \
\r
846 sensor_series->gSeq_info.fps = SENSOR_1080P_FPS; \
\r
847 sensor_series->property = SEQUENCE_PREVIEW; \
\r
848 if (sensor_regarray_check(sensor_1080p, sizeof(sensor_1080p)/sizeof(struct rk_sensor_reg))==0) { \
\r
849 sensor_series->data = sensor_1080p; \
\r
851 SENSOR_TR("sensor_1080p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_1080p"); \
\r
857 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
858 spsensor->common_sensor.sensor_focus.sensor_wq = create_workqueue(SENSOR_NAME_STRING(_af_workqueue)); \
\r
859 if (spsensor->common_sensor.sensor_focus.sensor_wq == NULL) {\
\r
860 SENSOR_TR("%s create fail, so auto focus is disable!", SENSOR_NAME_STRING(_af_workqueue));\
\r
861 CFG_FunDis(sensor_config,CFG_Focus);\
\r
862 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
863 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
864 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
865 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
868 spsensor->common_sensor.sensor_focus.sensor_wq = NULL;\
\r
869 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
870 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
871 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
872 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
875 spsensor->common_sensor.info_priv.bus_parameter = SENSOR_BUS_PARAM; \
\r
876 spsensor->common_sensor.info_priv.chip_ident = SENSOR_V4L2_IDENT; \
\r
877 spsensor->common_sensor.info_priv.chip_id = SensorChipID;\
\r
878 spsensor->common_sensor.info_priv.chip_id_num = sizeof(SensorChipID)/sizeof(SensorChipID[0]);\
\r
880 generic_sensor_get_max_min_res(spsensor->common_sensor.info_priv.sensor_series , \
\r
881 spsensor->common_sensor.info_priv.num_series, \
\r
882 &(spsensor->common_sensor.info_priv.max_real_res), \
\r
883 &(spsensor->common_sensor.info_priv.max_res), \
\r
884 &(spsensor->common_sensor.info_priv.min_res)); \
\r
887 for (i=0; i<32; i++)\
\r
888 if (SensorConfiguration & (1<<i))\
\r
890 num += sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s); \
\r
891 controls = (struct v4l2_queryctrl*)kzalloc(sizeof(struct v4l2_queryctrl)*num,GFP_KERNEL); \
\r
892 if (controls == NULL) { \
\r
893 SENSOR_TR("kzalloc struct v4l2_queryctrl(%d) failed",num); \
\r
896 spsensor->common_sensor.sensor_controls = controls; \
\r
897 sensor_ops.controls = controls; \
\r
898 sensor_ops.num_controls = num; \
\r
900 ctrls = (struct sensor_v4l2ctrl_info_s*)kzalloc(sizeof(struct sensor_v4l2ctrl_info_s)*num,GFP_KERNEL); \
\r
901 if (ctrls == NULL) { \
\r
902 SENSOR_TR("kzalloc struct sensor_v4l2ctrl_info_s(%d) failed",num); \
\r
905 spsensor->common_sensor.ctrls = ctrls; \
\r
906 for (i=0; i<num; i++) { \
\r
907 ctrls->qctrl = controls; \
\r
908 ctrls->num_ctrls = num; \
\r
912 controls = spsensor->common_sensor.sensor_controls; \
\r
913 ctrls = spsensor->common_sensor.ctrls; \
\r
916 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
917 num += sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
918 menus = (struct v4l2_querymenu*)kzalloc(sizeof(struct v4l2_querymenu)*num,GFP_KERNEL); \
\r
919 if (menus == NULL) { \
\r
920 SENSOR_TR("kzalloc struct v4l2_querymenu(%d) failed",num); \
\r
923 sensor_ops.menus = menus; \
\r
924 sensor_ops.num_menus = num; \
\r
926 sensor_ops.suspend = sensor_suspend; \
\r
927 sensor_ops.resume = sensor_resume; \
\r
928 sensor_ops.set_bus_param = generic_sensor_set_bus_param; \
\r
929 sensor_ops.query_bus_param = generic_sensor_query_bus_param; \
\r
931 if (CFG_FunChk(sensor_config,CFG_WhiteBalance)) { \
\r
932 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_DO_WHITE_BALANCE,V4L2_CTRL_TYPE_MENU, \
\r
933 "White Balance Control",0,4,1,0,sensor_v4l2ctrl_default_cb,sensor_WhiteBalanceSeqe); \
\r
937 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,0,"auto",0); \
\r
939 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,1,"incandescent",0); \
\r
941 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,2,"fluorescent",0); \
\r
943 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,3,"daylight",0); \
\r
945 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,4,"cloudy-daylight",0); \
\r
949 if (CFG_FunChk(sensor_config,CFG_Brightness)) { \
\r
950 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_BRIGHTNESS,V4L2_CTRL_TYPE_INTEGER, \
\r
951 "Brightness Control",-3,2,1,0,sensor_v4l2ctrl_default_cb,sensor_BrightnessSeqe); \
\r
955 if (CFG_FunChk(sensor_config,CFG_Effect)) { \
\r
956 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EFFECT,V4L2_CTRL_TYPE_MENU, \
\r
957 "Effect Control",0,5,1,0,sensor_v4l2ctrl_default_cb,sensor_EffectSeqe); \
\r
961 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,0,"none",0); \
\r
963 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,1,"mono",0); \
\r
965 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,2,"negative",0); \
\r
967 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,3,"sepia",0); \
\r
969 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,4,"posterize",0); \
\r
971 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,5,"aqua",0); \
\r
974 if (CFG_FunChk(sensor_config,CFG_Exposure)) { \
\r
975 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EXPOSURE,V4L2_CTRL_TYPE_INTEGER, \
\r
976 "Exposure Control",0,6,1,0,sensor_v4l2ctrl_default_cb,sensor_ExposureSeqe); \
\r
980 if (CFG_FunChk(sensor_config,CFG_Saturation)) { \
\r
981 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SATURATION,V4L2_CTRL_TYPE_INTEGER, \
\r
982 "Saturation Control",0,2,1,0,sensor_v4l2ctrl_default_cb,sensor_SaturationSeqe); \
\r
986 if (CFG_FunChk(sensor_config,CFG_Contrast)) { \
\r
987 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_CONTRAST,V4L2_CTRL_TYPE_INTEGER, \
\r
988 "Contrast Control",-3,3,1,0,sensor_v4l2ctrl_default_cb,sensor_ContrastSeqe); \
\r
992 if (CFG_FunChk(sensor_config,CFG_Mirror)) { \
\r
993 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_HFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
994 "Mirror Control",0,1,1,0,sensor_v4l2ctrl_mirror_cb,NULL); \
\r
998 if (CFG_FunChk(sensor_config,CFG_Flip)) { \
\r
999 ctrls->qctrl = controls; \
\r
1000 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_VFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1001 "Flip Control",0,1,1,0,sensor_v4l2ctrl_flip_cb,NULL); \
\r
1005 if (CFG_FunChk(sensor_config,CFG_Scene)) { \
\r
1006 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SCENE,V4L2_CTRL_TYPE_MENU, \
\r
1007 "Scene Control",0,1,1,0,sensor_v4l2ctrl_default_cb,sensor_SceneSeqe); \
\r
1011 v4l2_querymenu_init(menus,V4L2_CID_SCENE,0,"auto",0); \
\r
1013 v4l2_querymenu_init(menus,V4L2_CID_SCENE,1,"night",0); \
\r
1016 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1017 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_AUTO,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1018 "Focus Control",0,2,1,0,sensor_focus_default_cb,NULL); \
\r
1023 if (CFG_FunChk(sensor_config,CFG_FocusRelative)) { \
\r
1024 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_RELATIVE,V4L2_CTRL_TYPE_INTEGER, \
\r
1025 "Focus Control",-1,1,1,0,sensor_focus_default_cb,NULL); \
\r
1030 if (CFG_FunChk(sensor_config,CFG_FocusAbsolute)) { \
\r
1031 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_ABSOLUTE,V4L2_CTRL_TYPE_INTEGER, \
\r
1032 "Focus Control",0,255,1,125,sensor_focus_default_cb,NULL); \
\r
1036 if (CFG_FunChk(sensor_config,CFG_FocusZone)) { \
\r
1037 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUSZONE,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1038 "Focus Control",0,1,1,0,NULL,NULL); \
\r
1042 if (CFG_FunChk(sensor_config,CFG_FocusContinues)) { \
\r
1043 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_CONTINUOUS,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1044 "Focus Control",0,1,1,0,sensor_focus_default_cb,NULL); \
\r
1048 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) { \
\r
1049 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FACEDETECT,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1050 "FaceDEt Control",0,1,1,0,sensor_face_detect_default_cb,NULL); \
\r
1054 if (config_flash) { \
\r
1055 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FLASH,V4L2_CTRL_TYPE_MENU, \
\r
1056 "Flash Control",0,3,1,0,sensor_v4l2ctrl_flash_cb,NULL); \
\r
1060 v4l2_querymenu_init(menus,V4L2_CID_FLASH,0,"off",0); \
\r
1062 v4l2_querymenu_init(menus,V4L2_CID_FLASH,1,"auto",0); \
\r
1064 v4l2_querymenu_init(menus,V4L2_CID_FLASH,2,"on",0); \
\r
1066 v4l2_querymenu_init(menus,V4L2_CID_FLASH,3,"torch",0); \
\r
1070 for (i=0; i<(sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s)); i++) { \
\r
1072 control = spsensor->common_sensor.sensor_controls; \
\r
1073 while (control < controls) \
\r
1075 if (control->id == sensor_controls[i].qctrl.id) { \
\r
1076 control->id = 0xffffffff; \
\r
1081 memcpy(controls, &sensor_controls[i].qctrl,sizeof(struct v4l2_queryctrl)); \
\r
1084 ctrls->sensor_Seqe = sensor_controls[i].sensor_Seqe; \
\r
1085 ctrls->cur_value = sensor_controls[i].qctrl.default_value; \
\r
1086 ctrls->cb = sensor_controls[i].cb; \
\r
1090 for (i=0; i<(sizeof(sensor_menus)/sizeof(struct v4l2_querymenu)); i++) { \
\r
1091 num = sensor_ops.num_menus - sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
1092 menu = sensor_ops.menus; \
\r
1094 if (menu->id == sensor_menus[i].id) { \
\r
1095 menu->id = 0xffffffff; \
\r
1100 memcpy(menus, &sensor_menus[i],sizeof(struct v4l2_querymenu)); \
\r
1104 spsensor->common_sensor.info_priv.datafmt = sensor_colour_fmts; \
\r
1105 spsensor->common_sensor.info_priv.num_datafmt = ARRAY_SIZE(sensor_colour_fmts); \
\r
1106 spsensor->common_sensor.sensor_ops = &sensor_ops; \
\r
1107 icd->ops = &sensor_ops; \
\r
1108 spsensor->common_sensor.info_priv.curfmt= sensor_colour_fmts[0]; \
\r
1110 if (config_flash) { \
\r
1111 hrtimer_init(&(spsensor->common_sensor.flash_off_timer.timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL); \
\r
1112 spsensor->common_sensor.flash_off_timer.icd = icd; \
\r
1114 if(CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1115 mutex_init(&spsensor->common_sensor.sensor_focus.focus_lock); \
\r
1116 spsensor->common_sensor.sensor_focus.focus_mode = WqCmd_af_invalid; \
\r
1117 spsensor->common_sensor.sensor_focus.focus_state = FocusState_Inval;\
\r
1118 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = sensor_focus_init_usr_cb; \
\r
1119 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = sensor_focus_af_single_usr_cb; \
\r
1120 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = sensor_focus_af_near_usr_cb; \
\r
1121 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb = sensor_focus_af_far_usr_cb; \
\r
1122 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb = sensor_focus_af_specialpos_usr_cb; \
\r
1123 if(CFG_FunChk(sensor_config,CFG_FocusContinues)) {\
\r
1124 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb = sensor_focus_af_const_usr_cb; \
\r
1125 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_pause_cb = sensor_focus_af_const_pause_usr_cb; \
\r
1127 if(CFG_FunChk(sensor_config,CFG_FocusZone)) \
\r
1128 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb = sensor_focus_af_zoneupdate_usr_cb; \
\r
1129 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb = sensor_focus_af_close_usr_cb; \
\r
1131 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = NULL; \
\r
1132 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = NULL; \
\r
1133 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = NULL; \
\r
1134 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb =NULL; \
\r
1135 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb =NULL; \
\r
1136 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb =NULL; \
\r
1137 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb =NULL; \
\r
1138 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb =NULL; \
\r
1141 memcpy(spsensor->common_sensor.dev_name,dev_name(icd->pdev), sizeof(spsensor->common_sensor.dev_name)-1); \
\r
1142 sensor_init_parameters_user(spsensor,icd); \
\r
1146 #define sensor_v4l2_struct_initialization() static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {\
\r
1147 .init = generic_sensor_init,\
\r
1148 .g_ctrl = generic_sensor_g_control,\
\r
1149 .s_ctrl = generic_sensor_s_control,\
\r
1150 .g_ext_ctrls = generic_sensor_g_ext_controls,\
\r
1151 .s_ext_ctrls = generic_sensor_s_ext_controls,\
\r
1152 .g_chip_ident = generic_sensor_g_chip_ident,\
\r
1153 .ioctl = generic_sensor_ioctl,\
\r
1156 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {\
\r
1157 .s_mbus_fmt = generic_sensor_s_fmt,\
\r
1158 .g_mbus_fmt = generic_sensor_g_fmt,\
\r
1159 .try_mbus_fmt = generic_sensor_try_fmt,\
\r
1160 .enum_mbus_fmt = generic_sensor_enum_fmt,\
\r
1161 .enum_frameintervals = generic_sensor_enum_frameintervals,\
\r
1162 .s_stream = generic_sensor_s_stream,\
\r
1164 static struct v4l2_subdev_ops sensor_subdev_ops = {\
\r
1165 .core = &sensor_subdev_core_ops,\
\r
1166 .video = &sensor_subdev_video_ops,\
\r
1169 static const struct i2c_device_id sensor_id[] = {\
\r
1170 {SENSOR_NAME_STRING(), 0 },\
\r
1174 MODULE_DEVICE_TABLE(i2c, sensor_id);
\r
1177 #define sensor_probe_default_code() static int sensor_probe(struct i2c_client *client,\
\r
1178 const struct i2c_device_id *did)\
\r
1180 struct specific_sensor *spsensor=NULL;\
\r
1181 struct soc_camera_device *icd = client->dev.platform_data;\
\r
1182 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);\
\r
1183 struct soc_camera_link *icl;\
\r
1187 dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\
\r
1189 goto sensor_probe_end;\
\r
1192 icl = to_soc_camera_link(icd);\
\r
1194 SENSOR_TR("driver needs platform data! But it is failed\n");\
\r
1196 goto sensor_probe_end;\
\r
1199 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\
\r
1200 SENSOR_TR("I2C-Adapter doesn't support I2C_FUNC_I2C\n");\
\r
1202 goto sensor_probe_end;\
\r
1205 spsensor = kzalloc(sizeof(struct specific_sensor), GFP_KERNEL);\
\r
1208 SENSOR_TR("kzalloc failed\n");\
\r
1209 goto sensor_probe_end;\
\r
1212 v4l2_i2c_subdev_init(&spsensor->common_sensor.subdev, client, &sensor_subdev_ops);\
\r
1213 sensor_init_parameters(spsensor,icd);\
\r
1215 ret = sensor_video_probe(icd, client);\
\r
1217 sensor_probe_end:\
\r
1220 if (icd->ops->controls) {\
\r
1221 kfree(icd->ops->controls);\
\r
1222 icd->ops->controls = NULL;\
\r
1224 if (icd->ops->menus) {\
\r
1225 kfree(icd->ops->menus);\
\r
1226 icd->ops->menus = NULL;\
\r
1230 i2c_set_clientdata(client, NULL);\
\r
1231 client->driver = NULL;\
\r
1240 #define sensor_remove_default_code() static int sensor_remove(struct i2c_client *client)\
\r
1242 struct generic_sensor*sensor = to_generic_sensor(client);\
\r
1243 struct soc_camera_device *icd = client->dev.platform_data;\
\r
1244 struct specific_sensor *spsensor = to_specific_sensor(sensor);\
\r
1245 int sensor_config;\
\r
1247 sensor_config = SensorConfiguration;\
\r
1248 if(CFG_FunChk(sensor_config,CFG_Focus)){ \
\r
1249 if (sensor->sensor_focus.sensor_wq) {\
\r
1250 destroy_workqueue(sensor->sensor_focus.sensor_wq);\
\r
1251 sensor->sensor_focus.sensor_wq = NULL;\
\r
1255 if (icd->ops->controls) {\
\r
1256 kfree(icd->ops->controls);\
\r
1257 icd->ops->controls = NULL;\
\r
1259 if (icd->ops->menus) {\
\r
1260 kfree(icd->ops->menus);\
\r
1261 icd->ops->menus = NULL;\
\r
1265 i2c_set_clientdata(client, NULL);\
\r
1266 client->driver = NULL;\
\r
1275 #define sensor_driver_default_module_code() static struct i2c_driver sensor_i2c_driver = {\
\r
1277 .name = SENSOR_NAME_STRING(),\
\r
1279 .probe = sensor_probe,\
\r
1280 .remove = sensor_remove,\
\r
1281 .id_table = sensor_id,\
\r
1284 static int __init sensor_mod_init(void)\
\r
1286 return i2c_add_driver(&sensor_i2c_driver);\
\r
1289 static void __exit sensor_mod_exit(void)\
\r
1291 i2c_del_driver(&sensor_i2c_driver);\
\r
1294 device_initcall_sync(sensor_mod_init);\
\r
1295 module_exit(sensor_mod_exit);\
\r
1297 MODULE_DESCRIPTION(SENSOR_NAME_STRING(sensor driver));\
\r
1298 MODULE_AUTHOR("<ddl@rock-chips.com,zyc@rock-chips.com>");\
\r
1299 MODULE_LICENSE("GPL");
\r