drivers/media/video/rk29_camera.c

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