int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
printk("%s_i2c_probe called\n", client->name); /* LGE_CHANGE, Show log always, 2012-05-24, [email protected] */
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->name);
return rc;
}
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)
goto probe_fail;
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
static int ov5693_probe(struct platform_device *pdev)
{
int rc = 0;
pr_info("%s\n", __func__);
rc = msm_sensor_register(pdev, ov5693_sensor_v4l2_probe);
if(rc >= 0)
ov5693_sysfs_init();
return rc;
}
int32_t msm_sensor_delay_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s %s_delay_i2c_probe called\n", __func__, client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
if (!s_ctrl->wait_num_frames)
s_ctrl->wait_num_frames = 1;
pr_err("%s %s probe succeeded\n", __func__, client->name);
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
s_ctrl->sensor_v4l2_subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->sensor_v4l2_subdev.entity, 0, NULL, 0);
s_ctrl->sensor_v4l2_subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->sensor_v4l2_subdev.entity.group_id = SENSOR_DEV;
s_ctrl->sensor_v4l2_subdev.entity.name =
s_ctrl->sensor_v4l2_subdev.name;
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
s_ctrl->sensor_v4l2_subdev.entity.revision =
s_ctrl->sensor_v4l2_subdev.devnode->num;
if (rc > 0)
rc = 0;
return rc;
}
int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->name);
return rc;
}
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)
goto probe_fail;
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
int32_t imx105_sunny_msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
int ret = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
CDBG("i2c_check_functionality failed\n");
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s: NULL sensor data\n", __func__);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0)
goto probe_fail;
rc = msm_sensor_match_id(s_ctrl);
if (rc < 0)
goto probe_fail;
/*zhanglijun add for otp begin*/
ret= imx105_sunny_otp_data_read();
if(ret < 0)
printk("imx105_sunny ========= otp read data error!\n");
/*zhanglijun add for otp end*/
#if 0
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
#endif
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
if(s_ctrl->sensor_name)
{
strncpy((char *)s_ctrl->sensordata->sensor_name, s_ctrl->sensor_name, CAMERA_NAME_LEN -1);
printk("the name for project menu is %s\n", s_ctrl->sensordata->sensor_name);
}
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
CDBG("%s_i2c_probe failed\n", client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
int32_t as0260_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
SKYCDBG("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
SKYCERR("i2c_check_functionality failed\n");
//rc = -EFAULT;
return rc;
//goto probe_fail;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
rc = -EFAULT;
//return rc;
goto probe_fail;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
SKYCERR("%s %s NULL sensor data\n", __func__, client->name);
rc = -EFAULT;
goto probe_fail;
}
//We need to change gpio number for using pmic gpio
as0260_trans_gpio_pm_to_sys(&sgpios[0], s_ctrl, CAMIO_PM_MAX);
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
SKYCERR("%s %s power up failed\n", __func__, client->name);
//return rc;
rc = -EFAULT;
goto probe_fail;
}
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)
goto probe_fail;
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto i2c_probe_end;
probe_fail:
printk(KERN_ERR "%s:%s failed\n", __func__, client->name);
i2c_probe_end:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
printk(KERN_INFO "%s:%s success\n",__func__, client->name);
return rc;
}
int32_t msm_ov9740_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
pr_err("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s: NULL sensor data\n", __func__);
return -EFAULT;
}
s_ctrl->reg_ptr = kzalloc(sizeof(struct regulator *)
* s_ctrl->sensordata->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: %d\n", __func__, __LINE__);
s_ctrl->func_tbl->sensor_power_up(s_ctrl);
#ifdef CONFIG_SENSOR_INFO
msm_sensorinfo_set_front_sensor_id(s_ctrl->sensor_id_info->sensor_id);
#else
//do nothing here
#endif
rc = msm_sensor_match_id(s_ctrl);
if (rc < 0)
goto probe_fail;
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
pr_err("%s_i2c_probe failed\n", client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (s_ctrl->func_tbl->sensor_setting(s_ctrl, MSM_SENSOR_REG_INIT, 0) < 0)
{
pr_err("%s sensor_setting init failed\n",__func__);
return rc;
}
if (s_ctrl->func_tbl->sensor_setting(s_ctrl, MSM_SENSOR_UPDATE_PERIODIC, 0) < 0)
{
pr_err("%s sensor_setting init failed\n",__func__);
return rc;
}
msleep(10);
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
int32_t mt9m114_msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
pr_err("%s %s_i2c_probe \n", __func__, client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
s_ctrl->sensor_device_type = MSM_SENSOR_I2C_DEVICE;
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->name);
return rc;
}
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)
goto probe_fail;
#ifdef CONFIG_SENSOR_INFO
msm_sensorinfo_set_front_sensor_id(s_ctrl->sensor_id_info->sensor_id);
#else
//do nothing here
#endif
if (!s_ctrl->wait_num_frames)
s_ctrl->wait_num_frames = 1 * Q10;
pr_err("%s %s probe succeeded\n", __func__, client->name);
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
s_ctrl->sensor_v4l2_subdev.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->sensor_v4l2_subdev.entity, 0, NULL, 0);
s_ctrl->sensor_v4l2_subdev.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->sensor_v4l2_subdev.entity.group_id = SENSOR_DEV;
s_ctrl->sensor_v4l2_subdev.entity.name =
s_ctrl->sensor_v4l2_subdev.name;
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
s_ctrl->sensor_v4l2_subdev.entity.revision =
s_ctrl->sensor_v4l2_subdev.devnode->num;
msm_sensor_enable_debugfs(s_ctrl);
goto power_down;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
s_ctrl->sensor_state = MSM_SENSOR_POWER_DOWN;
return rc;
}
static int sr130pc10_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
pr_info("%s_i2c_probe called", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_info("i2c_check_functionality failed\n");
rc = -ENOTSUPP;
goto probe_failure;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_info("s_ctrl->sensor_i2c_client is NULL\n");
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s: NULL sensor data\n", __func__);
return -EFAULT;
}
sr130pc10_client = client;
sr130pc10_dev = s_ctrl->sensor_i2c_client->client->dev;
sr130pc10_ctrl = kzalloc(sizeof(struct sr130pc10_ctrl), GFP_KERNEL);
if (!sr130pc10_ctrl) {
pr_info("sr130pc10_ctrl alloc failed!\n");
return -ENOMEM;
}
sr130pc10_exif = kzalloc(sizeof(struct sr130pc10_exif_data),
GFP_KERNEL);
if (!sr130pc10_exif) {
pr_info("Cannot allocate memory fo EXIF structure!");
kfree(sr130pc10_exif);
rc = -ENOMEM;
}
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
&sr130pc10_subdev_ops);
sr130pc10_ctrl->sensor_dev = &s_ctrl->sensor_v4l2_subdev;
sr130pc10_ctrl->sensordata = client->dev.platform_data;
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
pr_info("sr130pc10_probe succeeded!");
return 0;
probe_failure:
pr_info("sr130pc10_probe failed!");
return rc;
}
static int ov2720_probe(struct platform_device *pdev)
{
return msm_sensor_register(pdev, ov2720_sensor_v4l2_probe);
}
static int s5k8aay_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CAM_DEBUG(" E");
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
cam_err("i2c_check_functionality failed");
rc = -ENOTSUPP;
goto probe_failure;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
cam_err("s_ctrl->sensor_i2c_client is NULL");
rc = -EFAULT;
goto probe_failure;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
cam_err(" NULL sensor data");
rc = -EFAULT;
goto probe_failure;
}
s5k8aay_client = client;
s5k8aay_dev = s_ctrl->sensor_i2c_client->client->dev;
s5k8aay_ctrl = kzalloc(sizeof(struct s5k8aay_ctrl), GFP_KERNEL);
if (!s5k8aay_ctrl) {
cam_err(" s5k8aay_ctrl alloc failed!");
rc = -ENOMEM;
goto probe_failure;
}
memset(s5k8aay_ctrl, 0, sizeof(s5k8aay_ctrl));
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
&s5k8aay_subdev_ops);
s5k8aay_ctrl->sensor_dev = &s_ctrl->sensor_v4l2_subdev;
s5k8aay_ctrl->sensordata = client->dev.platform_data;
rc = msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
if (rc < 0) {
cam_err(" msm_sensor_register failed!");
kfree(s5k8aay_ctrl);
goto probe_failure;
}
CAM_DEBUG(" success!");
CAM_DEBUG(" X");
return 0;
probe_failure:
CAM_DEBUG(" fail!");
CAM_DEBUG(" X");
return rc;
}
int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
char front_cam[10] = "mt9m114";
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s_i2c_probe called\n", client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
CDBG("i2c_check_functionality failed\n");
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s: NULL sensor data\n", __func__);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0)
goto probe_fail;
rc = msm_sensor_match_id(s_ctrl);
/*BEGIN Chaoyen_Wu@pegatron[2012.4.12][front camera 2nd source porting]*/
if(rc < 0 && !(strcmp(client->name, front_cam))){
s_ctrl->sensor_i2c_client->client->addr = s_ctrl->sensor_i2c_addr_high;
CDBG("2nd source i2c addr: 0x%x\n",s_ctrl->sensor_i2c_client->client->addr);
rc = msm_sensor_match_id(s_ctrl);
}
/*END Chaoyen_Wu@pegatron[2012.4.12][front camera 2nd source porting]*/
if (rc < 0)
goto probe_fail;
if (s_ctrl->sensor_eeprom_client != NULL) {
struct msm_camera_eeprom_client *eeprom_client =
s_ctrl->sensor_eeprom_client;
if (eeprom_client->func_tbl.eeprom_init != NULL &&
eeprom_client->func_tbl.eeprom_release != NULL) {
rc = eeprom_client->func_tbl.eeprom_init(
eeprom_client,
s_ctrl->sensor_i2c_client->client->adapter);
if (rc < 0)
goto probe_fail;
rc = msm_camera_eeprom_read_tbl(eeprom_client,
eeprom_client->read_tbl, eeprom_client->read_tbl_size);
eeprom_client->func_tbl.eeprom_release(eeprom_client);
if (rc < 0)
goto probe_fail;
}
}
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
CDBG("%s_i2c_probe failed\n", client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
int32_t msm_sensor_platform_probe(struct platform_device *pdev, void *data)
{
int32_t rc = 0;
struct msm_sensor_ctrl_t *s_ctrl = (struct msm_sensor_ctrl_t *)data;
struct device_driver *driver;
struct device *dev;
s_ctrl->pdev = pdev;
CDBG("%s called data %p\n", __func__, data);
if (pdev->dev.of_node) {
rc = msm_sensor_init_sensor_data(pdev, s_ctrl);
if (rc < 0) {
pr_err("%s failed line %d\n", __func__, __LINE__);
return rc;
}
}
s_ctrl->sensor_i2c_client->cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!s_ctrl->sensor_i2c_client->cci_client) {
pr_err("%s failed line %d\n", __func__, __LINE__);
return rc;
}
driver = driver_find(MSM_CCI_DRV_NAME, &platform_bus_type);
if (!driver) {
pr_err("%s failed line %d\n", __func__, __LINE__);
return rc;
}
dev = driver_find_device(driver, NULL, 0,
msm_sensor_subdev_match_core);
if (!dev) {
pr_err("%s failed line %d\n", __func__, __LINE__);
return rc;
}
s_ctrl->sensor_i2c_client->cci_client->cci_subdev =
dev_get_drvdata(dev);
CDBG("%s sd %p\n", __func__,
s_ctrl->sensor_i2c_client->cci_client->cci_subdev);
s_ctrl->sensor_i2c_client->cci_client->cci_i2c_master = MASTER_0;
s_ctrl->sensor_i2c_client->cci_client->sid =
s_ctrl->sensor_i2c_addr >> 1;
s_ctrl->sensor_i2c_client->cci_client->retries = 0;
s_ctrl->sensor_i2c_client->cci_client->id_map = 0;
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__,
pdev->id_entry->name);
return rc;
}
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)
goto probe_fail;
v4l2_subdev_init(&s_ctrl->sensor_v4l2_subdev,
s_ctrl->sensor_v4l2_subdev_ops);
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s",
s_ctrl->sensordata->sensor_name);
v4l2_set_subdevdata(&s_ctrl->sensor_v4l2_subdev, pdev);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
pr_err("%s %s probe failed\n", __func__, pdev->id_entry->name);
power_down:
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
return rc;
}
int32_t msm_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_sensor_ctrl_t *s_ctrl;
CDBG("%s %s_i2c_probe called\n", __func__, client->name);
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->name);
return rc;
}
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)
goto probe_fail;
#ifdef CONFIG_MACH_ACER_A9
if (s_ctrl->sensor_info) {
if (create_device_info(s_ctrl->sensor_info))
pr_err("%s: create_device_info failed\n", __func__);
} else {
pr_err("%s: %s doesn't contain device info\n",
__func__, s_ctrl->sensor_i2c_driver->driver.name);
}
#endif
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto power_down;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
power_down:
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
pr_err("%s %s success\n", __func__,client->name);
return rc;
}
int32_t mt9d113_sensor_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
#if 0
uint16_t chipid = 999;
#endif
struct msm_sensor_ctrl_t *s_ctrl;
pr_err("%s i2c_probe called\n", __func__); //build
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s %s i2c_check_functionality failed\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
#if 1
mt9d113_client = client;
#else
mt9d113_work = kzalloc(sizeof(s5k6aafx13_work_t), GFP_KERNEL);
if (!mt9d113_work) {
pr_err("%s (-ENOMEM)\n", __func__);
return -ENOMEM;
}
i2c_set_clientdata(client, s5k6aafx13_work);
mt9d113_client = client;
#endif
s_ctrl = (struct msm_sensor_ctrl_t *)(id->driver_data);
if (s_ctrl->sensor_i2c_client != NULL) {
s_ctrl->sensor_i2c_client->client = client;
if (s_ctrl->sensor_i2c_addr != 0)
s_ctrl->sensor_i2c_client->client->addr =
s_ctrl->sensor_i2c_addr;
} else {
pr_err("%s %s sensor_i2c_client NULL\n",
__func__, client->name);
rc = -EFAULT;
return rc;
}
s_ctrl->sensordata = client->dev.platform_data;
if (s_ctrl->sensordata == NULL) {
pr_err("%s %s NULL sensor data\n", __func__, client->name);
return -EFAULT;
}
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl);
if (rc < 0) {
pr_err("%s %s power up failed\n", __func__, client->name);
return rc;
}
#if 0//check
pr_err("msm_sensor id: %d\n", chipid);
// msleep(3000);
// pr_err("msleep(3000);\n");
rc = msm_camera_i2c_read(
s_ctrl->sensor_i2c_client,
s_ctrl->sensor_id_info->sensor_id_reg_addr, &chipid,
MSM_CAMERA_I2C_WORD_DATA);
pr_err("msm_sensor id: %d\n", chipid);
if (rc < 0) {
pr_err("%s: %s: read id failed\n", __func__,
s_ctrl->sensordata->sensor_name);
//return rc;
goto probe_fail;
}
#else
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)
goto probe_fail;
#endif
snprintf(s_ctrl->sensor_v4l2_subdev.name,
sizeof(s_ctrl->sensor_v4l2_subdev.name), "%s", id->name);
v4l2_i2c_subdev_init(&s_ctrl->sensor_v4l2_subdev, client,
s_ctrl->sensor_v4l2_subdev_ops);
msm_sensor_register(&s_ctrl->sensor_v4l2_subdev);
goto i2c_probe_end;
probe_fail:
pr_err("%s %s_i2c_probe failed\n", __func__, client->name);
i2c_probe_end:
#if 1
if (rc > 0)
rc = 0;
s_ctrl->func_tbl->sensor_power_down(s_ctrl);
#endif
CDBG("%s_i2c_probe end\n", client->name);
return rc;
}
