drivers/media/video/rk29_camera.c

   1 #include <mach/rk29_camera.h> \r
   2 \r
   3 #ifndef PMEM_CAM_SIZE\r
   4 #ifdef CONFIG_VIDEO_RK29 \r
   5 /*---------------- Camera Sensor Fixed Macro Begin  ------------------------*/\r
   6 // Below Macro is fixed, programer don't change it!!!!!!\r
   7 #define _CONS(a,b) a##b\r
   8 #define CONS(a,b) _CONS(a,b)\r
   9 \r
  10 #define __STR(x) #x\r
  11 #define _STR(x) __STR(x)\r
  12 #define STR(x) _STR(x)\r
  13 \r
  14 #if (CONFIG_SENSOR_IIC_ADDR_0 != 0x00)\r
  15 #define PMEM_SENSOR_FULL_RESOLUTION_0  CONS(CONFIG_SENSOR_0,_FULL_RESOLUTION)\r
  16 #if !(PMEM_SENSOR_FULL_RESOLUTION_0)\r
  17 #undef PMEM_SENSOR_FULL_RESOLUTION_0\r
  18 #define PMEM_SENSOR_FULL_RESOLUTION_0  0x500000\r
  19 #endif\r
  20 #else\r
  21 #define PMEM_SENSOR_FULL_RESOLUTION_0  0x00\r
  22 #endif\r
  23  \r
  24 #if (CONFIG_SENSOR_IIC_ADDR_1 != 0x00)\r
  25 #define PMEM_SENSOR_FULL_RESOLUTION_1  CONS(CONFIG_SENSOR_1,_FULL_RESOLUTION)\r
  26 #if !(PMEM_SENSOR_FULL_RESOLUTION_1)\r
  27 #undef PMEM_SENSOR_FULL_RESOLUTION_1\r
  28 #define PMEM_SENSOR_FULL_RESOLUTION_1  0x500000\r
  29 #endif\r
  30 #else\r
  31 #define PMEM_SENSOR_FULL_RESOLUTION_1  0x00\r
  32 #endif\r
  33 \r
  34 #if (PMEM_SENSOR_FULL_RESOLUTION_0 > PMEM_SENSOR_FULL_RESOLUTION_1)\r
  35 #define PMEM_CAM_FULL_RESOLUTION   PMEM_SENSOR_FULL_RESOLUTION_0\r
  36 #else\r
  37 #define PMEM_CAM_FULL_RESOLUTION   PMEM_SENSOR_FULL_RESOLUTION_1\r
  38 #endif\r
  39 \r
  40 #if (PMEM_CAM_FULL_RESOLUTION == 0x500000)\r
  41 #define PMEM_CAM_NECESSARY   0x1200000       /* 1280*720*1.5*4(preview) + 7.5M(capture raw) + 4M(jpeg encode output) */\r
  42 #elif (PMEM_CAM_FULL_RESOLUTION == 0x300000)\r
  43 #define PMEM_CAM_NECESSARY   0xe00000        /* 1280*720*1.5*4(preview) + 4.5M(capture raw) + 3M(jpeg encode output) */\r
  44 #elif (PMEM_CAM_FULL_RESOLUTION == 0x200000) /* 1280*720*1.5*4(preview) + 3M(capture raw) + 3M(jpeg encode output) */\r
  45 #define PMEM_CAM_NECESSARY   0xc00000\r
  46 #elif ((PMEM_CAM_FULL_RESOLUTION == 0x100000) || (PMEM_CAM_FULL_RESOLUTION == 0x130000))\r
  47 #define PMEM_CAM_NECESSARY   0x800000        /* 800*600*1.5*4(preview) + 2M(capture raw) + 2M(jpeg encode output) */\r
  48 #elif (PMEM_CAM_FULL_RESOLUTION == 0x30000)\r
  49 #define PMEM_CAM_NECESSARY   0x400000        /* 640*480*1.5*4(preview) + 1M(capture raw) + 1M(jpeg encode output) */\r
  50 #else\r
  51 #define PMEM_CAM_NECESSARY   0x1200000\r
  52 #endif\r
  53 /*---------------- Camera Sensor Fixed Macro End  ------------------------*/\r
  54 #else   //#ifdef CONFIG_VIDEO_RK29 \r
  55 #define PMEM_CAM_NECESSARY   0x00000000\r
  56 #endif\r
  57 #else   // #ifdef PMEM_CAM_SIZE\r
  58 \r
  59 /*****************************************************************************************\r
  60  * camera  devices\r
  61  * author: ddl@rock-chips.com\r
  62  *****************************************************************************************/\r
  63 #ifdef CONFIG_VIDEO_RK29 \r
  64 static int camera_debug;\r
  65 module_param(camera_debug, int, S_IRUGO|S_IWUSR);\r
  66 \r
  67 #define ddprintk(level, fmt, arg...) do {                       \\r
  68         if (camera_debug >= level)                                      \\r
  69             printk(KERN_WARNING"rk29_cam_io: " fmt , ## arg); } while (0)\r
  70 \r
  71 #define dprintk(format, ...) ddprintk(1, format, ## __VA_ARGS__)    \r
  72 \r
  73 #define SENSOR_NAME_0 STR(CONFIG_SENSOR_0)                      /* back camera sensor */\r
  74 #define SENSOR_NAME_1 STR(CONFIG_SENSOR_1)                      /* front camera sensor */\r
  75 #define SENSOR_DEVICE_NAME_0  STR(CONS(CONFIG_SENSOR_0, _back))\r
  76 #define SENSOR_DEVICE_NAME_1  STR(CONS(CONFIG_SENSOR_1, _front))\r
  77 \r
  78 static int rk29_sensor_io_init(void);\r
  79 static int rk29_sensor_io_deinit(int sensor);\r
  80 static int rk29_sensor_ioctrl(struct device *dev,enum rk29camera_ioctrl_cmd cmd,int on);\r
  81 \r
  82 static struct rk29camera_platform_data rk29_camera_platform_data = {\r
  83     .io_init = rk29_sensor_io_init,\r
  84     .io_deinit = rk29_sensor_io_deinit,\r
  85     .sensor_ioctrl = rk29_sensor_ioctrl,\r
  86     .gpio_res = {\r
  87         {\r
  88             .gpio_reset = CONFIG_SENSOR_RESET_PIN_0,\r
  89             .gpio_power = CONFIG_SENSOR_POWER_PIN_0,\r
  90             .gpio_powerdown = CONFIG_SENSOR_POWERDN_PIN_0,\r
  91             .gpio_flash = CONFIG_SENSOR_FALSH_PIN_0,\r
  92             .gpio_flag = (CONFIG_SENSOR_POWERACTIVE_LEVEL_0|CONFIG_SENSOR_RESETACTIVE_LEVEL_0|CONFIG_SENSOR_POWERDNACTIVE_LEVEL_0|CONFIG_SENSOR_FLASHACTIVE_LEVEL_0),\r
  93             .gpio_init = 0,\r
  94             .dev_name = SENSOR_DEVICE_NAME_0,\r
  95         }, {\r
  96             .gpio_reset = CONFIG_SENSOR_RESET_PIN_1,\r
  97             .gpio_power = CONFIG_SENSOR_POWER_PIN_1,\r
  98             .gpio_powerdown = CONFIG_SENSOR_POWERDN_PIN_1,\r
  99             .gpio_flash = CONFIG_SENSOR_FALSH_PIN_1,\r
 100             .gpio_flag = (CONFIG_SENSOR_POWERACTIVE_LEVEL_1|CONFIG_SENSOR_RESETACTIVE_LEVEL_1|CONFIG_SENSOR_POWERDNACTIVE_LEVEL_1|CONFIG_SENSOR_FLASHACTIVE_LEVEL_1),\r
 101             .gpio_init = 0,\r
 102             .dev_name = SENSOR_DEVICE_NAME_1,\r
 103         }\r
 104     },\r
 105         #ifdef CONFIG_VIDEO_RK29_WORK_IPP\r
 106         .meminfo = {\r
 107             .name  = "camera_ipp_mem",\r
 108                 .start = MEM_CAMIPP_BASE,\r
 109                 .size   = MEM_CAMIPP_SIZE,\r
 110         }\r
 111         #endif\r
 112 };\r
 113 \r
 114 \r
 115 \r
 116 static int sensor_power_default_cb (struct rk29camera_gpio_res *res, int on)\r
 117 {\r
 118     int camera_power = res->gpio_power;\r
 119     int camera_ioflag = res->gpio_flag;\r
 120     int camera_io_init = res->gpio_init;\r
 121     int ret = 0;\r
 122     \r
 123     if (camera_power != INVALID_GPIO)  {\r
 124                      if (camera_io_init & RK29_CAM_POWERACTIVE_MASK) {\r
 125             if (on) {\r
 126                 gpio_set_value(camera_power, ((camera_ioflag&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 127                         dprintk("\n%s..%s..PowerPin=%d ..PinLevel = %x   \n",__FUNCTION__,res->dev_name, camera_power, ((camera_ioflag&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 128                         msleep(10);\r
 129                 } else {\r
 130                         gpio_set_value(camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 131                         dprintk("\n%s..%s..PowerPin=%d ..PinLevel = %x   \n",__FUNCTION__,res->dev_name, camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 132                 }\r
 133                 } else {\r
 134                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 135                         printk("\n%s..%s..PowerPin=%d request failed!\n",__FUNCTION__,res->dev_name,camera_power);\r
 136             }        \r
 137     } else {\r
 138                 ret = RK29_CAM_EIO_INVALID;\r
 139     } \r
 140 \r
 141     return ret;\r
 142 }\r
 143 \r
 144 static int sensor_reset_default_cb (struct rk29camera_gpio_res *res, int on)\r
 145 {\r
 146     int camera_reset = res->gpio_reset;\r
 147     int camera_ioflag = res->gpio_flag;\r
 148     int camera_io_init = res->gpio_init;  \r
 149     int ret = 0;\r
 150     \r
 151     if (camera_reset != INVALID_GPIO) {\r
 152                 if (camera_io_init & RK29_CAM_RESETACTIVE_MASK) {\r
 153                         if (on) {\r
 154                         gpio_set_value(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 155                         dprintk("\n%s..%s..ResetPin=%d ..PinLevel = %x \n",__FUNCTION__,res->dev_name,camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 156                         } else {\r
 157                                 gpio_set_value(camera_reset,(((~camera_ioflag)&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 158                         dprintk("\n%s..%s..ResetPin= %d..PinLevel = %x   \n",__FUNCTION__,res->dev_name, camera_reset, (((~camera_ioflag)&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 159                 }\r
 160                 } else {\r
 161                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 162                         printk("\n%s..%s..ResetPin=%d request failed!\n",__FUNCTION__,res->dev_name,camera_reset);\r
 163                 }\r
 164     } else {\r
 165                 ret = RK29_CAM_EIO_INVALID;\r
 166     }\r
 167 \r
 168     return ret;\r
 169 }\r
 170 \r
 171 static int sensor_powerdown_default_cb (struct rk29camera_gpio_res *res, int on)\r
 172 {\r
 173     int camera_powerdown = res->gpio_powerdown;\r
 174     int camera_ioflag = res->gpio_flag;\r
 175     int camera_io_init = res->gpio_init;  \r
 176     int ret = 0;    \r
 177 \r
 178     if (camera_powerdown != INVALID_GPIO) {\r
 179                 if (camera_io_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 180                         if (on) {\r
 181                         gpio_set_value(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 182                         dprintk("\n%s..%s..PowerDownPin=%d ..PinLevel = %x \n",__FUNCTION__,res->dev_name,camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 183                         } else {\r
 184                                 gpio_set_value(camera_powerdown,(((~camera_ioflag)&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 185                         dprintk("\n%s..%s..PowerDownPin= %d..PinLevel = %x   \n",__FUNCTION__,res->dev_name, camera_powerdown, (((~camera_ioflag)&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 186                 }\r
 187                 } else {\r
 188                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 189                         dprintk("\n%s..%s..PowerDownPin=%d request failed!\n",__FUNCTION__,res->dev_name,camera_powerdown);\r
 190                 }\r
 191     } else {\r
 192                 ret = RK29_CAM_EIO_INVALID;\r
 193     }\r
 194     return ret;\r
 195 }\r
 196 \r
 197 \r
 198 static int sensor_flash_default_cb (struct rk29camera_gpio_res *res, int on)\r
 199 {\r
 200     int camera_flash = res->gpio_flash;\r
 201     int camera_ioflag = res->gpio_flag;\r
 202     int camera_io_init = res->gpio_init;  \r
 203     int ret = 0;    \r
 204 \r
 205     if (camera_flash != INVALID_GPIO) {\r
 206                 if (camera_io_init & RK29_CAM_FLASHACTIVE_MASK) {\r
 207             switch (on)\r
 208             {\r
 209                 case Flash_Off:\r
 210                 {\r
 211                     gpio_set_value(camera_flash,(((~camera_ioflag)&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 212                             dprintk("\n%s..%s..FlashPin= %d..PinLevel = %x   \n",__FUNCTION__,res->dev_name, camera_flash, (((~camera_ioflag)&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS)); \r
 213                             break;\r
 214                 }\r
 215 \r
 216                 case Flash_On:\r
 217                 {\r
 218                     gpio_set_value(camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 219                             dprintk("\n%s..%s..FlashPin=%d ..PinLevel = %x \n",__FUNCTION__,res->dev_name,camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 220                             break;\r
 221                 }\r
 222 \r
 223                 case Flash_Torch:\r
 224                 {\r
 225                     gpio_set_value(camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 226                             dprintk("\n%s..%s..FlashPin=%d ..PinLevel = %x \n",__FUNCTION__,res->dev_name,camera_flash, ((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 227                             break;\r
 228                 }\r
 229 \r
 230                 default:\r
 231                 {\r
 232                     printk("\n%s..%s..Flash command(%d) is invalidate \n",__FUNCTION__,res->dev_name,on);\r
 233                     break;\r
 234                 }\r
 235             }\r
 236                 } else {\r
 237                         ret = RK29_CAM_EIO_REQUESTFAIL;\r
 238                         printk("\n%s..%s..FlashPin=%d request failed!\n",__FUNCTION__,res->dev_name,camera_flash);\r
 239                 }\r
 240     } else {\r
 241                 ret = RK29_CAM_EIO_INVALID;\r
 242     }\r
 243     return ret;\r
 244 }\r
 245 \r
 246 \r
 247 static int rk29_sensor_io_init(void)\r
 248 {\r
 249     int ret = 0, i;\r
 250     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;\r
 251         unsigned int camera_powerdown = INVALID_GPIO, camera_flash = INVALID_GPIO;\r
 252         unsigned int camera_ioflag;\r
 253 \r
 254     if (sensor_ioctl_cb.sensor_power_cb == NULL)\r
 255         sensor_ioctl_cb.sensor_power_cb = sensor_power_default_cb;\r
 256     if (sensor_ioctl_cb.sensor_reset_cb == NULL)\r
 257         sensor_ioctl_cb.sensor_reset_cb = sensor_reset_default_cb;\r
 258     if (sensor_ioctl_cb.sensor_powerdown_cb == NULL)\r
 259         sensor_ioctl_cb.sensor_powerdown_cb = sensor_powerdown_default_cb;\r
 260     if (sensor_ioctl_cb.sensor_flash_cb == NULL)\r
 261         sensor_ioctl_cb.sensor_flash_cb = sensor_flash_default_cb;\r
 262     \r
 263     for (i=0; i<2; i++) {\r
 264         camera_reset = rk29_camera_platform_data.gpio_res[i].gpio_reset;\r
 265         camera_power = rk29_camera_platform_data.gpio_res[i].gpio_power;\r
 266                 camera_powerdown = rk29_camera_platform_data.gpio_res[i].gpio_powerdown;\r
 267         camera_flash = rk29_camera_platform_data.gpio_res[i].gpio_flash;\r
 268                 camera_ioflag = rk29_camera_platform_data.gpio_res[i].gpio_flag;\r
 269                 rk29_camera_platform_data.gpio_res[i].gpio_init = 0;\r
 270 \r
 271         if (camera_power != INVALID_GPIO) {\r
 272             ret = gpio_request(camera_power, "camera power");\r
 273             if (ret) {\r
 274                 if (i == 0) {\r
 275                                     goto sensor_io_int_loop_end;\r
 276                 } else {\r
 277                     if (camera_power != rk29_camera_platform_data.gpio_res[0].gpio_power)\r
 278                         goto sensor_io_int_loop_end;\r
 279                 }\r
 280             }\r
 281 \r
 282                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_POWERACTIVE_MASK;\r
 283             gpio_set_value(camera_reset, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 284             gpio_direction_output(camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 285 \r
 286                         printk("\n%s....power pin(%d) init success(0x%x)  \n",__FUNCTION__,camera_power,(((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));\r
 287 \r
 288         }\r
 289 \r
 290         if (camera_reset != INVALID_GPIO) {\r
 291             ret = gpio_request(camera_reset, "camera reset");\r
 292             if (ret)\r
 293                                 goto sensor_io_int_loop_end;\r
 294                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_RESETACTIVE_MASK;\r
 295             gpio_set_value(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 296             gpio_direction_output(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 297 \r
 298                         dprintk("\n%s....reset pin(%d) init success(0x%x)\n",__FUNCTION__,camera_reset,((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));\r
 299 \r
 300         }\r
 301 \r
 302                 if (camera_powerdown != INVALID_GPIO) {\r
 303             ret = gpio_request(camera_powerdown, "camera powerdown");\r
 304             if (ret)\r
 305                                 goto sensor_io_int_loop_end;\r
 306                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_POWERDNACTIVE_MASK;\r
 307             gpio_set_value(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 308             gpio_direction_output(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 309 \r
 310                         printk("\n%s....powerdown pin(%d) init success(0x%x) \n",__FUNCTION__,camera_powerdown,((camera_ioflag&RK29_CAM_POWERDNACTIVE_BITPOS)>>RK29_CAM_POWERDNACTIVE_BITPOS));\r
 311 \r
 312         }\r
 313 \r
 314                 if (camera_flash != INVALID_GPIO) {\r
 315             ret = gpio_request(camera_flash, "camera flash");\r
 316             if (ret)\r
 317                                 goto sensor_io_int_loop_end;\r
 318                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_FLASHACTIVE_MASK;\r
 319             gpio_set_value(camera_flash, ((~camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));    /* falsh off */\r
 320             gpio_direction_output(camera_flash, ((~camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 321 \r
 322                         dprintk("\n%s....flash pin(%d) init success(0x%x) \n",__FUNCTION__,camera_flash,((camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 323 \r
 324         }\r
 325                 continue;\r
 326 sensor_io_int_loop_end:\r
 327                 rk29_sensor_io_deinit(i);\r
 328                 continue;\r
 329     }\r
 330 \r
 331     return 0;\r
 332 }\r
 333 \r
 334 static int rk29_sensor_io_deinit(int sensor)\r
 335 {\r
 336     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;\r
 337         unsigned int camera_powerdown = INVALID_GPIO, camera_flash = INVALID_GPIO;\r
 338 \r
 339     camera_reset = rk29_camera_platform_data.gpio_res[sensor].gpio_reset;\r
 340     camera_power = rk29_camera_platform_data.gpio_res[sensor].gpio_power;\r
 341         camera_powerdown = rk29_camera_platform_data.gpio_res[sensor].gpio_powerdown;\r
 342     camera_flash = rk29_camera_platform_data.gpio_res[sensor].gpio_flash;\r
 343 \r
 344         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_POWERACTIVE_MASK) {\r
 345             if (camera_power != INVALID_GPIO) {\r
 346                 gpio_direction_input(camera_power);\r
 347                 gpio_free(camera_power);\r
 348             }\r
 349         }\r
 350 \r
 351         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_RESETACTIVE_MASK) {\r
 352             if (camera_reset != INVALID_GPIO)  {\r
 353                 gpio_direction_input(camera_reset);\r
 354                 gpio_free(camera_reset);\r
 355             }\r
 356         }\r
 357 \r
 358         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_POWERDNACTIVE_MASK) {\r
 359             if (camera_powerdown != INVALID_GPIO)  {\r
 360                 gpio_direction_input(camera_powerdown);\r
 361                 gpio_free(camera_powerdown);\r
 362             }\r
 363         }\r
 364 \r
 365         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_FLASHACTIVE_MASK) {\r
 366             if (camera_flash != INVALID_GPIO)  {\r
 367                 gpio_direction_input(camera_flash);\r
 368                 gpio_free(camera_flash);\r
 369             }\r
 370         }\r
 371 \r
 372         rk29_camera_platform_data.gpio_res[sensor].gpio_init = 0;\r
 373     return 0;\r
 374 }\r
 375 static int rk29_sensor_ioctrl(struct device *dev,enum rk29camera_ioctrl_cmd cmd, int on)\r
 376 {\r
 377     struct rk29camera_gpio_res *res = NULL;    \r
 378         int ret = RK29_CAM_IO_SUCCESS;\r
 379 \r
 380     if(rk29_camera_platform_data.gpio_res[0].dev_name &&  (strcmp(rk29_camera_platform_data.gpio_res[0].dev_name, dev_name(dev)) == 0)) {\r
 381                 res = (struct rk29camera_gpio_res *)&rk29_camera_platform_data.gpio_res[0];\r
 382     } else if (rk29_camera_platform_data.gpio_res[1].dev_name && (strcmp(rk29_camera_platform_data.gpio_res[1].dev_name, dev_name(dev)) == 0)) {\r
 383         res = (struct rk29camera_gpio_res *)&rk29_camera_platform_data.gpio_res[1];\r
 384     } else {\r
 385         printk(KERN_ERR "%s is not regisiterd in rk29_camera_platform_data!!\n",dev_name(dev));\r
 386         ret = RK29_CAM_EIO_INVALID;\r
 387         goto rk29_sensor_ioctrl_end;\r
 388     }\r
 389 \r
 390         switch (cmd)\r
 391         {\r
 392                 case Cam_Power:\r
 393                 {\r
 394                         if (sensor_ioctl_cb.sensor_power_cb) {\r
 395                 ret = sensor_ioctl_cb.sensor_power_cb(res, on);\r
 396                         } else {\r
 397                 printk(KERN_ERR "sensor_ioctl_cb.sensor_power_cb is NULL");\r
 398                 WARN_ON(1);\r
 399                         }\r
 400                         break;\r
 401                 }\r
 402                 case Cam_Reset:\r
 403                 {\r
 404                         if (sensor_ioctl_cb.sensor_reset_cb) {\r
 405                 ret = sensor_ioctl_cb.sensor_reset_cb(res, on);\r
 406                         } else {\r
 407                 printk(KERN_ERR "sensor_ioctl_cb.sensor_reset_cb is NULL");\r
 408                 WARN_ON(1);\r
 409                         }\r
 410                         break;\r
 411                 }\r
 412 \r
 413                 case Cam_PowerDown:\r
 414                 {\r
 415                         if (sensor_ioctl_cb.sensor_powerdown_cb) {\r
 416                 ret = sensor_ioctl_cb.sensor_powerdown_cb(res, on);\r
 417                         } else {\r
 418                 printk(KERN_ERR "sensor_ioctl_cb.sensor_powerdown_cb is NULL");\r
 419                 WARN_ON(1);\r
 420                         }\r
 421                         break;\r
 422                 }\r
 423 \r
 424                 case Cam_Flash:\r
 425                 {\r
 426                         if (sensor_ioctl_cb.sensor_flash_cb) {\r
 427                 ret = sensor_ioctl_cb.sensor_flash_cb(res, on);\r
 428                         } else {\r
 429                 printk(KERN_ERR "sensor_ioctl_cb.sensor_flash_cb is NULL!");\r
 430                 WARN_ON(1);\r
 431                         }\r
 432                         break;\r
 433                 }\r
 434 \r
 435                 default:\r
 436                 {\r
 437                         printk("%s cmd(0x%x) is unknown!\n",__FUNCTION__, cmd);\r
 438                         break;\r
 439                 }\r
 440         }\r
 441 rk29_sensor_ioctrl_end:\r
 442     return ret;\r
 443 }\r
 444 static int rk29_sensor_power(struct device *dev, int on)\r
 445 {\r
 446         rk29_sensor_ioctrl(dev,Cam_Power,on);\r
 447     return 0;\r
 448 }\r
 449 #if 0\r
 450 static int rk29_sensor_reset(struct device *dev)\r
 451 {\r
 452         rk29_sensor_ioctrl(dev,Cam_Reset,1);\r
 453         msleep(2);\r
 454         rk29_sensor_ioctrl(dev,Cam_Reset,0);\r
 455         return 0;\r
 456 }\r
 457 #endif\r
 458 static int rk29_sensor_powerdown(struct device *dev, int on)\r
 459 {\r
 460         return rk29_sensor_ioctrl(dev,Cam_PowerDown,on);\r
 461 }\r
 462 #if (CONFIG_SENSOR_IIC_ADDR_0 != 0x00)\r
 463 static struct i2c_board_info rk29_i2c_cam_info_0[] = {\r
 464         {\r
 465                 I2C_BOARD_INFO(SENSOR_NAME_0, CONFIG_SENSOR_IIC_ADDR_0>>1)\r
 466         },\r
 467 };\r
 468 \r
 469 static struct soc_camera_link rk29_iclink_0 = {\r
 470         .bus_id         = RK29_CAM_PLATFORM_DEV_ID,\r
 471         .power          = rk29_sensor_power,\r
 472         .powerdown  = rk29_sensor_powerdown,\r
 473         .board_info     = &rk29_i2c_cam_info_0[0],\r
 474         .i2c_adapter_id = CONFIG_SENSOR_IIC_ADAPTER_ID_0,\r
 475         .module_name    = SENSOR_NAME_0,\r
 476 };\r
 477 \r
 478 /*platform_device : soc-camera need  */\r
 479 static struct platform_device rk29_soc_camera_pdrv_0 = {\r
 480         .name   = "soc-camera-pdrv",\r
 481         .id     = 0,\r
 482         .dev    = {\r
 483                 .init_name = SENSOR_DEVICE_NAME_0,\r
 484                 .platform_data = &rk29_iclink_0,\r
 485         },\r
 486 };\r
 487 #endif\r
 488 static struct i2c_board_info rk29_i2c_cam_info_1[] = {\r
 489         {\r
 490                 I2C_BOARD_INFO(SENSOR_NAME_1, CONFIG_SENSOR_IIC_ADDR_1>>1)\r
 491         },\r
 492 };\r
 493 \r
 494 static struct soc_camera_link rk29_iclink_1 = {\r
 495         .bus_id         = RK29_CAM_PLATFORM_DEV_ID,\r
 496         .power          = rk29_sensor_power,\r
 497         .powerdown  = rk29_sensor_powerdown,\r
 498         .board_info     = &rk29_i2c_cam_info_1[0],\r
 499         .i2c_adapter_id = CONFIG_SENSOR_IIC_ADAPTER_ID_1,\r
 500         .module_name    = SENSOR_NAME_1,\r
 501 };\r
 502 \r
 503 /*platform_device : soc-camera need  */\r
 504 static struct platform_device rk29_soc_camera_pdrv_1 = {\r
 505         .name   = "soc-camera-pdrv",\r
 506         .id     = 1,\r
 507         .dev    = {\r
 508                 .init_name = SENSOR_DEVICE_NAME_1,\r
 509                 .platform_data = &rk29_iclink_1,\r
 510         },\r
 511 };\r
 512 \r
 513 \r
 514 static u64 rockchip_device_camera_dmamask = 0xffffffffUL;\r
 515 static struct resource rk29_camera_resource[] = {\r
 516         [0] = {\r
 517                 .start = RK29_VIP_PHYS,\r
 518                 .end   = RK29_VIP_PHYS + RK29_VIP_SIZE - 1,\r
 519                 .flags = IORESOURCE_MEM,\r
 520         },\r
 521         [1] = {\r
 522                 .start = IRQ_VIP,\r
 523                 .end   = IRQ_VIP,\r
 524                 .flags = IORESOURCE_IRQ,\r
 525         }\r
 526 };\r
 527 \r
 528 /*platform_device : */\r
 529 static struct platform_device rk29_device_camera = {\r
 530         .name             = RK29_CAM_DRV_NAME,\r
 531         .id               = RK29_CAM_PLATFORM_DEV_ID,               /* This is used to put cameras on this interface */\r
 532         .num_resources    = ARRAY_SIZE(rk29_camera_resource),\r
 533         .resource         = rk29_camera_resource,\r
 534         .dev            = {\r
 535                 .dma_mask = &rockchip_device_camera_dmamask,\r
 536                 .coherent_dma_mask = 0xffffffffUL,\r
 537                 .platform_data  = &rk29_camera_platform_data,\r
 538         }\r
 539 };\r
 540 \r
 541 static struct android_pmem_platform_data android_pmem_cam_pdata = {\r
 542         .name           = "pmem_cam",\r
 543         .start          = PMEM_CAM_BASE,\r
 544         .size           = PMEM_CAM_SIZE,\r
 545         .no_allocator   = 1,\r
 546         .cached         = 1,\r
 547 };\r
 548 \r
 549 static struct platform_device android_pmem_cam_device = {\r
 550         .name           = "android_pmem",\r
 551         .id             = 1,\r
 552         .dev            = {\r
 553                 .platform_data = &android_pmem_cam_pdata,\r
 554         },\r
 555 };\r
 556 \r
 557 #endif\r
 558 \r
 559 #endif //#ifdef CONFIG_VIDEO_RK29