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_io_r(csid_dev->base + CSID_HW_VERSION_ADDR);
*csid_version = csid_dev->hw_version;
#if DBG_CSID
enable_irq(csid_dev->irq->start);
#endif
return 0;
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;
}
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;
}
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;
}
static int32_t s5k4e1_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
printk("%s: E, %d\n", __func__, __LINE__); /* */
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(20);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
printk("%s: X, %d\n", __func__, __LINE__); /* */
return 0;
}
static int msm_csid_release(struct v4l2_subdev *sd)
{
uint32_t irq;
struct csid_device *csid_dev;
csid_dev = v4l2_get_subdevdata(sd);
irq = msm_io_r(csid_dev->base + CSID_IRQ_STATUS_ADDR);
msm_io_w(irq, csid_dev->base + CSID_IRQ_CLEAR_CMD_ADDR);
msm_io_w(0, csid_dev->base + CSID_IRQ_MASK_ADDR);
free_irq(csid_dev->irq->start, csid_dev);
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_clk_info), 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 0);
iounmap(csid_dev->base);
csid_dev->base = NULL;
return 0;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s\n", __func__);
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(20);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
#ifndef CONFIG_PANTECH_CAMERA
msm_camera_config_gpio_table(data, 0);
#endif
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
return 0;
}
static int32_t s5k4e1_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
printk("%s: E, %d\n", __func__, __LINE__); /* */
/* */
#ifdef LGIT_IEF_SWITCH
if(system_state != SYSTEM_BOOTING){
printk("[IEF_ON] Camera \n");
mipi_lgd_lcd_ief_on();
}
#endif
/* */
s_ctrl->func_tbl->sensor_stop_stream(s_ctrl);
msleep(20);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
printk("%s: X, %d\n", __func__, __LINE__); /* */
return 0;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s\n", __func__);
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);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
return 0;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s\n", __func__);
pr_err("%s: E: %s\n", __func__, data->sensor_name); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
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);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
pr_err("%s: X\n", __func__); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
return 0;
}
int32_t imx119_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
struct device *dev = NULL;
CDBG("%s\n", __func__);
pr_err("%s\n", __func__);
pr_err( " %s : E sensor name is %s \n",__func__, s_ctrl->sensordata->sensor_name);
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
dev = &s_ctrl->pdev->dev;
else
dev = &s_ctrl->sensor_i2c_client->client->dev;
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
MSM_CCI_RELEASE);
}
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
imx119_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(dev, imx119_cam_clk_info, s_ctrl->cam_clk,
ARRAY_SIZE(imx119_cam_clk_info), 0);
usleep(5);
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 );
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
pr_err( " %s : X sensor name is %s \n",__func__, s_ctrl->sensordata->sensor_name);
gpio_free(MSM_CAM2_RST_EN);
return 0;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s\n", __func__);
pr_err("%s: E: %s\n", __func__, data->sensor_name); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
/* LGE_CHANGE_S, Turn IEF off in camera mode, 2012-10-23 */
#ifdef LGIT_IEF_SWITCH_L1V
if(system_state != SYSTEM_BOOTING){
printk("[IEF_ON] Camera \n");
mipi_lgd_lcd_ief_on();
}
#endif
/* LGE_CHANGE_E, Turn IEF off in camera mode, 2012-10-23*/
/* LGE_CHANGE_S, Turn IEF off in camera mode except KeepScreenOn, 2012-09-13, [email protected] */
#ifdef LGIT_IEF_SWITCH_VU2
sub_cam_id_for_keep_screen_on = -1;
if(system_state != SYSTEM_BOOTING){
printk("[IEF_ON] Camera \n");
mipi_lgit_lcd_ief_on();
}
#endif
/* LGE_CHANGE_E, Turn IEF off in camera mode except KeepScreenOn, 2012-09-13, [email protected] */
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);
#ifdef CONFIG_S5K4E1
msleep(20);
#endif
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
pr_err("%s: X\n", __func__); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
return 0;
}
static int msm_csid_release(struct csid_device *csid_dev)
{
uint32_t irq;
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_V2) {
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_V3) {
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_8974_vreg_info, ARRAY_SIZE(csid_8974_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
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);
}
iounmap(csid_dev->base);
csid_dev->base = NULL;
return 0;
}
int32_t mt9m114_msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
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;
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE) {
msm_sensor_cci_util(s_ctrl->sensor_i2c_client,
MSM_CCI_RELEASE);
}
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);
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(0);
if (s_ctrl->sensor_device_type == MSM_SENSOR_I2C_DEVICE)
msm_cam_clk_enable(dev, cam_8960_clk_info, s_ctrl->cam_clk,
ARRAY_SIZE(cam_8960_clk_info), 0);
else
msm_cam_clk_enable(dev, cam_8974_clk_info, s_ctrl->cam_clk,
ARRAY_SIZE(cam_8974_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
if(!mt9m114_IsPowered){
pr_err("%s: power down\n", __func__);
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);
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);
kfree(s_ctrl->reg_ptr);
}
msm_camera_request_gpio_table(data, 0);
s_ctrl->curr_res = MSM_SENSOR_INVALID_RES;
return 0;
}
int32_t msm_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
CDBG("%s\n", __func__);
pr_err("%s: E: %s\n", __func__, data->sensor_name); /* */
/* */
#ifdef LGIT_IEF_SWITCH_L1V
if(system_state != SYSTEM_BOOTING){
printk("[IEF_ON] Camera \n");
mipi_lgd_lcd_ief_on();
}
#endif
/* */
/* */
#ifdef LGIT_IEF_SWITCH_VU2
sub_cam_id_for_keep_screen_on = -1;
if(system_state != SYSTEM_BOOTING){
printk("[IEF_ON] Camera \n");
mipi_lgit_lcd_ief_on();
}
#endif
/* */
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);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
pr_err("%s: X\n", __func__); /* */
return 0;
}
static int msm_csid_release(struct v4l2_subdev *sd)
{
struct csid_device *csid_dev;
csid_dev = v4l2_get_subdevdata(sd);
#if DBG_CSID
free_irq((csid_dev->irq->start, 0);
#endif
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_clk_info), 0);
msm_camera_enable_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 0);
msm_camera_config_vreg(&csid_dev->pdev->dev, csid_vreg_info,
ARRAY_SIZE(csid_vreg_info), &csid_dev->csi_vdd, 0);
iounmap(csid_dev->base);
return 0;
}
static int32_t s5k4e1_sensor_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
printk("%s: E, %d\n", __func__, __LINE__); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */
/* LGE_CHANGE_S, Turn IEF off in camera mode, 2012-10-23 */
#ifdef LGIT_IEF_SWITCH
if(system_state != SYSTEM_BOOTING){
printk("[IEF_ON] Camera \n");
mipi_lgd_lcd_ief_on();
}
#endif
/* LGE_CHANGE_E, Turn IEF off in camera mode, 2012-10-23*/
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);
msleep(20);
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,
cam_clk_info, &s_ctrl->cam_clk, ARRAY_SIZE(cam_clk_info), 0);
msm_camera_config_gpio_table(data, 0);
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);
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);
msm_camera_request_gpio_table(data, 0);
kfree(s_ctrl->reg_ptr);
printk("%s: X, %d\n", __func__, __LINE__); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */
return 0;
}
int msm_csid_release(struct csid_device *csid_dev, uint32_t bypass)
{
uint32_t irq;
uint8_t core_id = 0;
if (csid_dev->csid_state != CSID_POWER_UP) {
pr_err("%s: csid invalid state %d\n", __func__,
csid_dev->csid_state);
return -EINVAL;
}
pr_err("%s - %d", __func__, csid_dev->refcnt-1);
/* skip if reserved */
if (csid_dev->refcnt) {
if (!csid_dev->reserved_adp) {
msm_csid_soft_reset(csid_dev);
pr_err("%s - resetting csid", __func__);
}
if (--csid_dev->refcnt)
return 0;
} else {
pr_err("%s refcnt already 0!", __func__);
}
if (csid_dev->reserved_adp) {
pr_err("%s - csid reserved!", __func__);
return 0;
}
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_V2) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_8960_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_8960_clk_info), 0);
if (!bypass) {
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_V3) {
core_id = csid_dev->pdev->id;
if (core_id)
msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8974_clk_info[core_id].clk_info,
csid_dev->csid_clk,
csid_8974_clk_info[core_id].num_clk_info, 0);
msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8974_clk_info[0].clk_info, csid_dev->csid0_clk,
csid_8974_clk_info[0].num_clk_info, 0);
if (!bypass) {
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);
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);
}
}
iounmap(csid_dev->base);
csid_dev->base = NULL;
csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
}
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;
}
#if DBG_CSID
rc = request_irq(csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
msm_cam_clk_enable(&csid_dev->pdev->dev, csid_clk_info,
csid_dev->csid_clk, ARRAY_SIZE(csid_clk_info), 0);
iounmap(csid_dev->base);
return rc;
}
#endif
*csid_version = csid_dev->hw_version;
return 0;
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);
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;
}
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_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: clock 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_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;
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_vreg_info, ARRAY_SIZE(csid_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_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;
}
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__); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */
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);
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);
printk("%s: X, %d\n", __func__, __LINE__); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */
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 msm_sensor_bayer_power_down(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t size = 0, index = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
struct msm_camera_power_seq_t *power_seq = NULL;
CDBG("%s\n", __func__);
if (s_ctrl->power_seq) {
power_seq = s_ctrl->power_seq;
size = s_ctrl->num_power_seq;
} else {
power_seq = &sensor_power_seq[0];
size = ARRAY_SIZE(sensor_power_seq);
}
for (index = (size - 1); index >= 0; index--) {
switch (power_seq[index].power_config) {
case CONFIG_I2C_MUX:
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->
use_i2c_mux)
msm_sensor_bayer_disable_i2c_mux(
data->sensor_platform_info->i2c_conf);
break;
case CONFIG_EXT_POWER_CTRL:
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(0);
break;
case CONFIG_CLK:
msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->
dev, cam_clk_info, s_ctrl->cam_clk,
ARRAY_SIZE(cam_clk_info), 0);
break;
case ENABLE_GPIO:
msm_camera_config_gpio_table(data, 0);
break;
case ENABLE_VREG:
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);
break;
case REQUEST_VREG:
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);
break;
case REQUEST_GPIO:
msm_camera_request_gpio_table(data, 0);
break;
default:
pr_err("%s error power config %d\n", __func__,
power_seq[index].power_config);
break;
}
}
kfree(s_ctrl->reg_ptr);
return 0;
}
int32_t msm_sensor_bayer_config(struct msm_sensor_ctrl_t *s_ctrl,
void __user *argp)
{
struct sensor_cfg_data cdata;
long rc = 0;
if (copy_from_user(&cdata,
(void *)argp,
sizeof(struct sensor_cfg_data)))
return -EFAULT;
mutex_lock(s_ctrl->msm_sensor_mutex);
CDBG("%s:%d %s cfgtype = %d\n", __func__, __LINE__,
s_ctrl->sensordata->sensor_name, cdata.cfgtype);
switch (cdata.cfgtype) {
case CFG_WRITE_I2C_ARRAY: {
struct msm_camera_i2c_reg_setting conf_array;
struct msm_camera_i2c_reg_array *regs = NULL;
if (copy_from_user(&conf_array,
(void *)cdata.cfg.setting,
sizeof(struct msm_camera_i2c_reg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
regs = kzalloc(conf_array.size * sizeof(
struct msm_camera_i2c_reg_array),
GFP_KERNEL);
if (!regs) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
if (copy_from_user(regs, (void *)conf_array.reg_setting,
conf_array.size * sizeof(
struct msm_camera_i2c_reg_array))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(regs);
rc = -EFAULT;
break;
}
conf_array.reg_setting = regs;
rc = msm_camera_i2c_write_bayer_table(s_ctrl->sensor_i2c_client,
&conf_array);
kfree(regs);
break;
}
case CFG_READ_I2C_ARRAY: {
struct msm_camera_i2c_reg_setting conf_array;
struct msm_camera_i2c_reg_array *regs;
int index;
if (copy_from_user(&conf_array,
(void *)cdata.cfg.setting,
sizeof(struct msm_camera_i2c_reg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
regs = kzalloc(conf_array.size * sizeof(
struct msm_camera_i2c_reg_array),
GFP_KERNEL);
if (!regs) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
kfree(regs);
break;
}
if (copy_from_user(regs, (void *)conf_array.reg_setting,
conf_array.size * sizeof(
struct msm_camera_i2c_reg_array))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(regs);
rc = -EFAULT;
break;
}
s_ctrl->sensor_i2c_client->addr_type = conf_array.addr_type;
for (index = 0; index < conf_array.size; index++) {
msm_camera_i2c_read(s_ctrl->sensor_i2c_client,
regs[index].reg_addr,
®s[index].reg_data,
conf_array.data_type
);
}
if (copy_to_user(conf_array.reg_setting,
regs,
conf_array.size * sizeof(
struct msm_camera_i2c_reg_array))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(regs);
rc = -EFAULT;
break;
}
s_ctrl->sensor_i2c_client->addr_type = conf_array.addr_type;
kfree(regs);
break;
}
case CFG_PCLK_CHANGE: {
uint32_t pclk = cdata.cfg.pclk;
v4l2_subdev_notify(&s_ctrl->sensor_v4l2_subdev,
NOTIFY_PCLK_CHANGE, &pclk);
break;
}
case CFG_GPIO_OP: {
struct msm_cam_gpio_operation gop;
if (copy_from_user(&gop,
(void *)cdata.cfg.setting,
sizeof(struct msm_cam_gpio_operation))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
}
switch (gop.op_type) {
case GPIO_GET_VALUE:
gop.value = gpio_get_value(gop.address);
if (copy_from_user((void *)cdata.cfg.setting,
&gop,
sizeof(struct msm_cam_gpio_operation))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
break;
case GPIO_SET_VALUE:
gpio_set_value(gop.address, gop.value);
break;
case GPIO_SET_DIRECTION_INPUT:
gpio_direction_input(gop.address);
break;
case GPIO_SET_DIRECTION_OUTPUT:
gpio_direction_output(gop.address, gop.value);
break;
case GPIO_REQUEST:
gpio_request(gop.address, gop.tag);
break;
case GPIO_FREE:
gpio_free(gop.address);
break;
default:
break;
}
break;
}
case CFG_GET_CSI_PARAMS:
if (s_ctrl->func_tbl->sensor_get_csi_params == NULL) {
rc = -EFAULT;
break;
}
rc = s_ctrl->func_tbl->sensor_get_csi_params(
s_ctrl,
&cdata.cfg.csi_lane_params);
if (copy_to_user((void *)argp,
&cdata,
sizeof(struct sensor_cfg_data)))
rc = -EFAULT;
break;
case CFG_POWER_UP:
if (s_ctrl->func_tbl->sensor_power_up)
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
else
rc = -EFAULT;
break;
case CFG_POWER_DOWN:
if (s_ctrl->func_tbl->sensor_power_down)
rc = s_ctrl->func_tbl->sensor_power_down(
s_ctrl);
else
rc = -EFAULT;
break;
case CFG_CONFIG_VREG_ARRAY: {
struct msm_camera_vreg_setting vreg_setting;
struct camera_vreg_t *cam_vreg = NULL;
if (copy_from_user(&vreg_setting,
(void *)cdata.cfg.setting,
sizeof(struct msm_camera_vreg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
cam_vreg = kzalloc(vreg_setting.num_vreg * sizeof(
struct camera_vreg_t),
GFP_KERNEL);
if (!cam_vreg) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
if (copy_from_user(cam_vreg, (void *)vreg_setting.cam_vreg,
vreg_setting.num_vreg * sizeof(
struct camera_vreg_t))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(cam_vreg);
rc = -EFAULT;
break;
}
rc = msm_camera_config_vreg(
&s_ctrl->sensor_i2c_client->client->dev,
cam_vreg,
vreg_setting.num_vreg,
NULL,
0,
s_ctrl->reg_ptr,
vreg_setting.enable);
if (rc < 0) {
kfree(cam_vreg);
pr_err("%s: regulator on failed\n", __func__);
break;
}
rc = msm_camera_enable_vreg(
&s_ctrl->sensor_i2c_client->client->dev,
cam_vreg,
vreg_setting.num_vreg,
NULL,
0,
s_ctrl->reg_ptr,
vreg_setting.enable);
if (rc < 0) {
kfree(cam_vreg);
pr_err("%s: enable regulator failed\n", __func__);
break;
}
kfree(cam_vreg);
break;
}
case CFG_CONFIG_CLK_ARRAY: {
struct msm_cam_clk_setting clk_setting;
struct msm_cam_clk_info *clk_info = NULL;
if (copy_from_user(&clk_setting,
(void *)cdata.cfg.setting,
sizeof(struct msm_camera_vreg_setting))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
clk_info = kzalloc(clk_setting.num_clk_info * sizeof(
struct msm_cam_clk_info),
GFP_KERNEL);
if (!clk_info) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
break;
}
if (copy_from_user(clk_info, (void *)clk_setting.clk_info,
clk_setting.num_clk_info * sizeof(
struct msm_cam_clk_info))) {
pr_err("%s:%d failed\n", __func__, __LINE__);
kfree(clk_info);
rc = -EFAULT;
break;
}
rc = msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->dev,
clk_info, s_ctrl->cam_clk,
clk_setting.num_clk_info,
clk_setting.enable);
kfree(clk_info);
break;
}
case CFG_GET_EEPROM_DATA: {
if (copy_to_user((void *)cdata.cfg.eeprom_data.eeprom_data,
&s_ctrl->eeprom_data, s_ctrl->eeprom_data.length)) {
pr_err("%s:%d failed\n", __func__, __LINE__);
rc = -EFAULT;
}
cdata.cfg.eeprom_data.index = s_ctrl->eeprom_data.length;
break;
}
default:
rc = -EFAULT;
break;
}
mutex_unlock(s_ctrl->msm_sensor_mutex);
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;
}
int32_t msm_sensor_bayer_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0, size = 0, index = 0;
struct msm_camera_sensor_info *data = s_ctrl->sensordata;
struct msm_camera_power_seq_t *power_seq = NULL;
CDBG("%s: %d\n", __func__, __LINE__);
if (s_ctrl->power_seq) {
power_seq = s_ctrl->power_seq;
size = s_ctrl->num_power_seq;
} else {
power_seq = &sensor_power_seq[0];
size = ARRAY_SIZE(sensor_power_seq);
}
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;
}
for (index = 0; index < size; index++) {
switch (power_seq[index].power_config) {
case REQUEST_GPIO:
rc = msm_camera_request_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: request gpio failed\n", __func__);
goto ERROR;
}
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
case REQUEST_VREG:
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) {
pr_err("%s: regulator on failed\n", __func__);
goto ERROR;
}
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
case ENABLE_VREG:
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) {
pr_err("%s: enable regulator failed\n",
__func__);
goto ERROR;
}
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
case ENABLE_GPIO:
rc = msm_camera_config_gpio_table(data, 1);
if (rc < 0) {
pr_err("%s: config gpio failed\n", __func__);
goto ERROR;
}
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
case CONFIG_CLK:
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 ERROR;
}
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
case CONFIG_EXT_POWER_CTRL:
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
case CONFIG_I2C_MUX:
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->
use_i2c_mux)
msm_sensor_bayer_enable_i2c_mux(
data->sensor_platform_info->i2c_conf);
if (power_seq[index].delay)
usleep_range(power_seq[index].delay * 1000,
(power_seq[index].delay * 1000) + 1000);
break;
default:
pr_err("%s error power config %d\n", __func__,
power_seq[index].power_config);
rc = -EINVAL;
break;
}
}
return rc;
ERROR:
for (index--; index >= 0; index--) {
switch (power_seq[index].power_config) {
case CONFIG_I2C_MUX:
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->
use_i2c_mux)
msm_sensor_bayer_disable_i2c_mux(
data->sensor_platform_info->i2c_conf);
break;
case CONFIG_EXT_POWER_CTRL:
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(0);
break;
case CONFIG_CLK:
msm_cam_clk_enable(&s_ctrl->sensor_i2c_client->client->
dev, cam_clk_info, s_ctrl->cam_clk,
ARRAY_SIZE(cam_clk_info), 0);
break;
case ENABLE_GPIO:
msm_camera_config_gpio_table(data, 0);
break;
case ENABLE_VREG:
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);
break;
case REQUEST_VREG:
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);
break;
case REQUEST_GPIO:
msm_camera_request_gpio_table(data, 0);
break;
default:
pr_err("%s error power config %d\n", __func__,
power_seq[index].power_config);
break;
}
}
kfree(s_ctrl->reg_ptr);
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;
}
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;
}
if (data->sensor_platform_info->ext_power_ctrl != NULL)
data->sensor_platform_info->ext_power_ctrl(1);
usleep_range(1000, 2000);
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;
}
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 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__);
pr_err("%s: E: %s\n", __func__, data->sensor_name); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
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;
}
#ifdef CONFIG_S5K4E1
/* minimum sleep 20ms for EEPROM read */
msleep(20);
#else
usleep_range(1000, 2000);
#endif
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);
pr_err("%s: X\n", __func__); /* LGE_CHANGE, For debugging, 2012-07-03, [email protected] */
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 imx119_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;
CDBG("%s: %d\n", __func__, __LINE__);
if (s_ctrl->sensor_device_type == MSM_SENSOR_PLATFORM_DEVICE)
dev = &s_ctrl->pdev->dev;
else
dev = &s_ctrl->sensor_i2c_client->client->dev;
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 = 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) {
LDBGE("%s: regulator on failed\n", __func__);
goto config_vreg_failed;
}
/* */
rc = gpio_request(MSM_CAM2_RST_EN, "VTCAM_RST_EN");
if (rc) {
LDBGE("%s: PM request gpio failed\n", __func__);
}
/* */
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) {
LDBGE("%s: enable regulator failed\n", __func__);
goto enable_vreg_failed;
}
/* */
usleep(100);
rc =pm8xxx_gpio_config(MSM_CAM2_RST_EN, &gpio28_param);
if (rc) {
LDBGE("%s: pm8xxx_gpio_config on failed\n", __func__);
}
/* */
rc = gpio_direction_output(MSM_CAM2_RST_EN, 1);
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->sensor_device_type == MSM_SENSOR_I2C_DEVICE) {
if (s_ctrl->clk_rate != 0)
imx119_cam_clk_info->clk_rate = s_ctrl->clk_rate;
rc = msm_cam_clk_enable(dev, imx119_cam_clk_info,
s_ctrl->cam_clk, ARRAY_SIZE(imx119_cam_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)
imx119_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;
pr_err( " %s : X sensor name is %s \n",__func__, s_ctrl->sensordata->sensor_name);
return rc;
cci_init_failed:
if (data->sensor_platform_info->i2c_conf &&
data->sensor_platform_info->i2c_conf->use_i2c_mux)
imx119_msm_sensor_disable_i2c_mux(
data->sensor_platform_info->i2c_conf);
enable_clk_failed:
rc = gpio_direction_output(MSM_CAM2_RST_EN, 0);
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);
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->reg_ptr = NULL;
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;
}
pr_info("%s: CSID_VERSION = 0x%x\n", __func__,
csid_dev->ctrl_reg->csid_reg.csid_version);
/* power up */
if (csid_dev->ctrl_reg->csid_reg.csid_version < CSID_VERSION_V22) {
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);
} else {
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;
}
if (csid_dev->ctrl_reg->csid_reg.csid_version < CSID_VERSION_V22) {
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);
} else {
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;
}
csid_dev->reg_ptr = regulator_get(&(csid_dev->pdev->dev),
"qcom,gdscr-vdd");
if (IS_ERR_OR_NULL(csid_dev->reg_ptr)) {
pr_debug(" %s: Failed in getting TOP gdscr regulator handle",
__func__);
} else {
rc = regulator_enable(csid_dev->reg_ptr);
if (rc) {
pr_err(" %s: regulator enable failed for GDSCR\n",
__func__);
goto gdscr_regulator_enable_failed;
}
}
if (csid_dev->ctrl_reg->csid_reg.csid_version == CSID_VERSION_V22)
msm_cam_clk_sel_src(&csid_dev->pdev->dev,
&csid_clk_info[3], csid_clk_src_info,
csid_dev->num_clk_src_info);
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_clk_info, csid_dev->csid_clk,
csid_dev->num_clk, 1);
if (rc < 0) {
pr_err("%s:%d clock enable failed\n",
__func__, __LINE__);
goto clk_enable_failed;
}
CDBG("%s:%d called\n", __func__, __LINE__);
csid_dev->hw_version =
msm_camera_io_r(csid_dev->base +
csid_dev->ctrl_reg->csid_reg.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;
return rc;
clk_enable_failed:
if (csid_dev->ctrl_reg->csid_reg.csid_version < CSID_VERSION_V22) {
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 {
msm_camera_enable_vreg(&csid_dev->pdev->dev,
csid_vreg_info, ARRAY_SIZE(csid_vreg_info),
NULL, 0, &csid_dev->csi_vdd, 0);
}
gdscr_regulator_enable_failed:
if (!IS_ERR_OR_NULL(csid_dev->reg_ptr)) {
regulator_disable(csid_dev->reg_ptr);
regulator_put(csid_dev->reg_ptr);
csid_dev->reg_ptr = NULL;
}
vreg_enable_failed:
if (csid_dev->ctrl_reg->csid_reg.csid_version < CSID_VERSION_V22) {
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 {
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;
}
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) ||
(csid_dev->hw_version == CSID_VERSION_V31_3)) {
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_V37) ||
(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;
}
if (!IS_ERR_OR_NULL(csid_dev->reg_ptr)) {
regulator_disable(csid_dev->reg_ptr);
regulator_put(csid_dev->reg_ptr);
}
iounmap(csid_dev->base);
csid_dev->base = NULL;
csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
}
int msm_csid_init(struct csid_device *csid_dev,
uint32_t *csid_version, uint32_t bypass)
{
int rc = 0;
uint8_t core_id = 0;
if (!csid_version) {
pr_err("%s:%d csid_version NULL\n", __func__, __LINE__);
rc = -EINVAL;
return rc;
}
pr_debug("%s - %d", __func__, csid_dev->refcnt+1);
/* skip if reserved */
if (csid_dev->refcnt++) {
return 0;
}
if (!bypass) {
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_V2) {
if (!bypass) {
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: clock enable failed\n", __func__);
goto clk_enable_failed;
}
} else if (CSID_VERSION == CSID_VERSION_V3) {
if (!bypass) {
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[0].clk_info, csid_dev->csid0_clk,
csid_8974_clk_info[0].num_clk_info, 1);
if (rc < 0) {
pr_err("%s: clock enable failed\n", __func__);
goto csid0_clk_enable_failed;
}
core_id = csid_dev->pdev->id;
if (core_id) {
rc = msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8974_clk_info[core_id].clk_info,
csid_dev->csid_clk,
csid_8974_clk_info[core_id].num_clk_info, 1);
if (rc < 0) {
pr_err("%s: clock 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);
csid_dev->csid_state = CSID_POWER_UP;
return rc;
clk_enable_failed:
if (CSID_VERSION == CSID_VERSION_V3) {
msm_cam_clk_enable(&csid_dev->pdev->dev,
csid_8974_clk_info[0].clk_info, csid_dev->csid0_clk,
csid_8974_clk_info[0].num_clk_info, 0);
}
csid0_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;
}
