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