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"//yzm
\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
520 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
521 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
522 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
526 if (value == 3) { /* ddl@rock-chips.com: torch */
\r
527 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Torch); /* Flash On */
\r
529 generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Off);
\r
532 ctrl_info->cur_value = value; /* ddl@rock-chips.com : v0.1.3 */
\r
536 static inline int sensor_focus_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
537 struct v4l2_ext_control *ext_ctrl,bool is_set)
\r
539 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
540 int value = ext_ctrl->value;
\r
542 struct generic_sensor* sensor = to_generic_sensor(client);
\r
544 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
545 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
546 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
550 if(sensor->sensor_focus.focus_state == FocusState_Inval){
\r
551 printk(KERN_ERR "%s(%d): focus have not been init success yet\n",__FUNCTION__,__LINE__);
\r
554 switch (ext_ctrl->id)
\r
556 case V4L2_CID_FOCUS_ABSOLUTE:
\r
557 sensor->sensor_focus.focus_delay = WqCmd_af_special_pos;
\r
559 case V4L2_CID_FOCUS_RELATIVE:
\r
560 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
561 sensor->sensor_focus.focus_delay = WqCmd_af_near_pos;
\r
563 sensor->sensor_focus.focus_delay = WqCmd_af_far_pos;
\r
566 case V4L2_CID_FOCUS_AUTO:
\r
567 sensor->sensor_focus.focus_delay = WqCmd_af_single;
\r
569 case V4L2_CID_FOCUS_CONTINUOUS:
\r
570 sensor->sensor_focus.focus_delay = WqCmd_af_continues;
\r
573 printk(KERN_ERR "%s(%d):not support this focus mode",__FUNCTION__,__LINE__ );
\r
577 switch (ext_ctrl->id)
\r
579 case V4L2_CID_FOCUS_ABSOLUTE:
\r
581 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
582 //need do something?
\r
585 if (ctrl_info->cur_value != value) {
\r
586 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
587 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
588 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
589 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
591 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_special_pos, value, true);
\r
593 ctrl_info->cur_value = value;
\r
596 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
601 case V4L2_CID_FOCUS_RELATIVE:
\r
603 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
604 //need do something?
\r
607 if (ctrl_info->cur_value != value) {
\r
608 if (ext_ctrl->value == ctrl_info->qctrl->minimum)
\r
609 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_near_pos, value, true);
\r
610 else if(ext_ctrl->value == ctrl_info->qctrl->maximum)
\r
611 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_far_pos, value, true);
\r
613 ctrl_info->cur_value = value;
\r
616 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
621 case V4L2_CID_FOCUS_AUTO:
\r
623 /****************yzm**************
\r
624 mutex_lock(&sensor->sensor_focus.focus_lock);
\r
626 sensor->sensor_focus.focus_zone.lx = ext_ctrl->rect[0];
\r
627 sensor->sensor_focus.focus_zone.ty = ext_ctrl->rect[1];
\r
628 sensor->sensor_focus.focus_zone.rx = ext_ctrl->rect[2];
\r
629 sensor->sensor_focus.focus_zone.dy = ext_ctrl->rect[3];
\r
630 mutex_unlock(&sensor->sensor_focus.focus_lock);
\r
632 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){
\r
633 //need do something?
\r
634 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
636 if((value==1) || (sensor->sensor_focus.focus_mode==V4L2_CID_FOCUS_AUTO)){
\r
637 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_update_zone, value, true);
\r
638 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_single, value, true);
\r
639 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_AUTO;
\r
640 }else if(value == 0){
\r
641 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
645 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
647 *///*******************yzm*************end
\r
651 case V4L2_CID_FOCUS_CONTINUOUS:
\r
653 if((value==1) && (sensor->sensor_focus.focus_mode!=V4L2_CID_FOCUS_CONTINUOUS)){
\r
654 //have to close focus firstly?
\r
655 //generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
656 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_continues, value, true);
\r
658 sensor->sensor_focus.focus_mode = V4L2_CID_FOCUS_CONTINUOUS;
\r
659 }else if(value ==0){
\r
660 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_close, value, true);
\r
664 printk(KERN_ERR"\n %s valure = %d is invalidate.. \n",__FUNCTION__,value);
\r
673 static inline int sensor_face_detect_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
674 struct v4l2_ext_control *ext_ctrl,bool is_set)
\r
676 struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));
\r
677 int value = ext_ctrl->value;
\r
679 struct generic_sensor* sensor = to_generic_sensor(client);
\r
680 if ((value < ctrl_info->qctrl->minimum) || (value > ctrl_info->qctrl->maximum)) {
\r
681 printk(KERN_ERR "%s(%d): value(0x%x) isn't between in (0x%x,0x%x)\n",__FUNCTION__,__LINE__,value,
\r
682 ctrl_info->qctrl->minimum,ctrl_info->qctrl->maximum);
\r
685 if(ctrl_info->cur_value != value){
\r
686 if(sensor->sensor_cb.sensor_face_detect_cb)
\r
687 ret = (sensor->sensor_cb.sensor_face_detect_cb)(client,value);
\r
689 ctrl_info->cur_value = value;
\r
693 static int sensor_v4l2ctrl_mirror_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
694 struct v4l2_ext_control *ext_ctrl);
\r
695 static int sensor_v4l2ctrl_flip_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
696 struct v4l2_ext_control *ext_ctrl);
\r
698 static inline int sensor_v4l2ctrl_mirror_default_cb(struct soc_camera_device *icd, struct sensor_v4l2ctrl_info_s *ctrl_info,
\r
699 struct v4l2_ext_control *ext_ctrl,bool is_set){
\r
700 return sensor_v4l2ctrl_mirror_cb(icd,ctrl_info, ext_ctrl);
\r
704 static inline int sensor_v4l2ctrl_flip_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_flip_cb(icd,ctrl_info, ext_ctrl);
\r
711 #define new_user_v4l2ctrl(ctl_id,ctl_type,ctl_name,ctl_min,ctl_max,ctl_step,default_val,callback,seqe)\
\r
717 .minimum = ctl_min,\
\r
718 .maximum = ctl_max,\
\r
720 .default_value = default_val,\
\r
723 .sensor_Seqe = seqe,\
\r
727 #define new_usr_v4l2menu(menu_id,menu_idx,menu_name,menu_rev)\
\r
730 .index = menu_idx,\
\r
731 .name = menu_name,\
\r
732 .reserved = menu_rev,\
\r
735 #define sensor_init_parameters_default_code() static void sensor_init_parameters(struct specific_sensor* spsensor,struct soc_camera_device *icd)\
\r
738 struct rk_sensor_sequence *sensor_series; \
\r
739 struct v4l2_queryctrl *controls, *control; \
\r
740 struct sensor_v4l2ctrl_info_s *ctrls; \
\r
741 struct v4l2_querymenu *menus,*menu; \
\r
742 struct soc_camera_desc *desc = to_soc_camera_desc(icd);\
\r
743 struct rk29camera_platform_data *pdata = desc->subdev_desc.drv_priv; \
\r
744 struct rkcamera_platform_data *sensor_device=NULL,*new_camera; \
\r
745 struct rk_sensor_reg *reg_data; \
\r
746 int config_flash = 0;\
\r
747 int sensor_config;\
\r
748 struct soc_camera_ops* sensor_ops_p = NULL;\
\r
750 if (pdata == NULL) {\
\r
751 printk("WARNING: Camera sensor device is registered in board by CONFIG_SENSOR_XX,\n"\
\r
752 "Please register camera sesnor deivce in struct rkcamera_platform_data new_camera[]\n");\
\r
755 sensor_config = SensorConfiguration;\
\r
756 new_camera = pdata->register_dev_new; \
\r
757 while(new_camera != NULL){\
\r
758 if (strcmp(dev_name(icd->pdev), new_camera->dev_name) == 0) { \
\r
759 sensor_device = new_camera; \
\r
762 new_camera = new_camera->next_camera; \
\r
765 if(sensor_device && sensor_device->flash)\
\r
767 spsensor->common_sensor.info_priv.gReg_mask = 0x00; \
\r
768 spsensor->common_sensor.info_priv.gVal_mask = 0x00; \
\r
769 for (i=0; i<SENSOR_REGISTER_LEN; i++) \
\r
770 spsensor->common_sensor.info_priv.gReg_mask |= (0xff<<(i*8)); \
\r
771 for (i=0; i<SENSOR_VALUE_LEN; i++) \
\r
772 spsensor->common_sensor.info_priv.gVal_mask |= (0xff<<(i*8)); \
\r
773 spsensor->common_sensor.info_priv.gI2c_speed = 100000; \
\r
774 if (sensor_regarray_check(sensor_softreset_data, sizeof(sensor_softreset_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
775 spsensor->common_sensor.info_priv.sensor_SfRstSeqe = sensor_softreset_data; \
\r
777 SENSOR_TR("sensor_softreset_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_softreset_data"); \
\r
780 if (sensor_regarray_check(sensor_check_id_data, sizeof(sensor_check_id_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
781 spsensor->common_sensor.info_priv.sensor_CkIdSeqe= sensor_check_id_data; \
\r
783 SENSOR_TR("sensor_check_id_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_check_id_data"); \
\r
786 spsensor->common_sensor.sensor_cb.sensor_activate_cb = sensor_activate_cb; \
\r
787 spsensor->common_sensor.sensor_cb.sensor_deactivate_cb = sensor_deactivate_cb; \
\r
788 spsensor->common_sensor.sensor_cb.sensor_mirror_cb = sensor_mirror_cb; \
\r
789 spsensor->common_sensor.sensor_cb.sensor_flip_cb = sensor_flip_cb; \
\r
790 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_th = sensor_s_fmt_cb_th; \
\r
791 spsensor->common_sensor.sensor_cb.sensor_s_fmt_cb_bh = sensor_s_fmt_cb_bh; \
\r
792 spsensor->common_sensor.sensor_cb.sensor_try_fmt_cb_th = sensor_try_fmt_cb_th;\
\r
793 spsensor->common_sensor.sensor_cb.sensor_softreset_cb = sensor_softrest_usr_cb;\
\r
794 spsensor->common_sensor.sensor_cb.sensor_check_id_cb = sensor_check_id_usr_cb;\
\r
795 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) \
\r
796 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = sensor_face_detect_usr_cb; \
\r
798 spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = NULL; \
\r
801 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
804 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
808 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) \
\r
811 sensor_series = (struct rk_sensor_sequence*)kzalloc(sizeof(struct rk_sensor_sequence)*num,GFP_KERNEL); \
\r
812 if (sensor_series == NULL) { \
\r
813 SENSOR_TR("malloc sensor_series failed! n"); \
\r
816 spsensor->common_sensor.info_priv.sensor_series = sensor_series; \
\r
817 spsensor->common_sensor.info_priv.num_series = num; \
\r
818 spsensor->common_sensor.crop_percent = SENSOR_CROP_PERCENT;\
\r
820 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
821 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
822 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
823 sensor_series->property = SEQUENCE_INIT; \
\r
824 if (sensor_regarray_check(sensor_init_data, sizeof(sensor_init_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
825 sensor_series->data = sensor_init_data; \
\r
827 SENSOR_TR("sensor_init_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_int_data"); \
\r
832 sensor_series->gSeq_info.w = SENSOR_PREVIEW_W; \
\r
833 sensor_series->gSeq_info.h = SENSOR_PREVIEW_H; \
\r
834 sensor_series->gSeq_info.fps = SENSOR_PREVIEW_FPS; \
\r
835 sensor_series->property = SEQUENCE_PREVIEW; \
\r
836 if (sensor_regarray_check(sensor_preview_data, sizeof(sensor_preview_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
837 sensor_series->data = sensor_preview_data; \
\r
839 SENSOR_TR("sensor_preview_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_preview_data"); \
\r
844 if (sensor_get_full_width_height(CONS(SENSOR_NAME,_FULL_RESOLUTION),&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
845 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
846 sensor_series->property = SEQUENCE_CAPTURE; \
\r
847 if (sensor_regarray_check(sensor_fullres_lowfps_data, sizeof(sensor_fullres_lowfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
848 sensor_series->data = sensor_fullres_lowfps_data; \
\r
850 SENSOR_TR("sensor_fullres_lowfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_lowfps_data"); \
\r
854 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
859 sensor_series->gSeq_info.w = (sensor_series-1)->gSeq_info.w; \
\r
860 sensor_series->gSeq_info.h = (sensor_series-1)->gSeq_info.h; \
\r
861 sensor_series->gSeq_info.fps = SENSOR_FULLRES_H_FPS; \
\r
862 sensor_series->property = SEQUENCE_PREVIEW; \
\r
863 if (sensor_regarray_check(sensor_fullres_highfps_data, sizeof(sensor_fullres_highfps_data)/sizeof(struct rk_sensor_reg))==0) { \
\r
864 sensor_series->data = sensor_fullres_highfps_data; \
\r
866 SENSOR_TR("sensor_fullres_highfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_highfps_data"); \
\r
870 if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) { \
\r
872 if (sensor_get_full_width_height(sensor_device->resolution,&sensor_series->gSeq_info.w,&sensor_series->gSeq_info.h) == 0) { \
\r
873 sensor_series->gSeq_info.fps = SENSOR_FULLRES_L_FPS; \
\r
874 sensor_series->property = SEQUENCE_CAPTURE; \
\r
875 reg_data = kzalloc(sizeof(struct rk_sensor_reg)*2,GFP_KERNEL); \
\r
876 if (reg_data == NULL) { \
\r
877 SENSOR_TR("kzalloc interpolate reg_data failed"); \
\r
879 sensor_series->data = reg_data; \
\r
880 reg_data->reg = SEQCMD_INTERPOLATION; \
\r
882 reg_data->reg = SEQCMD_END; \
\r
885 SENSOR_TR("generic_sensor_get_width_height failed!"); \
\r
890 if (sensor_720p[0].reg != SEQCMD_END) { \
\r
892 sensor_series->gSeq_info.w = 1280; \
\r
893 sensor_series->gSeq_info.h = 720; \
\r
894 sensor_series->gSeq_info.fps = SENSOR_720P_FPS; \
\r
895 sensor_series->property = SEQUENCE_PREVIEW; \
\r
896 if (sensor_regarray_check(sensor_720p, sizeof(sensor_720p)/sizeof(struct rk_sensor_reg))==0) { \
\r
897 sensor_series->data = sensor_720p; \
\r
899 SENSOR_TR("sensor_720p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_720p"); \
\r
904 if (sensor_1080p[0].reg != SEQCMD_END) { \
\r
906 sensor_series->gSeq_info.w = 1920; \
\r
907 sensor_series->gSeq_info.h = 1080; \
\r
908 sensor_series->gSeq_info.fps = SENSOR_1080P_FPS; \
\r
909 sensor_series->property = SEQUENCE_PREVIEW; \
\r
910 if (sensor_regarray_check(sensor_1080p, sizeof(sensor_1080p)/sizeof(struct rk_sensor_reg))==0) { \
\r
911 sensor_series->data = sensor_1080p; \
\r
913 SENSOR_TR("sensor_1080p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_1080p"); \
\r
919 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
920 spsensor->common_sensor.sensor_focus.sensor_wq = create_workqueue(SENSOR_NAME_STRING(_af_workqueue)); \
\r
921 if (spsensor->common_sensor.sensor_focus.sensor_wq == NULL) {\
\r
922 SENSOR_TR("%s create fail, so auto focus is disable!", SENSOR_NAME_STRING(_af_workqueue));\
\r
923 CFG_FunDis(sensor_config,CFG_Focus);\
\r
924 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
925 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
926 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
927 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
930 spsensor->common_sensor.sensor_focus.sensor_wq = NULL;\
\r
931 CFG_FunDis(sensor_config,CFG_FocusContinues);\
\r
932 CFG_FunDis(sensor_config,CFG_FocusZone);\
\r
933 CFG_FunDis(sensor_config,CFG_FocusRelative);\
\r
934 CFG_FunDis(sensor_config,CFG_FocusAbsolute);\
\r
937 spsensor->common_sensor.info_priv.bus_parameter = SENSOR_BUS_PARAM; \
\r
938 spsensor->common_sensor.info_priv.chip_ident = SENSOR_V4L2_IDENT; \
\r
939 spsensor->common_sensor.info_priv.chip_id = SensorChipID;\
\r
940 spsensor->common_sensor.info_priv.chip_id_num = sizeof(SensorChipID)/sizeof(SensorChipID[0]);\
\r
942 generic_sensor_get_max_min_res(spsensor->common_sensor.info_priv.sensor_series , \
\r
943 spsensor->common_sensor.info_priv.num_series, \
\r
944 &(spsensor->common_sensor.info_priv.max_real_res), \
\r
945 &(spsensor->common_sensor.info_priv.max_res), \
\r
946 &(spsensor->common_sensor.info_priv.min_res)); \
\r
949 for (i=0; i<32; i++)\
\r
950 if (SensorConfiguration & (1<<i))\
\r
952 num += sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s); \
\r
953 num += config_flash;\
\r
954 controls = (struct v4l2_queryctrl*)kzalloc(sizeof(struct v4l2_queryctrl)*num,GFP_KERNEL); \
\r
955 if (controls == NULL) { \
\r
956 SENSOR_TR("kzalloc struct v4l2_queryctrl(%d) failed",num); \
\r
959 spsensor->common_sensor.sensor_controls = controls; \
\r
960 sensor_ops_p = (struct soc_camera_ops*)kzalloc(sizeof(struct soc_camera_ops),GFP_KERNEL); \
\r
961 if (sensor_ops_p == NULL) { \
\r
962 SENSOR_TR("kzalloc struct soc_camera_ops failed"); \
\r
965 sensor_ops_p->controls = controls; \
\r
966 sensor_ops_p->num_controls = num; \
\r
968 ctrls = (struct sensor_v4l2ctrl_info_s*)kzalloc(sizeof(struct sensor_v4l2ctrl_info_s)*num,GFP_KERNEL); \
\r
969 if (ctrls == NULL) { \
\r
970 SENSOR_TR("kzalloc struct sensor_v4l2ctrl_info_s(%d) failed",num); \
\r
973 spsensor->common_sensor.ctrls = ctrls; \
\r
974 for (i=0; i<num; i++) { \
\r
975 ctrls->qctrl = controls; \
\r
976 ctrls->num_ctrls = num; \
\r
980 controls = spsensor->common_sensor.sensor_controls; \
\r
981 ctrls = spsensor->common_sensor.ctrls; \
\r
984 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
985 num += sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
986 menus = (struct v4l2_querymenu*)kzalloc(sizeof(struct v4l2_querymenu)*num,GFP_KERNEL); \
\r
987 if (menus == NULL) { \
\r
988 SENSOR_TR("kzalloc struct v4l2_querymenu(%d) failed",num); \
\r
991 sensor_ops_p->menus = menus; \
\r
992 sensor_ops_p->num_menus = num; \
\r
994 sensor_ops_p->suspend = sensor_suspend; \
\r
995 sensor_ops_p->resume = sensor_resume; \
\r
996 sensor_ops_p->set_bus_param = generic_sensor_set_bus_param; \
\r
997 sensor_ops_p->query_bus_param = generic_sensor_query_bus_param; \
\r
999 if (sizeof(sensor_ZoomSeqe)/sizeof(struct rk_sensor_reg *))\
\r
1000 sensor_ZoomSeqe[0] = NULL;\
\r
1002 if (CFG_FunChk(sensor_config,CFG_WhiteBalance)) { \
\r
1003 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_DO_WHITE_BALANCE,V4L2_CTRL_TYPE_MENU, \
\r
1004 "White Balance Control",0,4,1,0,sensor_v4l2ctrl_default_cb,sensor_WhiteBalanceSeqe); \
\r
1008 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,0,"auto",0); \
\r
1010 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,1,"incandescent",0); \
\r
1012 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,2,"fluorescent",0); \
\r
1014 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,3,"daylight",0); \
\r
1016 v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,4,"cloudy-daylight",0); \
\r
1020 if (CFG_FunChk(sensor_config,CFG_Brightness)) { \
\r
1021 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_BRIGHTNESS,V4L2_CTRL_TYPE_INTEGER, \
\r
1022 "Brightness Control",-3,2,1,0,sensor_v4l2ctrl_default_cb,sensor_BrightnessSeqe); \
\r
1026 if (CFG_FunChk(sensor_config,CFG_Effect)) { \
\r
1027 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EFFECT,V4L2_CTRL_TYPE_MENU, \
\r
1028 "Effect Control",0,5,1,0,sensor_v4l2ctrl_default_cb,sensor_EffectSeqe); \
\r
1032 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,0,"none",0); \
\r
1034 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,1,"mono",0); \
\r
1036 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,2,"negative",0); \
\r
1038 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,3,"sepia",0); \
\r
1040 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,4,"posterize",0); \
\r
1042 v4l2_querymenu_init(menus,V4L2_CID_EFFECT,5,"aqua",0); \
\r
1045 if (CFG_FunChk(sensor_config,CFG_Exposure)) { \
\r
1046 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_EXPOSURE,V4L2_CTRL_TYPE_INTEGER, \
\r
1047 "Exposure Control",0,6,1,0,sensor_v4l2ctrl_default_cb,sensor_ExposureSeqe); \
\r
1051 if (CFG_FunChk(sensor_config,CFG_Saturation)) { \
\r
1052 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SATURATION,V4L2_CTRL_TYPE_INTEGER, \
\r
1053 "Saturation Control",0,2,1,0,sensor_v4l2ctrl_default_cb,sensor_SaturationSeqe); \
\r
1057 if (CFG_FunChk(sensor_config,CFG_Contrast)) { \
\r
1058 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_CONTRAST,V4L2_CTRL_TYPE_INTEGER, \
\r
1059 "Contrast Control",-3,3,1,0,sensor_v4l2ctrl_default_cb,sensor_ContrastSeqe); \
\r
1063 if (CFG_FunChk(sensor_config,CFG_Mirror)) { \
\r
1064 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_HFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1065 "Mirror Control",0,1,1,0,sensor_v4l2ctrl_mirror_default_cb,NULL); \
\r
1069 if (CFG_FunChk(sensor_config,CFG_Flip)) { \
\r
1070 ctrls->qctrl = controls; \
\r
1071 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_VFLIP,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1072 "Flip Control",0,1,1,0,sensor_v4l2ctrl_flip_default_cb,NULL); \
\r
1076 if (CFG_FunChk(sensor_config,CFG_Scene)) { \
\r
1077 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_SCENE,V4L2_CTRL_TYPE_MENU, \
\r
1078 "Scene Control",0,1,1,0,sensor_v4l2ctrl_default_cb,sensor_SceneSeqe); \
\r
1082 v4l2_querymenu_init(menus,V4L2_CID_SCENE,0,"auto",0); \
\r
1084 v4l2_querymenu_init(menus,V4L2_CID_SCENE,1,"night",0); \
\r
1087 if (CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1088 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_AUTO,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1089 "Focus Control",0,2,1,0,sensor_focus_default_cb,NULL); \
\r
1094 if (CFG_FunChk(sensor_config,CFG_FocusRelative)) { \
\r
1095 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_RELATIVE,V4L2_CTRL_TYPE_INTEGER, \
\r
1096 "Focus Control",-1,1,1,0,sensor_focus_default_cb,NULL); \
\r
1101 if (CFG_FunChk(sensor_config,CFG_FocusAbsolute)) { \
\r
1102 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_ABSOLUTE,V4L2_CTRL_TYPE_INTEGER, \
\r
1103 "Focus Control",0,255,1,125,sensor_focus_default_cb,NULL); \
\r
1107 if (CFG_FunChk(sensor_config,CFG_FocusZone)) { \
\r
1108 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUSZONE,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1109 "Focus Control",0,1,1,0,NULL,NULL); \
\r
1113 if (CFG_FunChk(sensor_config,CFG_FocusContinues)) { \
\r
1114 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FOCUS_CONTINUOUS,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1115 "Focus Control",0,1,1,0,sensor_focus_default_cb,NULL); \
\r
1119 if (CFG_FunChk(sensor_config,CFG_FACE_DETECT)) { \
\r
1120 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FACEDETECT,V4L2_CTRL_TYPE_BOOLEAN, \
\r
1121 "FaceDEt Control",0,1,1,0,sensor_face_detect_default_cb,NULL); \
\r
1125 if (config_flash) { \
\r
1126 sensor_v4l2ctrl_info_init(ctrls,V4L2_CID_FLASH,V4L2_CTRL_TYPE_MENU, \
\r
1127 "Flash Control",0,3,1,0,sensor_v4l2ctrl_flash_cb,NULL); \
\r
1131 v4l2_querymenu_init(menus,V4L2_CID_FLASH,0,"off",0); \
\r
1133 v4l2_querymenu_init(menus,V4L2_CID_FLASH,1,"auto",0); \
\r
1135 v4l2_querymenu_init(menus,V4L2_CID_FLASH,2,"on",0); \
\r
1137 v4l2_querymenu_init(menus,V4L2_CID_FLASH,3,"torch",0); \
\r
1141 for (i=0; i<(sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s)); i++) { \
\r
1143 control = spsensor->common_sensor.sensor_controls; \
\r
1144 while (control < controls) \
\r
1146 if (control->id == sensor_controls[i].qctrl.id) { \
\r
1147 control->id = 0xffffffff; \
\r
1152 memcpy(controls, &sensor_controls[i].qctrl,sizeof(struct v4l2_queryctrl)); \
\r
1155 ctrls->sensor_Seqe = sensor_controls[i].sensor_Seqe; \
\r
1156 ctrls->cur_value = sensor_controls[i].qctrl.default_value; \
\r
1157 ctrls->cb = sensor_controls[i].cb; \
\r
1161 for (i=0; i<(sizeof(sensor_menus)/sizeof(struct v4l2_querymenu)); i++) { \
\r
1162 num = sensor_ops_p->num_menus - sizeof(sensor_menus)/sizeof(struct v4l2_querymenu); \
\r
1163 menu = sensor_ops_p->menus; \
\r
1165 if (menu->id == sensor_menus[i].id) { \
\r
1166 menu->id = 0xffffffff; \
\r
1171 memcpy(menus, &sensor_menus[i],sizeof(struct v4l2_querymenu)); \
\r
1175 spsensor->common_sensor.info_priv.datafmt = sensor_colour_fmts; \
\r
1176 spsensor->common_sensor.info_priv.num_datafmt = ARRAY_SIZE(sensor_colour_fmts); \
\r
1177 spsensor->common_sensor.sensor_ops = sensor_ops_p; \
\r
1178 icd->ops = sensor_ops_p; \
\r
1179 spsensor->common_sensor.info_priv.curfmt= sensor_colour_fmts[0]; \
\r
1181 if (config_flash) { \
\r
1182 hrtimer_init(&(spsensor->common_sensor.flash_off_timer.timer), CLOCK_MONOTONIC, HRTIMER_MODE_REL); \
\r
1183 spsensor->common_sensor.flash_off_timer.icd = icd; \
\r
1185 if(CFG_FunChk(sensor_config,CFG_Focus)) { \
\r
1186 mutex_init(&spsensor->common_sensor.sensor_focus.focus_lock); \
\r
1187 spsensor->common_sensor.sensor_focus.focus_mode = WqCmd_af_invalid; \
\r
1188 spsensor->common_sensor.sensor_focus.focus_state = FocusState_Inval;\
\r
1189 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = sensor_focus_init_usr_cb; \
\r
1190 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = sensor_focus_af_single_usr_cb; \
\r
1191 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = sensor_focus_af_near_usr_cb; \
\r
1192 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb = sensor_focus_af_far_usr_cb; \
\r
1193 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb = sensor_focus_af_specialpos_usr_cb; \
\r
1194 if(CFG_FunChk(sensor_config,CFG_FocusContinues)) {\
\r
1195 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb = sensor_focus_af_const_usr_cb; \
\r
1196 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_pause_cb = sensor_focus_af_const_pause_usr_cb; \
\r
1198 if(CFG_FunChk(sensor_config,CFG_FocusZone)) \
\r
1199 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb = sensor_focus_af_zoneupdate_usr_cb; \
\r
1200 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb = sensor_focus_af_close_usr_cb; \
\r
1202 spsensor->common_sensor.sensor_focus.focus_cb.sensor_focus_init_cb = NULL; \
\r
1203 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_single_cb = NULL; \
\r
1204 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_near_cb = NULL; \
\r
1205 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_far_cb =NULL; \
\r
1206 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_specialpos_cb =NULL; \
\r
1207 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_const_cb =NULL; \
\r
1208 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_zoneupdate_cb =NULL; \
\r
1209 spsensor->common_sensor.sensor_focus.focus_cb.sensor_af_close_cb =NULL; \
\r
1212 memcpy(spsensor->common_sensor.dev_name,dev_name(icd->pdev), sizeof(spsensor->common_sensor.dev_name)-1); \
\r
1213 sensor_init_parameters_user(spsensor,icd); \
\r
1217 #define sensor_v4l2_struct_initialization() static struct v4l2_subdev_core_ops sensor_subdev_core_ops = {\
\r
1218 .init = generic_sensor_init,\
\r
1219 .g_ctrl = generic_sensor_g_control,\
\r
1220 .s_ctrl = generic_sensor_s_control,\
\r
1221 .g_ext_ctrls = generic_sensor_g_ext_controls,\
\r
1222 .s_ext_ctrls = generic_sensor_s_ext_controls,\
\r
1223 .g_chip_ident = generic_sensor_g_chip_ident,\
\r
1224 .ioctl = generic_sensor_ioctl,\
\r
1225 .s_power = generic_sensor_s_power,\
\r
1228 static struct v4l2_subdev_video_ops sensor_subdev_video_ops = {\
\r
1229 .s_mbus_fmt = generic_sensor_s_fmt,\
\r
1230 .g_mbus_fmt = generic_sensor_g_fmt,\
\r
1231 .cropcap = generic_sensor_cropcap,\
\r
1232 .try_mbus_fmt = generic_sensor_try_fmt,\
\r
1233 .enum_mbus_fmt = generic_sensor_enum_fmt,\
\r
1234 .enum_frameintervals = generic_sensor_enum_frameintervals,\
\r
1235 .s_stream = generic_sensor_s_stream,\
\r
1236 .enum_framesizes = generic_sensor_enum_framesizes,\
\r
1238 static struct v4l2_subdev_ops sensor_subdev_ops = {\
\r
1239 .core = &sensor_subdev_core_ops,\
\r
1240 .video = &sensor_subdev_video_ops,\
\r
1243 static const struct i2c_device_id sensor_id[] = {\
\r
1244 {SENSOR_NAME_STRING(), 0 },\
\r
1248 MODULE_DEVICE_TABLE(i2c, sensor_id);
\r
1251 #define sensor_probe_default_code() static int sensor_probe(struct i2c_client *client,\
\r
1252 const struct i2c_device_id *did)\
\r
1254 struct specific_sensor *spsensor=NULL;\
\r
1255 struct soc_camera_subdev_desc *ssdd = client->dev.platform_data;\
\r
1256 struct soc_camera_desc *desc = container_of(ssdd,struct soc_camera_desc,subdev_desc);\
\r
1257 struct soc_camera_device *icd = ssdd->socdev;\
\r
1258 struct i2c_adapter *adapter = to_i2c_adapter(client->dev.parent);\
\r
1263 dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\
\r
1265 goto sensor_probe_end;\
\r
1268 desc = to_soc_camera_desc(icd);\
\r
1270 SENSOR_TR("driver needs platform data! But it is failed\n");\
\r
1272 goto sensor_probe_end;\
\r
1275 if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\
\r
1276 SENSOR_TR("I2C-Adapter doesn't support I2C_FUNC_I2C\n");\
\r
1278 goto sensor_probe_end;\
\r
1281 spsensor = kzalloc(sizeof(struct specific_sensor), GFP_KERNEL);\
\r
1284 SENSOR_TR("kzalloc failed\n");\
\r
1285 goto sensor_probe_end;\
\r
1288 v4l2_i2c_subdev_init(&spsensor->common_sensor.subdev, client, &sensor_subdev_ops);\
\r
1289 sensor_init_parameters(spsensor,icd);\
\r
1291 ret = sensor_video_probe(icd, client);\
\r
1293 sensor_probe_end:\
\r
1296 if (icd->ops->controls) {\
\r
1297 kfree(icd->ops->controls);\
\r
1298 icd->ops->controls = NULL;\
\r
1300 if (icd->ops->menus) {\
\r
1301 kfree(icd->ops->menus);\
\r
1302 icd->ops->menus = NULL;\
\r
1307 i2c_set_clientdata(client, NULL);\
\r
1308 client->driver = NULL;\
\r
1317 #define sensor_remove_default_code() static int sensor_remove(struct i2c_client *client)\
\r
1319 struct generic_sensor*sensor = to_generic_sensor(client);\
\r
1320 struct soc_camera_subdev_desc *ssdd = client->dev.platform_data;\
\r
1321 struct soc_camera_device *icd = ssdd->socdev;\
\r
1322 struct specific_sensor *spsensor = to_specific_sensor(sensor);\
\r
1323 int sensor_config;\
\r
1325 sensor_config = SensorConfiguration;\
\r
1326 if(CFG_FunChk(sensor_config,CFG_Focus)){ \
\r
1327 if (sensor->sensor_focus.sensor_wq) {\
\r
1328 destroy_workqueue(sensor->sensor_focus.sensor_wq);\
\r
1329 sensor->sensor_focus.sensor_wq = NULL;\
\r
1333 if (icd->ops->controls) {\
\r
1334 kfree(icd->ops->controls);\
\r
1335 icd->ops->controls = NULL;\
\r
1337 if (icd->ops->menus) {\
\r
1338 kfree(icd->ops->menus);\
\r
1339 icd->ops->menus = NULL;\
\r
1344 i2c_set_clientdata(client, NULL);\
\r
1345 client->driver = NULL;\
\r
1354 #define sensor_driver_default_module_code() static struct i2c_driver sensor_i2c_driver = {\
\r
1356 .name = SENSOR_NAME_STRING(),\
\r
1358 .probe = sensor_probe,\
\r
1359 .remove = sensor_remove,\
\r
1360 .id_table = sensor_id,\
\r
1363 static int __init sensor_mod_init(void)\
\r
1365 return i2c_add_driver(&sensor_i2c_driver);\
\r
1368 static void __exit sensor_mod_exit(void)\
\r
1370 i2c_del_driver(&sensor_i2c_driver);\
\r
1373 device_initcall_sync(sensor_mod_init);\
\r
1374 module_exit(sensor_mod_exit);\
\r
1375 MODULE_DESCRIPTION(SENSOR_NAME_STRING(sensor driver)); \
\r
1376 MODULE_AUTHOR("<ddl@rock-chips.com,zyc@rock-chips.com>");\
\r
1378 MODULE_LICENSE("GPL");
\r