drivers/media/video/generic_sensor.h

   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
  19 \r
  20 #define MIN(x,y)   ((x<y) ? x: y)\r
  21 #define MAX(x,y)        ((x>y) ? x: y)\r
  22 \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
  25 \r
  26 //to generic sensor\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
  29 \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
  33 \r
  34 #define SENSOR_CROP_PERCENT   0         // Redefine this macro in sensor driver if user want to crop\r
  35 \r
  36 #define SENSOR_INIT_IS_ERR       (0x00<<28)\r
  37 #define SENSOR_INIT_IS_OK        (0x01<<28)\r
  38 \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
  45 \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
  50 \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
  55 \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
  73 \r
  74 #define CFG_FunChk(a,b)                      ((a&b)==b) \r
  75 #define CFG_FunDis(a,b)                      (a &= (~b))\r
  76 \r
  77 enum rk_sensor_sequence_property {\r
  78         SEQUENCE_INIT =1,\r
  79         SEQUENCE_PREVIEW,\r
  80         SEQUENCE_CAPTURE\r
  81 };\r
  82 \r
  83 struct rk_sensor_reg {\r
  84         unsigned int reg;\r
  85         unsigned int val;\r
  86         unsigned int reg_mask;\r
  87         unsigned int val_mask;\r
  88 };\r
  89 \r
  90 struct rk_sensor_seq_info {\r
  91         unsigned short w;\r
  92         unsigned short h;\r
  93         unsigned short fps;\r
  94 };\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
  99 };\r
 100 \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
 105 };\r
 106 \r
 107 \r
 108 //focus work\r
 109 enum rk_sensor_focus_wq_cmd\r
 110 {\r
 111         WqCmd_af_invalid = -1,\r
 112         WqCmd_af_init =1,\r
 113         WqCmd_af_single,\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
 117         WqCmd_af_close,\r
 118         WqCmd_af_special_pos,\r
 119         WqCmd_af_near_pos,\r
 120         WqCmd_af_far_pos\r
 121         \r
 122 };\r
 123 enum rk_sensor_focus_sensor_wq_result\r
 124 {\r
 125         WqRet_success = 0,\r
 126         WqRet_fail = -1,\r
 127         WqRet_inval = -2\r
 128 };\r
 129 \r
 130 enum rk_sensor_focus_state\r
 131 {\r
 132     FocusState_Inval,\r
 133     FocusState_Inited\r
 134 };\r
 135 \r
 136 struct rk_sensor_focus_work\r
 137 {\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
 143         bool wait;\r
 144         int var;        \r
 145 };\r
 146 \r
 147 //focus structs\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
 158         //\r
 159 };\r
 160 //zone from hal is [-1000,-1000,1000,1000],must map to sensor's zone.\r
 161 struct rk_sensor_focus_zone{\r
 162         int lx;\r
 163         int ty;\r
 164         int rx;\r
 165         int dy;\r
 166 };\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
 175 };\r
 176 \r
 177 \r
 178 typedef struct rk_sensor_priv_s\r
 179 {\r
 180     int mirror;\r
 181         bool snap2preview;\r
 182         bool video2preview;\r
 183         struct rk_sensor_sequence* winseqe_cur_addr;\r
 184         struct rk_sensor_datafmt* datafmt;\r
 185         int num_datafmt;\r
 186         struct rk_sensor_datafmt curfmt;\r
 187         unsigned int funmodule_state;\r
 188         //\r
 189         struct rk_sensor_sequence* sensor_series;\r
 190         int num_series; \r
 191 \r
 192     struct rk_sensor_reg* sensor_SfRstSeqe;\r
 193     struct rk_sensor_reg* sensor_CkIdSeqe;\r
 194     \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
 201         int chip_ident;\r
 202         unsigned int gReg_mask;\r
 203         unsigned int gVal_mask;\r
 204         unsigned int gI2c_speed;\r
 205 \r
 206     bool stream;\r
 207         \r
 208 } rk_sensor_info_priv_t;\r
 209 \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
 215     int cur_value;\r
 216     int num_ctrls;\r
 217 };\r
 218 \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
 224 };\r
 225 \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
 234 \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
 240 \r
 241 };\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
 246 };\r
 247 \r
 248 struct generic_sensor\r
 249 {\r
 250     char dev_name[32];\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
 255 \r
 256     int crop_percent;\r
 257 \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
 268         \r
 269 };\r
 270 \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
 309 \r
 310 static inline int sensor_get_full_width_height(int full_resolution, unsigned short *w, unsigned short *h)\r
 311 {\r
 312     switch (full_resolution) \r
 313     {\r
 314         case 0x30000:\r
 315         {\r
 316             *w = 640;\r
 317             *h = 480;\r
 318             break;\r
 319         } \r
 320 \r
 321         case 0x100000:\r
 322         {\r
 323             *w = 1024;\r
 324             *h = 768;\r
 325             break;\r
 326         }   \r
 327         \r
 328         case 0x130000:\r
 329         {\r
 330             *w = 1280;\r
 331             *h = 1024;\r
 332             break;\r
 333         }\r
 334 \r
 335         case 0x200000:\r
 336         {\r
 337             *w = 1600;\r
 338             *h = 1200;\r
 339             break;\r
 340         }\r
 341         case 0x210000:\r
 342         {\r
 343             *w = 1920;\r
 344             *h = 1080;\r
 345             break;\r
 346         }\r
 347 \r
 348         case 0x300000:\r
 349         {\r
 350             *w = 2048;\r
 351             *h = 1536;\r
 352             break;\r
 353         }\r
 354 \r
 355         case 0x500000:\r
 356         {\r
 357             *w = 2592;\r
 358             *h = 1944;\r
 359             break;\r
 360         }\r
 361 \r
 362         case 0x800000:\r
 363         {\r
 364             *w = 3264;\r
 365             *h = 2448;\r
 366             break;\r
 367         }\r
 368         \r
 369         default:\r
 370             return -1;\r
 371     }\r
 372 \r
 373     return 0;\r
 374 }\r
 375 static inline int sensor_video_probe(struct soc_camera_device *icd,\r
 376                                    struct i2c_client *client)\r
 377 {\r
 378         int ret;\r
 379         \r
 380         struct generic_sensor *sensor = to_generic_sensor(client);\r
 381 \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
 386                 ret = -ENODEV;\r
 387                 goto sensor_video_probe_end;\r
 388         }\r
 389         \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
 392 \r
 393 sensor_video_probe_end: \r
 394         return ret;\r
 395 }\r
 396 \r
 397 static inline int sensor_regarray_check(struct rk_sensor_reg *data, int reg_num)\r
 398 {\r
 399     struct rk_sensor_reg *data_ptr;\r
 400 \r
 401     data_ptr = data+reg_num-1;\r
 402     if (data_ptr->reg == SEQCMD_END) {\r
 403         return 0;\r
 404     } else { \r
 405         printk(KERN_ERR "%s(%d): data[%d].reg = 0x%x\n",__FUNCTION__,__LINE__,reg_num-1,data_ptr->reg);\r
 406         return -1;\r
 407     }\r
 408     \r
 409 }\r
 410 \r
 411 static inline void sensor_v4l2ctrl_info_init (struct sensor_v4l2ctrl_info_s *ptr,\r
 412                                         unsigned int id,\r
 413                                         enum v4l2_ctrl_type type,\r
 414                                         char *name,\r
 415                                         int min,\r
 416                                         int max,\r
 417                                         int step,\r
 418                                         int default_val,\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
 422                                         )\r
 423 {\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
 431     ptr->cb = cb;\r
 432     ptr->sensor_Seqe = sensor_seqe;\r
 433     return;\r
 434 }\r
 435 \r
 436 static inline struct sensor_v4l2ctrl_info_s* sensor_find_ctrl(\r
 437         struct sensor_v4l2ctrl_info_s *ops, int id)\r
 438 {\r
 439         int i;\r
 440 \r
 441         for (i = 0; i < ops[0].num_ctrls; i++)\r
 442                 if (ops[i].qctrl->id == id)\r
 443                         return &ops[i];\r
 444 \r
 445         return NULL;\r
 446 }\r
 447 \r
 448 static inline void v4l2_querymenu_init (struct v4l2_querymenu *ptr,\r
 449                                         unsigned int id,\r
 450                                         unsigned int index,\r
 451                                         char *name,\r
 452                                         unsigned int reserved)\r
 453 {\r
 454     ptr->id = id;\r
 455         ptr->index = index;\r
 456         strcat(ptr->name,name);\r
 457         ptr->reserved = reserved;\r
 458 \r
 459     return;\r
 460 }\r
 461 \r
 462 static inline int sensor_v4l2ctrl_replace_cb(struct generic_sensor *sensor, int id, void *cb)\r
 463 {\r
 464     int i,num;\r
 465     struct sensor_v4l2ctrl_info_s* ctrls;\r
 466 \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
 471             ctrls->cb = cb;\r
 472             break;\r
 473         }\r
 474     } \r
 475 \r
 476     if (i>=num) {\r
 477         printk(KERN_ERR "%s(%d): v4l2_control id(0x%x) isn't exist\n",__FUNCTION__,__LINE__,id);\r
 478     } else {\r
 479         return 0;\r
 480     }\r
 481 }\r
 482 \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
 485 {\r
 486     struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));    \r
 487     int value = ext_ctrl->value;\r
 488     int index;\r
 489     \r
 490     if(!is_set){\r
 491         return 0;\r
 492     }\r
 493 \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
 497         return -EINVAL;\r
 498     }\r
 499 \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
 504             return -EINVAL;\r
 505         }\r
 506 \r
 507         ctrl_info->cur_value = value;\r
 508         return 0;\r
 509     } else {\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
 511         return -EINVAL;\r
 512     }\r
 513 }\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
 516 {\r
 517     //struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));\r
 518     int value = ext_ctrl->value;\r
 519 \r
 520         \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
 524                 }\r
 525                 \r
 526                 return 0;\r
 527         }\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
 531         return -EINVAL;\r
 532     }\r
 533 \r
 534     if (value == 3) {            /* ddl@rock-chips.com: torch */\r
 535         generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Torch);   /* Flash On */\r
 536     } else {\r
 537         generic_sensor_ioctrl(icd, Sensor_Flash, Flash_Off);\r
 538     }\r
 539     \r
 540     ctrl_info->cur_value = value;  /* ddl@rock-chips.com : v0.1.3 */\r
 541     \r
 542     return 0;\r
 543 }\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
 546 {\r
 547         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));    \r
 548         int value = ext_ctrl->value;\r
 549         int ret = 0;\r
 550         struct generic_sensor* sensor = to_generic_sensor(client);\r
 551     \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
 555                 return -EINVAL;\r
 556         }\r
 557 \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
 560                 //set focus delay\r
 561                 \r
 562                 switch (ext_ctrl->id)\r
 563                 {\r
 564                         case V4L2_CID_FOCUS_ABSOLUTE:\r
 565                                 sensor->sensor_focus.focus_delay = WqCmd_af_special_pos;\r
 566                                 break;\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
 570                                 else\r
 571                                         sensor->sensor_focus.focus_delay = WqCmd_af_far_pos;\r
 572                                 break;\r
 573                         \r
 574                         case V4L2_CID_FOCUS_AUTO:\r
 575                                 sensor->sensor_focus.focus_delay = WqCmd_af_single;\r
 576                                 break;\r
 577                         case V4L2_CID_FOCUS_CONTINUOUS:\r
 578                                 sensor->sensor_focus.focus_delay = WqCmd_af_continues;\r
 579                                 break;\r
 580                         default:\r
 581                                 printk(KERN_ERR "%s(%d):not support this focus mode",__FUNCTION__,__LINE__ );\r
 582                 }\r
 583                 return -EINVAL;\r
 584         }\r
 585         switch (ext_ctrl->id)\r
 586         {\r
 587                 case V4L2_CID_FOCUS_ABSOLUTE:\r
 588                         {\r
 589                                 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){\r
 590                                         //need do something?\r
 591 \r
 592                                 }\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
 598                                         else\r
 599                                                 ret = generic_sensor_af_workqueue_set(icd, WqCmd_af_special_pos, value, true);\r
 600                                         if(ret == 0){\r
 601                                                 ctrl_info->cur_value = value;\r
 602                                         } else {\r
 603                                                 ret = -EINVAL;\r
 604                                                 printk(KERN_ERR"\n %s valure = %d is invalidate..       \n",__FUNCTION__,value);\r
 605                                         }\r
 606                                 }\r
 607                                 break;\r
 608                         }\r
 609                 case V4L2_CID_FOCUS_RELATIVE:\r
 610                         {\r
 611                                 if(sensor->sensor_focus.focus_mode ==V4L2_CID_FOCUS_CONTINUOUS){\r
 612                                         //need do something?\r
 613                                 \r
 614                                 }\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
 620                                         if(ret == 0){\r
 621                                                 ctrl_info->cur_value = value;\r
 622                                         } else {\r
 623                                                 ret = -EINVAL;\r
 624                                                 printk(KERN_ERR"\n %s valure = %d is invalidate..       \n",__FUNCTION__,value);\r
 625                                         }\r
 626                                 }\r
 627                                 break;\r
 628                         }\r
 629                 case V4L2_CID_FOCUS_AUTO:\r
 630                         {\r
 631                 mutex_lock(&sensor->sensor_focus.focus_lock);\r
 632                 //get focuszone\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
 638               \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
 642                                 }\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
 649                                 }\r
 650                                 if(ret != 0){\r
 651                                         ret = -EINVAL;\r
 652                                         printk(KERN_ERR"\n %s valure = %d is invalidate..       \n",__FUNCTION__,value);\r
 653                                 }\r
 654                                 break;\r
 655                                 \r
 656                         }\r
 657                 case V4L2_CID_FOCUS_CONTINUOUS:\r
 658                         {\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
 663 \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
 667                                 }\r
 668                                 if(ret != 0){\r
 669                                         ret = -EINVAL;\r
 670                                         printk(KERN_ERR"\n %s valure = %d is invalidate..       \n",__FUNCTION__,value);\r
 671                                 }\r
 672                                 break;\r
 673                         }\r
 674                 \r
 675         }\r
 676         return ret;\r
 677 \r
 678 }\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
 681 {\r
 682         struct i2c_client *client = to_i2c_client(to_soc_camera_control(icd));    \r
 683         int value = ext_ctrl->value;\r
 684         int ret = 0;\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
 689                 return -EINVAL;\r
 690         }\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
 694                 if(ret ==0)\r
 695                         ctrl_info->cur_value = value;\r
 696         }\r
 697         return ret;\r
 698 }\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
 703                                                                                                          \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
 707                                                                                          \r
 708 \r
 709 }\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
 713                                                                                          \r
 714 \r
 715 }\r
 716 \r
 717 #define new_user_v4l2ctrl(ctl_id,ctl_type,ctl_name,ctl_min,ctl_max,ctl_step,default_val,callback,seqe)\\r
 718 {\\r
 719     .qctrl = {\\r
 720                 .id     = ctl_id,\\r
 721                 .type           = ctl_type,\\r
 722                 .name           = ctl_name,\\r
 723                 .minimum        = ctl_min,\\r
 724                 .maximum        = ctl_max,\\r
 725                 .step           = ctl_step,\\r
 726                 .default_value = default_val,\\r
 727         },\\r
 728         .cb = callback,\\r
 729         .sensor_Seqe = seqe,\\r
 730 }\r
 731     \r
 732 \r
 733 #define new_usr_v4l2menu(menu_id,menu_idx,menu_name,menu_rev)\\r
 734     {\\r
 735         .id = menu_id,\\r
 736         .index = menu_idx,\\r
 737         .name = menu_name,\\r
 738         .reserved = menu_rev,\\r
 739     }\r
 740 \r
 741 #define sensor_init_parameters_default_code() static void sensor_init_parameters(struct specific_sensor* spsensor,struct soc_camera_device *icd)\\r
 742 { \\r
 743     int num,i; \\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
 755  \\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
 759         BUG();\\r
 760     }\\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
 766             break; \\r
 767         } \\r
 768         new_camera = new_camera->next_camera; \\r
 769     } \\r
 770  \\r
 771     if(sensor_device && sensor_device->flash)\\r
 772             config_flash = 1;\\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
 782     } else { \\r
 783         SENSOR_TR("sensor_softreset_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_softreset_data"); \\r
 784         BUG(); \\r
 785     } \\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
 788     } else { \\r
 789         SENSOR_TR("sensor_check_id_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_check_id_data"); \\r
 790         BUG(); \\r
 791     } \\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
 803     else \\r
 804         spsensor->common_sensor.sensor_cb.sensor_face_detect_cb = NULL; \\r
 805  \\r
 806     num = 4;  \\r
 807     if (sensor_720p[0].reg != SEQCMD_END) {  \\r
 808         num++;  \\r
 809     }  \\r
 810     if (sensor_1080p[0].reg != SEQCMD_END) {  \\r
 811         num++;  \\r
 812     } \\r
 813  \\r
 814     if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) \\r
 815         num++; \\r
 816  \\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
 820         BUG();  \\r
 821     } else {  \\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
 825  \\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
 832         } else { \\r
 833             SENSOR_TR("sensor_init_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_int_data"); \\r
 834             BUG(); \\r
 835         } \\r
 836  \\r
 837         sensor_series++;  \\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
 844         } else { \\r
 845             SENSOR_TR("sensor_preview_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_preview_data"); \\r
 846             BUG(); \\r
 847         } \\r
 848  \\r
 849         sensor_series++;  \\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
 855             } else { \\r
 856                 SENSOR_TR("sensor_fullres_lowfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_lowfps_data"); \\r
 857                 BUG(); \\r
 858             } \\r
 859         } else {  \\r
 860             SENSOR_TR("generic_sensor_get_width_height failed!");  \\r
 861             BUG();  \\r
 862         }  \\r
 863  \\r
 864         sensor_series++;  \\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
 871         } else { \\r
 872             SENSOR_TR("sensor_fullres_highfps_data haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_fullres_highfps_data"); \\r
 873             BUG(); \\r
 874         } \\r
 875  \\r
 876         if (sensor_device && (sensor_device->resolution > CONS(SENSOR_NAME,_FULL_RESOLUTION))) { \\r
 877             sensor_series++; \\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
 884                 } else { \\r
 885                     sensor_series->data = reg_data; \\r
 886                     reg_data->reg = SEQCMD_INTERPOLATION; \\r
 887                     reg_data++; \\r
 888                     reg_data->reg = SEQCMD_END; \\r
 889                 } \\r
 890             } else {  \\r
 891                 SENSOR_TR("generic_sensor_get_width_height failed!");  \\r
 892                 BUG();  \\r
 893             } \\r
 894         } \\r
 895  \\r
 896         if (sensor_720p[0].reg != SEQCMD_END) {  \\r
 897             sensor_series++;  \\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
 904             } else { \\r
 905                 SENSOR_TR("sensor_720p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_720p"); \\r
 906                 BUG(); \\r
 907             } \\r
 908         }  \\r
 909  \\r
 910         if (sensor_1080p[0].reg != SEQCMD_END) {  \\r
 911             sensor_series++;  \\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
 918             } else { \\r
 919                 SENSOR_TR("sensor_1080p haven't SensorEnd flag! Please fill SensorEnd in the last of sensor_1080p"); \\r
 920                 BUG(); \\r
 921             } \\r
 922         }  \\r
 923     } \\r
 924  \\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
 934         }\\r
 935     } else {\\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
 941     }\\r
 942 \\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
 947 \\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
 953  \\r
 954     num = 0;\\r
 955     for (i=0; i<32; i++)\\r
 956         if (SensorConfiguration & (1<<i))\\r
 957             num++;\\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
 963         BUG();  \\r
 964     }  \\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
 969                 BUG();  \\r
 970         }  \\r
 971     sensor_ops_p->controls = controls;  \\r
 972     sensor_ops_p->num_controls = num;  \\r
 973   \\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
 977         BUG();  \\r
 978     }  \\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
 983         ctrls++;  \\r
 984         controls++; \\r
 985     }  \\r
 986     controls = spsensor->common_sensor.sensor_controls; \\r
 987     ctrls = spsensor->common_sensor.ctrls;  \\r
 988  \\r
 989     num = 0;  \\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
 995         BUG();  \\r
 996     }  \\r
 997     sensor_ops_p->menus = menus;  \\r
 998     sensor_ops_p->num_menus = num;  \\r
 999  \\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
