arch/arm/mach-rockchip/rk_camera.c

   1 #include "rk_camera.h"\r
   2 #include "rk30_camera.h"\r
   3 #include <linux/gpio.h>\r
   4 #include <linux/delay.h>\r
   5 #include <linux/version.h>\r
   6 #include <linux/moduleparam.h>\r
   7 #include <linux/of_gpio.h>\r
   8 /**********yzm***********/\r
   9 #include <linux/of.h>\r
  10 #include <linux/of_irq.h>\r
  11 #include <linux/kernel.h>\r
  12 #include <linux/of_address.h>\r
  13 #include <linux/of_platform.h>\r
  14 #include <linux/of_fdt.h>\r
  15 #include <linux/module.h>\r
  16 /**********yzm***********/\r
  17 \r
  18 //#define PMEM_CAM_NECESSARY     0x00000000    /*yzm*/\r
  19 \r
  20 static int camio_version = KERNEL_VERSION(0,1,9);/*yzm camio_version*/ \r
  21 module_param(camio_version, int, S_IRUGO);\r
  22 \r
  23 static int camera_debug = 0;/*yzm*/ \r
  24 module_param(camera_debug, int, S_IRUGO|S_IWUSR);    \r
  25 \r
  26 #undef  CAMMODULE_NAME\r
  27 #define CAMMODULE_NAME   "rk_cam_io"\r
  28 \r
  29 #define ddprintk(level, fmt, arg...) do {                       \\r
  30         if (camera_debug >= level)                                      \\r
  31             printk(KERN_WARNING"%s(%d):" fmt"\n", CAMMODULE_NAME,__LINE__,## arg); } while (0)\r
  32 \r
  33 #define dprintk(format, ...) ddprintk(1, format, ## __VA_ARGS__)  \r
  34 #define eprintk(format, ...) printk(KERN_ERR "%s(%d):" format"\n",CAMMODULE_NAME,__LINE__,## __VA_ARGS__)  \r
  35 #define debug_printk(format, ...) ddprintk(3, format, ## __VA_ARGS__)  \r
  36 \r
  37 static int rk_sensor_io_init(void);\r
  38 static int rk_sensor_io_deinit(int sensor);\r
  39 static int rk_sensor_ioctrl(struct device *dev,enum rk29camera_ioctrl_cmd cmd, int on);\r
  40 static int rk_sensor_power(struct device *dev, int on);\r
  41 static int rk_sensor_register(void);\r
  42 /*static int rk_sensor_reset(struct device *dev);*/\r
  43 \r
  44 static int rk_dts_sensor_probe(struct platform_device *pdev);\r
  45 static int rk_dts_sensor_remove(struct platform_device *pdev);\r
  46 static int rk_dts_cif_probe(struct platform_device *pdev);\r
  47 static int rk_dts_cif_remove(struct platform_device *pdev);\r
  48 \r
  49 static int rk_sensor_powerdown(struct device *dev, int on);\r
  50 \r
  51 static struct rkcamera_platform_data *new_camera_head;  \r
  52 \r
  53 static struct rk29camera_platform_data rk_camera_platform_data = {\r
  54     .io_init = rk_sensor_io_init,\r
  55     .io_deinit = rk_sensor_io_deinit,\r
  56     .sensor_ioctrl = rk_sensor_ioctrl,\r
  57     .sensor_register = rk_sensor_register,\r
  58 \r
  59 };\r
  60 \r
  61 struct rk29camera_platform_ioctl_cb     sensor_ioctl_cb = {\r
  62         .sensor_power_cb = NULL,\r
  63         .sensor_reset_cb = NULL,\r
  64         .sensor_powerdown_cb = NULL,\r
  65         .sensor_flash_cb = NULL,\r
  66         .sensor_af_cb = NULL,\r
  67 };\r
  68 \r
  69 \r
  70 static u64 rockchip_device_camera_dmamask = 0xffffffffUL;\r
  71 #if RK_SUPPORT_CIF0\r
  72 static struct resource rk_camera_resource_host_0[2] = {};\r
  73 #endif\r
  74 #if RK_SUPPORT_CIF1\r
  75 static struct resource rk_camera_resource_host_1[2] = {};\r
  76 #endif\r
  77 \r
  78 #if RK_SUPPORT_CIF0\r
  79  struct platform_device rk_device_camera_host_0 = {\r
  80         .name             = RK29_CAM_DRV_NAME,\r
  81         .id       = RK_CAM_PLATFORM_DEV_ID_0,                           /* This is used to put cameras on this interface*/ \r
  82         .num_resources= 2,\r
  83         .resource         = rk_camera_resource_host_0,/*yzm*/\r
  84         .dev                    = {\r
  85                 .dma_mask = &rockchip_device_camera_dmamask,\r
  86                 .coherent_dma_mask = 0xffffffffUL,\r
  87                 .platform_data  = &rk_camera_platform_data,\r
  88         }\r
  89 };\r
  90 #endif\r
  91 \r
  92 #if RK_SUPPORT_CIF1\r
  93  struct platform_device rk_device_camera_host_1 = {\r
  94         .name             = RK29_CAM_DRV_NAME,\r
  95         .id       = RK_CAM_PLATFORM_DEV_ID_1,                           /* This is used to put cameras on this interface */\r
  96         .num_resources    = ARRAY_SIZE(rk_camera_resource_host_1),\r
  97         .resource         = rk_camera_resource_host_1,/*yzm*/\r
  98         .dev                    = {\r
  99                 .dma_mask = &rockchip_device_camera_dmamask,\r
 100                 .coherent_dma_mask = 0xffffffffUL,\r
 101                 .platform_data  = &rk_camera_platform_data,\r
 102         }\r
 103 };\r
 104 #endif\r
 105 \r
 106 \r
 107 \r
 108 static const struct of_device_id of_match_cif[] = {\r
 109     { .compatible = "rockchip,cif" },\r
 110         {},\r
 111 };\r
 112 \r
 113 MODULE_DEVICE_TABLE(of,of_match_cif);\r
 114 static struct platform_driver rk_cif_driver =\r
 115 {\r
 116     .driver     = {\r
 117         .name   = RK3288_CIF_NAME,              \r
 118                 .owner = THIS_MODULE,\r
 119         .of_match_table = of_match_ptr(of_match_cif),\r
 120     },\r
 121     .probe              = rk_dts_cif_probe,\r
 122     .remove             = rk_dts_cif_remove,\r
 123 };\r
 124 \r
 125 static const struct of_device_id of_match_sensor[] = {\r
 126     { .compatible = "rockchip,sensor" },\r
 127 };\r
 128 MODULE_DEVICE_TABLE(of,of_match_sensor);\r
 129 static struct platform_driver rk_sensor_driver =\r
 130 {\r
 131     .driver     = {\r
 132         .name   = RK3288_SENSOR_NAME,              \r
 133                 .owner  = THIS_MODULE,\r
 134         .of_match_table = of_match_ptr(of_match_sensor),\r
 135     },\r
 136     .probe              = rk_dts_sensor_probe,\r
 137     .remove             = rk_dts_sensor_remove,\r
 138 };\r
 139 \r
 140 \r
 141 static int rk_dts_sensor_remove(struct platform_device *pdev)\r
 142 {\r
 143         return 0;\r
 144 }\r
 145 static int      rk_dts_sensor_probe(struct platform_device *pdev)\r
 146 {\r
 147         struct device_node *np, *cp;\r
 148         int sensor_num = 0;\r
 149         struct device *dev = &pdev->dev;\r
 150         struct rkcamera_platform_data *new_camera_list;\r
 151         \r
 152 \r
 153         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 154         \r
 155         np = dev->of_node;\r
 156         if (!np)\r
 157                 return -ENODEV;\r
 158         for_each_child_of_node(np, cp) {\r
 159                 u32 flash_attach,mir,i2c_rata,i2c_chl,i2c_add,cif_chl,mclk_rate,is_front;\r
 160                 u32 resolution,pwdn_info,powerup_sequence,orientation;\r
 161                 \r
 162                 u32     powerdown = INVALID_GPIO,power = INVALID_GPIO,reset = INVALID_GPIO;\r
 163                 u32 af = INVALID_GPIO,flash = INVALID_GPIO;\r
 164 \r
 165                 int pwr_active = INVALID_VALUE, rst_active = INVALID_VALUE, pwdn_active = INVALID_VALUE;\r
 166                 struct rkcamera_platform_data *new_camera; \r
 167                 new_camera = kzalloc(sizeof(struct rkcamera_platform_data),GFP_KERNEL);\r
 168                 if(!sensor_num)\r
 169                 {                       \r
 170                         new_camera_head = new_camera;\r
 171                         rk_camera_platform_data.register_dev_new = new_camera_head;\r
 172                         new_camera_list = new_camera;\r
 173                 }\r
 174                 sensor_num ++;\r
 175                 new_camera_list->next_camera = new_camera;\r
 176                 new_camera_list = new_camera;\r
 177         \r
 178                 if (of_property_read_u32(cp, "flash_attach", &flash_attach)) {\r
 179                         dprintk("%s:Get %s rockchip,flash_attach failed!\n",__func__, cp->name);                                \r
 180                 }\r
 181                 if (of_property_read_u32(cp, "mir", &mir)) {\r
 182                         dprintk("%s:Get %s rockchip,mir failed!\n",__func__, cp->name);                         \r
 183                 }\r
 184                 if (of_property_read_u32(cp, "i2c_rata", &i2c_rata)) {\r
 185                         dprintk("%s:Get %s rockchip,i2c_rata failed!\n",__func__, cp->name);                            \r
 186                 }\r
 187                 if (of_property_read_u32(cp, "i2c_chl", &i2c_chl)) {\r
 188                         dprintk("%s:Get %s rockchip,i2c_chl failed!\n",__func__, cp->name);                             \r
 189                 }\r
 190                 if (of_property_read_u32(cp, "cif_chl", &cif_chl)) {\r
 191                         dprintk("%s:Get %s rockchip,cif_chl failed!\n",__func__, cp->name);                             \r
 192                 }\r
 193                 if (of_property_read_u32(cp, "mclk_rate", &mclk_rate)) {\r
 194                         dprintk("%s:Get %s rockchip,mclk_rate failed!\n",__func__, cp->name);                           \r
 195                 }\r
 196                 if (of_property_read_u32(cp, "is_front", &is_front)) {\r
 197                         dprintk("%s:Get %s rockchip,is_front failed!\n",__func__, cp->name);                            \r
 198                 }\r
 199                 if (of_property_read_u32(cp, "rockchip,powerdown", &powerdown)) {\r
 200                                 printk("%s:Get %s rockchip,powerdown failed!\n",__func__, cp->name);                            \r
 201                 }\r
 202                 if (of_property_read_u32(cp, "pwdn_active", &pwdn_active)) {\r
 203                                 dprintk("%s:Get %s pwdn_active failed!\n",__func__, cp->name);                          \r
 204                 }\r
 205                 if (of_property_read_u32(cp, "rockchip,power", &power)) {\r
 206                                 printk("%s:Get %s rockchip,power failed!\n",__func__, cp->name);                                \r
 207                 }\r
 208                 if (of_property_read_u32(cp, "pwr_active", &pwr_active)) {\r
 209                                 dprintk("%s:Get %s pwr_active failed!\n",__func__, cp->name);                           \r
 210                 }\r
 211                 if (of_property_read_u32(cp, "rockchip,reset", &reset)) {\r
 212                                 printk("%s:Get %s rockchip,reset failed!\n",__func__, cp->name);                                \r
 213                 }\r
 214                 if (of_property_read_u32(cp, "rst_active", &rst_active)) {\r
 215                                 dprintk("%s:Get %s rst_active failed!\n",__func__, cp->name);                           \r
 216                 }\r
 217                 if (of_property_read_u32(cp, "rockchip,af", &af)) {\r
 218                                 printk("%s:Get %s rockchip,af failed!\n",__func__, cp->name);                           \r
 219                 }\r
 220                 if (of_property_read_u32(cp, "rockchip,flash", &flash)) {\r
 221                                 printk("%s:Get %s rockchip,flash failed!\n",__func__, cp->name);                                \r
 222                 }\r
 223                 if (of_property_read_u32(cp, "i2c_add", &i2c_add)) {\r
 224                         printk("%s:Get %s rockchip,i2c_add failed!\n",__func__, cp->name);                              \r
 225                 }\r
 226                 if (of_property_read_u32(cp, "resolution", &resolution)) {\r
 227                         printk("%s:Get %s rockchip,resolution failed!\n",__func__, cp->name);                           \r
 228                 }\r
 229                 if (of_property_read_u32(cp, "pwdn_info", &pwdn_info)) {\r
 230                         printk("%s:Get %s rockchip,pwdn_info failed!\n",__func__, cp->name);                            \r
 231                 }\r
 232                 if (of_property_read_u32(cp, "powerup_sequence", &powerup_sequence)) {\r
 233                         printk("%s:Get %s rockchip,powerup_sequence failed!\n",__func__, cp->name);                             \r
 234                 }\r
 235                 if (of_property_read_u32(cp, "orientation", &orientation)) {\r
 236                         printk("%s:Get %s rockchip,orientation failed!\n",__func__, cp->name);                          \r
 237                 }\r
 238                 \r
 239                 strcpy(new_camera->dev.i2c_cam_info.type, cp->name);\r
 240                 new_camera->dev.i2c_cam_info.addr = i2c_add>>1;\r
 241                 new_camera->dev.desc_info.host_desc.bus_id = RK29_CAM_PLATFORM_DEV_ID+cif_chl;/*yzm*/\r
 242                 new_camera->dev.desc_info.host_desc.i2c_adapter_id = i2c_chl;/*yzm*/\r
 243                 new_camera->dev.desc_info.host_desc.module_name = cp->name;/*const*/\r
 244                 new_camera->dev.device_info.name = "soc-camera-pdrv";\r
 245                 if(is_front)\r
 246                         sprintf(new_camera->dev_name,"%s_%s",cp->name,"front");\r
 247                 else\r
 248                         sprintf(new_camera->dev_name,"%s_%s",cp->name,"back");\r
 249                 new_camera->dev.device_info.dev.init_name =(const char*)&new_camera->dev_name[0];\r
 250                 new_camera->io.gpio_reset = reset;\r
 251                 new_camera->io.gpio_powerdown = powerdown;\r
 252                 new_camera->io.gpio_power = power;\r
 253                 new_camera->io.gpio_af = af;\r
 254                 new_camera->io.gpio_flash = flash;\r
 255                 new_camera->io.gpio_flag = ((pwr_active&0x01)<<RK29_CAM_POWERACTIVE_BITPOS)|((rst_active&0x01)<<RK29_CAM_RESETACTIVE_BITPOS)|((pwdn_active&0x01)<<RK29_CAM_POWERDNACTIVE_BITPOS);\r
 256                 new_camera->orientation = orientation;\r
 257                 new_camera->resolution = resolution;\r
 258                 new_camera->mirror = mir;\r
 259                 new_camera->i2c_rate = i2c_rata;\r
 260                 new_camera->flash = flash_attach;\r
 261                 new_camera->pwdn_info = ((pwdn_info&0x10)|0x01);\r
 262                 new_camera->powerup_sequence = powerup_sequence;\r
 263                 new_camera->mclk_rate = mclk_rate;\r
 264                 new_camera->of_node = cp;\r
 265                         \r
 266                     debug_printk( "******************* /n power = %x\n", power);\r
 267                         debug_printk( "******************* /n powerdown = %x\n", powerdown);\r
 268                         debug_printk( "******************* /n i2c_add = %x\n", new_camera->dev.i2c_cam_info.addr << 1);\r
 269                         debug_printk( "******************* /n i2c_chl = %d\n", new_camera->dev.desc_info.host_desc.i2c_adapter_id);\r
 270                         debug_printk( "******************* /n init_name = %s\n", new_camera->dev.device_info.dev.init_name);\r
 271                         debug_printk( "******************* /n dev_name = %s\n", new_camera->dev_name);\r
 272                         debug_printk( "******************* /n module_name = %s\n", new_camera->dev.desc_info.host_desc.module_name);\r
 273         };\r
 274         new_camera_list->next_camera = NULL;\r
 275         return 0;\r
 276 }\r
 277         \r
 278 static int rk_dts_cif_remove(struct platform_device *pdev)\r
 279 {\r
 280          return 0;\r
 281 }\r
 282         \r
 283 static int rk_dts_cif_probe(struct platform_device *pdev) /*yzm*/\r
 284 {\r
 285         int irq,err;\r
 286         struct device *dev = &pdev->dev;\r
 287                 \r
 288         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 289         \r
 290         rk_camera_platform_data.cif_dev = &pdev->dev;\r
 291         \r
 292         err = of_address_to_resource(dev->of_node, 0, &rk_camera_resource_host_0[0]);\r
 293         if (err < 0){\r
 294                 printk(KERN_EMERG "Get register resource from %s platform device failed!",pdev->name);\r
 295                 return -ENODEV;\r
 296         }\r
 297         rk_camera_resource_host_0[0].flags = IORESOURCE_MEM;\r
 298         /*map irqs*/\r
 299         irq = irq_of_parse_and_map(dev->of_node, 0);\r
 300         if (irq < 0) {\r
 301                 printk(KERN_EMERG "Get irq resource from %s platform device failed!",pdev->name);\r
 302                 return -ENODEV;;\r
 303         }\r
 304         rk_camera_resource_host_0[1].start = irq;\r
 305         rk_camera_resource_host_0[1].end   = irq;\r
 306         rk_camera_resource_host_0[1].flags = IORESOURCE_IRQ;\r
 307         return 0;\r
 308 }\r
 309         \r
 310 static int rk_cif_sensor_init(void)\r
 311 {\r
 312         \r
 313         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 314         platform_driver_register(&rk_cif_driver);       \r
 315                 \r
 316         platform_driver_register(&rk_sensor_driver);    \r
 317 \r
 318         return 0;\r
 319 }\r
 320 \r
 321 /************yzm**************end*/\r
 322 \r
 323 static int sensor_power_default_cb (struct rk29camera_gpio_res *res, int on)\r
 324 {\r
 325     int camera_power = res->gpio_power;\r
 326     int camera_ioflag = res->gpio_flag;\r
 327     int camera_io_init = res->gpio_init;\r
 328     int ret = 0;\r
 329 \r
 330 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 331 \r
 332     \r
 333     if (camera_power != INVALID_GPIO)  {\r
 334                 if (camera_io_init & RK29_CAM_POWERACTIVE_MASK) {\r
 335             if (on) {\r
 336                 /*gpio_set_value(camera_power, ((camera_ioflag&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));*/\r
 337                                 gpio_direction_output(camera_power,1);\r
 338                                 dprintk("%s PowerPin=%d ..PinLevel = %x",res->dev_name, camera_power, ((camera_ioflag&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 339                         msleep(10);\r
 340                 } else {\r
 341                         /*gpio_set_value(camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));*/\r
 342                                 gpio_direction_output(camera_power,0);\r
 343                                 dprintk("%s PowerPin=%d ..PinLevel = %x",res->dev_name, camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 344                 }\r
 345                 } else {\r
 346                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 347                         eprintk("%s PowerPin=%d request failed!", res->dev_name,camera_power);\r
 348             }        \r
 349     } else {\r
 350                 ret = RK29_CAM_EIO_INVALID;\r
 351     } \r
 352 \r
 353     return ret;\r
 354 }\r
 355 \r
 356 static int sensor_reset_default_cb (struct rk29camera_gpio_res *res, int on)\r
 357 {\r
 358     int camera_reset = res->gpio_reset;\r
 359     int camera_ioflag = res->gpio_flag;\r
 360     int camera_io_init = res->gpio_init;  \r
 361     int ret = 0;\r
 362 \r
 363         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 364 \r
 365     \r
 366     if (camera_reset != INVALID_GPIO) {\r
 367                 if (camera_io_init & RK29_CAM_RESETACTIVE_MASK) {\r
 368                         if (on) {\r
 369                         gpio_set_value(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 370                         dprintk("%s ResetPin=%d ..PinLevel = %x",res->dev_name,camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 371                         } else {\r
 372                                 gpio_set_value(camera_reset,(((~camera_ioflag)&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 373                         dprintk("%s ResetPin= %d..PinLevel = %x",res->dev_name, camera_reset, (((~camera_ioflag)&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 374                 }\r
 375                 } else {\r
 376                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 377                         eprintk("%s ResetPin=%d request failed!", res->dev_name,camera_reset);\r
 378                 }\r
 379     } else {\r
 380                 ret = RK29_CAM_EIO_INVALID;\r
 381     }\r
 382 \r
 383     return ret;\r
 384 }\r
 385 \r
 386 static int sensor_powerdown_default_cb (struct rk29camera_gpio_res *res, int on)\r
 387 {\r
 388     int camera_powerdown = res->gpio_powerdown;\r
 389     int camera_ioflag = res->gpio_flag;\r
 390     int camera_io_init = res->gpio_init;  \r
 391     int ret = 0;    \r
 392 \r
 393         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 394 \r
 395 \r
 396     if (camera_powerdown != INVALID_GPIO) {\r
 397                 if (camera_io_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 398                         if (on) {\r
 399                         gpio_set_value(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 400                         dprintk("%s PowerDownPin=%d ..PinLevel = %x" ,res->dev_name,camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 401                         } else {\r
 402                                 gpio_set_value(camera_powerdown,(((~camera_ioflag)&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 403                         dprintk("%s PowerDownPin= %d..PinLevel = %x" ,res->dev_name, camera_powerdown, (((~camera_ioflag)&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 404                 }\r
 405                 } else {\r
 406                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 407                         dprintk("%s PowerDownPin=%d request failed!", res->dev_name,camera_powerdown);\r
 408                 }\r
 409     } else {\r
 410                 ret = RK29_CAM_EIO_INVALID;\r
 411     }\r
 412     return ret;\r
 413 }\r
 414 \r
 415 \r
 416 static int sensor_flash_default_cb (struct rk29camera_gpio_res *res, int on)\r
 417 {\r
 418     int camera_flash = res->gpio_flash;\r
 419     int camera_ioflag = res->gpio_flag;\r
 420     int camera_io_init = res->gpio_init;  \r
 421     int ret = 0;    \r
 422 \r
 423         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 424 \r
 425 \r
 426     if (camera_flash != INVALID_GPIO) {\r
 427                 if (camera_io_init & RK29_CAM_FLASHACTIVE_MASK) {\r
 428             switch (on)\r
 429             {\r
 430                 case Flash_Off:\r
 431                 {\r
 432                     gpio_set_value(camera_flash,(((~camera_ioflag)&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 433                             dprintk("%s FlashPin= %d..PinLevel = %x", res->dev_name, camera_flash, (((~camera_ioflag)&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS)); \r
 434                             break;\r
 435                 }\r
 436 \r
 437                 case Flash_On:\r
 438                 {\r
 439                     gpio_set_value(camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 440                             dprintk("%s FlashPin=%d ..PinLevel = %x", res->dev_name,camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 441                             break;\r
 442                 }\r
 443 \r
 444                 case Flash_Torch:\r
 445                 {\r
 446                     gpio_set_value(camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 447                             dprintk("%s FlashPin=%d ..PinLevel = %x", res->dev_name,camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 448                             break;\r
 449                 }\r
 450 \r
 451                 default:\r
 452                 {\r
 453                     eprintk("%s Flash command(%d) is invalidate", res->dev_name,on);\r
 454                     break;\r
 455                 }\r
 456             }\r
 457                 } else {\r
 458                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 459                         eprintk("%s FlashPin=%d request failed!", res->dev_name,camera_flash);\r
 460                 }\r
 461     } else {\r
 462                 ret = RK29_CAM_EIO_INVALID;\r
 463     }\r
 464     return ret;\r
 465 }\r
 466 \r
 467 static int sensor_afpower_default_cb (struct rk29camera_gpio_res *res, int on)\r
 468 {\r
 469         int ret = 0;   \r
 470         int camera_af = res->gpio_af;\r
 471         \r
 472         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 473 \r
 474         \r
 475         if (camera_af != INVALID_GPIO) {\r
 476                 gpio_set_value(camera_af, on);\r
 477         }\r
 478 \r
 479         return ret;\r
 480 }\r
 481 \r
 482 static int _rk_sensor_io_init_(struct rk29camera_gpio_res *gpio_res,struct device_node *of_node)\r
 483 {\r
 484     int ret = 0;\r
 485     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;\r
 486         unsigned int camera_powerdown = INVALID_GPIO, camera_flash = INVALID_GPIO;\r
 487         unsigned int camera_af = INVALID_GPIO,camera_ioflag;\r
 488     struct rk29camera_gpio_res *io_res;\r
 489     bool io_requested_in_camera;\r
 490         enum of_gpio_flags flags;\r
 491         \r
 492         struct rkcamera_platform_data *new_camera;/*yzm*/\r
 493         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 494 \r
 495 \r
 496     camera_reset = gpio_res->gpio_reset;\r
 497         camera_power = gpio_res->gpio_power;\r
 498         camera_powerdown = gpio_res->gpio_powerdown;\r
 499         camera_flash = gpio_res->gpio_flash;\r
 500         camera_af = gpio_res->gpio_af;  \r
 501         camera_ioflag = gpio_res->gpio_flag;\r
 502         gpio_res->gpio_init = 0;\r
 503 \r
 504     if (camera_power != INVALID_GPIO) {\r
 505                 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$/ camera_power  = %x\n", camera_power );\r
 506 \r
 507                 camera_power = of_get_named_gpio_flags(of_node,"rockchip,power",0,&flags);/*yzm*/\r
 508                 gpio_res->gpio_power = camera_power;/*yzm information back to the IO*/\r
 509 \r
 510                 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$/ camera_power  = %x\n", camera_power );  \r
 511 \r
 512                 ret = gpio_request(camera_power, "camera power"); \r
 513         if (ret) {\r
 514                         \r
 515             io_requested_in_camera = false;\r
 516 \r
 517             if (io_requested_in_camera==false) {\r
 518 \r
 519                                 new_camera = new_camera_head;\r
 520                 while (new_camera != NULL) {\r
 521                     io_res = &new_camera->io;\r
 522                     if (io_res->gpio_init & RK29_CAM_POWERACTIVE_MASK) {\r
 523                         if (io_res->gpio_power == camera_power)\r
 524                             io_requested_in_camera = true;    \r
 525                     }\r
 526                     new_camera = new_camera->next_camera;\r
 527                 }\r
 528 \r
 529             }\r
 530             \r
 531             if (io_requested_in_camera==false) {\r
 532                 printk( "%s power pin(%d) init failed\n", gpio_res->dev_name,camera_power);\r
 533                 goto _rk_sensor_io_init_end_;\r
 534             } else {\r
 535                 ret =0;\r
 536             }\r
 537         }\r
 538       \r
 539                 gpio_res->gpio_init |= RK29_CAM_POWERACTIVE_MASK;\r
 540         gpio_set_value(camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 541         gpio_direction_output(camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 542 \r
 543                 dprintk("%s power pin(%d) init success(0x%x)" ,gpio_res->dev_name,camera_power,(((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 544 \r
 545     }\r
 546 /*\r
 547     if (camera_reset != INVALID_GPIO) {\r
 548         ret = gpio_request(camera_reset, "camera reset");\r
 549         if (ret) {\r
 550             io_requested_in_camera = false;\r
 551             for (i=0; i<RK_CAM_NUM; i++) {\r
 552                 io_res = &rk_camera_platform_data.gpio_res[i];\r
 553                 if (io_res->gpio_init & RK29_CAM_RESETACTIVE_MASK) {\r
 554                     if (io_res->gpio_reset == camera_reset)\r
 555                         io_requested_in_camera = true;    \r
 556                 }\r
 557             }\r
 558 \r
 559             if (io_requested_in_camera==false) {\r
 560                 i=0;\r
 561                 while (strstr(new_camera[i].dev_name,"end")==NULL) {\r
 562                     io_res = &new_camera[i].io;\r
 563                     if (io_res->gpio_init & RK29_CAM_RESETACTIVE_MASK) {\r
 564                         if (io_res->gpio_reset == camera_reset)\r
 565                             io_requested_in_camera = true;    \r
 566                     }\r
 567                     i++;\r
 568                 }\r
 569             }\r
 570             \r
 571             if (io_requested_in_camera==false) {\r
 572                 eprintk("%s reset pin(%d) init failed" ,gpio_res->dev_name,camera_reset);\r
 573                 goto _rk_sensor_io_init_end_;\r
 574             } else {\r
 575                 ret =0;\r
 576             }\r
 577         }\r
 578 \r
 579         if (rk_camera_platform_data.iomux(camera_reset,dev) < 0) {\r
 580             ret = -1;\r
 581             eprintk("%s reset pin(%d) iomux init failed", gpio_res->dev_name,camera_reset);\r
 582             goto _rk_sensor_io_init_end_;\r
 583         }\r
 584         \r
 585                 gpio_res->gpio_init |= RK29_CAM_RESETACTIVE_MASK;\r
 586         gpio_set_value(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 587         gpio_direction_output(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 588 \r
 589                 dprintk("%s reset pin(%d) init success(0x%x)" ,gpio_res->dev_name,camera_reset,((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 590 \r
 591     }\r
 592 */\r
 593         if (camera_powerdown != INVALID_GPIO) {\r
 594                 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$/ camera_powerdown  = %x\n", camera_powerdown );\r
 595 \r
 596                 camera_powerdown = of_get_named_gpio_flags(of_node,"rockchip,powerdown",0,&flags);/*yzm*/\r
 597                 gpio_res->gpio_powerdown = camera_powerdown;/*yzm information back to the IO*/\r
 598 \r
 599                 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$/ camera_powerdown  = %x\n", camera_powerdown );  \r
 600                 ret = gpio_request(camera_powerdown, "camera powerdown");\r
 601         if (ret) {\r
 602             io_requested_in_camera = false;\r
 603 \r
 604             if (io_requested_in_camera==false) {\r
 605                                 \r
 606                 new_camera = new_camera_head;\r
 607                 while (new_camera != NULL) {\r
 608                     io_res = &new_camera->io;\r
 609                     if (io_res->gpio_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 610                         if (io_res->gpio_powerdown == camera_powerdown)\r
 611                             io_requested_in_camera = true;    \r
 612                     }\r
 613                     new_camera = new_camera->next_camera;\r
 614                 }\r
 615             }\r
 616             \r
 617             if (io_requested_in_camera==false) {\r
 618                 eprintk("%s powerdown pin(%d) init failed",gpio_res->dev_name,camera_powerdown);\r
 619                 goto _rk_sensor_io_init_end_;\r
 620             } else {\r
 621                 ret =0;\r
 622             }\r
 623         }\r
 624                 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s(),iomux is ok\n", __FILE__, __LINE__,__FUNCTION__);\r
 625         \r
 626                 gpio_res->gpio_init |= RK29_CAM_POWERDNACTIVE_MASK;\r
 627         gpio_set_value(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 628         gpio_direction_output(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 629 \r
 630                 dprintk("%s powerdown pin(%d) init success(0x%x)" ,gpio_res->dev_name,camera_powerdown,((camera_ioflag&RK29_CAM_POWERDNACTIVE_BITPOS)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 631 \r
 632     }\r
 633 /*\r
 634         if (camera_flash != INVALID_GPIO) {\r
 635         ret = gpio_request(camera_flash, "camera flash");\r
 636         if (ret) {\r
 637             io_requested_in_camera = false;\r
 638             for (i=0; i<RK_CAM_NUM; i++) {\r
 639                 io_res = &rk_camera_platform_data.gpio_res[i];\r
 640                 if (io_res->gpio_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 641                     if (io_res->gpio_powerdown == camera_powerdown)\r
 642                         io_requested_in_camera = true;    \r
 643                 }\r
 644             }\r
 645 \r
 646             if (io_requested_in_camera==false) {\r
 647                 i=0;\r
 648                 while (strstr(new_camera[i].dev_name,"end")==NULL) {\r
 649                     io_res = &new_camera[i].io;\r
 650                     if (io_res->gpio_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 651                         if (io_res->gpio_powerdown == camera_powerdown)\r
 652                             io_requested_in_camera = true;    \r
 653                     }\r
 654                     i++;\r
 655                 }\r
 656             }\r
 657             \r
 658             ret = 0;        //ddl@rock-chips.com : flash is only a function, sensor is also run;\r
 659             if (io_requested_in_camera==false) {\r
 660                 eprintk("%s flash pin(%d) init failed",gpio_res->dev_name,camera_flash);\r
 661                 goto _rk_sensor_io_init_end_;\r
 662             }\r
 663         }\r
 664 \r
 665 \r
 666         if (rk_camera_platform_data.iomux(camera_flash,dev) < 0) {\r
 667             printk("%s flash pin(%d) iomux init failed\n",gpio_res->dev_name,camera_flash);                            \r
 668         }\r
 669         \r
 670                 gpio_res->gpio_init |= RK29_CAM_FLASHACTIVE_MASK;\r
 671         gpio_set_value(camera_flash, ((~camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));   //  falsh off \r
 672         gpio_direction_output(camera_flash, ((~camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 673 \r
 674                 dprintk("%s flash pin(%d) init success(0x%x)",gpio_res->dev_name, camera_flash,((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 675 \r
 676     }  \r
 677 \r
 678 \r
 679         if (camera_af != INVALID_GPIO) {\r
 680                 ret = gpio_request(camera_af, "camera af");\r
 681                 if (ret) {\r
 682                         io_requested_in_camera = false;\r
 683                         for (i=0; i<RK_CAM_NUM; i++) {\r
 684                                 io_res = &rk_camera_platform_data.gpio_res[i];\r
 685                                 if (io_res->gpio_init & RK29_CAM_AFACTIVE_MASK) {\r
 686                                         if (io_res->gpio_af == camera_af)\r
 687                                                 io_requested_in_camera = true;    \r
 688                                 }\r
 689                         }\r
 690 \r
 691                         if (io_requested_in_camera==false) {\r
 692                                 i=0;\r
 693                                 while (strstr(new_camera[i].dev_name,"end")==NULL) {\r
 694                                         io_res = &new_camera[i].io;\r
 695                                         if (io_res->gpio_init & RK29_CAM_AFACTIVE_MASK) {\r
 696                                                 if (io_res->gpio_af == camera_af)\r
 697                                                         io_requested_in_camera = true;    \r
 698                                         }\r
 699                                         i++;\r
 700                                 }\r
 701                         }\r
 702                         \r
 703                         if (io_requested_in_camera==false) {\r
 704                                 eprintk("%s af pin(%d) init failed",gpio_res->dev_name,camera_af);\r
 705                                 goto _rk_sensor_io_init_end_;\r
 706                         } else {\r
 707                 ret =0;\r
 708             }\r
 709                         \r
 710                 }\r
 711 \r
 712 \r
 713                 if (rk_camera_platform_data.iomux(camera_af,dev) < 0) {\r
 714                          ret = -1;\r
 715                         eprintk("%s af pin(%d) iomux init failed\n",gpio_res->dev_name,camera_af);      \r
 716             goto _rk_sensor_io_init_end_;                       \r
 717                 }\r
 718                 \r
 719                 gpio_res->gpio_init |= RK29_CAM_AFACTIVE_MASK;\r
 720                 //gpio_direction_output(camera_af, ((camera_ioflag&RK29_CAM_AFACTIVE_MASK)>>RK29_CAM_AFACTIVE_BITPOS));\r
 721                 dprintk("%s af pin(%d) init success",gpio_res->dev_name, camera_af);\r
 722 \r
 723         }\r
 724 */\r
 725 \r
 726         \r
 727 _rk_sensor_io_init_end_:\r
 728     return ret;\r
 729 \r
 730 }\r
 731 \r
 732 static int _rk_sensor_io_deinit_(struct rk29camera_gpio_res *gpio_res)\r
 733 {\r
 734     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;\r
 735         unsigned int camera_powerdown = INVALID_GPIO, camera_flash = INVALID_GPIO,camera_af = INVALID_GPIO;\r
 736 \r
 737         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 738 \r
 739     \r
 740     camera_reset = gpio_res->gpio_reset;\r
 741     camera_power = gpio_res->gpio_power;\r
 742         camera_powerdown = gpio_res->gpio_powerdown;\r
 743     camera_flash = gpio_res->gpio_flash;\r
 744     camera_af = gpio_res->gpio_af;\r
 745 \r
 746         if (gpio_res->gpio_init & RK29_CAM_POWERACTIVE_MASK) {\r
 747             if (camera_power != INVALID_GPIO) {\r
 748                 gpio_direction_input(camera_power);\r
 749                 gpio_free(camera_power);\r
 750             }\r
 751         }\r
 752 \r
 753         if (gpio_res->gpio_init & RK29_CAM_RESETACTIVE_MASK) {\r
 754             if (camera_reset != INVALID_GPIO)  {\r
 755                 gpio_direction_input(camera_reset);\r
 756                 gpio_free(camera_reset);\r
 757             }\r
 758         }\r
 759 \r
 760         if (gpio_res->gpio_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 761             if (camera_powerdown != INVALID_GPIO)  {\r
 762                 gpio_direction_input(camera_powerdown);\r
 763                 gpio_free(camera_powerdown);\r
 764             }\r
 765         }\r
 766 \r
 767         if (gpio_res->gpio_init & RK29_CAM_FLASHACTIVE_MASK) {\r
 768             if (camera_flash != INVALID_GPIO)  {\r
 769                 gpio_direction_input(camera_flash);\r
 770                 gpio_free(camera_flash);\r
 771             }\r
 772         }\r
 773         if (gpio_res->gpio_init & RK29_CAM_AFACTIVE_MASK) {\r
 774             if (camera_af != INVALID_GPIO)  {\r
 775                /* gpio_direction_input(camera_af);*/\r
 776                 gpio_free(camera_af);\r
 777             }\r
 778         }       \r
 779         gpio_res->gpio_init = 0;\r
 780         \r
 781     return 0;\r
 782 }\r
 783 \r
 784 static int rk_sensor_io_init(void)\r
 785 {\r
 786         static bool is_init = false;\r
 787         \r
 788         struct rkcamera_platform_data *new_camera;\r
 789         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 790 \r
 791     if(is_init) {               \r
 792                 return 0;\r
 793         } else {\r
 794                 is_init = true;\r
 795         }\r
 796     \r
 797     if (sensor_ioctl_cb.sensor_power_cb == NULL)\r
 798         sensor_ioctl_cb.sensor_power_cb = sensor_power_default_cb;\r
 799     if (sensor_ioctl_cb.sensor_reset_cb == NULL)\r
 800         sensor_ioctl_cb.sensor_reset_cb = sensor_reset_default_cb;\r
 801     if (sensor_ioctl_cb.sensor_powerdown_cb == NULL)\r
 802         sensor_ioctl_cb.sensor_powerdown_cb = sensor_powerdown_default_cb;\r
 803     if (sensor_ioctl_cb.sensor_flash_cb == NULL)\r
 804         sensor_ioctl_cb.sensor_flash_cb = sensor_flash_default_cb;\r
 805     if (sensor_ioctl_cb.sensor_af_cb == NULL)\r
 806         sensor_ioctl_cb.sensor_af_cb = sensor_afpower_default_cb;       \r
 807 \r
 808         /**********yzm*********/\r
 809         new_camera = new_camera_head;\r
 810         while(new_camera != NULL)\r
 811         {\r
 812                 if (_rk_sensor_io_init_(&new_camera->io,new_camera->of_node)<0)\r
 813             _rk_sensor_io_deinit_(&new_camera->io);\r
 814                 new_camera = new_camera->next_camera;\r
 815         }\r
 816         return 0;\r
 817 }\r
 818 \r
 819 static int rk_sensor_io_deinit(int sensor)\r
 820 {\r
 821         struct rkcamera_platform_data *new_camera;\r
 822 \r
 823         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 824 \r
 825         new_camera = new_camera_head;\r
 826         while(new_camera != NULL)\r
 827         {\r
 828                 _rk_sensor_io_deinit_(&new_camera->io);\r
 829                 new_camera = new_camera->next_camera;\r
 830         }\r
 831 \r
 832     return 0;\r
 833 }\r
 834 static int rk_sensor_ioctrl(struct device *dev,enum rk29camera_ioctrl_cmd cmd, int on)\r
 835 {\r
 836     struct rk29camera_gpio_res *res = NULL;\r
 837     struct rkcamera_platform_data *new_cam_dev = NULL;\r
 838         struct rk29camera_platform_data* plat_data = &rk_camera_platform_data;\r
 839     int ret = RK29_CAM_IO_SUCCESS,i = 0;\r
 840         struct soc_camera_desc *dev_icl = NULL;/*yzm*/\r
 841         struct rkcamera_platform_data *new_camera;\r
 842         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
 843 \r
 844     if (res == NULL) {\r
 845                 new_camera = new_camera_head;\r
 846                 while(new_camera != NULL)\r
 847                 {\r
 848             if (strcmp(new_camera->dev_name, dev_name(dev)) == 0) {\r
 849                 res = (struct rk29camera_gpio_res *)&new_camera->io; \r
 850                 new_cam_dev = &new_camera[i];\r
 851                                  dev_icl = &new_camera->dev.desc_info;/*yzm*/\r
 852                 break;\r
 853             }\r
 854             new_camera = new_camera->next_camera;;\r
 855         }               \r
 856     }\r
 857     \r
 858     if (res == NULL) {\r
 859         eprintk("%s is not regisiterd in rk29_camera_platform_data!!",dev_name(dev));\r
 860         ret = RK29_CAM_EIO_INVALID;\r
 861         goto rk_sensor_ioctrl_end;\r
 862     }\r
 863         \r
 864         switch (cmd)\r
 865         {\r
 866                 case Cam_Power:\r
 867                 {\r
 868                         if (sensor_ioctl_cb.sensor_power_cb) {\r
 869                 ret = sensor_ioctl_cb.sensor_power_cb(res, on);   \r
 870                 ret = (ret != RK29_CAM_EIO_INVALID)?ret:0;     /* ddl@rock-chips.com: v0.1.1 */ \r
 871                         } else {\r
 872                 eprintk("sensor_ioctl_cb.sensor_power_cb is NULL");\r
 873                 WARN_ON(1);\r
 874                         }\r
 875 \r
 876                         printk("ret: %d\n",ret);\r
 877                         break;\r
 878                 }\r
 879                 case Cam_Reset:\r
 880                 {\r
 881                         if (sensor_ioctl_cb.sensor_reset_cb) {\r
 882                 ret = sensor_ioctl_cb.sensor_reset_cb(res, on);\r
 883 \r
 884                 ret = (ret != RK29_CAM_EIO_INVALID)?ret:0;\r
 885                         } else {\r
 886                 eprintk( "sensor_ioctl_cb.sensor_reset_cb is NULL");\r
 887                 WARN_ON(1);\r
 888                         }\r
 889                         break;\r
 890                 }\r
 891 \r
 892                 case Cam_PowerDown:\r
 893                 {\r
 894                         if (sensor_ioctl_cb.sensor_powerdown_cb) {\r
 895                 ret = sensor_ioctl_cb.sensor_powerdown_cb(res, on);\r
 896                         } else {\r
 897                 eprintk( "sensor_ioctl_cb.sensor_powerdown_cb is NULL");\r
 898                 WARN_ON(1);\r
 899                         }\r
 900                         break;\r
 901                 }\r
 902 \r
 903                 case Cam_Flash:\r
 904                 {\r
 905                         if (sensor_ioctl_cb.sensor_flash_cb) {\r
 906                 ret = sensor_ioctl_cb.sensor_flash_cb(res, on);\r
 907                         } else {\r
 908                 eprintk( "sensor_ioctl_cb.sensor_flash_cb is NULL!");\r
 909                 WARN_ON(1);\r
 910                         }\r
 911                         break;\r
 912                 }\r
 913                 \r
 914                 case Cam_Af:\r
 915                 {\r
 916                         if (sensor_ioctl_cb.sensor_af_cb) {\r
 917                 ret = sensor_ioctl_cb.sensor_af_cb(res, on);\r
 918                         } else {\r
 919                 eprintk( "sensor_ioctl_cb.sensor_af_cb is NULL!");\r
 920                 WARN_ON(1);\r
 921                         }\r
 922                         break;\r
 923                 }\r
 924 \r
 925         case Cam_Mclk:\r
 926         {\r
 927             if (plat_data->sensor_mclk && dev_icl) {\r
 928                                 plat_data->sensor_mclk(dev_icl->host_desc.bus_id,(on!=0)?1:0,on);/*yzm*/\r
 929             } else { \r
 930                 eprintk( "%s(%d): sensor_mclk(%p) or dev_icl(%p) is NULL",\r
 931                     __FUNCTION__,__LINE__,plat_data->sensor_mclk,dev_icl);\r
 932             }\r
 933             break;\r
 934         }\r
 935         \r
 936                 default:\r
 937                 {\r
 938                         eprintk("%s cmd(0x%x) is unknown!",__FUNCTION__, cmd);\r
 939                         break;\r
 940                 }\r
 941         }\r
 942 rk_sensor_ioctrl_end:\r
 943     return ret;\r
 944 }\r
 945 \r
 946 static int rk_sensor_pwrseq(struct device *dev,int powerup_sequence, int on, int mclk_rate)\r
 947 {\r
 948     int ret =0;\r
 949     int i,powerup_type;\r
 950 \r
 951         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
 952 \r
 953     \r
 954     for (i=0; i<8; i++) {\r
 955 \r
 956         if (on == 1)\r
 957             powerup_type = SENSOR_PWRSEQ_GET(powerup_sequence,i);\r
 958         else\r
 959             powerup_type = SENSOR_PWRSEQ_GET(powerup_sequence,(7-i));\r
 960         \r
 961         switch (powerup_type)\r
 962         {\r
 963             case SENSOR_PWRSEQ_AVDD:\r
 964             case SENSOR_PWRSEQ_DOVDD:\r
 965             case SENSOR_PWRSEQ_DVDD:\r
 966             case SENSOR_PWRSEQ_PWR:\r
 967             {  \r
 968                 ret = rk_sensor_ioctrl(dev,Cam_Power, on);\r
 969                 if (ret<0) {\r
 970                     eprintk("SENSOR_PWRSEQ_PWR failed");\r
 971                 } else { \r
 972                     msleep(10);\r
 973                     dprintk("SensorPwrSeq-power: %d",on);\r
 974                 }\r
 975                 break;\r
 976             }\r
 977 \r
 978             case SENSOR_PWRSEQ_HWRST:\r
 979             {\r
 980                 if(!on){\r
 981                     rk_sensor_ioctrl(dev,Cam_Reset, 1);\r
 982                 }else{\r
 983                     ret = rk_sensor_ioctrl(dev,Cam_Reset, 1);\r
 984                     msleep(2);\r
 985                     ret |= rk_sensor_ioctrl(dev,Cam_Reset, 0); \r
 986                 }\r
 987                 if (ret<0) {\r
 988                     eprintk("SENSOR_PWRSEQ_HWRST failed");\r
 989                 } else {\r
 990                     dprintk("SensorPwrSeq-reset: %d",on);\r
 991                 }\r
 992                 break;\r
 993             }\r
 994 \r
 995             case SENSOR_PWRSEQ_PWRDN:\r
 996             {     \r
 997                 ret = rk_sensor_ioctrl(dev,Cam_PowerDown, !on);\r
 998                 if (ret<0) {\r
 999                     eprintk("SENSOR_PWRSEQ_PWRDN failed");\r
1000                 } else {\r
1001                     dprintk("SensorPwrSeq-power down: %d",!on);\r
1002                 }\r
1003                 break;\r
1004             }\r
1005 \r
1006             case SENSOR_PWRSEQ_CLKIN:\r
1007             {\r
1008                 ret = rk_sensor_ioctrl(dev,Cam_Mclk, (on?mclk_rate:on));\r
1009                 if (ret<0) {\r
1010                     eprintk("SENSOR_PWRSEQ_CLKIN failed");\r
1011                 } else {\r
1012                     dprintk("SensorPwrSeq-clock: %d",on);\r
1013                 }\r
1014                 break;\r
1015             }\r
1016 \r
1017             default:\r
1018                 break;\r
1019         }\r
1020         \r
1021     } \r
1022 \r
1023     return ret;\r
1024 }\r
1025 \r
1026 static int rk_sensor_power(struct device *dev, int on)   /*icd->pdev*/\r
1027 {\r
1028     int powerup_sequence,mclk_rate;\r
1029     \r
1030     struct rk29camera_platform_data* plat_data = &rk_camera_platform_data;\r
1031     struct rk29camera_gpio_res *dev_io = NULL;\r
1032     struct rkcamera_platform_data *new_camera=NULL, *new_device=NULL;\r
1033     bool real_pwroff = true;\r
1034     int ret = 0;\r
1035 \r
1036         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
1037 \r
1038     new_camera = plat_data->register_dev_new;    /*new_camera[]*/\r
1039     \r
1040         while (new_camera != NULL) {\r
1041 \r
1042         if (new_camera->io.gpio_powerdown != INVALID_GPIO) {            \r
1043             gpio_direction_output(new_camera->io.gpio_powerdown,\r
1044                 ((new_camera->io.gpio_flag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));            \r
1045         }\r
1046 \r
1047                 debug_printk( "new_camera->dev_name= %s \n", new_camera->dev_name);     /*yzm*/\r
1048                 debug_printk( "dev_name(dev)= %s \n", dev_name(dev));    /*yzm*/\r
1049                 \r
1050         if (strcmp(new_camera->dev_name,dev_name(dev))) {               \r
1051                         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i\n", __FILE__, __LINE__);\r
1052             if (sensor_ioctl_cb.sensor_powerdown_cb && on)\r
1053                 {\r
1054                         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i\n", __FILE__, __LINE__);\r
1055                         sensor_ioctl_cb.sensor_powerdown_cb(&new_camera->io,1);\r
1056                 }\r
1057         } else {\r
1058             new_device = new_camera;\r
1059             dev_io = &new_camera->io;\r
1060             debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i\n", __FILE__, __LINE__);/*yzm*/\r
1061             if (!Sensor_Support_DirectResume(new_camera->pwdn_info))\r
1062                 real_pwroff = true;                     \r
1063             else\r
1064                 real_pwroff = false;\r
1065         }\r
1066         new_camera = new_camera->next_camera;\r
1067     }\r
1068 \r
1069     if (new_device != NULL) {\r
1070         powerup_sequence = new_device->powerup_sequence;\r
1071         if ((new_device->mclk_rate == 24) || (new_device->mclk_rate == 48))\r
1072             mclk_rate = new_device->mclk_rate*1000000;\r
1073         else \r
1074             mclk_rate = 24000000;\r
1075     } else {\r
1076         powerup_sequence = sensor_PWRSEQ_DEFAULT;\r
1077         mclk_rate = 24000000;\r
1078     }\r
1079         \r
1080     if (on) {\r
1081                 debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i\n", __FILE__, __LINE__);\r
1082         rk_sensor_pwrseq(dev, powerup_sequence, on,mclk_rate);  \r
1083     } else {\r
1084         if (real_pwroff) {\r
1085             if (rk_sensor_pwrseq(dev, powerup_sequence, on,mclk_rate)<0)    /* ddl@rock-chips.com: v0.1.5 */\r
1086                 goto PowerDown;\r
1087             \r
1088             /*ddl@rock-chips.com: all power down switch to Hi-Z after power off*/\r
1089             new_camera = plat_data->register_dev_new;\r
1090                         while (new_camera != NULL) {\r
1091                 if (new_camera->io.gpio_powerdown != INVALID_GPIO) {\r
1092                     gpio_direction_input(new_camera->io.gpio_powerdown);            \r
1093                 }\r
1094                 new_camera->pwdn_info |= 0x01;\r
1095                 new_camera = new_camera->next_camera;\r
1096             }\r
1097         } else {  \r
1098 PowerDown:\r
1099             rk_sensor_ioctrl(dev,Cam_PowerDown, !on);\r
1100 \r
1101             rk_sensor_ioctrl(dev,Cam_Mclk, 0);\r
1102         }\r
1103 \r
1104         mdelay(10);/* ddl@rock-chips.com: v0.1.3 */\r
1105     }\r
1106     return ret;\r
1107 }\r
1108 #if 0\r
1109 static int rk_sensor_reset(struct device *dev)\r
1110 {\r
1111 #if 0\r
1112         rk_sensor_ioctrl(dev,Cam_Reset,1);\r
1113         msleep(2);\r
1114         rk_sensor_ioctrl(dev,Cam_Reset,0);\r
1115 #else\r
1116     /*\r
1117     *ddl@rock-chips.com : the rest function invalidate, because this operate is put together in rk_sensor_power;\r
1118     */\r
1119 #endif\r
1120         return 0;\r
1121 }\r
1122 #endif\r
1123 static int rk_sensor_powerdown(struct device *dev, int on)\r
1124 {\r
1125 \r
1126         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()/n", __FILE__, __LINE__,__FUNCTION__);\r
1127 \r
1128         return rk_sensor_ioctrl(dev,Cam_PowerDown,on);\r
1129 }\r
1130 \r
1131 int rk_sensor_register(void)\r
1132 {\r
1133     int i;    \r
1134         struct rkcamera_platform_data *new_camera;      \r
1135         \r
1136     i = 0;\r
1137         debug_printk( "/$$$$$$$$$$$$$$$$$$$$$$//n Here I am: %s:%i-------%s()\n", __FILE__, __LINE__,__FUNCTION__);\r
1138 \r
1139         new_camera = new_camera_head;\r
1140         \r
1141         while (new_camera != NULL) {    \r
1142         if (new_camera->dev.i2c_cam_info.addr == INVALID_VALUE) {\r
1143             WARN(1, \r
1144                 KERN_ERR "%s(%d): new_camera[%d] i2c addr is invalidate!",\r
1145                 __FUNCTION__,__LINE__,i);\r
1146             continue;\r
1147         }\r
1148         sprintf(new_camera->dev_name,"%s_%d",new_camera->dev.device_info.dev.init_name,i+3);\r
1149         new_camera->dev.device_info.dev.init_name =(const char*)&new_camera->dev_name[0];\r
1150         new_camera->io.dev_name =(const char*)&new_camera->dev_name[0];\r
1151         if (new_camera->orientation == INVALID_VALUE) {\r
1152             if (strstr(new_camera->dev_name,"back")) {                     \r
1153                 new_camera->orientation = 90;\r
1154             } else {\r
1155                 new_camera->orientation = 270;\r
1156             }\r
1157         }\r
1158         /* ddl@rock-chips.com: v0.1.3 */\r
1159         if ((new_camera->fov_h <= 0) || (new_camera->fov_h>360))\r
1160             new_camera->fov_h = 100;\r
1161         \r
1162         if ((new_camera->fov_v <= 0) || (new_camera->fov_v>360))\r
1163             new_camera->fov_v = 100;        \r
1164 \r
1165                 new_camera->dev.desc_info.subdev_desc.power = rk_sensor_power;\r
1166                 new_camera->dev.desc_info.subdev_desc.powerdown = rk_sensor_powerdown;\r
1167                 new_camera->dev.desc_info.host_desc.board_info =&new_camera->dev.i2c_cam_info; \r
1168 \r
1169         new_camera->dev.device_info.id = i+6;\r
1170                 new_camera->dev.device_info.dev.platform_data = &new_camera->dev.desc_info;\r
1171                 new_camera->dev.desc_info.subdev_desc.drv_priv = &rk_camera_platform_data;\r
1172 \r
1173         platform_device_register(&(new_camera->dev.device_info));\r
1174                 i++;\r
1175         new_camera = new_camera->next_camera;\r
1176     }\r
1177         \r
1178                 return 0;\r
1179 }\r
1180 #include "../../../drivers/media/video/rk30_camera.c"\r