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!!!!!!
   7 #define _CONS(a,b) a##b
   8 #define CONS(a,b) _CONS(a,b)\r
   9 \r
  10 #define __STR(x) #x
  11 #define _STR(x) __STR(x)
  12 #define STR(x) _STR(x)\r
  13 \r
  14 #if (CONFIG_SENSOR_IIC_ADDR_0 != 0x00)
  15 #define PMEM_SENSOR_FULL_RESOLUTION_0  CONS(CONFIG_SENSOR_0,_FULL_RESOLUTION)
  16 #if !(PMEM_SENSOR_FULL_RESOLUTION_0)
  17 #undef PMEM_SENSOR_FULL_RESOLUTION_0
  18 #define PMEM_SENSOR_FULL_RESOLUTION_0  0x500000
  19 #endif
  20 #else
  21 #define PMEM_SENSOR_FULL_RESOLUTION_0  0x00
  22 #endif
  23
  24 #if (CONFIG_SENSOR_IIC_ADDR_1 != 0x00)
  25 #define PMEM_SENSOR_FULL_RESOLUTION_1  CONS(CONFIG_SENSOR_1,_FULL_RESOLUTION)
  26 #if !(PMEM_SENSOR_FULL_RESOLUTION_1)
  27 #undef PMEM_SENSOR_FULL_RESOLUTION_1
  28 #define PMEM_SENSOR_FULL_RESOLUTION_1  0x500000
  29 #endif
  30 #else
  31 #define PMEM_SENSOR_FULL_RESOLUTION_1  0x00
  32 #endif
  33
  34 #if (PMEM_SENSOR_FULL_RESOLUTION_0 > PMEM_SENSOR_FULL_RESOLUTION_1)
  35 #define PMEM_CAM_FULL_RESOLUTION   PMEM_SENSOR_FULL_RESOLUTION_0
  36 #else
  37 #define PMEM_CAM_FULL_RESOLUTION   PMEM_SENSOR_FULL_RESOLUTION_1
  38 #endif
  39
  40 #if (PMEM_CAM_FULL_RESOLUTION == 0x500000)
  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)
  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))
  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 /*****************************************************************************************
  60  * camera  devices
  61  * author: ddl@rock-chips.com
  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
  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 */
  74 #define SENSOR_NAME_1 STR(CONFIG_SENSOR_1)                      /* front camera sensor */
  75 #define SENSOR_DEVICE_NAME_0  STR(CONS(CONFIG_SENSOR_0, _back))
  76 #define SENSOR_DEVICE_NAME_1  STR(CONS(CONFIG_SENSOR_1, _front))
  77
  78 static int rk29_sensor_io_init(void);
  79 static int rk29_sensor_io_deinit(int sensor);
  80 static int rk29_sensor_ioctrl(struct device *dev,enum rk29camera_ioctrl_cmd cmd,int on);
  81
  82 static struct rk29camera_platform_data rk29_camera_platform_data = {\r
  83     .io_init = rk29_sensor_io_init,
  84     .io_deinit = rk29_sensor_io_deinit,
  85     .sensor_ioctrl = rk29_sensor_ioctrl,
  86     .gpio_res = {
  87         {
  88             .gpio_reset = CONFIG_SENSOR_RESET_PIN_0,
  89             .gpio_power = CONFIG_SENSOR_POWER_PIN_0,
  90             .gpio_powerdown = CONFIG_SENSOR_POWERDN_PIN_0,
  91             .gpio_flash = CONFIG_SENSOR_FALSH_PIN_0,
  92             .gpio_flag = (CONFIG_SENSOR_POWERACTIVE_LEVEL_0|CONFIG_SENSOR_RESETACTIVE_LEVEL_0|CONFIG_SENSOR_POWERDNACTIVE_LEVEL_0|CONFIG_SENSOR_FLASHACTIVE_LEVEL_0),
  93             .gpio_init = 0,
  94             .dev_name = SENSOR_DEVICE_NAME_0,
  95         }, {
  96             .gpio_reset = CONFIG_SENSOR_RESET_PIN_1,
  97             .gpio_power = CONFIG_SENSOR_POWER_PIN_1,
  98             .gpio_powerdown = CONFIG_SENSOR_POWERDN_PIN_1,
  99             .gpio_flash = CONFIG_SENSOR_FALSH_PIN_1,
 100             .gpio_flag = (CONFIG_SENSOR_POWERACTIVE_LEVEL_1|CONFIG_SENSOR_RESETACTIVE_LEVEL_1|CONFIG_SENSOR_POWERDNACTIVE_LEVEL_1|CONFIG_SENSOR_FLASHACTIVE_LEVEL_1),
 101             .gpio_init = 0,
 102             .dev_name = SENSOR_DEVICE_NAME_1,
 103         }
 104     },
 105         #ifdef CONFIG_VIDEO_RK29_WORK_IPP
 106         .meminfo = {
 107             .name  = "camera_ipp_mem",
 108                 .start = MEM_CAMIPP_BASE,
 109                 .size   = MEM_CAMIPP_SIZE,
 110         }
 111         #endif
 112 };\r
 113 \r
 114
 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 {
 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 }
 170 \r
 171 static int sensor_powerdown_default_cb (struct rk29camera_gpio_res *res, int on)\r
 172 {
 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 }
 196 \r
 197
 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
 247 static int rk29_sensor_io_init(void)
 248 {
 249     int ret = 0, i;
 250     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
 251         unsigned int camera_powerdown = INVALID_GPIO, camera_flash = INVALID_GPIO;
 252         unsigned int camera_ioflag;
 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++) {
 264         camera_reset = rk29_camera_platform_data.gpio_res[i].gpio_reset;
 265         camera_power = rk29_camera_platform_data.gpio_res[i].gpio_power;
 266                 camera_powerdown = rk29_camera_platform_data.gpio_res[i].gpio_powerdown;
 267         camera_flash = rk29_camera_platform_data.gpio_res[i].gpio_flash;
 268                 camera_ioflag = rk29_camera_platform_data.gpio_res[i].gpio_flag;
 269                 rk29_camera_platform_data.gpio_res[i].gpio_init = 0;
 270
 271         if (camera_power != INVALID_GPIO) {
 272             ret = gpio_request(camera_power, "camera power");
 273             if (ret) {
 274                 if (i == 0) {\r
 275                                     goto sensor_io_int_loop_end;
 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                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_POWERACTIVE_MASK;
 282             gpio_set_value(camera_reset, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));
 283             gpio_direction_output(camera_power, (((~camera_ioflag)&RK29_CAM_POWERACTIVE_MASK)>>RK29_CAM_POWERACTIVE_BITPOS));
 284
 285                         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
 286
 287         }
 288
 289         if (camera_reset != INVALID_GPIO) {
 290             ret = gpio_request(camera_reset, "camera reset");
 291             if (ret)
 292                                 goto sensor_io_int_loop_end;
 293                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_RESETACTIVE_MASK;
 294             gpio_set_value(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));
 295             gpio_direction_output(camera_reset, ((camera_ioflag&RK29_CAM_RESETACTIVE_MASK)>>RK29_CAM_RESETACTIVE_BITPOS));
 296
 297                         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
 298
 299         }
 300
 301                 if (camera_powerdown != INVALID_GPIO) {
 302             ret = gpio_request(camera_powerdown, "camera powerdown");
 303             if (ret)
 304                                 goto sensor_io_int_loop_end;
 305                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_POWERDNACTIVE_MASK;
 306             gpio_set_value(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));
 307             gpio_direction_output(camera_powerdown, ((camera_ioflag&RK29_CAM_POWERDNACTIVE_MASK)>>RK29_CAM_POWERDNACTIVE_BITPOS));
 308
 309                         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
 310
 311         }
 312
 313                 if (camera_flash != INVALID_GPIO) {
 314             ret = gpio_request(camera_flash, "camera flash");
 315             if (ret)
 316                                 goto sensor_io_int_loop_end;
 317                         rk29_camera_platform_data.gpio_res[i].gpio_init |= RK29_CAM_FLASHACTIVE_MASK;
 318             gpio_set_value(camera_flash, ((~camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));    /* falsh off */\r
 319             gpio_direction_output(camera_flash, ((~camera_ioflag&RK29_CAM_FLASHACTIVE_MASK)>>RK29_CAM_FLASHACTIVE_BITPOS));\r
 320
 321                         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
 322
 323         }
 324                 continue;
 325 sensor_io_int_loop_end:
 326                 rk29_sensor_io_deinit(i);
 327                 continue;
 328     }
 329
 330     return 0;
 331 }
 332
 333 static int rk29_sensor_io_deinit(int sensor)
 334 {
 335     unsigned int camera_reset = INVALID_GPIO, camera_power = INVALID_GPIO;
 336         unsigned int camera_powerdown = INVALID_GPIO, camera_flash = INVALID_GPIO;
 337
 338     camera_reset = rk29_camera_platform_data.gpio_res[sensor].gpio_reset;
 339     camera_power = rk29_camera_platform_data.gpio_res[sensor].gpio_power;
 340         camera_powerdown = rk29_camera_platform_data.gpio_res[sensor].gpio_powerdown;
 341     camera_flash = rk29_camera_platform_data.gpio_res[sensor].gpio_flash;
 342
 343         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_POWERACTIVE_MASK) {
 344             if (camera_power != INVALID_GPIO) {
 345                 gpio_direction_input(camera_power);
 346                 gpio_free(camera_power);
 347             }
 348         }
 349
 350         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_RESETACTIVE_MASK) {
 351             if (camera_reset != INVALID_GPIO)  {
 352                 gpio_direction_input(camera_reset);
 353                 gpio_free(camera_reset);
 354             }
 355         }
 356
 357         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_POWERDNACTIVE_MASK) {
 358             if (camera_powerdown != INVALID_GPIO)  {
 359                 gpio_direction_input(camera_powerdown);
 360                 gpio_free(camera_powerdown);
 361             }
 362         }
 363
 364         if (rk29_camera_platform_data.gpio_res[sensor].gpio_init & RK29_CAM_FLASHACTIVE_MASK) {
 365             if (camera_flash != INVALID_GPIO)  {
 366                 gpio_direction_input(camera_flash);
 367                 gpio_free(camera_flash);
 368             }
 369         }
 370
 371         rk29_camera_platform_data.gpio_res[sensor].gpio_init = 0;
 372     return 0;
 373 }
 374 static int rk29_sensor_ioctrl(struct device *dev,enum rk29camera_ioctrl_cmd cmd, int on)
 375 {
 376     struct rk29camera_gpio_res *res = NULL;    \r
 377         int ret = RK29_CAM_IO_SUCCESS;
 378
 379     if(rk29_camera_platform_data.gpio_res[0].dev_name &&  (strcmp(rk29_camera_platform_data.gpio_res[0].dev_name, dev_name(dev)) == 0)) {
 380                 res = (struct rk29camera_gpio_res *)&rk29_camera_platform_data.gpio_res[0];\r
 381     } 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)) {
 382         res = (struct rk29camera_gpio_res *)&rk29_camera_platform_data.gpio_res[1];\r
 383     } else {\r
 384         printk(KERN_ERR "%s is not regisiterd in rk29_camera_platform_data!!\n",dev_name(dev));\r
 385         ret = RK29_CAM_EIO_INVALID;\r
 386         goto rk29_sensor_ioctrl_end;\r
 387     }\r
 388
 389         switch (cmd)
 390         {
 391                 case Cam_Power:
 392                 {
 393                         if (sensor_ioctl_cb.sensor_power_cb) {\r
 394                 ret = sensor_ioctl_cb.sensor_power_cb(res, on);\r
 395                         } else {\r
 396                 printk(KERN_ERR "sensor_ioctl_cb.sensor_power_cb is NULL");\r
 397                 WARN_ON(1);\r
 398                         }\r
 399                         break;
 400                 }
 401                 case Cam_Reset:
 402                 {
 403                         if (sensor_ioctl_cb.sensor_reset_cb) {\r
 404                 ret = sensor_ioctl_cb.sensor_reset_cb(res, on);\r
 405                         } else {\r
 406                 printk(KERN_ERR "sensor_ioctl_cb.sensor_reset_cb is NULL");\r
 407                 WARN_ON(1);\r
 408                         }\r
 409                         break;
 410                 }
 411
 412                 case Cam_PowerDown:
 413                 {
 414                         if (sensor_ioctl_cb.sensor_powerdown_cb) {\r
 415                 ret = sensor_ioctl_cb.sensor_powerdown_cb(res, on);\r
 416                         } else {\r
 417                 printk(KERN_ERR "sensor_ioctl_cb.sensor_powerdown_cb is NULL");\r
 418                 WARN_ON(1);\r
 419                         }\r
 420                         break;
 421                 }
 422
 423                 case Cam_Flash:
 424                 {
 425                         if (sensor_ioctl_cb.sensor_flash_cb) {\r
 426                 ret = sensor_ioctl_cb.sensor_flash_cb(res, on);\r
 427                         } else {\r
 428                 printk(KERN_ERR "sensor_ioctl_cb.sensor_flash_cb is NULL!");\r
 429                 WARN_ON(1);\r
 430                         }\r
 431                         break;
 432                 }
 433
 434                 default:
 435                 {
 436                         printk("%s cmd(0x%x) is unknown!\n",__FUNCTION__, cmd);
 437                         break;
 438                 }
 439         }\r
 440 rk29_sensor_ioctrl_end:\r
 441     return ret;
 442 }
 443 static int rk29_sensor_power(struct device *dev, int on)
 444 {
 445         rk29_sensor_ioctrl(dev,Cam_Power,on);
 446     return 0;
 447 }\r
 448 #if 0\r
 449 static int rk29_sensor_reset(struct device *dev)
 450 {
 451         rk29_sensor_ioctrl(dev,Cam_Reset,1);
 452         msleep(2);
 453         rk29_sensor_ioctrl(dev,Cam_Reset,0);
 454         return 0;
 455 }\r
 456 #endif\r
 457 static int rk29_sensor_powerdown(struct device *dev, int on)
 458 {
 459         return rk29_sensor_ioctrl(dev,Cam_PowerDown,on);
 460 }
 461 #if (CONFIG_SENSOR_IIC_ADDR_0 != 0x00)
 462 static struct i2c_board_info rk29_i2c_cam_info_0[] = {
 463         {
 464                 I2C_BOARD_INFO(SENSOR_NAME_0, CONFIG_SENSOR_IIC_ADDR_0>>1)
 465         },
 466 };
 467
 468 static struct soc_camera_link rk29_iclink_0 = {
 469         .bus_id         = RK29_CAM_PLATFORM_DEV_ID,
 470         .power          = rk29_sensor_power,
 471         .powerdown  = rk29_sensor_powerdown,
 472         .board_info     = &rk29_i2c_cam_info_0[0],
 473         .i2c_adapter_id = CONFIG_SENSOR_IIC_ADAPTER_ID_0,
 474         .module_name    = SENSOR_NAME_0,
 475 };
 476
 477 /*platform_device : soc-camera need  */
 478 static struct platform_device rk29_soc_camera_pdrv_0 = {
 479         .name   = "soc-camera-pdrv",
 480         .id     = 0,
 481         .dev    = {
 482                 .init_name = SENSOR_DEVICE_NAME_0,
 483                 .platform_data = &rk29_iclink_0,
 484         },
 485 };
 486 #endif
 487 static struct i2c_board_info rk29_i2c_cam_info_1[] = {
 488         {
 489                 I2C_BOARD_INFO(SENSOR_NAME_1, CONFIG_SENSOR_IIC_ADDR_1>>1)
 490         },
 491 };
 492
 493 static struct soc_camera_link rk29_iclink_1 = {
 494         .bus_id         = RK29_CAM_PLATFORM_DEV_ID,
 495         .power          = rk29_sensor_power,
 496         .powerdown  = rk29_sensor_powerdown,
 497         .board_info     = &rk29_i2c_cam_info_1[0],
 498         .i2c_adapter_id = CONFIG_SENSOR_IIC_ADAPTER_ID_1,
 499         .module_name    = SENSOR_NAME_1,
 500 };
 501
 502 /*platform_device : soc-camera need  */
 503 static struct platform_device rk29_soc_camera_pdrv_1 = {
 504         .name   = "soc-camera-pdrv",
 505         .id     = 1,
 506         .dev    = {
 507                 .init_name = SENSOR_DEVICE_NAME_1,
 508                 .platform_data = &rk29_iclink_1,
 509         },
 510 };
 511
 512
 513 static u64 rockchip_device_camera_dmamask = 0xffffffffUL;
 514 static struct resource rk29_camera_resource[] = {
 515         [0] = {
 516                 .start = RK29_VIP_PHYS,
 517                 .end   = RK29_VIP_PHYS + RK29_VIP_SIZE - 1,
 518                 .flags = IORESOURCE_MEM,
 519         },
 520         [1] = {
 521                 .start = IRQ_VIP,
 522                 .end   = IRQ_VIP,
 523                 .flags = IORESOURCE_IRQ,
 524         }
 525 };
 526
 527 /*platform_device : */
 528 static struct platform_device rk29_device_camera = {
 529         .name             = RK29_CAM_DRV_NAME,
 530         .id               = RK29_CAM_PLATFORM_DEV_ID,               /* This is used to put cameras on this interface */
 531         .num_resources    = ARRAY_SIZE(rk29_camera_resource),
 532         .resource         = rk29_camera_resource,
 533         .dev            = {
 534                 .dma_mask = &rockchip_device_camera_dmamask,
 535                 .coherent_dma_mask = 0xffffffffUL,
 536                 .platform_data  = &rk29_camera_platform_data,
 537         }
 538 };
 539
 540 static struct android_pmem_platform_data android_pmem_cam_pdata = {
 541         .name           = "pmem_cam",
 542         .start          = PMEM_CAM_BASE,
 543         .size           = PMEM_CAM_SIZE,
 544         .no_allocator   = 1,
 545         .cached         = 1,
 546 };
 547
 548 static struct platform_device android_pmem_cam_device = {
 549         .name           = "android_pmem",
 550         .id             = 1,
 551         .dev            = {
 552                 .platform_data = &android_pmem_cam_pdata,
 553         },
 554 };\r
 555 \r
 556 #endif\r
 557 \r
 558 #endif //#ifdef CONFIG_VIDEO_RK29