1004  \\r
1005     if (sizeof(sensor_ZoomSeqe)/sizeof(struct rk_sensor_reg *))\\r
1006         sensor_ZoomSeqe[0] = NULL;\\r
1007 \\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
1011         controls++; \\r
1012         ctrls++;  \\r
1013  \\r
1014         v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,0,"auto",0); \\r
1015         menus++;  \\r
1016         v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,1,"incandescent",0);  \\r
1017         menus++;  \\r
1018         v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,2,"fluorescent",0);  \\r
1019         menus++;  \\r
1020         v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,3,"daylight",0);  \\r
1021         menus++;  \\r
1022         v4l2_querymenu_init(menus,V4L2_CID_DO_WHITE_BALANCE,4,"cloudy-daylight",0);  \\r
1023         menus++;  \\r
1024     }  \\r
1025  \\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
1029         controls++;  \\r
1030         ctrls++;  \\r
1031     }  \\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
1035         controls++; \\r
1036         ctrls++;  \\r
1037  \\r
1038         v4l2_querymenu_init(menus,V4L2_CID_EFFECT,0,"none",0);  \\r
1039         menus++; \\r
1040         v4l2_querymenu_init(menus,V4L2_CID_EFFECT,1,"mono",0);  \\r
1041         menus++; \\r
1042         v4l2_querymenu_init(menus,V4L2_CID_EFFECT,2,"negative",0); \\r
1043         menus++; \\r
1044         v4l2_querymenu_init(menus,V4L2_CID_EFFECT,3,"sepia",0); \\r
1045         menus++; \\r
1046         v4l2_querymenu_init(menus,V4L2_CID_EFFECT,4,"posterize",0); \\r
1047         menus++; \\r
1048         v4l2_querymenu_init(menus,V4L2_CID_EFFECT,5,"aqua",0); \\r
1049         menus++; \\r
1050     } \\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
1054         controls++;  \\r
1055         ctrls++;  \\r
1056     }  \\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
1060         controls++;  \\r
1061         ctrls++;  \\r
1062         }  \\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
1066         controls++;  \\r
1067         ctrls++;  \\r
1068         }  \\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
1072         controls++;  \\r
1073         ctrls++;  \\r
1074         }  \\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
1079         controls++;  \\r
1080         ctrls++;  \\r
1081         }  \\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
1085         controls++;  \\r
1086         ctrls++;  \\r
1087   \\r
1088         v4l2_querymenu_init(menus,V4L2_CID_SCENE,0,"auto",0);  \\r
1089         menus++;  \\r
1090         v4l2_querymenu_init(menus,V4L2_CID_SCENE,1,"night",0);  \\r
1091         menus++;  \\r
1092     }  \\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
1096            controls++;  \\r
1097            ctrls++;  \\r
1098     } \\r
1099  \\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
1103         controls++;  \\r
1104         ctrls++;  \\r
1105         } \\r
1106   \\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
1110         controls++;  \\r
1111         ctrls++;  \\r
1112     }  \\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
1116             controls++;  \\r
1117             ctrls++;  \\r
1118     } \\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
1122            controls++;  \\r
1123            ctrls++;  \\r
1124     } \\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
1128            controls++;  \\r
1129            ctrls++;  \\r
1130         } \\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
1134         controls++;  \\r
1135         ctrls++;  \\r
1136   \\r
1137         v4l2_querymenu_init(menus,V4L2_CID_FLASH,0,"off",0);  \\r
1138         menus++;  \\r
1139         v4l2_querymenu_init(menus,V4L2_CID_FLASH,1,"auto",0);  \\r
1140         menus++;  \\r
1141         v4l2_querymenu_init(menus,V4L2_CID_FLASH,2,"on",0);  \\r
1142         menus++;  \\r
1143         v4l2_querymenu_init(menus,V4L2_CID_FLASH,3,"torch",0);  \\r
1144         menus++;  \\r
1145     }  \\r
1146   \\r
1147     for (i=0; i<(sizeof(sensor_controls)/sizeof(struct sensor_v4l2ctrl_usr_s)); i++) { \\r
1148  \\r
1149         control = spsensor->common_sensor.sensor_controls; \\r
1150         while (control < controls) \\r
1151         { \\r
1152             if (control->id == sensor_controls[i].qctrl.id) { \\r
1153                 control->id = 0xffffffff; \\r
1154             } \\r
1155             control++; \\r
1156         } \\r
1157  \\r
1158         memcpy(controls, &sensor_controls[i].qctrl,sizeof(struct v4l2_queryctrl));  \\r
1159         controls++;  \\r
1160  \\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
1164         ctrls++; \\r
1165     }  \\r
1166  \\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
1170         while (num--) { \\r
1171             if (menu->id == sensor_menus[i].id) { \\r
1172                 menu->id = 0xffffffff; \\r
1173             } \\r
1174             menu++; \\r
1175         } \\r
1176  \\r
1177         memcpy(menus, &sensor_menus[i],sizeof(struct v4l2_querymenu));  \\r
1178         menus++;  \\r
1179     }  \\r
1180  \\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
1186  \\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
1190     } \\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
1203                 }\\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
1207         }else{ \\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
1216         } \\r
1217  \\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
1220 }\r
1221 \r
1222 \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
1232 };\\r
1233 \\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
1243 };\\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
1247 };\\r
1248 \\r
1249 static const struct i2c_device_id sensor_id[] = {\\r
1250         {SENSOR_NAME_STRING(), 0 },\\r
1251     {"\0",0}\\r
1252 };\\r
1253 \\r
1254 MODULE_DEVICE_TABLE(i2c, sensor_id);\r
1255 \r
1256 \r
1257 #define sensor_probe_default_code() static int sensor_probe(struct i2c_client *client,\\r
1258                          const struct i2c_device_id *did)\\r
1259 {\\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
1265 \\r
1266         int ret=0;\\r
1267 \\r
1268         if (!icd) {\\r
1269                 dev_err(&client->dev, "%s: missing soc-camera data!\n",SENSOR_NAME_STRING());\\r
1270                 ret = -EINVAL;\\r
1271         goto sensor_probe_end;\\r
1272         }\\r
1273 \\r
1274         desc = to_soc_camera_desc(icd);\\r
1275         if (!desc) {\\r
1276                 SENSOR_TR("driver needs platform data! But it is failed\n");\\r
1277                 ret = -EINVAL;\\r
1278         goto sensor_probe_end;\\r
1279         }\\r
1280 \\r
1281         if (!i2c_check_functionality(adapter, I2C_FUNC_I2C)) {\\r
1282                 SENSOR_TR("I2C-Adapter doesn't support I2C_FUNC_I2C\n");\\r
1283                 ret =  -EIO;\\r
1284         goto sensor_probe_end;\\r
1285         }\\r
1286 \\r
1287         spsensor = kzalloc(sizeof(struct specific_sensor), GFP_KERNEL);\\r
1288         if (!spsensor) {\\r
1289                 ret = -ENOMEM;\\r
1290         SENSOR_TR("kzalloc failed\n");\\r
1291         goto sensor_probe_end;\\r
1292         }\\r
1293 \\r
1294         v4l2_i2c_subdev_init(&spsensor->common_sensor.subdev, client, &sensor_subdev_ops);\\r
1295     sensor_init_parameters(spsensor,icd);\\r
1296 \\r
1297     ret = sensor_video_probe(icd, client);\\r
1298 \\r
1299 sensor_probe_end:\\r
1300     if (ret != 0) {\\r
1301         if (icd->ops) {\\r
1302             if (icd->ops->controls) {\\r
1303                 kfree(icd->ops->controls);\\r
1304                 icd->ops->controls = NULL;\\r
1305             }\\r
1306             if (icd->ops->menus) {\\r
1307                 kfree(icd->ops->menus);\\r
1308                 icd->ops->menus = NULL;\\r
1309             }\\r
1310             kfree(icd->ops);\\r
1311             icd->ops = NULL;\\r
1312         }\\r
1313         i2c_set_clientdata(client, NULL);\\r
1314         client->driver = NULL;\\r
1315         if (spsensor) {\\r
1316             kfree(spsensor);\\r
1317         }\\r
1318         spsensor = NULL;\\r
1319     }\\r
1320         return ret;\\r
1321 }\r
1322 \r
1323 #define sensor_remove_default_code() static int sensor_remove(struct i2c_client *client)\\r
1324 {\\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
1330 \\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
1336                 }\\r
1337         }\\r
1338     if (icd->ops) {\\r
1339         if (icd->ops->controls) {\\r
1340             kfree(icd->ops->controls);\\r
1341             icd->ops->controls = NULL;\\r
1342         }\\r
1343         if (icd->ops->menus) {\\r
1344             kfree(icd->ops->menus);\\r
1345             icd->ops->menus = NULL;\\r
1346         }\\r
1347             kfree(icd->ops);\\r
1348             icd->ops = NULL;\\r
1349     }\\r
1350         i2c_set_clientdata(client, NULL);\\r
1351         client->driver = NULL;\\r
1352     if (spsensor) {\\r
1353         kfree(spsensor);\\r
1354     }\\r
1355         spsensor = NULL;\\r
1356         return 0;\\r
1357 }\r
1358 \r
1359 \r
1360 #define sensor_driver_default_module_code() static struct i2c_driver sensor_i2c_driver = {\\r
1361         .driver = {\\r
1362                 .name = SENSOR_NAME_STRING(),\\r
1363         },\\r
1364         .probe          = sensor_probe,\\r
1365         .remove         = sensor_remove,\\r
1366         .id_table       = sensor_id,\\r
1367 };\\r
1368 \\r
1369 static int __init sensor_mod_init(void)\\r
1370 {\\r
1371         return i2c_add_driver(&sensor_i2c_driver);\\r
1372 }\\r
1373 \\r
1374 static void __exit sensor_mod_exit(void)\\r
1375 {\\r
1376         i2c_del_driver(&sensor_i2c_driver);\\r
1377 }\\r
1378 \\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
1383 \\r
1384 MODULE_LICENSE("GPL");\r
1385 #endif\r