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