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 <linux/module.h>
\r
16 #include "../../../arch/arm/mach-rockchip/rk30_camera.h"
\r
17 #include <linux/kernel.h>
\r
18 /* Camera Sensor driver */
\r
20 #define MIN(x,y) ((x<y) ? x: y)
\r
21 #define MAX(x,y) ((x>y) ? x: y)
\r
23 #define SENSOR_TR(format, ...) printk(KERN_ERR "%s(%d): " format"\n", SENSOR_NAME_STRING(),__LINE__, ## __VA_ARGS__)
\r
24 #define SENSOR_DG(format, ...) dprintk(1, "%s(%d): "format"\n", SENSOR_NAME_STRING(),__LINE__,## __VA_ARGS__)
\r
27 //a represents a i2c_client type point
\r
28 #define to_generic_sensor(a) (container_of(i2c_get_clientdata(a), struct generic_sensor, subdev))
\r
30 //to specific sensor
\r
31 //a represents a generic_sensor type point
\r
32 #define to_specific_sensor(a) (container_of(a, struct specific_sensor, common_sensor))
\r
34 #define SENSOR_CROP_PERCENT 0 // Redefine this macro in sensor driver if user want to crop
\r
36 #define SENSOR_INIT_IS_ERR (0x00<<28)
\r
37 #define SENSOR_INIT_IS_OK (0x01<<28)
\r
39 #define SEQCMD_STREAMCHK 0xFA000000
\r
40 #define SEQCMD_INVALIDATE 0xFB000000
\r
41 #define SEQCMD_INTERPOLATION 0xFC000000
\r
42 #define SEQCMD_WAIT_MS 0xFD000000
\r
43 #define SEQCMD_WAIT_US 0xFE000000
\r
44 #define SEQCMD_END 0xFF000000
\r
46 #define SensorReg0Val0(a,b) {SEQCMD_INVALIDATE,0,0,0}
\r
47 #define SensorReg1Val1(a,b) {a,b,0xff,0xff}
\r
48 #define SensorReg2Val1(a,b) {a,b,0xffff,0xff}
\r
49 #define SensorReg2Val2(a,b) {a,b,0xffff,0xffff}
\r
51 #define SensorStreamChk {SEQCMD_STREAMCHK,0,0,0}
\r
52 #define SensorWaitMs(a) {SEQCMD_WAIT_MS,a,0x00,0x00}
\r
53 #define SensorWaitUs(a) {SEQCMD_WAIT_US,a,0x00,0x00}
\r
54 #define SensorEnd {SEQCMD_END,0x00,0x00,0x00}
\r
56 #define CFG_WhiteBalance (1<<0)
\r
57 #define CFG_Brightness (1<<1)
\r
58 #define CFG_Contrast (1<<2)
\r
59 #define CFG_Saturation (1<<3)
\r
60 #define CFG_Effect (1<<4)
\r
61 #define CFG_Scene (1<<5)
\r
62 #define CFG_DigitalZoom (1<<6)
\r
63 #define CFG_Focus (1<<7)
\r
64 #define CFG_FocusContinues (1<<8)
\r
65 #define CFG_FocusZone (1<<9)
\r
66 #define CFG_FocusRelative (1<<10)
\r
67 #define CFG_FocusAbsolute (1<<11)
\r
68 #define CFG_FACE_DETECT (1<<12)
\r
69 #define CFG_Exposure (1<<13)
\r
70 #define CFG_Flash (1<<14)
\r
71 #define CFG_Mirror (1<<15)
\r
72 #define CFG_Flip (1<<16)
\r
74 #define CFG_FunChk(a,b) ((a&b)==b)
\r
75 #define CFG_FunDis(a,b) (a &= (~b))
\r
77 enum rk_sensor_sequence_property {
\r
83 struct rk_sensor_reg {
\r
86 unsigned int reg_mask;
\r
87 unsigned int val_mask;
\r
90 struct rk_sensor_seq_info {
\r
95 struct rk_sensor_sequence {
\r
96 struct rk_sensor_seq_info gSeq_info;
\r
97 enum rk_sensor_sequence_property property;
\r
98 struct rk_sensor_reg *data;
\r
101 /* only one fixed colorspace per pixelcode */
\r
102 struct rk_sensor_datafmt {
\r
103 enum v4l2_mbus_pixelcode code;
\r
104 enum v4l2_colorspace colorspace;
\r
109 enum rk_sensor_focus_wq_cmd
\r
111 WqCmd_af_invalid = -1,
\r
114 WqCmd_af_continues,
\r
115 WqCmd_af_continues_pause, /* ddl@rock-chips.com: v0.1.1 */
\r
116 WqCmd_af_update_zone,
\r
118 WqCmd_af_special_pos,
\r
123 enum rk_sensor_focus_sensor_wq_result
\r
130 enum rk_sensor_focus_state
\r
136 struct rk_sensor_focus_work
\r
138 struct i2c_client *client;
\r
139 struct delayed_work dwork;
\r
140 enum rk_sensor_focus_wq_cmd cmd;
\r
141 wait_queue_head_t done;
\r
142 enum rk_sensor_focus_sensor_wq_result result;
\r
148 struct rk_sensor_focus_cb{
\r
149 int (*sensor_focus_init_cb)(struct i2c_client *client);
\r
150 int (*sensor_af_single_cb)(struct i2c_client *client);
\r
151 int (*sensor_af_const_cb)(struct i2c_client *client);
\r
152 int (*sensor_af_const_pause_cb)(struct i2c_client *client);
\r
153 int (*sensor_af_zoneupdate_cb)(struct i2c_client *client, int *zone_tm_pos);
\r
154 int (*sensor_af_close_cb)(struct i2c_client *client);
\r
155 int (*sensor_af_near_cb)(struct i2c_client *client);
\r
156 int (*sensor_af_far_cb)(struct i2c_client *client);
\r
157 int (*sensor_af_specialpos_cb)(struct i2c_client *client,int pos);
\r
160 //zone from hal is [-1000,-1000,1000,1000],must map to sensor's zone.
\r
161 struct rk_sensor_focus_zone{
\r
167 struct rk_sensor_focus_op_s{
\r
168 struct rk_sensor_focus_cb focus_cb;
\r
169 struct workqueue_struct *sensor_wq;
\r
170 struct mutex focus_lock;
\r
171 unsigned int focus_state;
\r
172 unsigned int focus_mode; //show the focus mode
\r
173 struct rk_sensor_focus_zone focus_zone;
\r
174 enum rk_sensor_focus_wq_cmd focus_delay;
\r
178 typedef struct rk_sensor_priv_s
\r
182 bool video2preview;
\r
183 struct rk_sensor_sequence* winseqe_cur_addr;
\r
184 struct rk_sensor_datafmt* datafmt;
\r
186 struct rk_sensor_datafmt curfmt;
\r
187 unsigned int funmodule_state;
\r
189 struct rk_sensor_sequence* sensor_series;
\r
192 struct rk_sensor_reg* sensor_SfRstSeqe;
\r
193 struct rk_sensor_reg* sensor_CkIdSeqe;
\r
195 struct rk_sensor_seq_info max_res;//maybe interploted
\r
196 struct rk_sensor_seq_info max_real_res;
\r
197 struct rk_sensor_seq_info min_res;
\r
198 unsigned long bus_parameter;
\r
199 unsigned int *chip_id;
\r
200 unsigned int chip_id_num;
\r
202 unsigned int gReg_mask;
\r
203 unsigned int gVal_mask;
\r
204 unsigned int gI2c_speed;
\r
208 } rk_sensor_info_priv_t;
\r
210 struct sensor_v4l2ctrl_info_s {
\r
211 struct v4l2_queryctrl *qctrl;
\r
212 int (*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
213 struct v4l2_ext_control *ext_ctrl,bool is_set);
\r
214 struct rk_sensor_reg **sensor_Seqe;
\r
219 struct sensor_v4l2ctrl_usr_s {
\r
220 struct v4l2_queryctrl qctrl;
\r
221 int (*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
222 struct v4l2_ext_control *ext_ctrl,bool is_set);
\r
223 struct rk_sensor_reg **sensor_Seqe;
\r
226 struct sensor_ops_cb_s{
\r
227 int (*sensor_softreset_cb)(struct i2c_client *client,struct rk_sensor_reg *series);
\r
228 int (*sensor_check_id_cb)(struct i2c_client *client,struct rk_sensor_reg *series);
\r
229 int (*sensor_activate_cb)(struct i2c_client *client);
\r
230 int (*sensor_deactivate_cb)(struct i2c_client *client);
\r
231 int (*sensor_mirror_cb)(struct i2c_client *client, int mirror);
\r
232 int (*sensor_flip_cb)(struct i2c_client *client, int flip);
\r
233 int (*sensor_face_detect_cb)(struct i2c_client *client, int on);
\r
235 int (*sensor_s_fmt_cb_th)(struct i2c_client *client,struct v4l2_mbus_framefmt *mf, bool capture);
\r
236 int (*sensor_s_fmt_cb_bh)(struct i2c_client *client,struct v4l2_mbus_framefmt *mf, bool capture);
\r
237 int (*sensor_try_fmt_cb_th)(struct i2c_client *client,struct v4l2_mbus_framefmt *mf);
\r
238 int (*sensor_s_stream_cb)(struct v4l2_subdev *sd, int enable);
\r
239 int (*sensor_enum_framesizes)(struct v4l2_subdev *sd, struct v4l2_frmsizeenum *fsize);
\r
242 //flash off in fixed time to prevent from too hot , zyc
\r
243 struct rk_flash_timer{
\r
244 struct soc_camera_device *icd;
\r
245 struct hrtimer timer;
\r
248 struct generic_sensor
\r
251 struct v4l2_subdev subdev;
\r
252 struct i2c_client *client;
\r
253 rk_sensor_info_priv_t info_priv;
\r
254 int model; /* V4L2_IDENT_OV* codes from v4l2-chip-ident.h */
\r
258 bool is_need_tasklock;
\r
259 atomic_t tasklock_cnt;
\r
260 struct soc_camera_ops *sensor_ops;
\r
261 struct v4l2_queryctrl* sensor_controls;
\r
262 struct sensor_v4l2ctrl_info_s *ctrls;
\r
263 struct rk_flash_timer flash_off_timer;
\r
264 struct sensor_ops_cb_s sensor_cb;
\r
265 struct rk_sensor_focus_op_s sensor_focus;
\r
266 struct rk29camera_platform_data *sensor_io_request;
\r
267 struct rk29camera_gpio_res *sensor_gpio_res;
\r
271 extern int generic_sensor_softreset(struct i2c_client *client, struct rk_sensor_reg *series);
\r
272 extern int generic_sensor_check_id(struct i2c_client *client, struct rk_sensor_reg *series);
\r
273 extern int sensor_write_reg2val1(struct i2c_client *client, u16 reg,u8 val);
\r
274 extern int sensor_write_reg2val2(struct i2c_client *client, u16 reg,u16 val);
\r
275 extern int sensor_write_reg1val1(struct i2c_client *client, u8 reg,u8 val);
\r
276 extern int sensor_write_reg1val2(struct i2c_client *client, u8 reg,u16 val);
\r
277 extern int sensor_read_reg1val1(struct i2c_client *client, u8 reg,u8* val);
\r
278 extern int sensor_read_reg2val1(struct i2c_client *client, u16 reg,u8* val);
\r
279 extern int sensor_read_reg1val2(struct i2c_client *client, u8 reg,u16* val);
\r
280 extern int sensor_read_reg2val2(struct i2c_client *client, u16 reg,u16* val);
\r
281 extern int generic_sensor_write(struct i2c_client *client,struct rk_sensor_reg* sensor_reg);
\r
282 extern int generic_sensor_read(struct i2c_client *client, struct rk_sensor_reg* sensor_reg);
\r
283 extern int generic_sensor_write_array(struct i2c_client *client, struct rk_sensor_reg *regarray);
\r
284 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
285 ,struct rk_sensor_seq_info * max_res,struct rk_sensor_seq_info *min_res);
\r
286 extern int generic_sensor_init(struct v4l2_subdev *sd, u32 val);
\r
287 extern int generic_sensor_enum_frameintervals(struct v4l2_subdev *sd, struct v4l2_frmivalenum *fival);
\r
288 extern int generic_sensor_try_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
289 extern int generic_sensor_ioctrl(struct soc_camera_device *icd,enum rk29sensor_power_cmd cmd, int on);
\r
290 extern unsigned long generic_sensor_query_bus_param(struct soc_camera_device *icd);
\r
291 extern int generic_sensor_g_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
292 extern int generic_sensor_set_bus_param(struct soc_camera_device *icd,unsigned long flags);
\r
293 extern int generic_sensor_g_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
\r
294 extern int generic_sensor_s_control(struct v4l2_subdev *sd, struct v4l2_control *ctrl);
\r
295 extern int generic_sensor_g_ext_control(struct soc_camera_device *icd , struct v4l2_ext_control *ext_ctrl);
\r
296 extern int generic_sensor_s_ext_control(struct soc_camera_device *icd, struct v4l2_ext_control *ext_ctrl);
\r
297 extern int generic_sensor_g_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl);
\r
298 extern int generic_sensor_s_ext_controls(struct v4l2_subdev *sd, struct v4l2_ext_controls *ext_ctrl);
\r
299 extern long generic_sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg);
\r
300 extern int generic_sensor_s_power(struct v4l2_subdev *sd, int on);/*yzm*/
\r
301 extern int generic_sensor_enum_fmt(struct v4l2_subdev *sd, unsigned int index,enum v4l2_mbus_pixelcode *code);
\r
302 extern int generic_sensor_s_fmt(struct v4l2_subdev *sd, struct v4l2_mbus_framefmt *mf);
\r
303 extern int generic_sensor_g_chip_ident(struct v4l2_subdev *sd, struct v4l2_dbg_chip_ident *id);
\r
304 extern int generic_sensor_af_workqueue_set(struct soc_camera_device *icd, enum rk_sensor_focus_wq_cmd cmd, int var, bool wait);
\r
305 extern int generic_sensor_s_stream(struct v4l2_subdev *sd, int enable);
\r
306 extern int generic_sensor_writebuf(struct i2c_client *client, char *buf, int buf_size);
\r
307 extern int generic_sensor_cropcap(struct v4l2_subdev *sd, struct v4l2_cropcap *cc);
\r
308 extern int generic_sensor_enum_framesizes(struct v4l2_subdev *sd, struct v4l2_frmsizeenum *fsize);
\r
310 static inline int sensor_get_full_width_height(int full_resolution, unsigned short *w, unsigned short *h)
\r
312 switch (full_resolution)
\r
375 static inline int sensor_video_probe(struct soc_camera_device *icd,
\r
376 struct i2c_client *client)
\r
380 struct generic_sensor *sensor = to_generic_sensor(client);
\r
382 /* We must have a parent by now. And it cannot be a wrong one.
\r
383 * So this entire test is completely redundant. */
\r
384 if (!icd->parent ||
\r
385 to_soc_camera_host(icd->parent)->nr != icd->iface) {
\r
387 goto sensor_video_probe_end;
\r
390 generic_sensor_softreset(client,sensor->info_priv.sensor_SfRstSeqe);
\r
391 ret = generic_sensor_check_id(client,sensor->info_priv.sensor_CkIdSeqe);
\r
393 sensor_video_probe_end:
\r
397 static inline int sensor_regarray_check(struct rk_sensor_reg *data, int reg_num)
\r
399 struct rk_sensor_reg *data_ptr;
\r
401 data_ptr = data+reg_num-1;
\r
402 if (data_ptr->reg == SEQCMD_END) {
\r
405 printk(KERN_ERR "%s(%d): data[%d].reg = 0x%x\n",__FUNCTION__,__LINE__,reg_num-1,data_ptr->reg);
\r
411 static inline void sensor_v4l2ctrl_info_init (struct sensor_v4l2ctrl_info_s *ptr,
\r
413 enum v4l2_ctrl_type type,
\r
419 int(*cb)(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
420 struct v4l2_ext_control *ext_ctrl,bool is_set),
\r
421 struct rk_sensor_reg ** sensor_seqe
\r
424 ptr->qctrl->id = id;
\r
425 ptr->qctrl->type = type;
\r
426 ptr->qctrl->minimum = min;
\r
427 ptr->qctrl->maximum = max;
\r
428 ptr->qctrl->step = step;
\r
429 ptr->qctrl->default_value = default_val;
\r
430 ptr->cur_value = default_val;
\r
432 ptr->sensor_Seqe = sensor_seqe;
\r
436 static inline struct sensor_v4l2ctrl_info_s* sensor_find_ctrl(
\r
437 struct sensor_v4l2ctrl_info_s *ops, int id)
\r
441 for (i = 0; i < ops[0].num_ctrls; i++)
\r
442 if (ops[i].qctrl->id == id)
\r
448 static inline void v4l2_querymenu_init (struct v4l2_querymenu *ptr,
\r
450 unsigned int index,
\r
452 unsigned int reserved)
\r
455 ptr->index = index;
\r
456 strcat(ptr->name,name);
\r
457 ptr->reserved = reserved;
\r
462 static inline int sensor_v4l2ctrl_replace_cb(struct generic_sensor *sensor, int id, void *cb)
\r
465 struct sensor_v4l2ctrl_info_s* ctrls;
\r
467 ctrls = sensor->ctrls;
\r
468 num = ctrls->num_ctrls;
\r
469 for (i=0; i<num; i++,ctrls++) {
\r
470 if (ctrls->qctrl->id == id) {
\r
477 printk(KERN_ERR "%s(%d): v4l2_control id(0x%x) isn't exist\n",__FUNCTION__,__LINE__,id);
\r
483 static inline int sensor_v4l2ctrl_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
484 struct v4l2_ext_control *ext_ctrl,bool is_set)
\r
486 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
487 int value = ext_ctrl->value;
\r
494 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
495 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
496 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
500 index = value - ctrl_info->qctrl->minimum;
\r
501 if (ctrl_info->sensor_Seqe && (ctrl_info->sensor_Seqe[index] != NULL)) {
\r
502 if (generic_sensor_write_array(client, ctrl_info->sensor_Seqe[index]) != 0) {
\r
503 printk(KERN_ERR "%s(%d): sensor write array sensor_Seqe failed\n",__FUNCTION__,__LINE__);
\r
507 ctrl_info->cur_value = value;
\r
510 printk(KERN_ERR "%s(%d): ctrl_info(id=0x%x)'s sensor_Seqe is invalidate\n",__FUNCTION__,__LINE__,ctrl_info->qctrl->id);
\r
514 static inline int sensor_v4l2ctrl_flash_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
515 struct v4l2_ext_control *ext_ctrl,bool is_set)
\r
517 //struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
518 int value = ext_ctrl->value;
\r
521 if(value == 0xfefe5a5a){
\r
522 if ((ctrl_info->cur_value == 2) || (ctrl_info->cur_value == 1)) {
\r
523 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_On);
\r
528 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
529 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
530 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
534 if (value == 3) { /* ddl@rock-chips.com: torch */
\r
535 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Torch); /* Flash On */
\r
537 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
\r
540 ctrl_info->cur_value = value; /* ddl@rock-chips.com : v0.1.3 */
\r
544 static inline int sensor_focus_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
545 struct v4l2_ext_control *ext_ctrl,bool is_set)
\r
547 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
548 int value = ext_ctrl->value;
\r
550 struct generic_sensor* sensor = to_generic_sensor(client);
\r
552 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
553 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
554 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
558 if(sensor->sensor_focus.focus_state == FocusState_Inval){
\r
559 printk(KERN_ERR "%s(%d): focus have not been init success yet\n",__FUNCTION__,__LINE__);
\r
562 switch (ext_ctrl->id)
\r
564 case V4L2_CID_FOCUS_ABSOLUTE:
\r
565 sensor->sensor_focus.focus_delay = WqCmd_af_special_pos;
\r
567 case V4L2_CID_FOCUS_RELATIVE:
\r
568 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
569 sensor->sensor_focus.focus_delay = WqCmd_af_near_pos;
\r
571 sensor->sensor_focus.focus_delay = WqCmd_af_far_pos;
\r
574 case V4L2_CID_FOCUS_AUTO:
\r
575 sensor->sensor_focus.focus_delay = WqCmd_af_single;
\r
577 case V4L2_CID_FOCUS_CONTINUOUS:
\r
578 sensor->sensor_focus.focus_delay = WqCmd_af_continues;
\r
581 printk(KERN_ERR "%s(%d):not support this focus mode",__FUNCTION__,__LINE__ );
\r
585 switch (ext_ctrl->id)
\r
587 case V4L2_CID_FOCUS_ABSOLUTE:
\r
589 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
590 //need do something?
\r
593 if (ctrl_info->cur_value != value) {
\r
594 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
595 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
596 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
597 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
599 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_special_pos, value, true);
\r
601 ctrl_info->cur_value = value;
\r
604 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
609 case V4L2_CID_FOCUS_RELATIVE:
\r
611 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
612 //need do something?
\r
615 if (ctrl_info->cur_value != value) {
\r
616 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
617 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
618 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
619 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
621 ctrl_info->cur_value = value;
\r
624 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
629 case V4L2_CID_FOCUS_AUTO:
\r
631 mutex_lock(&sensor->sensor_focus.focus_lock);
\r
633 sensor->sensor_focus.focus_zone.lx = ext_ctrl->rect[0];
\r
634 sensor->sensor_focus.focus_zone.ty = ext_ctrl->rect[1];
\r
635 sensor->sensor_focus.focus_zone.rx = ext_ctrl->rect[2];
\r
636 sensor->sensor_focus.focus_zone.dy = ext_ctrl->rect[3];
\r
637 mutex_unlock(&sensor->sensor_focus.focus_lock);
\r
639 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
640 //need do something?
\r
641 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
643 if((value==1) || (sensor->sensor_focus.focus_mode==V4L2_CID_FOCUS_AUTO)){
\r
644 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_update_zone, value, true);
\r
645 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_single, value, true);
\r
646 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_AUTO;
\r
647 }else if(value == 0){
\r
648 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
652 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
657 case V4L2_CID_FOCUS_CONTINUOUS:
\r
659 if((value==1) && (sensor->sensor_focus.focus_mode!=V4L2_CID_FOCUS_CONTINUOUS)){
\r
660 //have to close focus firstly?
\r
661 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
662 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_continues, value, true);
\r
664 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_CONTINUOUS;
\r
665 }else if(value ==0){
\r
666 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
670 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
679 static inline int sensor_face_detect_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
680 struct v4l2_ext_control *ext_ctrl,bool is_set)
\r
682 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
683 int value = ext_ctrl->value;
\r
685 struct generic_sensor* sensor = to_generic_sensor(client);
\r
686 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
687 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
688 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
691 if(ctrl_info->cur_value != value){
\r
692 if(sensor->sensor_cb.sensor_face_detect_cb)
\r
693 ret = (sensor->sensor_cb.sensor_face_detect_cb)(client,value);
\r
695 ctrl_info->cur_value = value;
\r
699 static int sensor_v4l2ctrl_mirror_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
700 struct v4l2_ext_control *ext_ctrl);
\r
701 static int sensor_v4l2ctrl_flip_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
702 struct v4l2_ext_control *ext_ctrl);
\r
704 static inline int sensor_v4l2ctrl_mirror_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
705 struct v4l2_ext_control *ext_ctrl,bool is_set){
\r
706 return sensor_v4l2ctrl_mirror_cb(icd,ctrl_info, ext_ctrl);
\r
710 static inline int sensor_v4l2ctrl_flip_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
711 struct v4l2_ext_control *ext_ctrl,bool is_set){
\r
712 return sensor_v4l2ctrl_flip_cb(icd,ctrl_info, ext_ctrl);
\r
717 #define new_user_v4l2ctrl(ctl_id,ctl_type,ctl_name,ctl_min,ctl_max,ctl_step,default_val,callback,seqe)\
\r
723 .minimum = ctl_min,\
\r
724 .maximum = ctl_max,\
\r
726 .default_value = default_val,\
\r
729 .sensor_Seqe = seqe,\
\r
733 #define new_usr_v4l2menu(menu_id,menu_idx,menu_name,menu_rev)\
\r
736 .index = menu_idx,\
\r
737 .name = menu_name,\
\r
738 .reserved = menu_rev,\
\r
741 #define sensor_init_parameters_default_code() static void sensor_init_parameters(struct specific_sensor* spsensor,struct soc_camera_device *icd)\
\r
744 struct rk_sensor_sequence *sensor_series; \
\r
745 struct v4l2_queryctrl *controls, *control; \
\r
746 struct sensor_v4l2ctrl_info_s *ctrls; \
\r
747 struct v4l2_querymenu *menus,*menu; \
\r
748 struct soc_camera_desc *desc = to_soc_camera_desc(icd);\
\r
749 struct rk29camera_platform_data *pdata = desc->subdev_desc.drv_priv; \
\r
750 struct rkcamera_platform_data *sensor_device=NULL,*new_camera; \
\r
751 struct rk_sensor_reg *reg_data; \
\r
752 int config_flash = 0;\
\r
753 int sensor_config;\
\r
754 struct soc_camera_ops* sensor_ops_p = NULL;\
\r
756 if (pdata == NULL) {\
\r
757 printk("WARNING: Camera sensor device is registered in board by CONFIG_SENSOR_XX,\n"\
\r
758 "Please register camera sesnor deivce in struct rkcamera_platform_data new_camera[]\n");\
\r
761 sensor_config = SensorConfiguration;\
\r
762 new_camera = pdata->register_dev_new; \
\r
763 while(new_camera != NULL){\
\r
764 if (strcmp(dev_name(icd->pdev), new_camera->dev_name) == 0) { \
\r
765 sensor_device = new_camera; \
\r
768 new_camera = new_camera->next_camera; \
\r
771 if(sensor_device && sensor_device->flash)\
\r
773 spsensor->common_sensor.info_priv.gReg_mask = 0x00; \
\r
774 spsensor->common_sensor.info_priv.gVal_mask = 0x00; \
\r
775 for (i=0; i<SENSOR_REGISTER_LEN; i++) \
\r
776 spsensor->common_sensor.info_priv.gReg_mask |= (0xff<<(i*8)); \
\r
777 for (i=0; i<SENSOR_VALUE_LEN; i++) \
\r
778 spsensor->common_sensor.info_priv.gVal_mask |= (0xff<<(i*8)); \
\r
779 spsensor->common_sensor.info_priv.gI2c_speed = 100000; \
\r
780 if (sensor_regarray_check(sensor_softreset_data, sizeof(sensor_softreset_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
781 spsensor->common_sensor.info_priv.sensor_SfRstSeqe = sensor_softreset_data; \
\r
783 SENSOR_TR("sensor_softreset_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_softreset_data"); \
\r
786 if (sensor_regarray_check(sensor_check_id_data, sizeof(sensor_check_id_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
787 spsensor->common_sensor.info_priv.sensor_CkIdSeqe= sensor_check_id_data; \
\r
789 SENSOR_TR("sensor_check_id_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_check_id_data"); \
\r
792 spsensor->common_sensor.sensor_cb.sensor_activate_cb = sensor_activate_cb; \
\r
793 spsensor->common_sensor.sensor_cb.sensor_deactivate_cb = sensor_deactivate_cb; \
\r
794 spsensor->common_sensor.sensor_cb.sensor_mirror_cb = sensor_mirror_cb; \
\r
795 spsensor->common_sensor.sensor_cb.sensor_flip_cb = sensor_flip_cb; \
\r
796 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_th = sensor_s_fmt_cb_th; \
\r
797 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_bh = sensor_s_fmt_cb_bh; \
\r
798 spsensor->common_sensor.sensor_cb.sensor_try_fmt_cb_th = sensor_try_fmt_cb_th;\
\r
799 spsensor->common_sensor.sensor_cb.sensor_softreset_cb = sensor_softrest_usr_cb;\
\r
800 spsensor->common_sensor.sensor_cb.sensor_check_id_cb = sensor_check_id_usr_cb;\
\r
801 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) \
\r
802 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = sensor_face_detect_usr_cb; \
\r
804 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = NULL; \
\r
807 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
810 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
814 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) \
\r
817 sensor_series = (struct rk_sensor_sequence*)kzalloc(sizeof(struct rk_sensor_sequence)*num,GFP_KERNEL); \
\r
818 if (sensor_series == NULL) { \
\r
819 SENSOR_TR("malloc sensor_series failed! n"); \
\r
822 spsensor->common_sensor.info_priv.sensor_series = sensor_series; \
\r
823 spsensor->common_sensor.info_priv.num_series = num; \
\r
824 spsensor->common_sensor.crop_percent = SENSOR_CROP_PERCENT;\
\r
826 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
827 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
828 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
829 sensor_series->property = SEQUENCE_INIT; \
\r
830 if (sensor_regarray_check(sensor_init_data, sizeof(sensor_init_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
831 sensor_series->data = sensor_init_data; \
\r
833 SENSOR_TR("sensor_init_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_int_data"); \
\r
838 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
839 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
840 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
841 sensor_series->property = SEQUENCE_PREVIEW; \
\r
842 if (sensor_regarray_check(sensor_preview_data, sizeof(sensor_preview_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
843 sensor_series->data = sensor_preview_data; \
\r
845 SENSOR_TR("sensor_preview_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_preview_data"); \
\r
850 if (sensor_get_full_width_height(CONS(SENSOR_NAME,_FULL_RESOLUTION),&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
851 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
852 sensor_series->property = SEQUENCE_CAPTURE; \
\r
853 if (sensor_regarray_check(sensor_fullres_lowfps_data, sizeof(sensor_fullres_lowfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
854 sensor_series->data = sensor_fullres_lowfps_data; \
\r
856 SENSOR_TR("sensor_fullres_lowfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_lowfps_data"); \
\r
860 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
865 sensor_series->gSeq_info.w = (sensor_series-1)->gSeq_info.w; \
\r
866 sensor_series->gSeq_info.h = (sensor_series-1)->gSeq_info.h; \
\r
867 sensor_series->gSeq_info.fps = SENSOR_FULLRES_H_FPS; \
\r
868 sensor_series->property = SEQUENCE_PREVIEW; \
\r
869 if (sensor_regarray_check(sensor_fullres_highfps_data, sizeof(sensor_fullres_highfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
870 sensor_series->data = sensor_fullres_highfps_data; \
\r
872 SENSOR_TR("sensor_fullres_highfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_highfps_data"); \
\r
876 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) { \
\r
878 if (sensor_get_full_width_height(sensor_device->resolution,&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
879 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
880 sensor_series->property = SEQUENCE_CAPTURE; \
\r
881 reg_data = kzalloc(sizeof(struct rk_sensor_reg)*2,GFP_KERNEL); \
\r
882 if (reg_data == NULL) { \
\r
883 SENSOR_TR("kzalloc interpolate reg_data failed"); \
\r
885 sensor_series->data = reg_data; \
\r
886 reg_data->reg = SEQCMD_INTERPOLATION; \
\r
888 reg_data->reg = SEQCMD_END; \
\r
891 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
896 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
898 sensor_series->gSeq_info.w = 1280; \
\r
899 sensor_series->gSeq_info.h = 720; \
\r
900 sensor_series->gSeq_info.fps = SENSOR_720P_FPS; \
\r
901 sensor_series->property = SEQUENCE_PREVIEW; \
\r
902 if (sensor_regarray_check(sensor_720p, sizeof(sensor_720p)/sizeof(struct rk_sensor_reg))==0) { \
\r
903 sensor_series->data = sensor_720p; \
\r
905 SENSOR_TR("sensor_720p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_720p"); \
\r
910 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
912 sensor_series->gSeq_info.w = 1920; \
\r
913 sensor_series->gSeq_info.h = 1080; \
\r
914 sensor_series->gSeq_info.fps = SENSOR_1080P_FPS; \
\r
915 sensor_series->property = SEQUENCE_PREVIEW; \
\r
916 if (sensor_regarray_check(sensor_1080p, sizeof(sensor_1080p)/sizeof(struct rk_sensor_reg))==0) { \
\r
917 sensor_series->data = sensor_1080p; \
\r
919 SENSOR_TR("sensor_1080p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_1080p"); \
\r
925 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
926 spsensor->common_sensor.sensor_focus.sensor_wq = create_workqueue(SENSOR_NAME_STRING(_af_workqueue)); \
\r
927 if (spsensor->common_sensor.sensor_focus.sensor_wq == NULL) {\
\r
928 SENSOR_TR("%s create fail, so auto focus is disable!", SENSOR_NAME_STRING(_af_workqueue));\
\r
929 CFG_FunDis(sensor_config,CFG_Focus);\
\r
930 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
931 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
932 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
933 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
936 spsensor->common_sensor.sensor_focus.sensor_wq = NULL;\
\r
937 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
938 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
939 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
940 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
943 spsensor->common_sensor.info_priv.bus_parameter = SENSOR_BUS_PARAM; \
\r
944 spsensor->common_sensor.info_priv.chip_ident = SENSOR_V4L2_IDENT; \
\r
945 spsensor->common_sensor.info_priv.chip_id = SensorChipID;\
\r
946 spsensor->common_sensor.info_priv.chip_id_num = sizeof(SensorChipID)/sizeof(SensorChipID[0]);\
\r
948 generic_sensor_get_max_min_res(spsensor->common_sensor.info_priv.sensor_series , \
\r
949 spsensor->common_sensor.info_priv.num_series, \
\r
950 &(spsensor->common_sensor.info_priv.max_real_res), \
\r
951 &(spsensor->common_sensor.info_priv.max_res), \
\r
952 &(spsensor->common_sensor.info_priv.min_res)); \
\r
955 for (i=0; i<32; i++)\
\r
956 if (SensorConfiguration & (1<<i))\
\r
958 num += sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s); \
\r
959 num += config_flash;\
\r
960 controls = (struct v4l2_queryctrl*)kzalloc(sizeof(struct v4l2_queryctrl)*num,GFP_KERNEL); \
\r
961 if (controls == NULL) { \
\r
962 SENSOR_TR("kzalloc struct v4l2_queryctrl(%d) failed",num); \
\r
965 spsensor->common_sensor.sensor_controls = controls; \
\r
966 sensor_ops_p = (struct soc_camera_ops*)kzalloc(sizeof(struct soc_camera_ops),GFP_KERNEL); \
\r
967 if (sensor_ops_p == NULL) { \
\r
968 SENSOR_TR("kzalloc struct soc_camera_ops failed"); \
\r
971 sensor_ops_p->controls = controls; \
\r
972 sensor_ops_p->num_controls = num; \
\r
974 ctrls = (struct sensor_v4l2ctrl_info_s*)kzalloc(sizeof(struct sensor_v4l2ctrl_info_s)*num,GFP_KERNEL); \
\r
975 if (ctrls == NULL) { \
\r
976 SENSOR_TR("kzalloc struct sensor_v4l2ctrl_info_s(%d) failed",num); \
\r
979 spsensor->common_sensor.ctrls = ctrls; \
\r
980 for (i=0; i<num; i++) { \
\r
981 ctrls->qctrl = controls; \
\r
982 ctrls->num_ctrls = num; \
\r
986 controls = spsensor->common_sensor.sensor_controls; \
\r
987 ctrls = spsensor->common_sensor.ctrls; \
\r
990 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
991 num += sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
992 menus = (struct v4l2_querymenu*)kzalloc(sizeof(struct v4l2_querymenu)*num,GFP_KERNEL); \
\r
993 if (menus == NULL) { \
\r
994 SENSOR_TR("kzalloc struct v4l2_querymenu(%d) failed",num); \
\r
997 sensor_ops_p->menus = menus; \
\r
998 sensor_ops_p->num_menus = num; \
\r
1000 sensor_ops_p->suspend = sensor_suspend; \
\r
1001 sensor_ops_p->resume = sensor_resume; \
\r
1002 sensor_ops_p->set_bus_param = generic_sensor_set_bus_param; \
\r
1003 sensor_ops_p->query_bus_param = generic_sensor_query_bus_param; \
\r
1005 if (sizeof(sensor_ZoomSeqe)/sizeof(struct rk_sensor_reg *))\
\r
1006 sensor_ZoomSeqe[0] = NULL;\
\r
1008 if (CFG_FunChk(sensor_config,CFG_WhiteBalance)) { \
\r
1009 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_DO_WHITE_BALANCE,V4L2_CTRL_TYPE_MENU, \
\r
1010 "White Balance Control",0,4,1,0,sensor_v4l2ctrl_default_cb,sensor_WhiteBalanceSeqe); \
\r
1014 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,0,"auto",0); \
\r
1016 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,1,"incandescent",0); \
\r
1018 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,2,"fluorescent",0); \
\r
1020 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,3,"daylight",0); \
\r
1022 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,4,"cloudy-daylight",0); \
\r
1026 if (CFG_FunChk(sensor_config,CFG_Brightness)) { \
\r
1027 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_BRIGHTNESS,V4L2_CTRL_TYPE_INTEGER, \
\r
1028 "Brightness Control",-3,2,1,0,sensor_v4l2ctrl_default_cb,sensor_BrightnessSeqe); \
\r
1032 if (CFG_FunChk(sensor_config,CFG_Effect)) { \
\r
1033 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EFFECT,V4L2_CTRL_TYPE_MENU, \
\r
1034 "Effect Control",0,5,1,0,sensor_v4l2ctrl_default_cb,sensor_EffectSeqe); \
\r
1038 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,0,"none",0); \
\r
1040 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,1,"mono",0); \
\r
1042 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,2,"negative",0); \
\r
1044 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,3,"sepia",0); \
\r
1046 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,4,"posterize",0); \
\r
1048 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,5,"aqua",0); \
\r
1051 if (CFG_FunChk(sensor_config,CFG_Exposure)) { \
\r
1052 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EXPOSURE,V4L2_CTRL_TYPE_INTEGER, \
\r
1053 "Exposure Control",0,6,1,0,sensor_v4l2ctrl_default_cb,sensor_ExposureSeqe); \
\r
1057 if (CFG_FunChk(sensor_config,CFG_Saturation)) { \
\r
1058 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SATURATION,V4L2_CTRL_TYPE_INTEGER, \
\r
1059 "Saturation Control",0,2,1,0,sensor_v4l2ctrl_default_cb,sensor_SaturationSeqe); \
\r
1063 if (CFG_FunChk(sensor_config,CFG_Contrast)) { \
\r
1064 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_CONTRAST,V4L2_CTRL_TYPE_INTEGER, \
\r
1065 "Contrast Control",-3,3,1,0,sensor_v4l2ctrl_default_cb,sensor_ContrastSeqe); \
\r
1069 if (CFG_FunChk(sensor_config,CFG_Mirror)) { \
\r
1070 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_HFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1071 "Mirror Control",0,1,1,0,sensor_v4l2ctrl_mirror_default_cb,NULL); \
\r
1075 if (CFG_FunChk(sensor_config,CFG_Flip)) { \
\r
1076 ctrls->qctrl = controls; \
\r
1077 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_VFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1078 "Flip Control",0,1,1,0,sensor_v4l2ctrl_flip_default_cb,NULL); \
\r
1082 if (CFG_FunChk(sensor_config,CFG_Scene)) { \
\r
1083 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SCENE,V4L2_CTRL_TYPE_MENU, \
\r
1084 "Scene Control",0,1,1,0,sensor_v4l2ctrl_default_cb,sensor_SceneSeqe); \
\r
1088 v4l2_querymenu_init(menus,V4L2_CID_SCENE,0,"auto",0); \
\r
1090 v4l2_querymenu_init(menus,V4L2_CID_SCENE,1,"night",0); \
\r
1093 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1094 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_AUTO,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1095 "Focus Control",0,2,1,0,sensor_focus_default_cb,NULL); \
\r
1100 if (CFG_FunChk(sensor_config,CFG_FocusRelative)) { \
\r
1101 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_RELATIVE,V4L2_CTRL_TYPE_INTEGER, \
\r
1102 "Focus Control",-1,1,1,0,sensor_focus_default_cb,NULL); \
\r
1107 if (CFG_FunChk(sensor_config,CFG_FocusAbsolute)) { \
\r
1108 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_ABSOLUTE,V4L2_CTRL_TYPE_INTEGER, \
\r
1109 "Focus Control",0,255,1,125,sensor_focus_default_cb,NULL); \
\r
1113 if (CFG_FunChk(sensor_config,CFG_FocusZone)) { \
\r
1114 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUSZONE,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1115 "Focus Control",0,1,1,0,NULL,NULL); \
\r
1119 if (CFG_FunChk(sensor_config,CFG_FocusContinues)) { \
\r
1120 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_CONTINUOUS,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1121 "Focus Control",0,1,1,0,sensor_focus_default_cb,NULL); \
\r
1125 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) { \
\r
1126 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FACEDETECT,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1127 "FaceDEt Control",0,1,1,0,sensor_face_detect_default_cb,NULL); \
\r
1131 if (config_flash) { \
\r
1132 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FLASH,V4L2_CTRL_TYPE_MENU, \
\r
1133 "Flash Control",0,3,1,0,sensor_v4l2ctrl_flash_cb,NULL); \
\r
1137 v4l2_querymenu_init(menus,V4L2_CID_FLASH,0,"off",0); \
\r
1139 v4l2_querymenu_init(menus,V4L2_CID_FLASH,1,"auto",0); \
\r
1141 v4l2_querymenu_init(menus,V4L2_CID_FLASH,2,"on",0); \
\r
1143 v4l2_querymenu_init(menus,V4L2_CID_FLASH,3,"torch",0); \
\r
1147 for (i=0; i<(sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s)); i++) { \
\r
1149 control = spsensor->common_sensor.sensor_controls; \
\r
1150 while (control < controls) \
\r
1152 if (control->id == sensor_controls[i].qctrl.id) { \
\r
1153 control->id = 0xffffffff; \
\r
1158 memcpy(controls, &sensor_controls[i].qctrl,sizeof(struct v4l2_queryctrl)); \
\r
1161 ctrls->sensor_Seqe = sensor_controls[i].sensor_Seqe; \
\r
1162 ctrls->cur_value = sensor_controls[i].qctrl.default_value; \
\r
1163 ctrls->cb = sensor_controls[i].cb; \
\r
1167 for (i=0; i<(sizeof(sensor_menus)/sizeof(struct v4l2_querymenu)); i++) { \
\r
1168 num = sensor_ops_p->num_menus - sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
1169 menu = sensor_ops_p->menus; \
\r
1171 if (menu->id == sensor_menus[i].id) { \
\r
1172 menu->id = 0xffffffff; \
\r
1177 memcpy(menus, &sensor_menus[i],sizeof(struct v4l2_querymenu)); \
\r
1181 spsensor->common_sensor.info_priv.datafmt = sensor_colour_fmts; \
\r
1182 spsensor->common_sensor.info_priv.num_datafmt = ARRAY_SIZE(sensor_colour_fmts); \
\r
1183 spsensor->common_sensor.sensor_ops = sensor_ops_p; \
\r
1184 icd->ops = sensor_ops_p; \
\r
1185 spsensor->common_sensor.info_priv.curfmt= sensor_colour_fmts[0]; \
\r
1187 if (config_flash) { \
\r
1188 hrtimer_init(&(spsensor->common_sensor.flash_off_timer.timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL); \
\r
1189 spsensor->common_sensor.flash_off_timer.icd = icd; \
\r
1191 if(CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1192 mutex_init(&spsensor->common_sensor.sensor_focus.focus_lock); \
\r
1193 spsensor->common_sensor.sensor_focus.focus_mode = WqCmd_af_invalid; \
\r
1194 spsensor->common_sensor.sensor_focus.focus_state = FocusState_Inval;\
\r
1195 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = sensor_focus_init_usr_cb; \
\r
1196 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = sensor_focus_af_single_usr_cb; \
\r
1197 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = sensor_focus_af_near_usr_cb; \
\r
1198 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb = sensor_focus_af_far_usr_cb; \
\r
1199 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb = sensor_focus_af_specialpos_usr_cb; \
\r
1200 if(CFG_FunChk(sensor_config,CFG_FocusContinues)) {\
\r
1201 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb = sensor_focus_af_const_usr_cb; \
\r
1202 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_pause_cb = sensor_focus_af_const_pause_usr_cb; \
\r
1204 if(CFG_FunChk(sensor_config,CFG_FocusZone)) \
\r
1205 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb = sensor_focus_af_zoneupdate_usr_cb; \
\r
1206 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb = sensor_focus_af_close_usr_cb; \
\r
1208 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = NULL; \
\r
1209 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = NULL; \
\r
1210 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = NULL; \
\r
1211 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb =NULL; \
\r
1212 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb =NULL; \
\r
1213 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb =NULL; \
\r
1214 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb =NULL; \
\r
1215 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb =NULL; \
\r
1218 memcpy(spsensor->common_sensor.dev_name,dev_name(icd->pdev), sizeof(spsensor->common_sensor.dev_name)-1); \
\r
1219 sensor_init_parameters_user(spsensor,icd); \
\r
1223 #define sensor_v4l2_struct_initialization() static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {\
\r
1224 .init = generic_sensor_init,\
\r
1225 .g_ctrl = generic_sensor_g_control,\
\r
1226 .s_ctrl = generic_sensor_s_control,\
\r
1227 .g_ext_ctrls = generic_sensor_g_ext_controls,\
\r
1228 .s_ext_ctrls = generic_sensor_s_ext_controls,\
\r
1229 .g_chip_ident = generic_sensor_g_chip_ident,\
\r
1230 .ioctl = generic_sensor_ioctl,\
\r
1231 .s_power = generic_sensor_s_power,\
\r
1234 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {\
\r
1235 .s_mbus_fmt = generic_sensor_s_fmt,\
\r
1236 .g_mbus_fmt = generic_sensor_g_fmt,\
\r
1237 .cropcap = generic_sensor_cropcap,\
\r
1238 .try_mbus_fmt = generic_sensor_try_fmt,\
\r
1239 .enum_mbus_fmt = generic_sensor_enum_fmt,\
\r
1240 .enum_frameintervals = generic_sensor_enum_frameintervals,\
\r
1241 .s_stream = generic_sensor_s_stream,\
\r
1242 .enum_framesizes = generic_sensor_enum_framesizes,\
\r
1244 static struct v4l2_subdev_ops sensor_subdev_ops = {\
\r
1245 .core = &sensor_subdev_core_ops,\
\r
1246 .video = &sensor_subdev_video_ops,\
\r
1249 static const struct i2c_device_id sensor_id[] = {\
\r
1250 {SENSOR_NAME_STRING(), 0 },\
\r
1254 MODULE_DEVICE_TABLE(i2c, sensor_id);
\r
1257 #define sensor_probe_default_code() static int sensor_probe(struct i2c_client *client,\
\r
1258 const struct i2c_device_id *did)\
\r
1260 struct specific_sensor *spsensor=NULL;\
\r
1261 struct soc_camera_subdev_desc *ssdd = client->dev.platform_data;\
\r
1262 struct soc_camera_desc *desc = container_of(ssdd,struct soc_camera_desc,subdev_desc);\
\r
1263 struct soc_camera_device *icd = ssdd->socdev;\
\r
1264 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);\
\r
1269 dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\
\r
1271 goto sensor_probe_end;\
\r
1274 desc = to_soc_camera_desc(icd);\
\r
1276 SENSOR_TR("driver needs platform data! But it is failed\n");\
\r
1278 goto sensor_probe_end;\
\r
1281 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\
\r
1282 SENSOR_TR("I2C-Adapter doesn't support I2C_FUNC_I2C\n");\
\r
1284 goto sensor_probe_end;\
\r
1287 spsensor = kzalloc(sizeof(struct specific_sensor), GFP_KERNEL);\
\r
1290 SENSOR_TR("kzalloc failed\n");\
\r
1291 goto sensor_probe_end;\
\r
1294 v4l2_i2c_subdev_init(&spsensor->common_sensor.subdev, client, &sensor_subdev_ops);\
\r
1295 sensor_init_parameters(spsensor,icd);\
\r
1297 ret = sensor_video_probe(icd, client);\
\r
1299 sensor_probe_end:\
\r
1302 if (icd->ops->controls) {\
\r
1303 kfree(icd->ops->controls);\
\r
1304 icd->ops->controls = NULL;\
\r
1306 if (icd->ops->menus) {\
\r
1307 kfree(icd->ops->menus);\
\r
1308 icd->ops->menus = NULL;\
\r
1313 i2c_set_clientdata(client, NULL);\
\r
1314 client->driver = NULL;\
\r
1323 #define sensor_remove_default_code() static int sensor_remove(struct i2c_client *client)\
\r
1325 struct generic_sensor*sensor = to_generic_sensor(client);\
\r
1326 struct soc_camera_subdev_desc *ssdd = client->dev.platform_data;\
\r
1327 struct soc_camera_device *icd = ssdd->socdev;\
\r
1328 struct specific_sensor *spsensor = to_specific_sensor(sensor);\
\r
1329 int sensor_config;\
\r
1331 sensor_config = SensorConfiguration;\
\r
1332 if(CFG_FunChk(sensor_config,CFG_Focus)){ \
\r
1333 if (sensor->sensor_focus.sensor_wq) {\
\r
1334 destroy_workqueue(sensor->sensor_focus.sensor_wq);\
\r
1335 sensor->sensor_focus.sensor_wq = NULL;\
\r
1339 if (icd->ops->controls) {\
\r
1340 kfree(icd->ops->controls);\
\r
1341 icd->ops->controls = NULL;\
\r
1343 if (icd->ops->menus) {\
\r
1344 kfree(icd->ops->menus);\
\r
1345 icd->ops->menus = NULL;\
\r
1350 i2c_set_clientdata(client, NULL);\
\r
1351 client->driver = NULL;\
\r
1360 #define sensor_driver_default_module_code() static struct i2c_driver sensor_i2c_driver = {\
\r
1362 .name = SENSOR_NAME_STRING(),\
\r
1364 .probe = sensor_probe,\
\r
1365 .remove = sensor_remove,\
\r
1366 .id_table = sensor_id,\
\r
1369 static int __init sensor_mod_init(void)\
\r
1371 return i2c_add_driver(&sensor_i2c_driver);\
\r
1374 static void __exit sensor_mod_exit(void)\
\r
1376 i2c_del_driver(&sensor_i2c_driver);\
\r
1379 device_initcall_sync(sensor_mod_init);\
\r
1380 module_exit(sensor_mod_exit);\
\r
1381 MODULE_DESCRIPTION(SENSOR_NAME_STRING(sensor driver)); \
\r
1382 MODULE_AUTHOR("<ddl@rock-chips.com,zyc@rock-chips.com>");\
\r
1384 MODULE_LICENSE("GPL");
\r