static int s5k8aay_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc = 0;
int temp = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CAM_DEBUG(" E");
#ifdef CONFIG_LOAD_FILE
s5k8aay_regs_table_init();
#endif
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0)
cam_err(" request gpio failed");
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_stby, 0);
temp = gpio_get_value(data->sensor_platform_info->vt_sensor_stby);
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_reset, 0);
temp = gpio_get_value(data->sensor_platform_info->vt_sensor_reset);
gpio_set_value_cansleep(data->sensor_platform_info->sensor_reset, 0);
temp = gpio_get_value(data->sensor_platform_info->sensor_reset);
gpio_set_value_cansleep(data->sensor_platform_info->sensor_stby, 0);
temp = gpio_get_value(data->sensor_platform_info->sensor_stby);
/*Power on the LDOs */
data->sensor_platform_info->sensor_power_on(1);
/*standy VT */
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_stby, 1);
temp = gpio_get_value(data->sensor_platform_info->vt_sensor_stby);
/*Set Main clock */
gpio_tlmm_config(GPIO_CFG(data->sensor_platform_info->mclk,
1, GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN,
GPIO_CFG_2MA), GPIO_CFG_ENABLE);
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0)
cam_err(" clk enable failed");
usleep(15);
/*reset VT */
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_reset, 1);
temp = gpio_get_value(data->sensor_platform_info->vt_sensor_reset);
usleep(100);
/* sensor validation test */
rc = S5K8_BURST_WRT_LIST(s5k8aay_pre_common);
if (rc < 0) {
pr_info("Error in Front Camera Sensor Validation Test");
return rc;
}
s5k8aay_set_init_mode();
CAM_DEBUG(" X");
return rc;
}
int msm_gemini_platform_init(struct platform_device *pdev,
struct resource **mem,
void **base,
int *irq,
irqreturn_t (*handler) (int, void *),
void *context)
{
int rc = -1;
int gemini_irq;
struct resource *gemini_mem, *gemini_io, *gemini_irq_res;
void *gemini_base;
struct msm_gemini_device *pgmn_dev =
(struct msm_gemini_device *) context;
gemini_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!gemini_mem) {
GMN_PR_ERR("%s: no mem resource?\n", __func__);
return -ENODEV;
}
gemini_irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!gemini_irq_res) {
GMN_PR_ERR("no irq resource?\n");
return -ENODEV;
}
gemini_irq = gemini_irq_res->start;
gemini_io = request_mem_region(gemini_mem->start,
resource_size(gemini_mem), pdev->name);
if (!gemini_io) {
GMN_PR_ERR("%s: region already claimed\n", __func__);
return -EBUSY;
}
gemini_base = ioremap(gemini_mem->start, resource_size(gemini_mem));
if (!gemini_base) {
rc = -ENOMEM;
GMN_PR_ERR("%s: ioremap failed\n", __func__);
goto fail1;
}
pgmn_dev->hw_version = GEMINI_8X60;
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev, gemini_8x_clk_info,
pgmn_dev->gemini_clk, ARRAY_SIZE(gemini_8x_clk_info), 1);
if (rc < 0) {
pgmn_dev->hw_version = GEMINI_7X;
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev,
gemini_7x_clk_info, pgmn_dev->gemini_clk,
ARRAY_SIZE(gemini_7x_clk_info), 1);
if (rc < 0) {
GMN_PR_ERR("%s: clk failed rc = %d\n", __func__, rc);
goto fail2;
}
} else {
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev,
gemini_imem_clk_info, &pgmn_dev->gemini_clk[2],
ARRAY_SIZE(gemini_imem_clk_info), 1);
if (!rc)
pgmn_dev->hw_version = GEMINI_8960;
}
if (pgmn_dev->hw_version != GEMINI_7X) {
if (pgmn_dev->gemini_fs == NULL) {
pgmn_dev->gemini_fs =
regulator_get(&pgmn_dev->pdev->dev, "vdd");
if (IS_ERR(pgmn_dev->gemini_fs)) {
pr_err("%s: Regulator FS_ijpeg get failed %ld\n",
__func__, PTR_ERR(pgmn_dev->gemini_fs));
pgmn_dev->gemini_fs = NULL;
goto gemini_fs_failed;
} else if (regulator_enable(pgmn_dev->gemini_fs)) {
pr_err("%s: Regulator FS_ijpeg enable failed\n",
__func__);
regulator_put(pgmn_dev->gemini_fs);
pgmn_dev->gemini_fs = NULL;
goto gemini_fs_failed;
}
}
}
msm_gemini_hw_init(gemini_base, resource_size(gemini_mem));
rc = request_irq(gemini_irq, handler, IRQF_TRIGGER_RISING, "gemini",
context);
if (rc) {
GMN_PR_ERR("%s: request_irq failed, %d\n", __func__,
gemini_irq);
goto fail3;
}
*mem = gemini_mem;
*base = gemini_base;
*irq = gemini_irq;
#ifdef CONFIG_MSM_MULTIMEDIA_USE_ION
gemini_client = msm_ion_client_create(-1, "camera/gemini");
#endif
GMN_DBG("%s:%d] success\n", __func__, __LINE__);
return rc;
fail3:
if (pgmn_dev->hw_version != GEMINI_7X) {
regulator_disable(pgmn_dev->gemini_fs);
regulator_put(pgmn_dev->gemini_fs);
pgmn_dev->gemini_fs = NULL;
}
gemini_fs_failed:
if (pgmn_dev->hw_version == GEMINI_8960)
msm_cam_clk_enable(&pgmn_dev->pdev->dev, gemini_imem_clk_info,
&pgmn_dev->gemini_clk[2], ARRAY_SIZE(gemini_imem_clk_info), 0);
if (pgmn_dev->hw_version != GEMINI_7X)
msm_cam_clk_enable(&pgmn_dev->pdev->dev, gemini_8x_clk_info,
pgmn_dev->gemini_clk, ARRAY_SIZE(gemini_8x_clk_info), 0);
else
msm_cam_clk_enable(&pgmn_dev->pdev->dev, gemini_7x_clk_info,
pgmn_dev->gemini_clk, ARRAY_SIZE(gemini_7x_clk_info), 0);
fail2:
iounmap(gemini_base);
fail1:
release_mem_region(gemini_mem->start, resource_size(gemini_mem));
GMN_DBG("%s:%d] fail\n", __func__, __LINE__);
return rc;
}
int msm_camera_power_down(struct msm_camera_power_ctrl_t *ctrl,
enum msm_camera_device_type_t device_type,
struct msm_camera_i2c_client *sensor_i2c_client)
{
int index = 0, ret = 0;
struct msm_sensor_power_setting *pd = NULL;
struct msm_sensor_power_setting *ps;
CDBG("%s:%d\n", __func__, __LINE__);
if (!ctrl || !sensor_i2c_client) {
pr_err("failed ctrl %p sensor_i2c_client %p\n", ctrl,
sensor_i2c_client);
return -EINVAL;
}
if (device_type == MSM_CAMERA_PLATFORM_DEVICE)
sensor_i2c_client->i2c_func_tbl->i2c_util(
sensor_i2c_client, MSM_CCI_RELEASE);
for (index = 0; index < ctrl->power_down_setting_size; index++) {
CDBG("%s index %d\n", __func__, index);
pd = &ctrl->power_down_setting[index];
ps = NULL;
CDBG("%s type %d\n", __func__, pd->seq_type);
switch (pd->seq_type) {
case SENSOR_CLK:
ps = msm_camera_get_power_settings(ctrl,
pd->seq_type,
pd->seq_val);
if (ps)
msm_cam_clk_enable(ctrl->dev,
&ctrl->clk_info[0],
(struct clk **)&ps->data[0],
ctrl->clk_info_size,
0);
else
pr_err("%s error in power up/down seq data\n",
__func__);
break;
case SENSOR_GPIO:
if (pd->seq_val >= SENSOR_GPIO_MAX ||
!ctrl->gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
pd->seq_val,
SENSOR_GPIO_MAX);
continue;
}
if (!ctrl->gpio_conf->gpio_num_info->valid
[pd->seq_val])
continue;
gpio_set_value_cansleep(
ctrl->gpio_conf->gpio_num_info->gpio_num
[pd->seq_val],
0); //
break;
case SENSOR_VREG:
if (pd->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
pd->seq_val,
SENSOR_GPIO_MAX);
continue;
}
ps = msm_camera_get_power_settings(ctrl,
pd->seq_type,
pd->seq_val);
if (ps) {
if (pd->seq_val < ctrl->num_vreg)
msm_camera_config_single_vreg(ctrl->dev,
&ctrl->cam_vreg[pd->seq_val],
(struct regulator **)&ps->data[0],
0);
else
pr_err("%s:%d:seq_val:%d > num_vreg: %d\n"
, __func__, __LINE__,
pd->seq_val, ctrl->num_vreg);
} else
pr_err("%s error in power up/down seq data\n",
__func__);
break;
case SENSOR_I2C_MUX:
if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
msm_camera_disable_i2c_mux(ctrl->i2c_conf);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
pd->seq_type);
break;
}
if (pd->delay > 20) {
msleep(pd->delay);
} else if (pd->delay) {
usleep_range(pd->delay * 1000,
(pd->delay * 1000) + 1000);
}
}
if (ctrl->cam_pinctrl_status) {
ret = pinctrl_select_state(ctrl->pinctrl_info.pinctrl,
ctrl->pinctrl_info.gpio_state_suspend);
if (ret)
pr_err("%s:%d cannot set pin to suspend state",
__func__, __LINE__);
devm_pinctrl_put(ctrl->pinctrl_info.pinctrl);
}
ctrl->cam_pinctrl_status = 0;
msm_camera_request_gpio_table(
ctrl->gpio_conf->cam_gpio_req_tbl,
ctrl->gpio_conf->cam_gpio_req_tbl_size, 0);
CDBG("%s exit\n", __func__);
return 0;
}
int vpe_enable(uint32_t clk_rate, struct msm_cam_media_controller *mctl)
{
int rc = 0;
unsigned long flags = 0;
D("%s", __func__);
/* don't change the order of clock and irq.*/
spin_lock_irqsave(&vpe_ctrl->lock, flags);
if (vpe_ctrl->state != VPE_STATE_IDLE) {
pr_err("%s: VPE already enabled", __func__);
spin_unlock_irqrestore(&vpe_ctrl->lock, flags);
return 0;
}
vpe_ctrl->state = VPE_STATE_INIT;
spin_unlock_irqrestore(&vpe_ctrl->lock, flags);
enable_irq(vpe_ctrl->vpeirq->start);
if (vpe_ctrl->fs_vpe) {
rc = regulator_enable(vpe_ctrl->fs_vpe);
if (rc) {
pr_err("%s: Regulator enable failed\n", __func__);
goto vpe_fs_failed;
}
}
rc = msm_cam_clk_enable(&vpe_ctrl->pdev->dev, vpe_clk_info,
vpe_ctrl->vpe_clk, ARRAY_SIZE(vpe_clk_info), 1);
if (rc < 0)
goto vpe_clk_failed;
#ifdef CONFIG_MSM_IOMMU
if (mctl->domain == NULL) {
pr_err("%s: iommu domain not initialized\n", __func__);
rc = -EINVAL;
goto src_attach_failed;
}
rc = iommu_attach_device(mctl->domain, vpe_ctrl->iommu_ctx_src);
if (rc < 0) {
pr_err("%s: Device attach failed\n", __func__);
goto src_attach_failed;
}
rc = iommu_attach_device(mctl->domain, vpe_ctrl->iommu_ctx_dst);
if (rc < 0) {
pr_err("%s: Device attach failed\n", __func__);
goto dst_attach_failed;
}
#endif
return rc;
#ifdef CONFIG_MSM_IOMMU
dst_attach_failed:
iommu_detach_device(mctl->domain, vpe_ctrl->iommu_ctx_src);
src_attach_failed:
#endif
msm_cam_clk_enable(&vpe_ctrl->pdev->dev, vpe_clk_info,
vpe_ctrl->vpe_clk, ARRAY_SIZE(vpe_clk_info), 0);
vpe_clk_failed:
if (vpe_ctrl->fs_vpe)
regulator_disable(vpe_ctrl->fs_vpe);
vpe_fs_failed:
disable_irq(vpe_ctrl->vpeirq->start);
vpe_ctrl->state = VPE_STATE_IDLE;
return rc;
}
int32_t mt9m114_msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
struct device *dev = NULL;
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
dev = &s_ctrl->pdev->dev;
else
dev = &s_ctrl->sensor_i2c_client->client->dev;
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
if(!mt9m114_IsPowered){
s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
* data->sensor_platform_info->num_vreg, GFP_KERNEL);
if (!s_ctrl->reg_ptr) {
pr_err("%s: could not allocate mem for regulators\n",
__func__);
return -ENOMEM;
}
pr_err("%s: power up\n", __func__);
rc = msm_camera_config_vreg(dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto config_vreg_failed;
}
rc = msm_camera_enable_vreg(dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
pr_err("%s: enable regulator failed\n", __func__);
goto enable_vreg_failed;
}
mt9m114_IsPowered=1;
}
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE) {
if (s_ctrl->clk_rate != 0)
cam_8960_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(dev, cam_8960_clk_info,
s_ctrl->cam_clk, ARRAY_SIZE(cam_8960_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
} else {
rc = msm_cam_clk_enable(dev, cam_8974_clk_info,
s_ctrl->cam_clk, ARRAY_SIZE(cam_8974_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
}
if (!s_ctrl->power_seq_delay)
usleep_range(1000, 2000);
else if (s_ctrl->power_seq_delay < 20)
usleep_range((s_ctrl->power_seq_delay * 1000),
((s_ctrl->power_seq_delay * 1000) + 1000));
else
msleep(s_ctrl->power_seq_delay);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf);
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
rc = msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto cci_init_failed;
}
}
s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
return rc;
cci_init_failed:
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
msm_sensor_disable_i2c_mux(
data->sensor_platform_info->i2c_conf);
enable_clk_failed:
msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
msm_camera_enable_vreg(dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 0);
enable_vreg_failed:
msm_camera_config_vreg(dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 0);
if(mt9m114_IsPowered==1)
mt9m114_IsPowered=0;
config_vreg_failed:
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
kfree(s_ctrl->reg_ptr);
return rc;
}
static int msm_csid_init(struct csid_device *csid_dev, uint32_t *csid_version)
{
int rc = 0;
if (!csid_version) {
pr_err("%s:%d csid_version NULL\n", __func__, __LINE__);
rc = -EINVAL;
return rc;
}
csid_dev->base = ioremap(csid_dev->mem->start,
resource_size(csid_dev->mem));
if (!csid_dev->base) {
pr_err("%s csid_dev->base NULL\n", __func__);
rc = -ENOMEM;
return rc;
}
if (CSID_VERSION <= CSID_VERSION_V2) {
rc = msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto vreg_config_failed;
}
rc = msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto vreg_enable_failed;
}
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8960_clk_info, csid_dev->csid_clk,
ARRAY_SIZE(csid_8960_clk_info), 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto clk_enable_failed;
}
} else if (CSID_VERSION == CSID_VERSION_V3) {
rc = msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8974_vreg_info, ARRAY_SIZE(csid_8974_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto vreg_config_failed;
}
rc = msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8974_vreg_info, ARRAY_SIZE(csid_8974_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto vreg_enable_failed;
}
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8974_clk_info, csid_dev->csid_clk,
ARRAY_SIZE(csid_8974_clk_info), 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto clk_enable_failed;
}
}
csid_dev->hw_version =
msm_camera_io_r(csid_dev->base + CSID_HW_VERSION_ADDR);
*csid_version = csid_dev->hw_version;
init_completion(&csid_dev->reset_complete);
enable_irq(csid_dev->irq->start);
msm_csid_reset(csid_dev);
return rc;
clk_enable_failed:
if (CSID_VERSION <= CSID_VERSION_V2) {
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (CSID_VERSION == CSID_VERSION_V3) {
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8974_vreg_info, ARRAY_SIZE(csid_8974_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
}
vreg_enable_failed:
if (CSID_VERSION <= CSID_VERSION_V2) {
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (CSID_VERSION == CSID_VERSION_V3) {
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8974_vreg_info, ARRAY_SIZE(csid_8974_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
}
vreg_config_failed:
iounmap(csid_dev->base);
csid_dev->base = NULL;
return rc;
}
static int32_t ov8835_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct device *dev = &s_ctrl->sensor_i2c_client->client->dev;
struct msm_camera_sensor_info *info = s_ctrl->sensordata;
pr_debug("ov8835_power_up\n");
/* Request gpios */
rc = gpio_request(info->sensor_pwd, "ov8835");
if (rc < 0) {
pr_err("ov8835: gpio request sensor_pwd failed (%d)\n", rc);
goto power_up_done;
}
rc = gpio_request(info->sensor_reset, "ov8835");
if (rc < 0) {
pr_err("ov8835: gpio request sensor_reset failed (%d)\n", rc);
goto power_up_done;
}
/* Enable supplies */
rc = ov8835_regulator_on(&cam_vdig, dev, "cam_vdig", 1200000);
if (rc < 0)
goto power_up_done;
rc = ov8835_regulator_on(&cam_vio, dev, "cam_vio", 0);
if (rc < 0)
goto power_up_done;
rc = ov8835_regulator_on(&cam_afvdd, dev, "cam_afvdd", 2800000);
if (rc < 0)
goto power_up_done;
/* Set reset low */
gpio_direction_output(info->sensor_reset, 0);
/* Wait for core supplies to power up */
usleep(10000);
/*Enable MCLK*/
cam_mot_8960_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(dev, cam_mot_8960_clk_info,
s_ctrl->cam_clk, ARRAY_SIZE(cam_mot_8960_clk_info), 1);
if (rc < 0) {
pr_err("ov8835: msm_cam_clk_enable failed (%d)\n", rc);
goto power_up_done;
}
usleep(20000);
/* Set pwd high */
gpio_direction_output(info->sensor_pwd, 1);
usleep(26000);
/* Set reset high */
gpio_direction_output(info->sensor_reset, 1);
usleep(35000);
power_up_done:
return rc;
}
static int sr130pc10_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int err = 0;
int rc = 0;
int temp = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
#ifdef CONFIG_LOAD_FILE
if (0 > sr130pc10_regs_table_init()) {
CDBG("%s file open failed!\n", __func__);
rc = -1;
goto FAIL_END;
}
#endif
sr130pc10_ctrl->op_mode = 0;
sr130pc10_ctrl->dtp_mode = 0;
sr130pc10_ctrl->cam_mode = SENSOR_CAMERA;
sr130pc10_ctrl->settings.exposure = 0;
pr_info("=== Start ===");
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0)
pr_info(" request gpio failed");
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_stby, 0);
temp = __gpio_get_value(data->sensor_platform_info->vt_sensor_stby);
pr_info("check VT standby : %d", temp);
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_reset, 0);
temp = __gpio_get_value(data->sensor_platform_info->vt_sensor_reset);
pr_info("check VT reset : %d", temp);
gpio_set_value_cansleep(data->sensor_platform_info->sensor_reset, 0);
temp = __gpio_get_value(data->sensor_platform_info->sensor_reset);
pr_info("CAM_3M_RST : %d", temp);
gpio_set_value_cansleep(data->sensor_platform_info->sensor_stby, 0);
temp = __gpio_get_value(data->sensor_platform_info->sensor_stby);
pr_info("CAM_3M_ISP_INIT : %d", temp);
/*Power on the LDOs */
data->sensor_platform_info->sensor_power_on(1);
udelay(10);
/*standy VT */
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_stby, 1);
temp = __gpio_get_value(data->sensor_platform_info->vt_sensor_stby);
pr_info("check VT standby : %d", temp);
udelay(10);
/*Set Main clock */
gpio_tlmm_config(GPIO_CFG(data->sensor_platform_info->mclk, 1,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0) {
gpio_tlmm_config(GPIO_CFG(data->sensor_platform_info->mclk, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
pr_info(" Mclk enable failed");
}
if (rc != 0)
goto FAIL_END;
mdelay(12);
/*reset VT */
gpio_set_value_cansleep(data->sensor_platform_info->vt_sensor_reset, 1);
temp = __gpio_get_value(data->sensor_platform_info->vt_sensor_reset);
pr_info("check VT reset : %d", temp);
udelay(1500);
err = sr130pc10_sensor_write_list(sr130pc10_i2c_check,
sizeof(sr130pc10_i2c_check) /
sizeof(sr130pc10_i2c_check[0]),
"sr130pc10_i2c_check");
if (err == -EINVAL) {
cam_err("[sr130pc20] start1 fail!\n");
msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, \
ARRAY_SIZE(cam_clk_info), 0);
gpio_tlmm_config(GPIO_CFG(data->sensor_platform_info->mclk, 0,
GPIO_CFG_OUTPUT, GPIO_CFG_PULL_DOWN, GPIO_CFG_2MA),
GPIO_CFG_ENABLE);
udelay(10);
msm_camera_request_gpio_table(data, 0);
return -EIO;
}
FAIL_END:
if (rc) {
pr_info("Power up Failed!!");
msm_camera_request_gpio_table(data, 0);
} else {
pr_info("power up x");
}
return rc;
}
int msm_jpeg_platform_init(struct platform_device *pdev,
struct resource **mem,
void **base,
int *irq,
irqreturn_t (*handler) (int, void *),
void *context)
{
int rc = -1;
int jpeg_irq;
struct resource *jpeg_mem, *vbif_mem, *jpeg_io, *jpeg_irq_res;
void *jpeg_base;
struct msm_jpeg_device *pgmn_dev =
(struct msm_jpeg_device *) context;
pgmn_dev->state = MSM_JPEG_IDLE;
jpeg_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!jpeg_mem) {
JPEG_PR_ERR("%s: jpeg no mem resource?\n", __func__);
return -ENODEV;
}
vbif_mem = platform_get_resource(pdev, IORESOURCE_MEM, 1);
if (!vbif_mem) {
JPEG_PR_ERR("%s: vbif no mem resource?\n", __func__);
return -ENODEV;
}
jpeg_irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!jpeg_irq_res) {
JPEG_PR_ERR("no irq resource?\n");
return -ENODEV;
}
jpeg_irq = jpeg_irq_res->start;
JPEG_DBG("%s base address: 0x%lx, jpeg irq number: %d\n", __func__,
(unsigned long)jpeg_mem->start, jpeg_irq);
pgmn_dev->jpeg_bus_client =
msm_bus_scale_register_client(&msm_jpeg_bus_client_pdata);
if (!pgmn_dev->jpeg_bus_client) {
JPEG_PR_ERR("%s: Registration Failed!\n", __func__);
pgmn_dev->jpeg_bus_client = 0;
return -EINVAL;
}
msm_bus_scale_client_update_request(
pgmn_dev->jpeg_bus_client, 1);
jpeg_io = request_mem_region(jpeg_mem->start,
resource_size(jpeg_mem), pdev->name);
if (!jpeg_io) {
JPEG_PR_ERR("%s: region already claimed\n", __func__);
return -EBUSY;
}
jpeg_base = ioremap(jpeg_mem->start, resource_size(jpeg_mem));
if (!jpeg_base) {
rc = -ENOMEM;
JPEG_PR_ERR("%s: ioremap failed\n", __func__);
goto fail_remap;
}
pgmn_dev->jpeg_fs = regulator_get(&pgmn_dev->pdev->dev, "vdd");
rc = regulator_enable(pgmn_dev->jpeg_fs);
if (rc) {
JPEG_PR_ERR("%s:%d]jpeg regulator get failed\n",
__func__, __LINE__);
goto fail_fs;
}
if (msm_jpeg_get_clk_info(pgmn_dev, pgmn_dev->pdev) < 0) {
JPEG_PR_ERR("%s:%d]jpeg clock get failed\n",
__func__, __LINE__);
goto fail_fs;
}
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev, pgmn_dev->jpeg_clk_info,
pgmn_dev->jpeg_clk, pgmn_dev->num_clk, 1);
if (rc < 0) {
JPEG_PR_ERR("%s: clk failed rc = %d\n", __func__, rc);
goto fail_clk;
}
pgmn_dev->hw_version = readl_relaxed(jpeg_base +
JPEG_HW_VERSION);
JPEG_DBG_HIGH("%s:%d] jpeg HW version 0x%x", __func__, __LINE__,
pgmn_dev->hw_version);
pgmn_dev->jpeg_vbif = ioremap(vbif_mem->start, resource_size(vbif_mem));
if (!pgmn_dev->jpeg_vbif) {
rc = -ENOMEM;
JPEG_PR_ERR("%s: ioremap failed\n", __func__);
goto fail_vbif;
}
JPEG_DBG("%s:%d] jpeg_vbif 0x%lx", __func__, __LINE__,
(unsigned long)pgmn_dev->jpeg_vbif);
rc = msm_jpeg_attach_iommu(pgmn_dev);
if (rc < 0)
goto fail_iommu;
set_vbif_params(pgmn_dev, pgmn_dev->jpeg_vbif);
rc = request_irq(jpeg_irq, handler, IRQF_TRIGGER_RISING,
dev_name(&pdev->dev), context);
if (rc) {
JPEG_PR_ERR("%s: request_irq failed, %d\n", __func__,
jpeg_irq);
goto fail_request_irq;
}
*mem = jpeg_mem;
*base = jpeg_base;
*irq = jpeg_irq;
pgmn_dev->jpeg_client = msm_ion_client_create(dev_name(&pdev->dev));
JPEG_DBG("%s:%d] success\n", __func__, __LINE__);
pgmn_dev->state = MSM_JPEG_INIT;
return rc;
fail_request_irq:
msm_jpeg_detach_iommu(pgmn_dev);
fail_iommu:
iounmap(pgmn_dev->jpeg_vbif);
fail_vbif:
msm_cam_clk_enable(&pgmn_dev->pdev->dev, pgmn_dev->jpeg_clk_info,
pgmn_dev->jpeg_clk, pgmn_dev->num_clk, 0);
fail_clk:
regulator_disable(pgmn_dev->jpeg_fs);
regulator_put(pgmn_dev->jpeg_fs);
fail_fs:
iounmap(jpeg_base);
fail_remap:
release_mem_region(jpeg_mem->start, resource_size(jpeg_mem));
JPEG_DBG("%s:%d] fail\n", __func__, __LINE__);
return rc;
}
int32_t gc0339_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t index = 0;
struct msm_sensor_power_setting_array *power_setting_array = NULL;
struct msm_sensor_power_setting *power_setting = NULL;
struct msm_camera_sensor_board_info *data = s_ctrl->sensordata;
struct msm_camera_power_ctrl_t *power_info = &data->power_info;
struct msm_camera_gpio_conf *gpio_conf = power_info->gpio_conf;
CDBG("%s:%d\n", __func__, __LINE__);
power_setting_array = &s_ctrl->power_setting_array;
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_RELEASE);
}
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write(
s_ctrl->sensor_i2c_client,
0xfc,
0x01, MSM_CAMERA_I2C_BYTE_DATA);
for (index = (power_setting_array->size - 1); index >= 0; index--) {
CDBG("%s index %d\n", __func__, index);
power_setting = &power_setting_array->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(power_info->dev,
&power_info->clk_info[0],
(struct clk **)&power_setting->data[0],
power_info->clk_info_size,
0);
break;
case SENSOR_GPIO:
if (power_setting->seq_val >= SENSOR_GPIO_MAX ||
!gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
continue;
}
if (gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val])
gpio_set_value_cansleep(
gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
GPIOF_OUT_INIT_LOW);
break;
case SENSOR_VREG:
if (power_setting->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
continue;
}
msm_camera_config_single_vreg(power_info->dev,
&power_info->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
msm_camera_request_gpio_table(
gpio_conf->cam_gpio_req_tbl,
gpio_conf->cam_gpio_req_tbl_size, 0);
CDBG("%s exit\n", __func__);
return 0;
}
int ov680_power_up(struct msm_sensor_ctrl_t *s_ctrl, struct msm_sensor_power_setting* power_setting_table, int size)
{
int index, rc = 0;
struct msm_sensor_power_setting* power_setting;
struct msm_camera_sensor_board_info *data = s_ctrl->sensordata;
ov680_info("%s line %d", __func__, __LINE__);
/* request GPIO table */
rc = msm_camera_request_gpio_table(standby_gpios, sizeof(standby_gpios)/sizeof(standby_gpios[0]), 1);
if(rc){
ov680_err("%s msm_camera_request_gpio_table failed rc=%d %d", __func__, rc, __LINE__);
return rc;
}
for (index = 0; index < size; index++) {
ov680_dbg("%s index %d\n", __func__, index);
power_setting = &power_setting_table[index];
ov680_dbg("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
if (power_setting->seq_val >= s_ctrl->clk_info_size) {
pr_err("%s clk index %d >= max %d\n", __func__,
power_setting->seq_val,
s_ctrl->clk_info_size);
goto ov680_power_up_failed;
}
if (power_setting->config_val)
s_ctrl->clk_info[power_setting->seq_val].
clk_rate = power_setting->config_val;
ov680_dbg("%s Enable MCLK %d", __func__, __LINE__);
rc = msm_cam_clk_enable(s_ctrl->dev,
&s_ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
s_ctrl->clk_info_size,
1);
if (rc < 0) {
pr_err("%s: clk enable failed\n",
__func__);
goto ov680_power_up_failed;
}
break;
case SENSOR_VREG:
ov680_dbg("%s Enable VREG %d", __func__, __LINE__);
rc = msm_camera_config_single_vreg(s_ctrl->dev,
&data->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
1);
if (rc < 0) {
pr_err("%s: vreg enable failed\n",
__func__);
goto ov680_power_up_failed;
}
break;
case SENSOR_GPIO:
case SENSOR_I2C_MUX:
default:
ov680_info("Not handled");
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
/* call CCI INIT */
ov680_dbg("call CCI INIT");
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto ov680_power_up_failed;
}
return 0;
ov680_power_up_failed:
ov680_err("%s:%d failed\n", __func__, __LINE__);
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_RELEASE);
for (index--; index >= 0; index--) {
ov680_err("%s index %d\n", __func__, index);
power_setting = &power_setting_table[index];
ov680_err("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(s_ctrl->dev,
&s_ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
s_ctrl->clk_info_size,
0);
break;
case SENSOR_VREG:
msm_camera_config_single_vreg(s_ctrl->dev,
&data->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
break;
case SENSOR_GPIO:
case SENSOR_I2C_MUX:
default:
ov680_info("Not handled");
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
msm_camera_request_gpio_table(standby_gpios, sizeof(standby_gpios)/sizeof(standby_gpios[0]), 0);
return rc;
}
int32_t gc0339_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0, index = 0;
struct msm_sensor_power_setting_array *power_setting_array = NULL;
struct msm_sensor_power_setting *power_setting = NULL;
struct msm_camera_sensor_board_info *data = s_ctrl->sensordata;
struct msm_camera_power_ctrl_t *power_info = &data->power_info;
struct msm_camera_gpio_conf *gpio_conf = power_info->gpio_conf;
CDBG("%s:%d\n", __func__, __LINE__);
power_setting_array = &s_ctrl->power_setting_array;
if (gpio_conf->cam_gpiomux_conf_tbl != NULL) {
pr_err("%s:%d mux install\n", __func__, __LINE__);
msm_gpiomux_install(
(struct msm_gpiomux_config *)
gpio_conf->cam_gpiomux_conf_tbl,
gpio_conf->cam_gpiomux_conf_tbl_size);
}
rc = msm_camera_request_gpio_table(
gpio_conf->cam_gpio_req_tbl,
gpio_conf->cam_gpio_req_tbl_size, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
return rc;
}
for (index = 0; index < power_setting_array->size; index++) {
CDBG("%s index %d\n", __func__, index);
power_setting = &power_setting_array->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
if (power_setting->seq_val >=
power_info->clk_info_size) {
pr_err("%s clk index %d >= max %d\n", __func__,
power_setting->seq_val,
power_info->clk_info_size);
goto power_up_failed;
}
if (power_setting->config_val)
power_info->clk_info[power_setting->seq_val].
clk_rate = power_setting->config_val;
rc = msm_cam_clk_enable(power_info->dev,
&power_info->clk_info[0],
(struct clk **)&power_setting->data[0],
power_info->clk_info_size,
1);
if (rc < 0) {
pr_err("%s: clk enable failed\n",
__func__);
goto power_up_failed;
}
break;
case SENSOR_GPIO:
if (power_setting->seq_val >= SENSOR_GPIO_MAX ||
!gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
pr_debug("%s:%d gpio set val %d\n", __func__, __LINE__,
gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val]);
if (gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val])
gpio_set_value_cansleep(
gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
power_setting->config_val);
break;
case SENSOR_VREG:
if (power_setting->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
msm_camera_config_single_vreg(power_info->dev,
&power_info->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
1);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
rc = s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto power_up_failed;
}
}
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_write(
s_ctrl->sensor_i2c_client,
0xfc,
0x10, MSM_CAMERA_I2C_BYTE_DATA);
if (s_ctrl->func_tbl->sensor_match_id)
rc = s_ctrl->func_tbl->sensor_match_id(s_ctrl);
else
rc = msm_sensor_match_id(s_ctrl);
if (rc < 0) {
pr_err("%s:%d match id failed rc %d\n", __func__, __LINE__, rc);
goto power_up_failed;
}
CDBG("%s exit\n", __func__);
return 0;
power_up_failed:
pr_err("%s:%d failed\n", __func__, __LINE__);
if (s_ctrl->sensor_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
s_ctrl->sensor_i2c_client->i2c_func_tbl->i2c_util(
s_ctrl->sensor_i2c_client, MSM_CCI_RELEASE);
}
for (index--; index >= 0; index--) {
CDBG("%s index %d\n", __func__, index);
power_setting = &power_setting_array->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(power_info->dev,
&power_info->clk_info[0],
(struct clk **)&power_setting->data[0],
power_info->clk_info_size,
0);
break;
case SENSOR_GPIO:
if (gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val])
gpio_set_value_cansleep(
gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
GPIOF_OUT_INIT_LOW);
break;
case SENSOR_VREG:
msm_camera_config_single_vreg(power_info->dev,
&power_info->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
msm_camera_request_gpio_table(
gpio_conf->cam_gpio_req_tbl,
gpio_conf->cam_gpio_req_tbl_size, 0);
return rc;
}
int32_t s5k5ca_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *info = NULL;
//printk(" s5k5ca_sensor_power_up()\n");
info = s_ctrl->sensordata;
/* turn off PWDN & RST */
rc = gpio_request(info->sensor_pwd, "S5K5CA_PWDN");
if (rc < 0)
pr_err("%s: gpio_request--- failed!", __func__);
rc = gpio_request(info->sensor_reset, "S5K5CA_RST");
if (rc < 0)
pr_err("%s: gpio_request--- failed!", __func__);
gpio_direction_output(info->sensor_pwd, 0);
gpio_direction_output(info->sensor_reset, 0);
/*++ PeterShih - 20121004 Turn on ldo and vreg ++*/
rc = gpio_request( 14 , "S5K5CA_1.8V");
if (rc < 0)
pr_err("%s: gpio_request--- failed!", __func__);
rc = gpio_request( 10 , "S5K5CA_2.8V");
if (rc < 0)
pr_err("%s: gpio_request--- failed!", __func__);
gpio_direction_output(14, 1);
gpio_direction_output(10, 1);
/*-- PeterShih - 20121004 Turn on ldo and vreg --*/
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
// goto enable_clk_failed;
}
#if 0
rc = msm_sensor_power_up(s_ctrl);
if (rc < 0) {
CDBG("%s: msm_sensor_power_up failed\n", __func__);
return rc;
}
#endif
/* turn on PWDN & RST */
gpio_direction_output(info->sensor_pwd, 1);
gpio_direction_output(info->sensor_reset, 1);
rc=msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0xFCFC, 0xD000, MSM_CAMERA_I2C_WORD_DATA);
rc|=msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x002C, 0x0000, MSM_CAMERA_I2C_WORD_DATA);
rc|=msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x002E, 0x0040, MSM_CAMERA_I2C_WORD_DATA);
if (rc < 0)
pr_err("%s: rc:%d iic failed!", __func__,rc);
//detect sensor//
camera_id=gpio_get_value(13);
//Flea++
s_ctrl->sensordata->sensor_platform_info->hw_version=10|camera_id;
//Flea--
//pr_emerg(" s5k5ca_sensor_power_up() rc:%d camera_id:%d",rc,camera_id);
//
return rc;
};
int hi351_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
printk("%s: E %d\n", __func__, __LINE__);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
// 1. RESET LOW
if (data->sensor_reset_enable) {
rc = gpio_request(data->sensor_reset, "hi351_reset"); //msm_camera_request_gpio_table(reset pin already requested)
if (rc < 0)
pr_err("%s: gpio_request:CAM_RESET %d failed\n", __func__, data->sensor_reset);
rc = gpio_direction_output(data->sensor_reset, 0);
if (rc < 0)
pr_err("%s: gpio:CAM_RESET %d direction can't be set\n", __func__, data->sensor_reset);
}
// 2. PWDN LOW
rc = gpio_request(data->sensor_pwd, "hi351_pwdn");
if (rc < 0)
pr_err("%s: gpio_request:CAM_PWDN %d failed\n", __func__, data->sensor_pwd);
rc = gpio_direction_output(data->sensor_pwd, 0);
if (rc < 0)
pr_err("%s: gpio:CAM_PWDN %d direction can't be set\n", __func__, data->sensor_pwd);
msleep(1);
// 3. CAM PWR ON
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
msleep(1);
// 4. PWDN HIGH
rc = gpio_direction_output(data->sensor_pwd, 1);
if (rc < 0) {
pr_err("%s: gpio:CAM_PWDN %d direction can't be set\n", __func__, data->sensor_pwd);
}
msleep(1);
// 4. MCLK Enable
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
pr_err("MCLK set\n");
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
msleep(10);
// 6. RESET HIGH
rc = gpio_direction_output(data->sensor_reset, 1);
if (rc < 0)
pr_err("%s: gpio:CAM_RESET %d direction can't be set\n", __func__, data->sensor_reset);
msleep(1);
printk("%s: X %d\n", __func__, __LINE__);
return rc;
enable_clk_failed:
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
data->sensor_platform_info->ext_power_ctrl(0);
return rc;
}
static int msm_ispif_reset_hw(struct ispif_device *ispif)
{
int rc = 0;
long timeout = 0;
struct clk *reset_clk[ARRAY_SIZE(ispif_8974_reset_clk_info)];
struct clk *reset_clk1[ARRAY_SIZE(ispif_8626_reset_clk_info)];
ispif->clk_idx = 0;
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 1);
if (rc < 0) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8626_reset_clk_info, reset_clk1,
ARRAY_SIZE(ispif_8626_reset_clk_info), 1);
if (rc < 0) {
pr_err("%s: cannot enable clock, error = %d",
__func__, rc);
} else {
/* This is set when device is 8x26 */
ispif->clk_idx = 2;
}
} else {
/* This is set when device is 8974 */
ispif->clk_idx = 1;
}
init_completion(&ispif->reset_complete[VFE0]);
if (ispif->hw_num_isps > 1)
init_completion(&ispif->reset_complete[VFE1]);
/* initiate reset of ISPIF */
msm_camera_io_w(ISPIF_RST_CMD_MASK,
ispif->base + ISPIF_RST_CMD_ADDR);
if (ispif->hw_num_isps > 1)
msm_camera_io_w(ISPIF_RST_CMD_1_MASK,
ispif->base + ISPIF_RST_CMD_1_ADDR);
timeout = wait_for_completion_timeout(
&ispif->reset_complete[VFE0], msecs_to_jiffies(500));
CDBG("%s: VFE0 done\n", __func__);
if (timeout <= 0) {
pr_err("%s: VFE0 reset wait timeout\n", __func__);
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 0);
if (rc < 0) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8626_reset_clk_info, reset_clk1,
ARRAY_SIZE(ispif_8626_reset_clk_info), 0);
if (rc < 0)
pr_err("%s: VFE0 reset wait timeout\n",
__func__);
}
return -ETIMEDOUT;
}
if (ispif->hw_num_isps > 1) {
timeout = wait_for_completion_timeout(
&ispif->reset_complete[VFE1],
msecs_to_jiffies(500));
CDBG("%s: VFE1 done\n", __func__);
if (timeout <= 0) {
pr_err("%s: VFE1 reset wait timeout\n", __func__);
msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 0);
return -ETIMEDOUT;
}
}
if (ispif->clk_idx == 1) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 0);
if (rc < 0) {
pr_err("%s: cannot disable clock, error = %d",
__func__, rc);
}
}
if (ispif->clk_idx == 2) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8626_reset_clk_info, reset_clk1,
ARRAY_SIZE(ispif_8626_reset_clk_info), 0);
if (rc < 0) {
pr_err("%s: cannot disable clock, error = %d",
__func__, rc);
}
}
return rc;
}
int32_t t8ev4_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
printk("%s: E %d\n", __func__, __LINE__);
s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
* data->sensor_platform_info->num_vreg, GFP_KERNEL);
if (!s_ctrl->reg_ptr) {
pr_err("%s: could not allocate mem for regulators\n", __func__);
return -ENOMEM;
}
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
/* RESET LOW*/
if (data->sensor_reset_enable) {
rc = gpio_request(data->sensor_reset, "CAM_RESET");
if (rc < 0)
pr_err("%s: gpio_request:CAM_RESET %d failed\n", __func__, data->sensor_reset);
rc = gpio_direction_output(data->sensor_reset, 0);
if (rc < 0)
pr_err("%s: gpio:CAM_RESET %d direction can't be set\n", __func__, data->sensor_reset);
}
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
usleep_range(1000, 2000);
/* RESET HIGH */
if (data->sensor_reset_enable) {
rc = gpio_direction_output(data->sensor_reset, 1);
if (rc < 0)
pr_err("%s: gpio:CAM_RESET %d direction can't be set\n", __func__, data->sensor_reset);
}
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
printk("%s: X %d\n", __func__, __LINE__);
return rc;
enable_clk_failed:
msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
if (data->sensor_reset_enable) {
gpio_direction_output(data->sensor_reset, 0);
usleep_range(1000, 2000);
}
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
kfree(s_ctrl->reg_ptr);
printk("%s: X %d failed\n", __func__, __LINE__);
return rc;
}
static int msm_ispif_restart_frame_boundary(struct ispif_device *ispif,
struct msm_ispif_param_data *params)
{
int rc = 0, i;
long timeout = 0;
uint16_t cid_mask;
enum msm_ispif_intftype intftype;
enum msm_ispif_vfe_intf vfe_intf;
uint32_t vfe_mask = 0;
uint32_t intf_addr;
struct clk *reset_clk[ARRAY_SIZE(ispif_8974_reset_clk_info)];
struct clk *reset_clk1[ARRAY_SIZE(ispif_8626_reset_clk_info)];
ispif->clk_idx = 0;
if (ispif->ispif_state != ISPIF_POWER_UP) {
pr_err("%s: ispif invalid state %d\n", __func__,
ispif->ispif_state);
rc = -EPERM;
return rc;
}
for (i = 0; i < params->num; i++) {
vfe_intf = params->entries[i].vfe_intf;
vfe_mask |= (1 << vfe_intf);
}
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 1);
if (rc < 0) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8626_reset_clk_info, reset_clk1,
ARRAY_SIZE(ispif_8626_reset_clk_info), 1);
if (rc < 0) {
pr_err("%s: cannot enable clock, error = %d",
__func__, rc);
} else {
/* This is set when device is 8x26 */
ispif->clk_idx = 2;
}
} else {
/* This is set when device is 8974 */
ispif->clk_idx = 1;
}
if (vfe_mask & (1 << VFE0)) {
init_completion(&ispif->reset_complete[VFE0]);
pr_err("%s Init completion VFE0\n", __func__);
/* initiate reset of ISPIF */
msm_camera_io_w(0x00001FF9,
ispif->base + ISPIF_RST_CMD_ADDR);
}
if (ispif->hw_num_isps > 1 && (vfe_mask & (1 << VFE1))) {
init_completion(&ispif->reset_complete[VFE1]);
pr_err("%s Init completion VFE1\n", __func__);
msm_camera_io_w(0x00001FF9,
ispif->base + ISPIF_RST_CMD_1_ADDR);
}
if (vfe_mask & (1 << VFE0)) {
timeout = wait_for_completion_timeout(
&ispif->reset_complete[VFE0], msecs_to_jiffies(500));
if (timeout <= 0) {
pr_err("%s: VFE0 reset wait timeout\n", __func__);
rc = -ETIMEDOUT;
goto disable_clk;
}
}
if (ispif->hw_num_isps > 1 && (vfe_mask & (1 << VFE1))) {
timeout = wait_for_completion_timeout(
&ispif->reset_complete[VFE1],
msecs_to_jiffies(500));
if (timeout <= 0) {
pr_err("%s: VFE1 reset wait timeout\n", __func__);
rc = -ETIMEDOUT;
goto disable_clk;
}
}
pr_info("%s: ISPIF reset hw done", __func__);
if (ispif->clk_idx == 1) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 0);
if (rc < 0) {
pr_err("%s: cannot disable clock, error = %d",
__func__, rc);
goto end;
}
}
if (ispif->clk_idx == 2) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8626_reset_clk_info, reset_clk1,
ARRAY_SIZE(ispif_8626_reset_clk_info), 0);
if (rc < 0) {
pr_err("%s: cannot disable clock, error = %d",
__func__, rc);
goto end;
}
}
for (i = 0; i < params->num; i++) {
intftype = params->entries[i].intftype;
vfe_intf = params->entries[i].vfe_intf;
switch (params->entries[0].intftype) {
case PIX0:
intf_addr = ISPIF_VFE_m_PIX_INTF_n_STATUS(vfe_intf, 0);
break;
case RDI0:
intf_addr = ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe_intf, 0);
break;
case PIX1:
intf_addr = ISPIF_VFE_m_PIX_INTF_n_STATUS(vfe_intf, 1);
break;
case RDI1:
intf_addr = ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe_intf, 1);
break;
case RDI2:
intf_addr = ISPIF_VFE_m_RDI_INTF_n_STATUS(vfe_intf, 2);
break;
default:
pr_err("%s: invalid intftype=%d\n", __func__,
params->entries[i].intftype);
rc = -EPERM;
goto end;
}
msm_ispif_intf_cmd(ispif,
ISPIF_INTF_CMD_ENABLE_FRAME_BOUNDARY, params);
}
for (i = 0; i < params->num; i++) {
intftype = params->entries[i].intftype;
vfe_intf = params->entries[i].vfe_intf;
cid_mask = msm_ispif_get_cids_mask_from_cfg(
¶ms->entries[i]);
msm_ispif_enable_intf_cids(ispif, intftype,
cid_mask, vfe_intf, 1);
}
end:
return rc;
disable_clk:
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8974_reset_clk_info, reset_clk,
ARRAY_SIZE(ispif_8974_reset_clk_info), 0);
if (rc < 0) {
rc = msm_cam_clk_enable(&ispif->pdev->dev,
ispif_8626_reset_clk_info, reset_clk1,
ARRAY_SIZE(ispif_8626_reset_clk_info), 0);
if (rc < 0)
pr_err("%s: cannot enable clock, error = %d",
__func__, rc);
}
return -ETIMEDOUT;
}
int32_t hm03d5_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
struct device *dev = NULL;
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
dev = &s_ctrl->pdev->dev;
else
dev = &s_ctrl->sensor_i2c_client->client->dev;
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE) {
if (s_ctrl->clk_rate != 0)
cam_8960_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(dev, cam_8960_clk_info,
s_ctrl->cam_clk, ARRAY_SIZE(cam_8960_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
} else {
rc = msm_cam_clk_enable(dev, cam_8974_clk_info,
s_ctrl->cam_clk, ARRAY_SIZE(cam_8974_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
}
if (!s_ctrl->power_seq_delay)
usleep_range(1000, 2000);
else if (s_ctrl->power_seq_delay < 20)
usleep_range((s_ctrl->power_seq_delay * 1000),
((s_ctrl->power_seq_delay * 1000) + 1000));
else
msleep(s_ctrl->power_seq_delay);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf);
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
rc = msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto cci_init_failed;
}
}
s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
return rc;
cci_init_failed:
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
msm_sensor_disable_i2c_mux(
data->sensor_platform_info->i2c_conf);
enable_clk_failed:
msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
return rc;
}
static int msm_csid_init(struct v4l2_subdev *sd, uint32_t *csid_version)
{
int rc = 0;
struct csid_device *csid_dev;
csid_dev = v4l2_get_subdevdata(sd);
if (csid_dev == NULL) {
rc = -ENOMEM;
return rc;
}
csid_dev->base = ioremap(csid_dev->mem->start,
resource_size(csid_dev->mem));
if (!csid_dev->base) {
rc = -ENOMEM;
return rc;
}
rc = msm_camera_config_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto vreg_config_failed;
}
rc = msm_camera_enable_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto vreg_enable_failed;
}
rc = msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_clk_info), 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto clk_enable_failed;
}
csid_dev->hw_version =
msm_camera_io_r(csid_dev->base + CSID_HW_VERSION_ADDR);
*csid_version = csid_dev->hw_version;
init_completion(&csid_dev->reset_complete);
rc = request_irq(csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", csid_dev);
msm_csid_reset(csid_dev);
return rc;
clk_enable_failed:
msm_camera_enable_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 0);
vreg_enable_failed:
msm_camera_config_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 0);
vreg_config_failed:
iounmap(csid_dev->base);
csid_dev->base = NULL;
return rc;
}
int32_t imx132_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s: %d\n", __func__, __LINE__);
#ifdef LGIT_IEF_SWITCH
if(system_state != SYSTEM_BOOTING) {
mipi_lgit_lcd_ief_off();
}
#endif
s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
* data->sensor_platform_info->num_vreg, GFP_KERNEL);
if (!s_ctrl->reg_ptr) {
pr_err("%s: could not allocate mem for regulators\n",
__func__);
return -ENOMEM;
}
pr_err("%s: before request gpio, sensor name : %s", __func__, s_ctrl->sensordata->sensor_name);
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
rc = gpio_request(MSM_VT_PWR_EN, "VT_PWR_EN");
#if defined(CONFIG_MACH_APQ8064_GKKT) || defined(CONFIG_MACH_APQ8064_GKSK) || defined(CONFIG_MACH_APQ8064_GKU) || defined(CONFIG_MACH_APQ8064_GKATT)
if(lge_get_board_revno() >= HW_REV_C ||lge_get_board_revno() == HW_REV_1_0){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN);
rc = gpio_request(MSM_CAM2_RST_EN, "VTCAM_RST_EN");
}
if (rc) {
LDBGE("%s: PM request gpio failed\n", __func__);
}
#elif defined(CONFIG_MACH_APQ8064_GVDCM)
if(lge_get_board_revno() >= HW_REV_C){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN);
rc = gpio_request(MSM_CAM2_RST_EN, "VTCAM_RST_EN");
}
if (rc) {
LDBGE("%s: PM request gpio failed\n", __func__);
}
#endif
rc = msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
LDBGE("%s: regulator on failed\n", __func__);
goto config_vreg_failed;
}
rc =pm8xxx_gpio_config(MSM_VT_PWR_EN, &gpio35_param);
#if defined(CONFIG_MACH_APQ8064_GKKT) || defined(CONFIG_MACH_APQ8064_GKSK) || defined(CONFIG_MACH_APQ8064_GKU) || defined(CONFIG_MACH_APQ8064_GKATT)
if(lge_get_board_revno() >= HW_REV_C ||lge_get_board_revno() == HW_REV_1_0){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc =pm8xxx_gpio_config(MSM_CAM2_RST_EN, &gpio28_param);
}
if (rc) {
LDBGE("%s: pm8xxx_gpio_config on failed\n", __func__);
}
#elif defined(CONFIG_MACH_APQ8064_GVDCM)
if(lge_get_board_revno() >= HW_REV_C){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc =pm8xxx_gpio_config(MSM_CAM2_RST_EN, &gpio28_param);
}
if (rc) {
LDBGE("%s: pm8xxx_gpio_config on failed\n", __func__);
}
#endif
rc = gpio_direction_output(MSM_VT_PWR_EN, 0);
usleep(5);
rc = gpio_direction_output(MSM_VT_PWR_EN, 1);
if (rc) {
LDBGE("%s: gpio_direction_output enable failed\n", __func__);
}
rc = msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
LDBGE("%s: enable regulator failed\n", __func__);
goto enable_vreg_failed;
}
usleep(10);
#if defined(CONFIG_MACH_APQ8064_GKKT) || defined(CONFIG_MACH_APQ8064_GKSK) || defined(CONFIG_MACH_APQ8064_GKU) || defined(CONFIG_MACH_APQ8064_GKATT)
if(lge_get_board_revno() >= HW_REV_C ||lge_get_board_revno() == HW_REV_1_0){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc = gpio_direction_output(MSM_CAM2_RST_EN, 1);
}
#elif defined(CONFIG_MACH_APQ8064_GVDCM)
if(lge_get_board_revno() >= HW_REV_C){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc = gpio_direction_output(MSM_CAM2_RST_EN, 1);
}
#endif
else {
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
LDBGE("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
}
if (s_ctrl->clk_rate != 0)
imx132_cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
imx132_cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(imx132_cam_clk_info), 1);
if (rc < 0) {
LDBGE("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
usleep_range(1000, 2000);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
imx132_msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf);
return rc;
enable_clk_failed:
#if defined(CONFIG_MACH_APQ8064_GKKT) || defined(CONFIG_MACH_APQ8064_GKSK) || defined(CONFIG_MACH_APQ8064_GKU) || defined(CONFIG_MACH_APQ8064_GKATT)
if(lge_get_board_revno() >= HW_REV_C ||lge_get_board_revno() == HW_REV_1_0){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc = gpio_direction_output(MSM_CAM2_RST_EN, 0);
}
#elif defined(CONFIG_MACH_APQ8064_GVDCM)
if(lge_get_board_revno() >= HW_REV_C){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc = gpio_direction_output(MSM_CAM2_RST_EN, 0);
}
#endif
else {
msm_camera_config_gpio_table(data, 0);
}
config_gpio_failed:
msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 0);
enable_vreg_failed:
msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 0);
config_vreg_failed:
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
kfree(s_ctrl->reg_ptr);
return rc;
}
int32_t msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s: %d\n", __func__, __LINE__);
s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
* data->sensor_platform_info->num_vreg, GFP_KERNEL);
if (!s_ctrl->reg_ptr) {
pr_err("%s: could not allocate mem for regulators\n",
__func__);
return -ENOMEM;
}
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
rc = msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto config_vreg_failed;
}
rc = msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
pr_err("%s: enable regulator failed\n", __func__);
goto enable_vreg_failed;
}
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
usleep_range(1000, 2000);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
msm_sensor_enable_i2c_mux(data->sensor_platform_info->i2c_conf);
return rc;
enable_clk_failed:
msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 0);
enable_vreg_failed:
msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 0);
config_vreg_failed:
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
kfree(s_ctrl->reg_ptr);
return rc;
}
int32_t imx132_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s\n", __func__);
pr_err("%s\n", __func__);
/* LGE_CHANGE_S, [email protected], 2012-10-31, Wise screen / Because of the display engine */
sub_cam_id_for_keep_screen_on = -1;
/* LGE_CHANGE_E, [email protected], 2012-10-31, Wise screen / Because of the display engine */
/*LGE_UPDATE_S Color Engine Switch for camera, 2012.11.19, [email protected]*/
#ifdef LGIT_COLOR_ENGINE_SWITCH
if(system_state != SYSTEM_BOOTING) {
mipi_lgit_lcd_color_engine_on();
}
#endif
/*LGE_UPDATE_E Color Engine Switch for camera, 2012.11.19, [email protected]*/
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
imx132_msm_sensor_disable_i2c_mux(
data->sensor_platform_info->i2c_conf);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(0);
msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
imx132_cam_clk_info, s_ctrl->cam_clk, ARRAY_SIZE(imx132_cam_clk_info), 0);
/* LGE_CHANGE_S, increase timing margin, 2012.06.19, [email protected] */
usleep(5);
/* LGE_CHANGE_E, increase timing margin, 2012.06.19, [email protected] */
#if defined(CONFIG_MACH_APQ8064_GKKT) || defined(CONFIG_MACH_APQ8064_GKSK) || defined(CONFIG_MACH_APQ8064_GKU) || defined(CONFIG_MACH_APQ8064_GKATT)
if(lge_get_board_revno() >= HW_REV_C ||lge_get_board_revno() == HW_REV_1_0){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc = gpio_direction_output(MSM_CAM2_RST_EN, 0 );
}
#elif defined(CONFIG_MACH_APQ8064_GVDCM)
if(lge_get_board_revno() >= HW_REV_C){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
rc = gpio_direction_output(MSM_CAM2_RST_EN, 0 );
}
#endif
else {
msm_camera_config_gpio_table(data, 0);
}
/* LGE_CHANGE_S, Avoid Kernel Panic, 2012.11.12, jungki.kim[Start] */
if(s_ctrl->reg_ptr != NULL) {
msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 0);
msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->vreg_seq,
s_ctrl->num_vreg_seq,
s_ctrl->reg_ptr, 0);
kfree(s_ctrl->reg_ptr);
}
else {
// NULL!
LDBGE("%s: No Regulator Pointer!\n", __func__);
}
/* LGE_CHANGE_E, Avoid Kernel Panic, 2012.11.12, jungki.kim[End] */
rc = gpio_direction_output(MSM_VT_PWR_EN, 0);
if (rc) {
pr_err("%s: gpio_direction_output enable failed\n", __func__);
}
msm_camera_request_gpio_table(data, 0);
gpio_free(MSM_VT_PWR_EN);
#if defined(CONFIG_MACH_APQ8064_GKKT) || defined(CONFIG_MACH_APQ8064_GKSK) || defined(CONFIG_MACH_APQ8064_GKU) || defined(CONFIG_MACH_APQ8064_GKATT)
if(lge_get_board_revno() >= HW_REV_C ||lge_get_board_revno() == HW_REV_1_0){
LDBGI("%s: Revision [%d] MSM_CAM2_RST_EN GPIO No.%d\n",__func__, lge_get_board_revno(), MSM_CAM2_RST_EN );
gpio_free(MSM_CAM2_RST_EN);
}
#elif defined(CONFIG_MACH_APQ8064_GVDCM)
if(lge_get_board_revno() >= HW_REV_C){
pr_err("%s: Revision check! MSM_CAM2_RST_EN GPIO No.%d\n",__func__,MSM_CAM2_RST_EN );
gpio_free(MSM_CAM2_RST_EN);
}
#endif
return 0;
}
int msm_camera_power_down(struct msm_camera_power_ctrl_t *ctrl,
enum msm_camera_device_type_t device_type,
struct msm_camera_i2c_client *sensor_i2c_client)
{
int index = 0;
struct msm_sensor_power_setting *power_setting = NULL;
CDBG("%s:%d\n", __func__, __LINE__);
if (!ctrl || !sensor_i2c_client) {
pr_err("failed ctrl %p sensor_i2c_client %p\n", ctrl,
sensor_i2c_client);
return -EINVAL;
}
if (device_type == MSM_CAMERA_PLATFORM_DEVICE)
sensor_i2c_client->i2c_func_tbl->i2c_util(
sensor_i2c_client, MSM_CCI_RELEASE);
for (index = (ctrl->power_setting_size - 1); index >= 0; index--) {
CDBG("%s index %d\n", __func__, index);
power_setting = &ctrl->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(ctrl->dev,
&ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
ctrl->clk_info_size,
0);
break;
case SENSOR_GPIO:
if (power_setting->seq_val >= SENSOR_GPIO_MAX ||
!ctrl->gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
continue;
}
gpio_set_value_cansleep(
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->config_val]);
break;
case SENSOR_VREG:
if (power_setting->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
continue;
}
#ifndef FEATURE_KYOCERA_MCAM
msm_camera_config_single_vreg(ctrl->dev,
&ctrl->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
#endif
break;
case SENSOR_I2C_MUX:
if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
msm_camera_disable_i2c_mux(ctrl->i2c_conf);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
msm_camera_request_gpio_table(
ctrl->gpio_conf->cam_gpio_req_tbl,
ctrl->gpio_conf->cam_gpio_req_tbl_size, 0);
CDBG("%s exit\n", __func__);
return 0;
}
static int msm_csid_init(struct csid_device *csid_dev, uint32_t *csid_version)
{
int rc = 0;
struct camera_vreg_t *cam_vreg;
if (!csid_version) {
pr_err("%s:%d csid_version NULL\n", __func__, __LINE__);
rc = -EINVAL;
return rc;
}
if (csid_dev->csid_state == CSID_POWER_UP) {
pr_err("%s: csid invalid state %d\n", __func__,
csid_dev->csid_state);
rc = -EINVAL;
return rc;
}
csid_dev->base = ioremap(csid_dev->mem->start,
resource_size(csid_dev->mem));
if (!csid_dev->base) {
pr_err("%s csid_dev->base NULL\n", __func__);
rc = -ENOMEM;
return rc;
}
if (CSID_VERSION == CSID_VERSION_V20)
cam_vreg = csid_8960_vreg_info;
else
cam_vreg = csid_vreg_info;
if (CSID_VERSION < CSID_VERSION_V30) {
rc = msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto vreg_config_failed;
}
rc = msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto vreg_enable_failed;
}
if (CSID_VERSION == CSID_VERSION_V20) {
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8960_clk_info, csid_dev->csid_clk,
ARRAY_SIZE(csid_8960_clk_info), 1);
if (rc < 0) {
pr_err("%s: 8960: clock enable failed\n",
__func__);
goto clk_enable_failed;
}
} else {
msm_cam_clk_sel_src(&csid_dev->pdev->dev,
&csid_8610_clk_info[3], csid_8610_clk_src_info,
ARRAY_SIZE(csid_8610_clk_src_info));
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8610_clk_info, csid_dev->csid_clk,
ARRAY_SIZE(csid_8610_clk_info), 1);
if (rc < 0) {
pr_err("%s: 8610: clock enable failed\n",
__func__);
goto clk_enable_failed;
}
}
} else if (CSID_VERSION >= CSID_VERSION_V30) {
rc = msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto vreg_config_failed;
}
rc = msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 1);
if (rc < 0) {
pr_err("%s: regulator enable failed\n", __func__);
goto vreg_enable_failed;
}
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8974_clk_info, csid_dev->csid_clk,
ARRAY_SIZE(csid_8974_clk_info), 1);
if (rc < 0) {
pr_err("%s: clock enable failed\n", __func__);
goto clk_enable_failed;
}
}
CDBG("%s:%d called\n", __func__, __LINE__);
csid_dev->hw_version =
msm_camera_io_r(csid_dev->base + CSID_HW_VERSION_ADDR);
CDBG("%s:%d called csid_dev->hw_version %x\n", __func__, __LINE__,
csid_dev->hw_version);
*csid_version = csid_dev->hw_version;
init_completion(&csid_dev->reset_complete);
enable_irq(csid_dev->irq->start);
msm_csid_reset(csid_dev);
csid_dev->csid_state = CSID_POWER_UP;
/* LGE_CHANGE_S [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
wake_lock_timeout(&csid_dev->csid_wake_lock, 2*HZ);
/* LGE_CHANGE_E [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
return rc;
clk_enable_failed:
if (CSID_VERSION < CSID_VERSION_V30) {
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (CSID_VERSION >= CSID_VERSION_V30) {
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
}
vreg_enable_failed:
if (CSID_VERSION < CSID_VERSION_V30) {
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (CSID_VERSION >= CSID_VERSION_V30) {
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
}
vreg_config_failed:
iounmap(csid_dev->base);
csid_dev->base = NULL;
return rc;
}
int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
enum msm_camera_device_type_t device_type,
struct msm_camera_i2c_client *sensor_i2c_client)
{
int rc = 0, index = 0, no_gpio = 0;
struct msm_sensor_power_setting *power_setting = NULL;
CDBG("%s:%d\n", __func__, __LINE__);
if (!ctrl || !sensor_i2c_client) {
pr_err("failed ctrl %p sensor_i2c_client %p\n", ctrl,
sensor_i2c_client);
return -EINVAL;
}
if (ctrl->gpio_conf->cam_gpiomux_conf_tbl != NULL) {
pr_err("%s:%d mux install\n", __func__, __LINE__);
msm_gpiomux_install(
(struct msm_gpiomux_config *)
ctrl->gpio_conf->cam_gpiomux_conf_tbl,
ctrl->gpio_conf->cam_gpiomux_conf_tbl_size);
}
rc = msm_camera_request_gpio_table(
ctrl->gpio_conf->cam_gpio_req_tbl,
ctrl->gpio_conf->cam_gpio_req_tbl_size, 1);
if (rc < 0)
no_gpio = rc;
for (index = 0; index < ctrl->power_setting_size; index++) {
CDBG("%s index %d\n", __func__, index);
power_setting = &ctrl->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
if (power_setting->seq_val >= ctrl->clk_info_size) {
pr_err("%s clk index %d >= max %d\n", __func__,
power_setting->seq_val,
ctrl->clk_info_size);
goto power_up_failed;
}
if (power_setting->config_val)
ctrl->clk_info[power_setting->seq_val].
clk_rate = power_setting->config_val;
rc = msm_cam_clk_enable(ctrl->dev,
&ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
ctrl->clk_info_size,
1);
if (rc < 0) {
pr_err("%s: clk enable failed\n",
__func__);
goto power_up_failed;
}
break;
case SENSOR_GPIO:
if (no_gpio) {
pr_err("%s: request gpio failed\n", __func__);
return no_gpio;
}
if (power_setting->seq_val >= SENSOR_GPIO_MAX ||
!ctrl->gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
if (!ctrl->gpio_conf->gpio_num_info->valid
[power_setting->seq_val])
continue;
CDBG("%s:%d gpio set val %d\n", __func__, __LINE__,
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val]);
gpio_set_value_cansleep(
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
power_setting->config_val);
break;
case SENSOR_VREG:
if (power_setting->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
msm_camera_config_single_vreg(ctrl->dev,
&ctrl->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
1);
break;
case SENSOR_I2C_MUX:
if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
msm_camera_enable_i2c_mux(ctrl->i2c_conf);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
if (device_type == MSM_CAMERA_PLATFORM_DEVICE) {
rc = sensor_i2c_client->i2c_func_tbl->i2c_util(
sensor_i2c_client, MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto power_up_failed;
}
}
CDBG("%s exit\n", __func__);
return 0;
power_up_failed:
pr_err("%s:%d failed\n", __func__, __LINE__);
for (index--; index >= 0; index--) {
CDBG("%s index %d\n", __func__, index);
power_setting = &ctrl->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(ctrl->dev,
&ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
ctrl->clk_info_size,
0);
break;
case SENSOR_GPIO:
if (!ctrl->gpio_conf->gpio_num_info)
continue;
if (!ctrl->gpio_conf->gpio_num_info->valid
[power_setting->seq_val])
continue;
gpio_set_value_cansleep(
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val], GPIOF_OUT_INIT_LOW);
break;
case SENSOR_VREG:
msm_camera_config_single_vreg(ctrl->dev,
&ctrl->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
break;
case SENSOR_I2C_MUX:
if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
msm_camera_disable_i2c_mux(ctrl->i2c_conf);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
msm_camera_request_gpio_table(
ctrl->gpio_conf->cam_gpio_req_tbl,
ctrl->gpio_conf->cam_gpio_req_tbl_size, 0);
return rc;
}
static int msm_csid_release(struct csid_device *csid_dev)
{
uint32_t irq;
/* LGE_CHANGE_S [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
wake_unlock(&csid_dev->csid_wake_lock);
/* LGE_CHANGE_E [[email protected]][20130625] : To enter the deep sleep after finish camera open , for google talk */
if (csid_dev->csid_state != CSID_POWER_UP) {
pr_err("%s: csid invalid state %d\n", __func__,
csid_dev->csid_state);
return -EINVAL;
}
irq = msm_camera_io_r(csid_dev->base + CSID_IRQ_STATUS_ADDR);
msm_camera_io_w(irq, csid_dev->base + CSID_IRQ_CLEAR_CMD_ADDR);
msm_camera_io_w(0, csid_dev->base + CSID_IRQ_MASK_ADDR);
disable_irq(csid_dev->irq->start);
if (csid_dev->hw_version == CSID_VERSION_V20) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_8960_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_8960_clk_info), 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (csid_dev->hw_version == CSID_VERSION_V22) {
msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8610_clk_info,
csid_dev->csid_clk,
ARRAY_SIZE(csid_8610_clk_info), 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (csid_dev->hw_version >= CSID_VERSION_V30) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_8974_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_8974_clk_info), 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
}
iounmap(csid_dev->base);
csid_dev->base = NULL;
csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
}
int msm_camera_power_up(struct msm_camera_power_ctrl_t *ctrl,
enum msm_camera_device_type_t device_type,
struct msm_camera_i2c_client *sensor_i2c_client)
{
int rc = 0, index = 0, no_gpio = 0, ret = 0;
struct msm_sensor_power_setting *power_setting = NULL;
CDBG("%s:%d\n", __func__, __LINE__);
if (!ctrl || !sensor_i2c_client) {
pr_err("failed ctrl %p sensor_i2c_client %p\n", ctrl,
sensor_i2c_client);
return -EINVAL;
}
if (ctrl->gpio_conf->cam_gpiomux_conf_tbl != NULL) {
pr_err("%s:%d mux install\n", __func__, __LINE__);
}
ret = msm_camera_pinctrl_init(ctrl);
if (ret < 0) {
pr_err("%s:%d Initialization of pinctrl failed\n",
__func__, __LINE__);
ctrl->cam_pinctrl_status = 0;
} else {
ctrl->cam_pinctrl_status = 1;
}
rc = msm_camera_request_gpio_table(
ctrl->gpio_conf->cam_gpio_req_tbl,
ctrl->gpio_conf->cam_gpio_req_tbl_size, 1);
if (rc < 0)
no_gpio = rc;
if (ctrl->cam_pinctrl_status) {
ret = pinctrl_select_state(ctrl->pinctrl_info.pinctrl,
ctrl->pinctrl_info.gpio_state_active);
if (ret)
pr_err("%s:%d cannot set pin to active state",
__func__, __LINE__);
}
for (index = 0; index < ctrl->power_setting_size; index++) {
CDBG("%s index %d\n", __func__, index);
power_setting = &ctrl->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
if (power_setting->seq_val >= ctrl->clk_info_size) {
pr_err("%s clk index %d >= max %d\n", __func__,
power_setting->seq_val,
ctrl->clk_info_size);
goto power_up_failed;
}
if (power_setting->config_val)
ctrl->clk_info[power_setting->seq_val].
clk_rate = power_setting->config_val;
rc = msm_cam_clk_enable(ctrl->dev,
&ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
ctrl->clk_info_size,
1);
if (rc < 0) {
pr_err("%s: clk enable failed\n",
__func__);
goto power_up_failed;
}
break;
case SENSOR_GPIO:
if (no_gpio) {
pr_err("%s: request gpio failed\n", __func__);
//
#if defined (CONFIG_MACH_MSM8916_C70W_KR)
rc = no_gpio;
goto power_up_failed;
#else
return no_gpio;
#endif
//
}
if (power_setting->seq_val >= SENSOR_GPIO_MAX ||
!ctrl->gpio_conf->gpio_num_info) {
pr_err("%s gpio index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
if (!ctrl->gpio_conf->gpio_num_info->valid
[power_setting->seq_val])
continue;
CDBG("%s:%d gpio set val %d\n", __func__, __LINE__,
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val]);
gpio_set_value_cansleep(
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val],
(int) power_setting->config_val);
break;
case SENSOR_VREG:
if (power_setting->seq_val >= CAM_VREG_MAX) {
pr_err("%s vreg index %d >= max %d\n", __func__,
power_setting->seq_val,
SENSOR_GPIO_MAX);
goto power_up_failed;
}
if (power_setting->seq_val < ctrl->num_vreg)
msm_camera_config_single_vreg(ctrl->dev,
&ctrl->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
1);
else
pr_err("ERR:%s: %d usr_idx:%d dts_idx:%d\n",
__func__, __LINE__,
power_setting->seq_val, ctrl->num_vreg);
break;
case SENSOR_I2C_MUX:
if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
msm_camera_enable_i2c_mux(ctrl->i2c_conf);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
if (device_type == MSM_CAMERA_PLATFORM_DEVICE) {
rc = sensor_i2c_client->i2c_func_tbl->i2c_util(
sensor_i2c_client, MSM_CCI_INIT);
if (rc < 0) {
pr_err("%s cci_init failed\n", __func__);
goto power_up_failed;
}
}
CDBG("%s exit\n", __func__);
return 0;
power_up_failed:
pr_err("%s:%d failed\n", __func__, __LINE__);
for (index--; index >= 0; index--) {
CDBG("%s index %d\n", __func__, index);
power_setting = &ctrl->power_setting[index];
CDBG("%s type %d\n", __func__, power_setting->seq_type);
switch (power_setting->seq_type) {
case SENSOR_CLK:
msm_cam_clk_enable(ctrl->dev,
&ctrl->clk_info[0],
(struct clk **)&power_setting->data[0],
ctrl->clk_info_size,
0);
break;
case SENSOR_GPIO:
if (!ctrl->gpio_conf->gpio_num_info)
continue;
if (!ctrl->gpio_conf->gpio_num_info->valid
[power_setting->seq_val])
continue;
gpio_set_value_cansleep(
ctrl->gpio_conf->gpio_num_info->gpio_num
[power_setting->seq_val], GPIOF_OUT_INIT_LOW);
break;
case SENSOR_VREG:
if (power_setting->seq_val < ctrl->num_vreg)
msm_camera_config_single_vreg(ctrl->dev,
&ctrl->cam_vreg[power_setting->seq_val],
(struct regulator **)&power_setting->data[0],
0);
else
pr_err("%s:%d:seq_val: %d > num_vreg: %d\n",
__func__, __LINE__,
power_setting->seq_val, ctrl->num_vreg);
break;
case SENSOR_I2C_MUX:
if (ctrl->i2c_conf && ctrl->i2c_conf->use_i2c_mux)
msm_camera_disable_i2c_mux(ctrl->i2c_conf);
break;
default:
pr_err("%s error power seq type %d\n", __func__,
power_setting->seq_type);
break;
}
if (power_setting->delay > 20) {
msleep(power_setting->delay);
} else if (power_setting->delay) {
usleep_range(power_setting->delay * 1000,
(power_setting->delay * 1000) + 1000);
}
}
if (ctrl->cam_pinctrl_status) {
ret = pinctrl_select_state(ctrl->pinctrl_info.pinctrl,
ctrl->pinctrl_info.gpio_state_suspend);
if (ret)
pr_err("%s:%d cannot set pin to suspend state\n",
__func__, __LINE__);
devm_pinctrl_put(ctrl->pinctrl_info.pinctrl);
}
ctrl->cam_pinctrl_status = 0;
msm_camera_request_gpio_table(
ctrl->gpio_conf->cam_gpio_req_tbl,
ctrl->gpio_conf->cam_gpio_req_tbl_size, 0);
return rc;
}
static int32_t s5k4e1_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
printk("%s: E, %d\n", __func__, __LINE__); /* */
s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
* data->sensor_platform_info->num_vreg, GFP_KERNEL);
if (!s_ctrl->reg_ptr) {
pr_err("%s: could not allocate mem for regulators\n",
__func__);
return -ENOMEM;
}
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto request_gpio_failed;
}
rc = msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
pr_err("%s: regulator on failed\n", __func__);
goto config_vreg_failed;
}
rc = msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 1);
if (rc < 0) {
pr_err("%s: enable regulator failed\n", __func__);
goto enable_vreg_failed;
}
printk("%s: msm_camera_enable_vreg, %d\n", __func__, __LINE__);
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto config_gpio_failed;
}
if (s_ctrl->clk_rate != 0)
cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 1);
if (rc < 0) {
pr_err("%s: clk enable failed\n", __func__);
goto enable_clk_failed;
}
/* minimum sleep 20ms for EEPROM read */
msleep(20);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
/* */
#ifdef LGIT_IEF_SWITCH
if(system_state != SYSTEM_BOOTING){
printk("[IEF_OFF] Camera \n");
mipi_lgd_lcd_ief_off();
}
#endif
/* */
printk("%s: X, %d\n", __func__, __LINE__); /* */
return rc;
enable_clk_failed:
msm_camera_config_gpio_table(data, 0);
config_gpio_failed:
msm_camera_enable_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 0);
enable_vreg_failed:
msm_camera_config_vreg(&s_ctrl->sensor_i2c_client->client->dev,
s_ctrl->sensordata->sensor_platform_info->cam_vreg,
s_ctrl->sensordata->sensor_platform_info->num_vreg,
s_ctrl->reg_ptr, 0);
config_vreg_failed:
msm_camera_request_gpio_table(data, 0);
request_gpio_failed:
kfree(s_ctrl->reg_ptr);
return rc;
}
int msm_jpeg_platform_init(struct platform_device *pdev,
struct resource **mem,
void **base,
int *irq,
irqreturn_t (*handler) (int, void *),
void *context)
{
int rc = -1;
int i = 0;
int jpeg_irq;
struct resource *jpeg_mem, *jpeg_io, *jpeg_irq_res;
void *jpeg_base;
struct msm_jpeg_device *pgmn_dev =
(struct msm_jpeg_device *) context;
pgmn_dev->state = MSM_JPEG_IDLE;
jpeg_mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!jpeg_mem) {
JPEG_PR_ERR("%s: no mem resource?\n", __func__);
return -ENODEV;
}
jpeg_irq_res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
if (!jpeg_irq_res) {
JPEG_PR_ERR("no irq resource?\n");
return -ENODEV;
}
jpeg_irq = jpeg_irq_res->start;
JPEG_DBG("%s base address: 0x%x, jpeg irq number: %d\n", __func__,
jpeg_mem->start, jpeg_irq);
pgmn_dev->jpeg_bus_client =
msm_bus_scale_register_client(&msm_jpeg_bus_client_pdata);
if (!pgmn_dev->jpeg_bus_client) {
JPEG_PR_ERR("%s: Registration Failed!\n", __func__);
pgmn_dev->jpeg_bus_client = 0;
return -EINVAL;
}
msm_bus_scale_client_update_request(
pgmn_dev->jpeg_bus_client, 1);
jpeg_io = request_mem_region(jpeg_mem->start,
resource_size(jpeg_mem), pdev->name);
if (!jpeg_io) {
JPEG_PR_ERR("%s: region already claimed\n", __func__);
return -EBUSY;
}
jpeg_base = ioremap(jpeg_mem->start, resource_size(jpeg_mem));
if (!jpeg_base) {
rc = -ENOMEM;
JPEG_PR_ERR("%s: ioremap failed\n", __func__);
goto fail_remap;
}
pgmn_dev->jpeg_fs = regulator_get(&pgmn_dev->pdev->dev, "vdd");
rc = regulator_enable(pgmn_dev->jpeg_fs);
if (rc) {
JPEG_PR_ERR("%s:%d]jpeg regulator get failed\n",
__func__, __LINE__);
goto fail_fs;
}
rc = msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info,
pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 1);
if (rc < 0) {
JPEG_PR_ERR("%s: clk failed rc = %d\n", __func__, rc);
goto fail_clk;
}
pgmn_dev->hw_version = readl_relaxed(jpeg_base +
JPEG_HW_VERSION);
JPEG_DBG_HIGH("%s:%d] jpeg HW version 0x%x", __func__, __LINE__,
pgmn_dev->hw_version);
pgmn_dev->jpeg_vbif = ioremap(VBIF_BASE_ADDRESS, VBIF_REGION_SIZE);
if (!pgmn_dev->jpeg_vbif) {
rc = -ENOMEM;
JPEG_PR_ERR("%s:%d] ioremap failed\n", __func__, __LINE__);
goto fail_vbif;
}
JPEG_DBG("%s:%d] jpeg_vbif 0x%x", __func__, __LINE__,
(uint32_t)pgmn_dev->jpeg_vbif);
#ifdef CONFIG_MSM_IOMMU
for (i = 0; i < pgmn_dev->iommu_cnt; i++) {
rc = iommu_attach_device(pgmn_dev->domain,
pgmn_dev->iommu_ctx_arr[i]);
if (rc < 0) {
rc = -ENODEV;
JPEG_PR_ERR("%s: Device attach failed\n", __func__);
goto fail_iommu;
}
JPEG_DBG("%s:%d] dom 0x%x ctx 0x%x", __func__, __LINE__,
(uint32_t)pgmn_dev->domain,
(uint32_t)pgmn_dev->iommu_ctx_arr[i]);
}
#endif
set_vbif_params(pgmn_dev, pgmn_dev->jpeg_vbif);
rc = request_irq(jpeg_irq, handler, IRQF_TRIGGER_RISING, "jpeg",
context);
if (rc) {
JPEG_PR_ERR("%s: request_irq failed, %d\n", __func__,
jpeg_irq);
goto fail_request_irq;
}
*mem = jpeg_mem;
*base = jpeg_base;
*irq = jpeg_irq;
pgmn_dev->jpeg_client = msm_ion_client_create(-1, "camera/jpeg");
JPEG_DBG("%s:%d] success\n", __func__, __LINE__);
pgmn_dev->state = MSM_JPEG_INIT;
return rc;
fail_request_irq:
#ifdef CONFIG_MSM_IOMMU
for (i = 0; i < pgmn_dev->iommu_cnt; i++) {
JPEG_PR_ERR("%s:%d] dom 0x%x ctx 0x%x", __func__, __LINE__,
(uint32_t)pgmn_dev->domain,
(uint32_t)pgmn_dev->iommu_ctx_arr[i]);
iommu_detach_device(pgmn_dev->domain,
pgmn_dev->iommu_ctx_arr[i]);
}
#endif
fail_iommu:
iounmap(pgmn_dev->jpeg_vbif);
fail_vbif:
msm_cam_clk_enable(&pgmn_dev->pdev->dev, jpeg_8x_clk_info,
pgmn_dev->jpeg_clk, ARRAY_SIZE(jpeg_8x_clk_info), 0);
fail_clk:
rc = regulator_disable(pgmn_dev->jpeg_fs);
if (!rc)
regulator_put(pgmn_dev->jpeg_fs);
else
JPEG_PR_ERR("%s:%d] regulator disable failed %d",
__func__, __LINE__, rc);
pgmn_dev->jpeg_fs = NULL;
fail_fs:
iounmap(jpeg_base);
fail_remap:
release_mem_region(jpeg_mem->start, resource_size(jpeg_mem));
JPEG_DBG("%s:%d] fail\n", __func__, __LINE__);
return rc;
}
static int msm_csid_release(struct csid_device *csid_dev)
{
uint32_t irq;
if (csid_dev->csid_state != CSID_POWER_UP) {
pr_err("%s: csid invalid state %d\n", __func__,
csid_dev->csid_state);
return -EINVAL;
}
CDBG("%s:%d, hw_version = 0x%x\n", __func__, __LINE__,
csid_dev->hw_version);
irq = msm_camera_io_r(csid_dev->base +
csid_dev->ctrl_reg->csid_reg.csid_irq_status_addr);
msm_camera_io_w(irq, csid_dev->base +
csid_dev->ctrl_reg->csid_reg.csid_irq_clear_cmd_addr);
msm_camera_io_w(0, csid_dev->base +
csid_dev->ctrl_reg->csid_reg.csid_irq_mask_addr);
disable_irq(csid_dev->irq->start);
if (csid_dev->hw_version == CSID_VERSION_V20) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_8960_vreg_info, ARRAY_SIZE(csid_8960_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if (csid_dev->hw_version == CSID_VERSION_V22) {
msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_clk_info,
csid_dev->csid_clk,
csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if ((csid_dev->hw_version >= CSID_VERSION_V30 &&
csid_dev->hw_version < CSID_VERSION_V31) ||
(csid_dev->hw_version == CSID_VERSION_V40) ||
(csid_dev->hw_version == CSID_VERSION_V31_1)) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else if ((csid_dev->hw_version == CSID_VERSION_V31) ||
(csid_dev->hw_version == CSID_VERSION_V32) ||
(csid_dev->hw_version == CSID_VERSION_V33) ||
(csid_dev->hw_version == CSID_VERSION_V34)) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, csid_dev->num_clk, 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
} else {
pr_err("%s:%d, invalid hw version : 0x%x", __func__, __LINE__,
csid_dev->hw_version);
return -EINVAL;
}
iounmap(csid_dev->base);
csid_dev->base = NULL;
csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
}
