int sr130pc10_sensor_init(const struct msm_camera_sensor_info *data)
{
int i, rc = 0;
printk("[SR130PC10] %s/%d \n", __func__, __LINE__);
#ifdef CONFIG_LOAD_FILE
if(0 > sr130pc10_regs_table_init()) {
CDBG("%s file open failed!\n",__func__);
rc = -1;
goto init_fail;
}
#endif
sr130pc10_ctrl = kzalloc(sizeof(struct sr130pc10_ctrl_t), GFP_KERNEL);
if (!sr130pc10_ctrl) {
printk("[SR130PC10]sr130pc10_init failed!\n");
rc = -ENOMEM;
goto init_done;
}
prev_vtcall_mode=-1;
if (data)
sr130pc10_ctrl->sensordata = data;
/* Input MCLK = 24MHz */
msm_camio_clk_rate_set(24000000);
msleep(5);
msm_camio_camif_pad_reg_reset();
sr130pc10_set_power(true);
rc = sr130pc10_sensor_init_probe();
if(rc < 0)
{
for(i=0;i<5;i++)
{
printk("[SR130PC10]sr130pc10_sensor_init failed!\n");
sr130pc10_set_power(false);
mdelay(50);
msm_camio_camif_pad_reg_reset();
sr130pc10_set_power(true);
msleep(5);
rc = sr130pc10_sensor_init_probe();
probe_init_retry++;
if(rc >= 0)break;
}
if(rc < 0)goto init_fail;
}
init_done:
return rc;
init_fail:
kfree(sr130pc10_ctrl);
return rc;
}
int tcm9001md_power_on(void)
{
int rc = 0;
/* Setting MCLK = 24MHz */
msm_camio_clk_rate_set(24000000);
msm_camio_camif_pad_reg_reset();
printk(KERN_INFO "%s: Setting MCLK = 24MHz \n", __func__);
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->vga_rst_pin, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Re-set config for gpio %d .\n", __func__, tcm9001mdinfo->vga_rst_pin);
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->vga_pwdn_pin, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Re-set config for gpio %d .\n", __func__, tcm9001mdinfo->vga_pwdn_pin);
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->vga_power_en_pin, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
printk(KERN_INFO "%s: Re-set config for gpio %d .\n", __func__, tcm9001mdinfo->vga_power_en_pin);
/* Pull hight power enable = GPIO98 */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_power_en_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(1); //t1+t2+t3 = 1ms
/* Pull hight PWRDWN = CAM_VGA_STANDBY */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(2); //t4 = 1ms
/* Enable MCLK = 24MHz */
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->MCLK_PIN, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);//Div2-SW6-MM-MC-Camera-ModifiedPowerSequence-01*
printk(KERN_INFO "%s: Output MCLK end. \n", __func__);
mdelay(2);
/* Pull Low PWRDWN = CAM_VGA_STANDBY */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 0);
if (rc)
return rc;
mdelay(2); //t5 = 2ms
/* Pull High REDET = CAM_VGA_RST_N */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_rst_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(2); //t6 > 2ms
//Div2-SW6-MM-MC-FrontCameraInitFail-00+{
#ifdef CONFIG_TCM9001MD_STANDBY
tcm9001md_first_init = 0;
#endif
//Div2-SW6-MM-MC-FrontCameraInitFail-00+}
return rc;
}
static int s5k6aafx_hw_init()
{
int rc = 0;
printk("<=PCAM=> ++++++++++++++++++++++++++s5k6aafx test driver++++++++++++++++++++++++++++++++++++ \n");
gpio_tlmm_config(GPIO_CFG(CAM_RESET, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_RESET
gpio_tlmm_config(GPIO_CFG(CAM_STANDBY, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_STANDBY
gpio_tlmm_config(GPIO_CFG(CAM_EN, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_EN
gpio_tlmm_config(GPIO_CFG(CAM_VT_RST, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_VT_RST
gpio_tlmm_config(GPIO_CFG(CAM_VT_nSTBY, 0,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_VT_nSTBY
gpio_set_value(CAM_VT_RST, 0); //VT_RST -> DOWN
mdelay(30);
gpio_set_value(CAM_VT_nSTBY, 0); //VT_nSTBY -> DOWN
mdelay(30);
struct vreg* vreg_L8;
vreg_L8 = vreg_get(NULL, "gp7");
vreg_set_level(vreg_L8, 1500);
vreg_disable(vreg_L8);
mdelay(30);
gpio_set_value(CAM_EN, 0); //EN -> DOWN
msleep(300);
gpio_set_value(CAM_EN, 1); //EN -> UP
vreg_enable(vreg_L8);
mdelay(1);
gpio_set_value(CAM_VT_nSTBY, 1); //VT_nSTBY -> UP
mdelay(1);
/* Input MCLK = 24MHz */
gpio_tlmm_config(GPIO_CFG(CAM_MCLK, 1,GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_16MA), GPIO_CFG_ENABLE); //CAM_MCLK
msm_camio_clk_rate_set(24000000); //MCLK
msm_camio_camif_pad_reg_reset();
mdelay(1);
gpio_set_value(CAM_STANDBY, 1); //STBY -> UP
mdelay(1);
gpio_set_value(CAM_RESET, 1); //REST -> UP
mdelay(1);
gpio_set_value(CAM_STANDBY, 0); //STBY -> DOWN
mdelay(1);
gpio_set_value(CAM_VT_RST, 1); //VT_RST -> UP
mdelay(30);
cam_gpio_print(3); //debug
return rc;
}
static int vfe_7x_init(struct msm_vfe_resp *presp,
struct platform_device *dev)
{
int rc = 0;
init_waitqueue_head(&stopevent.wait);
stopevent.timeout = 200;
stopevent.state = 0;
if (presp && presp->vfe_resp)
resp = presp;
else{
CDBG_ERR("vfe_7k_init:fail here presp :0x%p presp->vfe_resp:0x%p\n",
presp,
presp->vfe_resp);
return -EFAULT;
}
/* Bring up all the required GPIOs and Clocks */
rc = msm_camio_enable(dev);
if (rc < 0){
CDBG_ERR("vfe_7k_init:msm_camio_enable fail\n");
return rc;
}
msm_camio_camif_pad_reg_reset();
extlen = sizeof(struct vfe_frame_extra);
extdata = kmalloc(extlen, GFP_ATOMIC);
if (!extdata) {
rc = -ENOMEM;
goto init_fail;
}
rc = msm_adsp_get("QCAMTASK", &qcam_mod, &vfe_7x_sync, NULL);
if (rc) {
rc = -EBUSY;
CDBG_ERR("vfe_7k_init:faile here %d\n",__LINE__);
goto get_qcam_fail;
}
rc = msm_adsp_get("VFETASK", &vfe_mod, &vfe_7x_sync, NULL);
if (rc) {
rc = -EBUSY;
CDBG_ERR("vfe_7k_init:faile here %d\n",__LINE__);
goto get_vfe_fail;
}
return 0;
get_vfe_fail:
msm_adsp_put(qcam_mod);
get_qcam_fail:
kfree(extdata);
init_fail:
extlen = 0;
return rc;
}
static int s5k6aafx_sensor_init_probe(struct msm_camera_sensor_info *data)
{
int rc = 0;
// int read_value=-1;
// unsigned short read_value_1 = 0;
// int i; //for loop
// int cnt = 0;
CAM_DEBUG("s5k6aafx_sensor_init_probe start");
gpio_set_value(CAM_STANDBY, 0);
//gpio_set_value(CAM_RESET, 0);
gpio_set_value_cansleep(CAM_RESET, 0);
CAM_DEBUG(" CAM PM already on \n");
//CAM_DEBUG(" 1. PMIC ON ");
//cam_pmic_onoff(ON);
//CAM_DEBUG(" 1. CAM_8M_RST = 0 ");
//gpio_set_value(CAM_8M_RST, LOW);
CAM_DEBUG(" 2. CAM_VT_nSTBY = 1 ");
gpio_set_value_cansleep(CAM_VT_nSTBY, 1);
mdelay(20);
CAM_DEBUG(" 3. CAM_VT_RST = 1 ");
gpio_set_value_cansleep(CAM_VT_RST, 1);
mdelay(30); // min 350ns
#if 0
////////////////////////////////////////////////////
#if 0//Mclk_timing for M4Mo spec. // -Jeonhk clock was enabled in vfe31_init
msm_camio_clk_enable(CAMIO_VFE_CLK);
msm_camio_clk_enable(CAMIO_MDC_CLK);
msm_camio_clk_enable(CAMIO_VFE_MDC_CLK);
#endif
CAM_DEBUG("START MCLK:24Mhz~~~~~");
// msm_camio_clk_rate_set(24000000);
mdelay(5);
msm_camio_camif_pad_reg_reset(); // this is not
mdelay(10);
////////////////////////////////////////////////////
#endif
s5k6aafx_start();
return rc;
init_probe_fail:
return rc;
}
static int ovm7692_sensor_init(const struct msm_camera_sensor_info *data)
{
int rc = 0;
mutex_lock(&ovm7692_mutex);
if (ovm7692_opened) {
pr_err("ovm7692_open already opened\n");
rc = -EBUSY;
goto init_done;
}
ovm7692_ctrl = kzalloc(sizeof(struct ovm7692_ctrl), GFP_KERNEL);
if (NULL == ovm7692_ctrl) {
pr_err("%s memory allocation failed\n", __func__);
rc = -ENOMEM;
goto init_done;
}
ovm7692_ctrl->sensordata = data;
ovm7692_ctrl->dev_mode = CAMERA_MODE_STANDBY;
ovm7692_effect = CAMERA_EFFECT_OFF;
msm_camio_camif_pad_reg_reset(); /* msm_io_vfe31 */
rc = ovm7692_sensor_init_probe(data);
if (rc < 0) {
pr_err("ovm7692_sensor_init failed!\n");
goto init_fail;
}
ovm7692_opened = 1;
CDBG("ovm7692_sensor_init done\n");
init_done:
mutex_unlock(&ovm7692_mutex);
return rc;
init_fail:
kfree(ovm7692_ctrl);
ovm7692_ctrl = NULL;
mutex_unlock(&ovm7692_mutex);
return rc;
}
int camera_power_on (void)
{
struct device *dev = lu3100_backlight_dev();
printk("dev = %d\n",dev);
aat28xx_ldo_set_level(dev, 1, 1200);
aat28xx_ldo_set_level(dev, 4, 2700);
aat28xx_ldo_set_level(dev, 2, 2700);
aat28xx_ldo_set_level(dev, 3, 2800);
aat28xx_ldo_enable(dev, 1, 1);
mdelay(1);
aat28xx_ldo_enable(dev, 4, 1);
mdelay(1);
aat28xx_ldo_enable(dev, 2, 1);
mdelay(1);
aat28xx_ldo_enable(dev, 3, 1);
mdelay(5);
#if 0
msm_camio_clk_rate_set(24000000);
mdelay(5);
msm_camio_camif_pad_reg_reset();
mdelay(5);
gpio_set_value(0, 1);
#endif
return 0;
}
static int vfe_init(struct msm_vfe_resp *presp)
{
int rc = 0;
rc = vfe_cmd_init(presp, vfe_pdev);
if (rc < 0)
return rc;
/* Bring up all the required GPIOs and Clocks */
//msm_camio_enable(dev);
msm_camio_camif_pad_reg_reset();
/* Move this to msm_vfe8x_proc.c */
rc = request_irq(INT_VFE, vfe_isr, IRQF_TRIGGER_RISING,
"vfe", 0);
if (rc < 0)
return rc;
enable_irq(INT_VFE);
return 0;
}
int camera_power_on (void)
{
int rc;
struct device *dev = su370_backlight_dev();
camera_power_mutex_lock();
if(lcd_bl_power_state == BL_POWER_SUSPEND)
{
u370_pwrsink_resume();
mdelay(50);
}
/* clear RESET, PWDN to Low*/
gpio_set_value(GPIO_CAM_RESET, 0);
gpio_set_value(GPIO_CAM_PWDN, 0);
/*AVDD power 2.8V*/
{ /* it is for rev.c and default */
struct vreg *vreg_mmc = vreg_get(0, "mmc");
vreg_set_level(vreg_mmc, 2800);
vreg_enable(vreg_mmc);
}
/* DVDD power 1.2V */
rc = aat28xx_ldo_set_level(dev, LDO_CAM_DVDD_NO, 1200);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_DVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
/*IOVDD power 2.6V*/
rc = aat28xx_ldo_set_level(dev, LDO_CAM_IOVDD_NO, 2600);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_IOVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AVDD_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
mdelay(5);
/*M Clock -24Mhz*/
msm_camio_clk_rate_set(mclk_rate);
mdelay(5);
msm_camio_camif_pad_reg_reset();
mdelay(5);
/*reset high*/
gpio_set_value(GPIO_CAM_RESET, 1);
mdelay(5);
/*Nstandby high*/
gpio_set_value(GPIO_CAM_PWDN, 1);
mdelay(8); // T2
camera_power_state = CAM_POWER_ON;
power_on_fail:
camera_power_mutex_unlock();
return rc;
}
int tcm9001md_sensor_standby(int on)
{
int rc = 0;
if(on == 1)//Entering stanby mode
{
//Software standby setting. Set this register with STANDBY.
rc = tcm9001md_i2c_write(tcm9001md_client, 0xFF, 0x05);//SLEEP: 0h: ON (Standby), 1h: OFF (Normal)
if (rc < 0)
return rc;
mdelay(1);
rc = tcm9001md_i2c_write(tcm9001md_client, 0x18, 0x1C);//STANDBY: 0h: ON (Standby), 1h: OFF (Normal)
if (rc < 0)
return rc;
printk(KERN_INFO "%s: SW standby done . \n", __func__);
mdelay(1);
// Enter HW standby
/* Pull Low REDET = CAM_VGA_RST_N */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_rst_pin, "tcm9001md", 0);
if (rc)
return rc;
mdelay(1);
/* Pull hight PWRDWN = CAM_VGA_STANDBY */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(1);
/* Disable MCLK = 24MHz */
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->MCLK_PIN, 0, GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL, GPIO_CFG_2MA), GPIO_CFG_ENABLE);
rc = fih_cam_output_gpio_control(tcm9001mdinfo->MCLK_PIN, "tcm9001md", 0);
if (rc)
return rc;
printk("%s: Disable mclk\n", __func__);
printk(KERN_INFO "%s: Enter Hw standby done . \n", __func__);
}
else//Exiting stanby mode
{
/* Setting MCLK = 24MHz */
msm_camio_clk_rate_set(24000000);
msm_camio_camif_pad_reg_reset();
printk(KERN_INFO "%s: Setting MCLK = 24MHz \n", __func__);
gpio_tlmm_config(GPIO_CFG(tcm9001mdinfo->MCLK_PIN, 1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA), GPIO_CFG_ENABLE);//Div2-SW6-MM-MC-Camera-ModifiedPowerSequence-01*
printk(KERN_INFO "%s: Output MCLK end. \n", __func__);
mdelay(1);
/* Pull Low PWRDWN = CAM_VGA_STANDBY */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_pwdn_pin, "tcm9001md", 0);
if (rc)
return rc;
mdelay(1);
/* Pull High REDET = CAM_VGA_RST_N */
rc = fih_cam_output_gpio_control(tcm9001mdinfo->vga_rst_pin, "tcm9001md", 1);
if (rc)
return rc;
mdelay(5);//Div2-SW6-MM-MC-AddErrorHandlingWhenCameraI2cReadAndWriteFail-00+
//Exit SW standby
rc = tcm9001md_i2c_write(tcm9001md_client, 0x18, 0x9C);//STANDBY: 0h: ON (Standby), 1h: OFF (Normal)
if (rc < 0)
return rc;
mdelay(1);
rc = tcm9001md_i2c_write(tcm9001md_client, 0xFF, 0x85);//SLEEP: 0h: ON (Standby), 1h: OFF (Normal)
if (rc < 0)
return rc;
printk(KERN_INFO "%s: Exit HW standby done. \n", __func__);
}
return rc;
}
static int vfe_proc_general(struct msm_vfe_command_8k *cmd)
{
int rc = 0;
CDBG("%s: cmdID = %d\n", __func__, cmd->id);
switch (cmd->id) {
case VFE_CMD_ID_RESET:
msm_camio_vfe_blk_reset();
msm_camio_camif_pad_reg_reset_2();
vfe_reset();
break;
case VFE_CMD_ID_START:{
struct vfe_cmd_start start;
CHECKED_COPY_FROM_USER(&start);
/* msm_camio_camif_pad_reg_reset_2(); */
msm_camio_camif_pad_reg_reset();
vfe_start(&start);
}
break;
case VFE_CMD_ID_CAMIF_CONFIG:{
struct vfe_cmd_camif_config camif;
CHECKED_COPY_FROM_USER(&camif);
vfe_camif_config(&camif);
}
break;
case VFE_CMD_ID_BLACK_LEVEL_CONFIG:{
struct vfe_cmd_black_level_config bl;
CHECKED_COPY_FROM_USER(&bl);
vfe_black_level_config(&bl);
}
break;
case VFE_CMD_ID_ROLL_OFF_CONFIG:{
/* rolloff is too big to be on the stack */
struct vfe_cmd_roll_off_config *rolloff =
kmalloc(sizeof(struct vfe_cmd_roll_off_config),
GFP_KERNEL);
if (!rolloff) {
pr_err("%s: out of memory\n", __func__);
rc = -ENOMEM;
break;
}
/* Wrap CHECKED_COPY_FROM_USER() in a do-while(0) loop
* to make sure we free rolloff when copy_from_user()
* fails.
*/
do {
CHECKED_COPY_FROM_USER(rolloff);
vfe_roll_off_config(rolloff);
} while (0);
kfree(rolloff);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG:{
struct vfe_cmd_demux_channel_gain_config demuxc;
CHECKED_COPY_FROM_USER(&demuxc);
/* demux is always enabled. */
vfe_demux_channel_gain_config(&demuxc);
}
break;
case VFE_CMD_ID_DEMOSAIC_CONFIG:{
struct vfe_cmd_demosaic_config demosaic;
CHECKED_COPY_FROM_USER(&demosaic);
vfe_demosaic_config(&demosaic);
}
break;
case VFE_CMD_ID_FOV_CROP_CONFIG:
case VFE_CMD_ID_FOV_CROP_UPDATE:{
struct vfe_cmd_fov_crop_config fov;
CHECKED_COPY_FROM_USER(&fov);
vfe_fov_crop_config(&fov);
}
break;
case VFE_CMD_ID_MAIN_SCALER_CONFIG:
case VFE_CMD_ID_MAIN_SCALER_UPDATE:{
struct vfe_cmd_main_scaler_config mainds;
CHECKED_COPY_FROM_USER(&mainds);
vfe_main_scaler_config(&mainds);
}
break;
case VFE_CMD_ID_WHITE_BALANCE_CONFIG:
case VFE_CMD_ID_WHITE_BALANCE_UPDATE:{
struct vfe_cmd_white_balance_config wb;
CHECKED_COPY_FROM_USER(&wb);
vfe_white_balance_config(&wb);
}
break;
case VFE_CMD_ID_COLOR_CORRECTION_CONFIG:
case VFE_CMD_ID_COLOR_CORRECTION_UPDATE:{
struct vfe_cmd_color_correction_config cc;
CHECKED_COPY_FROM_USER(&cc);
vfe_color_correction_config(&cc);
}
break;
case VFE_CMD_ID_LA_CONFIG:{
struct vfe_cmd_la_config la;
CHECKED_COPY_FROM_USER(&la);
vfe_la_config(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_CONFIG:{
struct vfe_cmd_rgb_gamma_config rgb;
CHECKED_COPY_FROM_USER(&rgb);
rc = vfe_rgb_gamma_config(&rgb);
}
break;
case VFE_CMD_ID_CHROMA_ENHAN_CONFIG:
case VFE_CMD_ID_CHROMA_ENHAN_UPDATE:{
struct vfe_cmd_chroma_enhan_config chrom;
CHECKED_COPY_FROM_USER(&chrom);
vfe_chroma_enhan_config(&chrom);
}
break;
case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG:
case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE:{
struct vfe_cmd_chroma_suppression_config chromsup;
CHECKED_COPY_FROM_USER(&chromsup);
vfe_chroma_sup_config(&chromsup);
}
break;
case VFE_CMD_ID_ASF_CONFIG:{
struct vfe_cmd_asf_config asf;
CHECKED_COPY_FROM_USER(&asf);
vfe_asf_config(&asf);
}
break;
case VFE_CMD_ID_SCALER2Y_CONFIG:
case VFE_CMD_ID_SCALER2Y_UPDATE:{
struct vfe_cmd_scaler2_config ds2y;
CHECKED_COPY_FROM_USER(&ds2y);
vfe_scaler2y_config(&ds2y);
}
break;
case VFE_CMD_ID_SCALER2CbCr_CONFIG:
case VFE_CMD_ID_SCALER2CbCr_UPDATE:{
struct vfe_cmd_scaler2_config ds2cbcr;
CHECKED_COPY_FROM_USER(&ds2cbcr);
vfe_scaler2cbcr_config(&ds2cbcr);
}
break;
case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG:{
struct vfe_cmd_chroma_subsample_config sub;
CHECKED_COPY_FROM_USER(&sub);
vfe_chroma_subsample_config(&sub);
}
break;
case VFE_CMD_ID_FRAME_SKIP_CONFIG:{
struct vfe_cmd_frame_skip_config fskip;
CHECKED_COPY_FROM_USER(&fskip);
vfe_frame_skip_config(&fskip);
}
break;
case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG:{
struct vfe_cmd_output_clamp_config clamp;
CHECKED_COPY_FROM_USER(&clamp);
vfe_output_clamp_config(&clamp);
}
break;
/* module update commands */
case VFE_CMD_ID_BLACK_LEVEL_UPDATE:{
struct vfe_cmd_black_level_config blk;
CHECKED_COPY_FROM_USER(&blk);
vfe_black_level_update(&blk);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE:{
struct vfe_cmd_demux_channel_gain_config dmu;
CHECKED_COPY_FROM_USER(&dmu);
vfe_demux_channel_gain_update(&dmu);
}
break;
case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE:{
struct vfe_cmd_demosaic_bpc_update demo_bpc;
CHECKED_COPY_FROM_USER(&demo_bpc);
vfe_demosaic_bpc_update(&demo_bpc);
}
break;
case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE:{
struct vfe_cmd_demosaic_abf_update demo_abf;
CHECKED_COPY_FROM_USER(&demo_abf);
vfe_demosaic_abf_update(&demo_abf);
}
break;
case VFE_CMD_ID_LA_UPDATE:{
struct vfe_cmd_la_config la;
CHECKED_COPY_FROM_USER(&la);
vfe_la_update(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_UPDATE:{
struct vfe_cmd_rgb_gamma_config rgb;
CHECKED_COPY_FROM_USER(&rgb);
rc = vfe_rgb_gamma_update(&rgb);
}
break;
case VFE_CMD_ID_ASF_UPDATE:{
struct vfe_cmd_asf_update asf;
CHECKED_COPY_FROM_USER(&asf);
vfe_asf_update(&asf);
}
break;
case VFE_CMD_ID_FRAME_SKIP_UPDATE:{
struct vfe_cmd_frame_skip_update fskip;
CHECKED_COPY_FROM_USER(&fskip);
vfe_frame_skip_update(&fskip);
}
break;
case VFE_CMD_ID_CAMIF_FRAME_UPDATE:{
struct vfe_cmds_camif_frame fup;
CHECKED_COPY_FROM_USER(&fup);
vfe_camif_frame_update(&fup);
}
break;
/* stats update commands */
case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE:{
struct vfe_cmd_stats_af_update afup;
CHECKED_COPY_FROM_USER(&afup);
vfe_stats_update_af(&afup);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_UPDATE:{
struct vfe_cmd_stats_wb_exp_update wbexp;
CHECKED_COPY_FROM_USER(&wbexp);
vfe_stats_update_wb_exp(&wbexp);
}
break;
/* control of start, stop, update, etc... */
case VFE_CMD_ID_STOP:
vfe_stop();
break;
case VFE_CMD_ID_GET_HW_VERSION:
break;
/* stats */
case VFE_CMD_ID_STATS_SETTING:{
struct vfe_cmd_stats_setting stats;
CHECKED_COPY_FROM_USER(&stats);
vfe_stats_setting(&stats);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_START:{
struct vfe_cmd_stats_af_start af;
CHECKED_COPY_FROM_USER(&af);
vfe_stats_start_af(&af);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_STOP:
vfe_stats_af_stop();
break;
case VFE_CMD_ID_STATS_WB_EXP_START:{
struct vfe_cmd_stats_wb_exp_start awexp;
CHECKED_COPY_FROM_USER(&awexp);
vfe_stats_start_wb_exp(&awexp);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_STOP:
vfe_stats_wb_exp_stop();
break;
case VFE_CMD_ID_ASYNC_TIMER_SETTING:
break;
case VFE_CMD_ID_UPDATE:
vfe_update();
break;
/* test gen */
case VFE_CMD_ID_TEST_GEN_START:
break;
case VFE_CMD_ID_EPOCH1_CONFIG:{
struct vfe_cmds_camif_epoch epoch1;
CHECKED_COPY_FROM_USER(&epoch1);
vfe_epoch1_config(&epoch1);
}
break;
/*
acknowledge from upper layer
these are not in general command.
case VFE_CMD_ID_OUTPUT1_ACK:
break;
case VFE_CMD_ID_OUTPUT2_ACK:
break;
case VFE_CMD_ID_EPOCH1_ACK:
break;
case VFE_CMD_ID_EPOCH2_ACK:
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_ACK:
break;
case VFE_CMD_ID_STATS_WB_EXP_ACK:
break;
*/
default:
pr_err("%s: invalid cmd id %d\n", __func__, cmd->id);
rc = -EINVAL;
break;
} /* switch */
return rc;
}
static int camera_dev_ioctl(struct inode *inode, struct file *file, unsigned int cmd, unsigned long arg)
{
int rc;
ddbg_print( "camera ioctl cmd = %u, arg = %lu\n", cmd, arg);
switch(cmd)
{
case CAMERA_RESET_WRITE:
rc = gpio_request (GPIO_RESET, GPIO_SENSOR_NAME);
if (!rc)
{
gpio_direction_output (GPIO_RESET, (arg ? 1 : 0));
dbg_print( "CAMERA_MISC set RESET line to %u\n", (arg ? 1 : 0));
}
gpio_free (GPIO_RESET);
if (rc)
{
err_print ("CAMERA_MISC: gpio_request () failed. rc = %d; cmd = %d; arg = %lu", rc, cmd, arg);
return -EIO;
}
break;
case CAMERA_POWERDOWN_WRITE:
rc = gpio_request (GPIO_POWERDOWN, GPIO_SENSOR_NAME);
if (!rc)
{
if (0 == arg)
{
#if 0 // TODO: NEED TO HANDLE MCLK
msm_camio_camif_pad_reg_reset();
mdelay (50);
#endif // TODO: NEED TO HANDLE MCLK
rc = gpio_direction_output (GPIO_POWERDOWN, 0);
}
else
{
rc = gpio_direction_output (GPIO_POWERDOWN, 1);
}
dbg_print( "CAMERA_MISC set POWERDOWN line to %u\n", (arg ? 1 : 0));
}
gpio_free (GPIO_POWERDOWN);
if (rc)
{
err_print ("CAMERA_MISC: gpio_request () failed. rc = %d; cmd = %u; arg = %lu", rc, cmd, arg);
return -EIO;
}
break;
case CAMERA_CLOCK_DISABLE:
msm_camio_camif_pad_reg_reset();
dbg_print( "CAMERA_MISC turned off MCLK done\n");
break;
case CAMERA_CLOCK_ENABLE:
/* enable mclk */
msm_camio_clk_rate_set ((int)arg);
dbg_print( "CAMERA_MISC set MCLK to %d\n", (int) arg);
break;
default:
err_print( "CAMERA_MISC received unsupported cmd; cmd = %u\n", cmd);
return -EIO;
break;
}
return 0;
}
/*
* mlm1183_sensor_init
* - It is called from OPEN.
*/
static int mlm1183_sensor_init(
const struct msm_camera_sensor_info* sensor_info
)
{
long rc = 0;
struct sensor_cfg_data cfg_data;
static struct vreg *vreg_cfg;
MLM1183_ENTER;
senser_info_mlm1183 = (struct msm_camera_sensor_info_mlm1183 *)sensor_info;
mlm1183_wait_flag = 0;
gpio_request(senser_info_mlm1183->sensor_info.sensor_pwd, "PWD");
gpio_request(senser_info_mlm1183->sensor_info.sensor_reset, "RST");
/* VCAML provide start */
cfg_data.cfg.gpio_cfg.port = senser_info_mlm1183->sensor_info.sensor_pwd;
cfg_data.cfg.gpio_cfg.ctl = GPIO_HIGH;
rc = mlm1183_sensor_set_gpio( &cfg_data );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
/* Wait:1ms */
mdelay(1);
/* VCAMD provide start */
cfg_data.cfg.pmic_cfg.id = senser_info_mlm1183->vcmd_pwd;
cfg_data.cfg.pmic_cfg.ctl = PMIC_ON;
rc = mlm1183_sensor_set_pmic( &cfg_data );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
/* VCAMA provide start */
cfg_data.cfg.pmic_cfg.id = senser_info_mlm1183->vcma_pwd;
cfg_data.cfg.pmic_cfg.ctl = PMIC_ON;
vreg_cfg = vreg_get(NULL, cfg_data.cfg.pmic_cfg.id);
vreg_set_level(vreg_cfg, 2800);
rc = mlm1183_sensor_set_pmic( &cfg_data );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
/* VCAMAF provide start */
cfg_data.cfg.pmic_cfg.id = senser_info_mlm1183->vcmaf_pwd;
cfg_data.cfg.pmic_cfg.ctl = PMIC_ON;
vreg_cfg = vreg_get(NULL, cfg_data.cfg.pmic_cfg.id);
vreg_set_level(vreg_cfg, 2800);
rc = mlm1183_sensor_set_pmic( &cfg_data );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
/* Wait:1ms */
msleep(1);
/* CAM_CLK provide start */
cfg_data.cfg.mclk_ctl = MCLK_ON;
rc = mlm1183_sensor_set_mclk( &cfg_data );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
/* Wait:5ms */
msleep(5);
/* Reset CAMIF PAD REG */
msm_camio_camif_pad_reg_reset();
/* Wait:5ms */
msleep(5);
/* reset cancel */
cfg_data.cfg.gpio_cfg.port = senser_info_mlm1183->sensor_info.sensor_reset;
cfg_data.cfg.gpio_cfg.ctl = GPIO_HIGH;
rc = mlm1183_sensor_set_gpio( &cfg_data );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
rc = request_irq( gpio_to_irq(MLM1183_INTERRUPT_PORT),
mlm1183_interrupt,
IRQF_TRIGGER_RISING,
"cam_trig_h",
0 );
if(rc != 0){
MLM1183_RETURN_N(rc);
}
MLM1183_RETURN_N(rc);
}
////////////////////////////////
// Power ON
////////////////////////////////
static int cam12mp_sensor_poweron(void)
{
struct vreg *vreg_gp1, *vreg_gp6;
LOGI("+%s()\n", __func__);
vreg_gp6 = vreg_get(NULL, "gp6");
if (IS_ERR(vreg_gp6)) {
LOGE(" - vreg_get(gp6) failed (%ld) !\n", PTR_ERR(vreg_gp6));
return -1;
}
if (vreg_set_level(vreg_gp6, 1800)) {
LOGE(" - vreg gp6 set level failed !\n");
return -1;
}
vreg_gp1 = vreg_get(NULL, "gp1");
if (IS_ERR(vreg_gp1)) {
LOGE(" - vreg_get(gp1) failed (%ld)\n", PTR_ERR(vreg_gp1));
return -1;
}
if (vreg_set_level(vreg_gp1, 2700)) {
LOGE(" - vreg gp1 set level failed !\n");
return -1;
}
sub_pmic_reg_ctrl(SUB_PMIC_REG2, SUB_PMIC_LDO_ON);
mdelay(1);
if (vreg_enable(vreg_gp6)) {
LOGE(" - vreg gp6 enable failed !\n");
goto _sensor_poweron_fail_1;
}
mdelay(1);
sub_pmic_ldo_ctrl(SUB_PMIC_CAM12V, SUB_PMIC_LDO_ON);
mdelay(1);
gpio_set_value(CAM_18V, 1);
mdelay(1);
sub_pmic_ldo_ctrl(SUB_PMIC_CAM28V, SUB_PMIC_LDO_ON);
mdelay(1);
if (vreg_enable(vreg_gp1)) {
LOGE(" - vreg gp1 enable failed !\n");
goto _sensor_poweron_fail_2;
}
mdelay(1);
gpio_tlmm_config(GPIO_CFG(MCLK, 1, GPIO_OUTPUT, GPIO_NO_PULL, GPIO_4MA), GPIO_ENABLE);
msm_camio_clk_rate_set(9600000);
msm_camio_camif_pad_reg_reset();
gpio_set_value(H_STBY, 1);
gpio_set_value(R_STBY, 1);
mdelay(1);
gpio_set_value(RESET, 1);
mdelay(4);
return 0;
_sensor_poweron_fail_2:
sub_pmic_ldo_ctrl(SUB_PMIC_CAM28V, SUB_PMIC_LDO_OFF);
gpio_set_value(CAM_18V, 0);
sub_pmic_ldo_ctrl(SUB_PMIC_CAM12V, SUB_PMIC_LDO_OFF);
vreg_disable(vreg_gp6);
_sensor_poweron_fail_1:
sub_pmic_reg_ctrl(SUB_PMIC_REG2, SUB_PMIC_LDO_OFF);
LOGI("-%s (fail.)\n", __func__);
return -1;
}
int camera_power_on (void)
{
int rc;
struct device *dev = su370_backlight_dev();
camera_power_mutex_lock();
if(lcd_bl_power_state == BL_POWER_SUSPEND)
{
u370_pwrsink_resume();
mdelay(50);
}
gpio_set_value(GPIO_CAM_RESET, 0);
gpio_set_value(GPIO_CAM_PWDN, 0);
{
struct vreg *vreg_mmc = vreg_get(0, "mmc");
vreg_set_level(vreg_mmc, 2800);
vreg_enable(vreg_mmc);
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_DVDD_NO, 1200);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_DVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_IOVDD_NO, 2600);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_IOVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AVDD_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
mdelay(5);
msm_camio_clk_rate_set(mclk_rate);
mdelay(5);
msm_camio_camif_pad_reg_reset();
mdelay(5);
gpio_set_value(GPIO_CAM_RESET, 1);
mdelay(5);
gpio_set_value(GPIO_CAM_PWDN, 1);
mdelay(8);
camera_power_state = CAM_POWER_ON;
power_on_fail:
camera_power_mutex_unlock();
return rc;
}
int camera_power_on (void)
{
int rc;
struct device *dev = gelato_backlight_dev();
int retry = 0;
/* clear RESET, PWDN to Low*/
gpio_set_value(GPIO_CAM_RESET, 0);
gpio_set_value(GPIO_CAM_PWDN, 0);
aat28xx_power(dev, 1);
/*
* 2011-04-23, [email protected]
* wait for Backlight IC enable.
* because camera application does not work well permanently after power on failure.
*/
for (retry = 100; retry != 0; retry--) {
/* FIXME: check the Backlight IC enable status using another method */
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AF_NO, 2800);
if (rc < 0) {
//printk("%s, wait for Backlight IC enabling, ramian retry %d\n", __func__, retry);
msleep(50);
} else {
break;
}
}
/*AVDD power 2.8V*/
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AF_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AF_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AF_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AF_NO);
goto power_on_fail;
}
/* DVDD power 1.2V */
rc = aat28xx_ldo_set_level(dev, LDO_CAM_DVDD_NO, 1800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_DVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
udelay(500);
/*AVDD power 2.7V*/
/* LGE_CHANGE
* Change AVDD level from 2.7V to 2.8V in order to reduce camera noise in dard environment.
* 2010-08-03. [email protected]
*/
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AVDD_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
udelay(100);
/*IOVDD power 2.6V*/
rc = aat28xx_ldo_set_level(dev, LDO_CAM_IOVDD_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_IOVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
mdelay(5);
/*M Clock -24Mhz*/
msm_camio_clk_rate_set(mclk_rate);
mdelay(5);
msm_camio_camif_pad_reg_reset();
mdelay(5);
/*Nstandby high*/
gpio_set_value(GPIO_CAM_PWDN, 1);
udelay(20);
/*reset high*/
gpio_set_value(GPIO_CAM_RESET, 1);
mdelay(5);
camera_power_state = CAM_POWER_ON;
/*Hitachi LCD LUT*/
if(gelato_panel_id==1){
mdp_load_hitachi_lut(2);
}
power_on_fail:
return rc;
}
int camera_power_on (void)
{
int rc;
struct device *dev = pecan_backlight_dev();
camera_power_mutex_lock();
if(lcd_bl_power_state == BL_POWER_SUSPEND)
{
pecan_pwrsink_resume();
mdelay(50);
}
/* clear RESET, PWDN to Low*/
gpio_set_value(GPIO_CAM_RESET, 0);
gpio_set_value(GPIO_CAM_PWDN, 0);
//2010-11-02
config_camera_off_gpios();
mdelay(40);
/*AVDD power 2.8V*/
if (lge_bd_rev == LGE_REV_B) {
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AF_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AF_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AF_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AF_NO);
goto power_on_fail;
}
} else { /* it is for rev.c and default */
struct vreg *vreg_mmc = vreg_get(0, "mmc");
vreg_set_level(vreg_mmc, 2800);
vreg_enable(vreg_mmc);
}
/* DVDD power 1.2V, change to 1.8V */
rc = aat28xx_ldo_set_level(dev, LDO_CAM_DVDD_NO, 1800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_DVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_DVDD_NO);
goto power_on_fail;
}
mdelay(1);
/*IOVDD power 2.6V*/
rc = aat28xx_ldo_set_level(dev, LDO_CAM_IOVDD_NO, 2600);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_IOVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_IOVDD_NO);
goto power_on_fail;
}
/*AVDD power 2.7V*/
/* LGE_CHANGE
* Change AVDD level from 2.7V to 2.8V in order to reduce camera noise in dard environment.
* 2010-08-03. [email protected]
*/
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AVDD_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AVDD_NO);
goto power_on_fail;
}
//mdelay(5);
/*M Clock -24Mhz*/
mdelay(20);
config_camera_on_gpios();
msm_camio_clk_rate_set(mclk_rate);
mdelay(5);
msm_camio_camif_pad_reg_reset();
mdelay(5);
/*Nstandby high*/
gpio_set_value(GPIO_CAM_PWDN, 0);
mdelay(1);
/*reset high*/
gpio_set_value(GPIO_CAM_RESET, 1);
mdelay(8); // T2
camera_power_state = CAM_POWER_ON;
power_on_fail:
camera_power_mutex_unlock();
return rc;
}
static int cam_hw_init()
{
int rc = 0;
struct vreg *vreg_L8;
int test_value;
pr_info("[sr030pc30] %s/%d\n", __func__, __LINE__);
gpio_tlmm_config(
GPIO_CFG(CAM_RESET, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_16MA), GPIO_CFG_ENABLE);/*CAM_RESET*/
gpio_tlmm_config(
GPIO_CFG(CAM_STANDBY, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_16MA), GPIO_CFG_ENABLE);/*CAM_STANDBY*/
gpio_tlmm_config(
GPIO_CFG(CAM_EN, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_16MA), GPIO_CFG_ENABLE);/*CAM_EN*/
gpio_tlmm_config(
GPIO_CFG(CAM_EN_2, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_16MA), GPIO_CFG_ENABLE); /*CAM_EN_2*/
gpio_tlmm_config(
GPIO_CFG(CAM_VT_RST, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_16MA), GPIO_CFG_ENABLE);/*CAM_VT_RST*/
gpio_tlmm_config(
GPIO_CFG(CAM_VT_nSTBY, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_16MA), GPIO_CFG_ENABLE);
vreg_L8 = vreg_get(NULL, "gp7");
vreg_set_level(vreg_L8, 1800);
gpio_set_value(CAM_RESET, 0);
gpio_set_value(CAM_STANDBY, 0);
gpio_set_value(CAM_EN, 0);
gpio_set_value(CAM_EN_2, 0);
gpio_set_value(CAM_VT_RST, 0);
gpio_set_value(CAM_VT_nSTBY, 0);
usleep(1000);
gpio_set_value(CAM_EN, 1); /*CAM_A_2.8V //CAM_EN->UP*/
usleep(1000);
vreg_enable(vreg_L8);
usleep(1000);
gpio_set_value(CAM_EN_2, 1); /*CAM_IO, CAM_D, EN_2->UP*/
usleep(1000);
gpio_set_value(CAM_VT_nSTBY, 1); /*VGA_STBY UP*/
usleep(1000);
gpio_tlmm_config(GPIO_CFG(CAM_MCLK, 1,
GPIO_CFG_OUTPUT, GPIO_CFG_NO_PULL,
GPIO_CFG_14MA), GPIO_CFG_ENABLE); /*CAM_MCLK*/
msm_camio_clk_rate_set(24000000); /*MCLK*/
msm_camio_camif_pad_reg_reset();
usleep(1000);
gpio_set_value(CAM_STANDBY, 1); /*3M_STBY UP*/
usleep(10000);
gpio_set_value(CAM_RESET, 1); /*3M_RESET UP*/
usleep(10000);
gpio_set_value(CAM_STANDBY, 0); /*3M_STBY DOWN*/
usleep(1000);
gpio_set_value(CAM_VT_RST, 1); /*VGA_RESET UP*/
usleep(50000);
return rc;
}
static int vfe_proc_general(struct msm_vfe_command_8k *cmd)
{
int rc = 0;
CDBG("%s: cmdID = %d\n", __func__, cmd->id);
switch (cmd->id) {
case VFE_CMD_ID_RESET:
msm_camio_vfe_blk_reset();
msm_camio_camif_pad_reg_reset_2();
vfe_reset();
break;
case VFE_CMD_ID_START: {
struct vfe_cmd_start start;
CHECKED_COPY_FROM_USER(&start);
msm_camio_camif_pad_reg_reset();
vfe_start(&start);
}
break;
case VFE_CMD_ID_CAMIF_CONFIG: {
struct vfe_cmd_camif_config camif;
CHECKED_COPY_FROM_USER(&camif);
vfe_camif_config(&camif);
}
break;
case VFE_CMD_ID_BLACK_LEVEL_CONFIG: {
struct vfe_cmd_black_level_config bl;
CHECKED_COPY_FROM_USER(&bl);
vfe_black_level_config(&bl);
}
break;
case VFE_CMD_ID_ROLL_OFF_CONFIG:{
struct vfe_cmd_roll_off_config *rolloff =
kmalloc(sizeof(struct vfe_cmd_roll_off_config),
GFP_KERNEL);
if (!rolloff) {
pr_err("%s: out of memory\n", __func__);
rc = -ENOMEM;
break;
}
do {
CHECKED_COPY_FROM_USER(rolloff);
vfe_roll_off_config(rolloff);
} while (0);
kfree(rolloff);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG: {
struct vfe_cmd_demux_channel_gain_config demuxc;
CHECKED_COPY_FROM_USER(&demuxc);
vfe_demux_channel_gain_config(&demuxc);
}
break;
case VFE_CMD_ID_DEMOSAIC_CONFIG: {
struct vfe_cmd_demosaic_config demosaic;
CHECKED_COPY_FROM_USER(&demosaic);
vfe_demosaic_config(&demosaic);
}
break;
case VFE_CMD_ID_FOV_CROP_CONFIG:
case VFE_CMD_ID_FOV_CROP_UPDATE: {
struct vfe_cmd_fov_crop_config fov;
CHECKED_COPY_FROM_USER(&fov);
vfe_fov_crop_config(&fov);
}
break;
case VFE_CMD_ID_MAIN_SCALER_CONFIG:
case VFE_CMD_ID_MAIN_SCALER_UPDATE: {
struct vfe_cmd_main_scaler_config mainds;
CHECKED_COPY_FROM_USER(&mainds);
vfe_main_scaler_config(&mainds);
}
break;
case VFE_CMD_ID_WHITE_BALANCE_CONFIG:
case VFE_CMD_ID_WHITE_BALANCE_UPDATE: {
struct vfe_cmd_white_balance_config wb;
CHECKED_COPY_FROM_USER(&wb);
vfe_white_balance_config(&wb);
}
break;
case VFE_CMD_ID_COLOR_CORRECTION_CONFIG:
case VFE_CMD_ID_COLOR_CORRECTION_UPDATE: {
struct vfe_cmd_color_correction_config cc;
CHECKED_COPY_FROM_USER(&cc);
vfe_color_correction_config(&cc);
}
break;
case VFE_CMD_ID_LA_CONFIG: {
struct vfe_cmd_la_config la;
CHECKED_COPY_FROM_USER(&la);
vfe_la_config(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_CONFIG: {
struct vfe_cmd_rgb_gamma_config rgb;
CHECKED_COPY_FROM_USER(&rgb);
rc = vfe_rgb_gamma_config(&rgb);
}
break;
case VFE_CMD_ID_CHROMA_ENHAN_CONFIG:
case VFE_CMD_ID_CHROMA_ENHAN_UPDATE: {
struct vfe_cmd_chroma_enhan_config chrom;
CHECKED_COPY_FROM_USER(&chrom);
vfe_chroma_enhan_config(&chrom);
}
break;
case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG:
case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE: {
struct vfe_cmd_chroma_suppression_config chromsup;
CHECKED_COPY_FROM_USER(&chromsup);
vfe_chroma_sup_config(&chromsup);
}
break;
case VFE_CMD_ID_ASF_CONFIG: {
struct vfe_cmd_asf_config asf;
CHECKED_COPY_FROM_USER(&asf);
vfe_asf_config(&asf);
}
break;
case VFE_CMD_ID_SCALER2Y_CONFIG:
case VFE_CMD_ID_SCALER2Y_UPDATE: {
struct vfe_cmd_scaler2_config ds2y;
CHECKED_COPY_FROM_USER(&ds2y);
vfe_scaler2y_config(&ds2y);
}
break;
case VFE_CMD_ID_SCALER2CbCr_CONFIG:
case VFE_CMD_ID_SCALER2CbCr_UPDATE: {
struct vfe_cmd_scaler2_config ds2cbcr;
CHECKED_COPY_FROM_USER(&ds2cbcr);
vfe_scaler2cbcr_config(&ds2cbcr);
}
break;
case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG: {
struct vfe_cmd_chroma_subsample_config sub;
CHECKED_COPY_FROM_USER(&sub);
vfe_chroma_subsample_config(&sub);
}
break;
case VFE_CMD_ID_FRAME_SKIP_CONFIG: {
struct vfe_cmd_frame_skip_config fskip;
CHECKED_COPY_FROM_USER(&fskip);
vfe_frame_skip_config(&fskip);
}
break;
case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG: {
struct vfe_cmd_output_clamp_config clamp;
CHECKED_COPY_FROM_USER(&clamp);
vfe_output_clamp_config(&clamp);
}
break;
case VFE_CMD_ID_BLACK_LEVEL_UPDATE: {
struct vfe_cmd_black_level_config blk;
CHECKED_COPY_FROM_USER(&blk);
vfe_black_level_update(&blk);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE: {
struct vfe_cmd_demux_channel_gain_config dmu;
CHECKED_COPY_FROM_USER(&dmu);
vfe_demux_channel_gain_update(&dmu);
}
break;
case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE: {
struct vfe_cmd_demosaic_bpc_update demo_bpc;
CHECKED_COPY_FROM_USER(&demo_bpc);
vfe_demosaic_bpc_update(&demo_bpc);
}
break;
case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE: {
struct vfe_cmd_demosaic_abf_update demo_abf;
CHECKED_COPY_FROM_USER(&demo_abf);
vfe_demosaic_abf_update(&demo_abf);
}
break;
case VFE_CMD_ID_LA_UPDATE: {
struct vfe_cmd_la_config la;
CHECKED_COPY_FROM_USER(&la);
vfe_la_update(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_UPDATE: {
struct vfe_cmd_rgb_gamma_config rgb;
CHECKED_COPY_FROM_USER(&rgb);
rc = vfe_rgb_gamma_update(&rgb);
}
break;
case VFE_CMD_ID_ASF_UPDATE: {
struct vfe_cmd_asf_update asf;
CHECKED_COPY_FROM_USER(&asf);
vfe_asf_update(&asf);
}
break;
case VFE_CMD_ID_FRAME_SKIP_UPDATE: {
struct vfe_cmd_frame_skip_update fskip;
CHECKED_COPY_FROM_USER(&fskip);
if (fskip.output2Pattern == 0xffffffff)
update_axi_qos(MSM_AXI_QOS_RECORDING);
else if (fskip.output2Pattern == 0)
update_axi_qos(MSM_AXI_QOS_PREVIEW);
vfe_frame_skip_update(&fskip);
}
break;
case VFE_CMD_ID_CAMIF_FRAME_UPDATE: {
struct vfe_cmds_camif_frame fup;
CHECKED_COPY_FROM_USER(&fup);
vfe_camif_frame_update(&fup);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE: {
struct vfe_cmd_stats_af_update afup;
CHECKED_COPY_FROM_USER(&afup);
vfe_stats_update_af(&afup);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_UPDATE: {
struct vfe_cmd_stats_wb_exp_update wbexp;
CHECKED_COPY_FROM_USER(&wbexp);
vfe_stats_update_wb_exp(&wbexp);
}
break;
case VFE_CMD_ID_STOP:
vfe_stop();
break;
case VFE_CMD_ID_GET_HW_VERSION:
break;
case VFE_CMD_ID_STATS_SETTING: {
struct vfe_cmd_stats_setting stats;
CHECKED_COPY_FROM_USER(&stats);
vfe_stats_setting(&stats);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_START: {
struct vfe_cmd_stats_af_start af;
CHECKED_COPY_FROM_USER(&af);
vfe_stats_start_af(&af);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_STOP:
vfe_stats_af_stop();
break;
case VFE_CMD_ID_STATS_WB_EXP_START: {
struct vfe_cmd_stats_wb_exp_start awexp;
CHECKED_COPY_FROM_USER(&awexp);
vfe_stats_start_wb_exp(&awexp);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_STOP:
vfe_stats_wb_exp_stop();
break;
case VFE_CMD_ID_ASYNC_TIMER_SETTING:
break;
case VFE_CMD_ID_UPDATE:
vfe_update();
break;
case VFE_CMD_ID_TEST_GEN_START:
break;
default:
pr_err("%s: invalid cmd id %d\n", __func__, cmd->id);
rc = -EINVAL;
break;
}
return rc;
}
int camera_power_on (void)
{
int rc;
struct device *dev = thunderg_backlight_dev();
gpio_set_value(GPIO_CAM_RESET, 0);
gpio_set_value(GPIO_CAM_PWDN, 0);
if (lge_bd_rev == LGE_REV_B) {
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AF_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AF_NO);
return rc;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AF_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AF_NO);
return rc;
}
} else {
struct vreg *vreg_mmc = vreg_get(0, "mmc");
vreg_set_level(vreg_mmc, 2800);
vreg_enable(vreg_mmc);
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_DVDD_NO, 1200);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_DVDD_NO);
return rc;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_DVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_DVDD_NO);
return rc;
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_IOVDD_NO, 2600);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_IOVDD_NO);
return rc;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_IOVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_IOVDD_NO);
return rc;
}
rc = aat28xx_ldo_set_level(dev, LDO_CAM_AVDD_NO, 2800);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d set level error\n", __func__, LDO_CAM_AVDD_NO);
return rc;
}
rc = aat28xx_ldo_enable(dev, LDO_CAM_AVDD_NO, 1);
if (rc < 0) {
printk(KERN_ERR "%s: ldo %d control error\n", __func__, LDO_CAM_AVDD_NO);
return rc;
}
mdelay(5);
msm_camio_clk_rate_set(mclk_rate);
mdelay(5);
msm_camio_camif_pad_reg_reset();
mdelay(5);
gpio_set_value(GPIO_CAM_RESET, 1);
mdelay(5);
gpio_set_value(GPIO_CAM_PWDN, 1);
mdelay(8);
return rc;
}
static int vfe_proc_general(struct msm_vfe_command_8k *cmd)
{
int rc = 0;
CDBG("vfe_proc_general: cmdID = %d\n", cmd->id);
switch (cmd->id) {
case VFE_CMD_ID_RESET:
msm_camio_vfe_blk_reset();
msm_camio_camif_pad_reg_reset_2();
vfe_reset();
break;
case VFE_CMD_ID_START: {
struct vfe_cmd_start start;
if (copy_from_user(&start,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
/* msm_camio_camif_pad_reg_reset_2(); */
msm_camio_camif_pad_reg_reset();
vfe_start(&start);
}
break;
case VFE_CMD_ID_CAMIF_CONFIG: {
struct vfe_cmd_camif_config camif;
if (copy_from_user(&camif,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_camif_config(&camif);
}
break;
case VFE_CMD_ID_BLACK_LEVEL_CONFIG: {
struct vfe_cmd_black_level_config bl;
if (copy_from_user(&bl,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_black_level_config(&bl);
}
break;
case VFE_CMD_ID_ROLL_OFF_CONFIG: {
struct vfe_cmd_roll_off_config rolloff;
if (copy_from_user(&rolloff,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_roll_off_config(&rolloff);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_CONFIG: {
struct vfe_cmd_demux_channel_gain_config demuxc;
if (copy_from_user(&demuxc,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
/* demux is always enabled. */
vfe_demux_channel_gain_config(&demuxc);
}
break;
case VFE_CMD_ID_DEMOSAIC_CONFIG: {
struct vfe_cmd_demosaic_config demosaic;
if (copy_from_user(&demosaic,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_demosaic_config(&demosaic);
}
break;
case VFE_CMD_ID_FOV_CROP_CONFIG:
case VFE_CMD_ID_FOV_CROP_UPDATE: {
struct vfe_cmd_fov_crop_config fov;
if (copy_from_user(&fov,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_fov_crop_config(&fov);
}
break;
case VFE_CMD_ID_MAIN_SCALER_CONFIG:
case VFE_CMD_ID_MAIN_SCALER_UPDATE: {
struct vfe_cmd_main_scaler_config mainds;
if (copy_from_user(&mainds,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_main_scaler_config(&mainds);
}
break;
case VFE_CMD_ID_WHITE_BALANCE_CONFIG:
case VFE_CMD_ID_WHITE_BALANCE_UPDATE: {
struct vfe_cmd_white_balance_config wb;
if (copy_from_user(&wb,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_white_balance_config(&wb);
}
break;
case VFE_CMD_ID_COLOR_CORRECTION_CONFIG:
case VFE_CMD_ID_COLOR_CORRECTION_UPDATE: {
struct vfe_cmd_color_correction_config cc;
if (copy_from_user(&cc,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_color_correction_config(&cc);
}
break;
case VFE_CMD_ID_LA_CONFIG: {
struct vfe_cmd_la_config la;
if (copy_from_user(&la,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_la_config(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_CONFIG: {
struct vfe_cmd_rgb_gamma_config rgb;
if (copy_from_user(&rgb,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
rc = vfe_rgb_gamma_config(&rgb);
}
break;
case VFE_CMD_ID_CHROMA_ENHAN_CONFIG:
case VFE_CMD_ID_CHROMA_ENHAN_UPDATE: {
struct vfe_cmd_chroma_enhan_config chrom;
if (copy_from_user(&chrom,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_chroma_enhan_config(&chrom);
}
break;
case VFE_CMD_ID_CHROMA_SUPPRESSION_CONFIG:
case VFE_CMD_ID_CHROMA_SUPPRESSION_UPDATE: {
struct vfe_cmd_chroma_suppression_config chromsup;
if (copy_from_user(&chromsup,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_chroma_sup_config(&chromsup);
}
break;
case VFE_CMD_ID_ASF_CONFIG: {
struct vfe_cmd_asf_config asf;
if (copy_from_user(&asf,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_asf_config(&asf);
}
break;
case VFE_CMD_ID_SCALER2Y_CONFIG:
case VFE_CMD_ID_SCALER2Y_UPDATE: {
struct vfe_cmd_scaler2_config ds2y;
if (copy_from_user(&ds2y,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_scaler2y_config(&ds2y);
}
break;
case VFE_CMD_ID_SCALER2CbCr_CONFIG:
case VFE_CMD_ID_SCALER2CbCr_UPDATE: {
struct vfe_cmd_scaler2_config ds2cbcr;
if (copy_from_user(&ds2cbcr,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_scaler2cbcr_config(&ds2cbcr);
}
break;
case VFE_CMD_ID_CHROMA_SUBSAMPLE_CONFIG: {
struct vfe_cmd_chroma_subsample_config sub;
if (copy_from_user(&sub,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_chroma_subsample_config(&sub);
}
break;
case VFE_CMD_ID_FRAME_SKIP_CONFIG: {
struct vfe_cmd_frame_skip_config fskip;
if (copy_from_user(&fskip,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_frame_skip_config(&fskip);
}
break;
case VFE_CMD_ID_OUTPUT_CLAMP_CONFIG: {
struct vfe_cmd_output_clamp_config clamp;
if (copy_from_user(&clamp,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_output_clamp_config(&clamp);
}
break;
/* module update commands */
case VFE_CMD_ID_BLACK_LEVEL_UPDATE: {
struct vfe_cmd_black_level_config blk;
if (copy_from_user(&blk,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_black_level_update(&blk);
}
break;
case VFE_CMD_ID_DEMUX_CHANNEL_GAIN_UPDATE: {
struct vfe_cmd_demux_channel_gain_config dmu;
if (copy_from_user(&dmu,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_demux_channel_gain_update(&dmu);
}
break;
case VFE_CMD_ID_DEMOSAIC_BPC_UPDATE: {
struct vfe_cmd_demosaic_bpc_update demo_bpc;
if (copy_from_user(&demo_bpc,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_demosaic_bpc_update(&demo_bpc);
}
break;
case VFE_CMD_ID_DEMOSAIC_ABF_UPDATE: {
struct vfe_cmd_demosaic_abf_update demo_abf;
if (copy_from_user(&demo_abf,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_demosaic_abf_update(&demo_abf);
}
break;
case VFE_CMD_ID_LA_UPDATE: {
struct vfe_cmd_la_config la;
if (copy_from_user(&la,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_la_update(&la);
}
break;
case VFE_CMD_ID_RGB_GAMMA_UPDATE: {
struct vfe_cmd_rgb_gamma_config rgb;
if (copy_from_user(&rgb,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
rc = vfe_rgb_gamma_update(&rgb);
}
break;
case VFE_CMD_ID_ASF_UPDATE: {
struct vfe_cmd_asf_update asf;
if (copy_from_user(&asf,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_asf_update(&asf);
}
break;
case VFE_CMD_ID_FRAME_SKIP_UPDATE: {
struct vfe_cmd_frame_skip_update fskip;
if (copy_from_user(&fskip,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_frame_skip_update(&fskip);
}
break;
case VFE_CMD_ID_CAMIF_FRAME_UPDATE: {
struct vfe_cmds_camif_frame fup;
if (copy_from_user(&fup,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_camif_frame_update(&fup);
}
break;
/* stats update commands */
case VFE_CMD_ID_STATS_AUTOFOCUS_UPDATE: {
struct vfe_cmd_stats_af_update afup;
if (copy_from_user(&afup,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_stats_update_af(&afup);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_UPDATE: {
struct vfe_cmd_stats_wb_exp_update wbexp;
if (copy_from_user(&wbexp,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_stats_update_wb_exp(&wbexp);
}
break;
/* control of start, stop, update, etc... */
case VFE_CMD_ID_STOP:
vfe_stop();
break;
case VFE_CMD_ID_GET_HW_VERSION:
break;
/* stats */
case VFE_CMD_ID_STATS_SETTING: {
struct vfe_cmd_stats_setting stats;
if (copy_from_user(&stats,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_stats_setting(&stats);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_START: {
struct vfe_cmd_stats_af_start af;
if (copy_from_user(&af,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_stats_start_af(&af);
}
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_STOP:
vfe_stats_af_stop();
break;
case VFE_CMD_ID_STATS_WB_EXP_START: {
struct vfe_cmd_stats_wb_exp_start awexp;
if (copy_from_user(&awexp,
(void __user *) cmd->value, cmd->length))
rc = -EFAULT;
vfe_stats_start_wb_exp(&awexp);
}
break;
case VFE_CMD_ID_STATS_WB_EXP_STOP:
vfe_stats_wb_exp_stop();
break;
case VFE_CMD_ID_ASYNC_TIMER_SETTING:
break;
case VFE_CMD_ID_UPDATE:
vfe_update();
break;
/* test gen */
case VFE_CMD_ID_TEST_GEN_START:
break;
/*
acknowledge from upper layer
these are not in general command.
case VFE_CMD_ID_OUTPUT1_ACK:
break;
case VFE_CMD_ID_OUTPUT2_ACK:
break;
case VFE_CMD_ID_EPOCH1_ACK:
break;
case VFE_CMD_ID_EPOCH2_ACK:
break;
case VFE_CMD_ID_STATS_AUTOFOCUS_ACK:
break;
case VFE_CMD_ID_STATS_WB_EXP_ACK:
break;
*/
default:
break;
} /* switch */
return rc;
}
static int cam_hw_init()
{
int rc = 0;
struct vreg *vreg_L8;
#ifdef CONFIG_MACH_ICON
msm_camio_camif_pad_reg_reset();
mdelay(10);
gpio_set_value(CAM_VT_RST, 1);
mdelay(1);
#else
printk(KERN_DEBUG
"<=PCAM=> ++++++++++++++++++++++++++"
"sr130pc10 test driver"
"++++++++++++++++++++++++++++++++++++\n");
gpio_tlmm_config(GPIO_CFG(CAM_RESET, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_RESET */
gpio_tlmm_config(GPIO_CFG(CAM_STANDBY, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_STANDBY */
gpio_tlmm_config(GPIO_CFG(CAM_EN, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_EN */
gpio_tlmm_config(GPIO_CFG(CAM_EN_2, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_EN_2 */
gpio_tlmm_config(GPIO_CFG(CAM_VT_RST, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_VT_RST */
gpio_tlmm_config(GPIO_CFG(CAM_VT_nSTBY, 0, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_VT_nSTBY */
vreg_L8 = vreg_get(NULL, "gp7");
vreg_set_level(vreg_L8, 1800);
vreg_disable(vreg_L8);
gpio_set_value(CAM_RESET, 0);
gpio_set_value(CAM_STANDBY, 0);
gpio_set_value(CAM_EN, 0);
gpio_set_value(CAM_EN_2, 0);
gpio_set_value(CAM_VT_RST, 0);
gpio_set_value(CAM_VT_nSTBY, 0);
/*mdelay(1); changed for coding rule*/
mdelay(1);
gpio_set_value(CAM_EN_2, 1); /*CAM_EN->UP */
gpio_set_value(CAM_EN, 1); /*CAM_EN->UP*/
vreg_enable(vreg_L8);
udelay(10);
gpio_set_value(CAM_VT_nSTBY, 1); /*VGA_STBY UP*/
udelay(10);
gpio_tlmm_config(GPIO_CFG(CAM_MCLK, 1, GPIO_CFG_OUTPUT,
GPIO_CFG_NO_PULL, GPIO_CFG_16MA),
GPIO_CFG_ENABLE); /*CAM_MCLK */
msm_camio_clk_rate_set(24000000); /*MCLK*/
msm_camio_camif_pad_reg_reset();
gpio_set_value(CAM_VT_RST, 1); /*VGA_RESET UP*/
mdelay(1);
#endif
return rc;
}
