int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_power_ctrl_t *power_info;
struct msm_camera_i2c_client *sensor_i2c_client;
struct msm_camera_slave_info *slave_info;
const char *sensor_name;
// CHECK_MERGE uint32_t retry = 0;
if (!s_ctrl) {
pr_err("%s:%d failed: %p\n",
__func__, __LINE__, s_ctrl);
return -EINVAL;
}
power_info = &s_ctrl->sensordata->power_info;
sensor_i2c_client = s_ctrl->sensor_i2c_client;
slave_info = s_ctrl->sensordata->slave_info;
sensor_name = s_ctrl->sensordata->sensor_name;
if (!power_info || !sensor_i2c_client || !slave_info ||
!sensor_name) {
pr_err("%s:%d failed: %p %p %p %p\n",
__func__, __LINE__, power_info,
sensor_i2c_client, slave_info, sensor_name);
return -EINVAL;
}
if (s_ctrl->sensor_state == MSM_SENSOR_POWER_UP) {
pr_err("%s:%d invalid sensor state %d\n", __func__, __LINE__,
s_ctrl->sensor_state);
return -EINVAL;
}
qdaemon_pid = current->pid;
qdaemon_tgid = current->tgid;
pr_info("[%s:%d] process: %s, pid: %d, tgid: %d\n", __func__, __LINE__, current->comm, qdaemon_pid, qdaemon_tgid);
pr_warn("[%s:%d] %s\n", __func__, __LINE__,
sensor_name);
CDBG("%s : camera_id %d\n", __func__, s_ctrl->cci_i2c_master);
rc = msm_camera_power_up(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client, s_ctrl->cci_i2c_master);
if (rc < 0) {
pr_err("%s : power up failed\n", __func__);
return rc;
}
s_ctrl->sensor_state = MSM_SENSOR_POWER_UP;
return rc;
}
int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_power_ctrl_t *power_info;
struct msm_camera_i2c_client *sensor_i2c_client;
struct msm_camera_slave_info *slave_info;
const char *sensor_name;
uint32_t retry = 0;
if (!s_ctrl) {
pr_err("%s:%d failed: %p\n",
__func__, __LINE__, s_ctrl);
return -EINVAL;
}
power_info = &s_ctrl->sensordata->power_info;
sensor_i2c_client = s_ctrl->sensor_i2c_client;
slave_info = s_ctrl->sensordata->slave_info;
sensor_name = s_ctrl->sensordata->sensor_name;
if (!power_info || !sensor_i2c_client || !slave_info ||
!sensor_name) {
pr_err("%s:%d failed: %p %p %p %p\n",
__func__, __LINE__, power_info,
sensor_i2c_client, slave_info, sensor_name);
return -EINVAL;
}
if (s_ctrl->set_mclk_23880000)
msm_sensor_adjust_mclk(power_info);
for (retry = 0; retry < 3; retry++) {
rc = msm_camera_power_up(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
if (rc < 0)
return rc;
rc = msm_sensor_check_id(s_ctrl);
if (rc < 0) {
msm_camera_power_down(power_info,
s_ctrl->sensor_device_type, sensor_i2c_client);
msleep(20);
continue;
} else {
break;
}
}
return rc;
}
/**
* msm_eeprom_power_up() - power up eeprom if it's not on
* @e_ctrl: control struct
* @down: output to indicate whether power down is needed later
*
* This function powers up EEPROM only if it's not already on. If power
* up is performed here, @down will be set to true. Caller should power
* down EEPROM after transaction if @down is true.
*/
static int msm_eeprom_power_up(struct msm_eeprom_ctrl_t *e_ctrl, bool *down)
{
int rc = 0;
rc = msm_eeprom_match_id(e_ctrl);
pr_warn("%s : E", __func__);
if (rc < 0) {
if (down) *down = true;
rc = msm_camera_power_up(&e_ctrl->eboard_info->power_info,
e_ctrl->eeprom_device_type, &e_ctrl->i2c_client);
} else {
if (down) *down = false;
}
return rc;
}
int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_power_ctrl_t *power_info;
struct msm_camera_i2c_client *sensor_i2c_client;
struct msm_camera_slave_info *slave_info;
const char *sensor_name;
#if defined(CONFIG_MACH_LGE)
/* Add sensor On/Off log */
pr_info("%s E, sensor name = %s\n", __func__, s_ctrl->sensordata->sensor_name);
#endif
if (!s_ctrl) {
pr_err("%s:%d failed: %p\n",
__func__, __LINE__, s_ctrl);
return -EINVAL;
}
power_info = &s_ctrl->sensordata->power_info;
sensor_i2c_client = s_ctrl->sensor_i2c_client;
slave_info = s_ctrl->sensordata->slave_info;
sensor_name = s_ctrl->sensordata->sensor_name;
if (!power_info || !sensor_i2c_client || !slave_info ||
!sensor_name) {
pr_err("%s:%d failed: %p %p %p %p\n",
__func__, __LINE__, power_info,
sensor_i2c_client, slave_info, sensor_name);
return -EINVAL;
}
rc = msm_camera_power_up(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
if (rc < 0)
return rc;
rc = msm_sensor_check_id(s_ctrl);
if (rc < 0)
msm_camera_power_down(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
#if defined(CONFIG_MACH_LGE)
/* Add sensor On/Off log */
pr_info("%s X, sensor name = %s\n", __func__, s_ctrl->sensordata->sensor_name);
#endif
return rc;
}
int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl,
struct msm_camera_power_ctrl_t *power_info,
struct msm_camera_i2c_client *sensor_i2c_client,
struct msm_camera_slave_info *slave_info,
const char *sensor_name)
{
int rc;
pr_err("%s\n", __func__);
if (!s_ctrl || !power_info || !sensor_i2c_client || !slave_info ||
!sensor_name) {
pr_err("%s:%d failed: %p %p %p %p %p\n",
__func__, __LINE__, s_ctrl, power_info,
sensor_i2c_client, slave_info, sensor_name);
return -EINVAL;
}
if (s_ctrl->sensor_state == MSM_SENSOR_POWER_UP) {
pr_err("%s:%d invalid sensor state %d\n", __func__, __LINE__,
s_ctrl->sensor_state);
return -EINVAL;
}
pr_warn("[%s:%d] %s", __func__, __LINE__,
sensor_name);
rc = msm_camera_power_up(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
if (rc < 0) {
pr_err("%s : power up failed", __func__);
return rc;
}
s_ctrl->sensor_state = MSM_SENSOR_POWER_UP;
pr_err("%s: %d\n", __func__, s_ctrl->sensor_state);
#if 1
rc = msm_sensor_check_id(s_ctrl, sensor_i2c_client, slave_info,
sensor_name);
// if (rc < 0)
// msm_sensor_power_down(power_info, s_ctrl->sensor_device_type,
// sensor_i2c_client);
#endif
return rc;
}
int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_power_ctrl_t *power_info;
struct msm_camera_i2c_client *sensor_i2c_client;
struct msm_camera_slave_info *slave_info;
const char *sensor_name;
if (!s_ctrl) {
pr_err("%s:%d failed: %p\n",
__func__, __LINE__, s_ctrl);
return -EINVAL;
}
power_info = &s_ctrl->sensordata->power_info;
sensor_i2c_client = s_ctrl->sensor_i2c_client;
slave_info = s_ctrl->sensordata->slave_info;
sensor_name = s_ctrl->sensordata->sensor_name;
if (!power_info || !sensor_i2c_client || !slave_info ||
!sensor_name) {
pr_err("%s:%d failed: %p %p %p %p\n",
__func__, __LINE__, power_info,
sensor_i2c_client, slave_info, sensor_name);
return -EINVAL;
}
rc = msm_camera_power_up(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
if (rc < 0)
return rc;
rc = msm_sensor_check_id(s_ctrl);
if (rc < 0)
msm_camera_power_down(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
return rc;
}
static int msm_eeprom_spi_setup(struct spi_device *spi)
{
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_i2c_client *client = NULL;
struct msm_camera_spi_client *spi_client;
struct msm_eeprom_board_info *eb_info;
struct msm_camera_power_ctrl_t *power_info = NULL;
int rc = 0;
e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
client = &e_ctrl->i2c_client;
e_ctrl->is_supported = 0;
spi_client = kzalloc(sizeof(spi_client), GFP_KERNEL);
if (!spi_client) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
kfree(e_ctrl);
return -ENOMEM;
}
rc = of_property_read_u32(spi->dev.of_node, "cell-index",
&e_ctrl->subdev_id);
CDBG("cell-index %d, rc %d\n", e_ctrl->subdev_id, rc);
if (rc) {
pr_err("failed rc %d\n", rc);
return rc;
}
e_ctrl->eeprom_device_type = MSM_CAMERA_SPI_DEVICE;
client->spi_client = spi_client;
spi_client->spi_master = spi;
client->i2c_func_tbl = &msm_eeprom_spi_func_tbl;
client->addr_type = MSM_CAMERA_I2C_3B_ADDR;
eb_info = kzalloc(sizeof(eb_info), GFP_KERNEL);
if (!eb_info)
goto spi_free;
e_ctrl->eboard_info = eb_info;
rc = of_property_read_string(spi->dev.of_node, "qcom,eeprom-name",
&eb_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
eb_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
power_info = &eb_info->power_info;
power_info->clk_info = cam_8974_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8974_clk_info);
power_info->dev = &spi->dev;
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc)
goto board_free;
/* set spi instruction info */
spi_client->retry_delay = 1;
spi_client->retries = 0;
if (msm_eeprom_spi_parse_of(spi_client)) {
dev_err(&spi->dev,
"%s: Error parsing device properties\n", __func__);
goto board_free;
}
rc = msm_eeprom_alloc_memory_map(e_ctrl, spi->dev.of_node);
if (rc)
goto board_free;
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto memmap_free;
}
/* check eeprom id */
rc = msm_eeprom_check_id(e_ctrl);
if (rc) {
CDBG("%s: eeprom not matching %d\n", __func__, rc);
goto power_down;
}
/* read eeprom */
rc = read_eeprom_memory(e_ctrl);
if (rc) {
dev_err(&spi->dev, "%s: read eeprom memory failed\n", __func__);
goto power_down;
}
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto memmap_free;
}
/* initiazlie subdev */
v4l2_spi_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->i2c_client.spi_client->spi_master,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = 1;
CDBG("%s success result=%d X\n", __func__, rc);
return 0;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
memmap_free:
kfree(e_ctrl->eboard_info->eeprom_map);
kfree(e_ctrl->memory_data);
board_free:
kfree(e_ctrl->eboard_info);
spi_free:
kfree(spi_client);
return rc;
}
static int32_t msm_flash_i2c_init(
struct msm_flash_ctrl_t *flash_ctrl,
struct msm_flash_cfg_data_t *flash_data)
{
int32_t rc = 0;
struct msm_flash_init_info_t *flash_init_info =
flash_data->cfg.flash_init_info;
struct msm_camera_i2c_reg_setting_array *settings = NULL;
#ifdef CONFIG_COMPAT
struct msm_sensor_power_setting_array32 *power_setting_array32 = NULL;
#endif
if (!flash_init_info || !flash_init_info->power_setting_array) {
pr_err("%s:%d failed: Null pointer\n", __func__, __LINE__);
return -EFAULT;
}
#ifdef CONFIG_COMPAT
if (is_compat_task()) {
power_setting_array32 = kzalloc(
sizeof(struct msm_sensor_power_setting_array32),
GFP_KERNEL);
if (!power_setting_array32) {
pr_err("%s mem allocation failed %d\n",
__func__, __LINE__);
return -ENOMEM;
}
if (copy_from_user(power_setting_array32,
(void *)flash_init_info->power_setting_array,
sizeof(struct msm_sensor_power_setting_array32))) {
pr_err("%s copy_from_user failed %d\n",
__func__, __LINE__);
return -EFAULT;
}
flash_ctrl->power_setting_array.size =
power_setting_array32->size;
flash_ctrl->power_setting_array.size_down =
power_setting_array32->size_down;
flash_ctrl->power_setting_array.power_down_setting =
compat_ptr(power_setting_array32->power_down_setting);
flash_ctrl->power_setting_array.power_setting =
compat_ptr(power_setting_array32->power_setting);
memcpy(&flash_ctrl->power_setting_array.power_down_setting_a,
&power_setting_array32->power_down_setting_a,
sizeof(power_setting_array32->power_down_setting_a));
memcpy(&flash_ctrl->power_setting_array.power_setting_a,
&power_setting_array32->power_setting_a,
sizeof(power_setting_array32->power_setting_a));
}
#endif
if (copy_from_user(&flash_ctrl->power_setting_array,
(void *)flash_init_info->power_setting_array,
sizeof(struct msm_sensor_power_setting_array))) {
pr_err("%s copy_from_user failed %d\n", __func__, __LINE__);
return -EFAULT;
}
flash_ctrl->power_info.power_setting =
flash_ctrl->power_setting_array.power_setting_a;
flash_ctrl->power_info.power_down_setting =
flash_ctrl->power_setting_array.power_down_setting_a;
flash_ctrl->power_info.power_setting_size =
flash_ctrl->power_setting_array.size;
flash_ctrl->power_info.power_down_setting_size =
flash_ctrl->power_setting_array.size_down;
rc = msm_camera_power_up(&flash_ctrl->power_info,
flash_ctrl->flash_device_type,
&flash_ctrl->flash_i2c_client);
if (rc < 0) {
pr_err("%s msm_camera_power_up failed %d\n",
__func__, __LINE__);
goto msm_flash_i2c_init_fail;
}
if (flash_data->cfg.flash_init_info->settings) {
settings = kzalloc(sizeof(
struct msm_camera_i2c_reg_setting_array), GFP_KERNEL);
if (!settings) {
pr_err("%s mem allocation failed %d\n",
__func__, __LINE__);
return -ENOMEM;
}
if (copy_from_user(settings, (void *)flash_init_info->settings,
sizeof(struct msm_camera_i2c_reg_setting_array))) {
kfree(settings);
pr_err("%s copy_from_user failed %d\n",
__func__, __LINE__);
return -EFAULT;
}
rc = msm_flash_i2c_write_table(flash_ctrl, settings);
kfree(settings);
if (rc < 0) {
pr_err("%s:%d msm_flash_i2c_write_table rc %d failed\n",
__func__, __LINE__, rc);
}
}
return 0;
msm_flash_i2c_init_fail:
return rc;
}
int msm_sensor_power_up(struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;
struct msm_camera_power_ctrl_t *power_info;
struct msm_camera_i2c_client *sensor_i2c_client;
struct msm_camera_slave_info *slave_info;
const char *sensor_name;
uint32_t retry = 0; /*LGE_CHANGE, power up retry, 2014-12-29, [email protected]*/
if (!s_ctrl) {
pr_err("%s:%d failed: %p\n",
__func__, __LINE__, s_ctrl);
return -EINVAL;
}
power_info = &s_ctrl->sensordata->power_info;
sensor_i2c_client = s_ctrl->sensor_i2c_client;
slave_info = s_ctrl->sensordata->slave_info;
sensor_name = s_ctrl->sensordata->sensor_name;
if (!power_info || !sensor_i2c_client || !slave_info ||
!sensor_name) {
pr_err("%s:%d failed: %p %p %p %p\n",
__func__, __LINE__, power_info,
sensor_i2c_client, slave_info, sensor_name);
return -EINVAL;
}
/*LGE_CHANGE_S, power up retry, 2014-12-29, [email protected]*/
for (retry = 0; retry < 3; retry++) {
/*LGE_CHANGE_E, power up retry, 2014-12-29, [email protected]*/
rc = msm_camera_power_up(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
if (rc < 0)
return rc;
rc = msm_sensor_check_id(s_ctrl);
/*LGE_CHANGE_S, mipi end packet issue, 2013-10-15, [email protected]*/
if(strncmp(s_ctrl->sensordata->sensor_name, "hi707", strlen("hi707")) == 0)
s_ctrl->isFirstStream = TRUE;
/*LGE_CHANGE_E, mipi end packet issue, 2013-10-15, [email protected]*/
/*LGE_CHANGE_S, power up retry, 2014-12-29, [email protected]*/
#if 0 //QCT Original
if (rc < 0)
msm_camera_power_down(power_info, s_ctrl->sensor_device_type,
sensor_i2c_client);
#else
if (rc < 0) {
msm_camera_power_down(power_info,
s_ctrl->sensor_device_type, sensor_i2c_client);
msleep(20);
continue;
} else {
break;
}
}
#endif
/*LGE_CHANGE_E, power up retry, 2014-12-29, [email protected]*/
return rc;
}
static int32_t msm_eeprom_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
int32_t j = 0;
uint32_t temp;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_eeprom_board_info *eb_info = NULL;
struct device_node *of_node = pdev->dev.of_node;
struct msm_camera_power_ctrl_t *power_info = NULL;
CDBG("%s E\n", __func__);
e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
e_ctrl->is_supported = 0;
if (!of_node) {
pr_err("%s dev.of_node NULL\n", __func__);
kfree(e_ctrl);
return -EINVAL;
}
rc = of_property_read_u32(of_node, "cell-index",
&pdev->id);
CDBG("cell-index %d, rc %d\n", pdev->id, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
kfree(e_ctrl);
return rc;
}
e_ctrl->subdev_id = pdev->id;
rc = of_property_read_u32(of_node, "qcom,cci-master",
&e_ctrl->cci_master);
CDBG("qcom,cci-master %d, rc %d\n", e_ctrl->cci_master, rc);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
kfree(e_ctrl);
return rc;
}
rc = of_property_read_u32(of_node, "qcom,slave-addr",
&temp);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
kfree(e_ctrl);
return rc;
}
/* Set platform device handle */
e_ctrl->pdev = pdev;
/* Set device type as platform device */
e_ctrl->eeprom_device_type = MSM_CAMERA_PLATFORM_DEVICE;
e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_cci_func_tbl;
e_ctrl->i2c_client.cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!e_ctrl->i2c_client.cci_client) {
pr_err("%s failed no memory\n", __func__);
kfree(e_ctrl);
return -ENOMEM;
}
e_ctrl->eboard_info = kzalloc(sizeof(
struct msm_eeprom_board_info), GFP_KERNEL);
if (!e_ctrl->eboard_info) {
pr_err("%s failed line %d\n", __func__, __LINE__);
rc = -ENOMEM;
goto cciclient_free;
}
eb_info = e_ctrl->eboard_info;
power_info = &eb_info->power_info;
eb_info->i2c_slaveaddr = temp;
power_info->clk_info = cam_8974_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8974_clk_info);
power_info->dev = &pdev->dev;
CDBG("qcom,slave-addr = 0x%X\n", eb_info->i2c_slaveaddr);
cci_client = e_ctrl->i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = e_ctrl->cci_master;
cci_client->sid = eb_info->i2c_slaveaddr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
rc = of_property_read_string(of_node, "qcom,eeprom-name",
&eb_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
eb_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc)
goto board_free;
rc = msm_eeprom_alloc_memory_map(e_ctrl, of_node);
if (rc)
goto board_free;
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto memdata_free;
}
rc = read_eeprom_memory(e_ctrl);
if (rc < 0) {
pr_err("%s read_eeprom_memory failed\n", __func__);
goto power_down;
}
pr_err("%s line %d\n", __func__, __LINE__);
for (j = 0; j < e_ctrl->num_bytes; j++)
CDBG("memory_data[%d] = 0x%X\n", j, e_ctrl->memory_data[j]);
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto memdata_free;
}
v4l2_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
platform_set_drvdata(pdev, &e_ctrl->msm_sd.sd);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(e_ctrl->msm_sd.sd.name,
ARRAY_SIZE(e_ctrl->msm_sd.sd.name), "msm_eeprom");
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = 1;
CDBG("%s X\n", __func__);
return rc;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
memdata_free:
kfree(e_ctrl->memory_data);
kfree(eb_info->eeprom_map);
board_free:
kfree(e_ctrl->eboard_info);
cciclient_free:
kfree(e_ctrl->i2c_client.cci_client);
kfree(e_ctrl);
return rc;
}
int32_t msm_eeprom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id) {
int rc = 0;
int32_t j = 0;
uint32_t temp = 0;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
struct device_node *of_node = client->dev.of_node;
CDBG("%s E\n", __func__);
if (!of_node) {
pr_err("%s of_node NULL\n", __func__);
return -EINVAL;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s i2c_check_functionality failed\n", __func__);
goto probe_failure;
}
e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
CDBG("%s client = %x\n", __func__, (unsigned int)client);
e_ctrl->eboard_info = kzalloc(sizeof(
struct msm_eeprom_board_info), GFP_KERNEL);
if (!e_ctrl->eboard_info) {
pr_err("%s:%d board info NULL\n", __func__, __LINE__);
return -EINVAL;
}
rc = of_property_read_u32(of_node, "qcom,slave-addr", &temp);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
return rc;
}
power_info = &e_ctrl->eboard_info->power_info;
e_ctrl->eboard_info->i2c_slaveaddr = temp;
e_ctrl->i2c_client.client = client;
e_ctrl->is_supported = 0;
/* Set device type as I2C */
e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE;
e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_qup_func_tbl;
if (e_ctrl->eboard_info->i2c_slaveaddr != 0)
e_ctrl->i2c_client.client->addr =
e_ctrl->eboard_info->i2c_slaveaddr;
power_info->clk_info = cam_8960_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8960_clk_info);
power_info->dev = &client->dev;
rc = of_property_read_string(of_node, "qcom,eeprom-name",
&e_ctrl->eboard_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
e_ctrl->eboard_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc)
goto board_free;
rc = msm_eeprom_alloc_memory_map(e_ctrl, of_node);
if (rc)
goto board_free;
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("%s failed power up %d\n", __func__, __LINE__);
goto memdata_free;
}
rc = read_eeprom_memory(e_ctrl);
if (rc < 0) {
pr_err("%s read_eeprom_memory failed\n", __func__);
goto power_down;
}
for (j = 0; j < e_ctrl->num_bytes; j++)
CDBG("memory_data[%d] = 0x%X\n", j, e_ctrl->memory_data[j]);
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto power_down;
}
/*IMPLEMENT READING PART*/
/* Initialize sub device */
v4l2_i2c_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->i2c_client.client,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = 1;
CDBG("%s success result=%d X\n", __func__, rc);
return rc;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
memdata_free:
kfree(e_ctrl->memory_data);
kfree(e_ctrl->eboard_info->eeprom_map);
board_free:
kfree(e_ctrl->eboard_info);
probe_failure:
pr_err("%s failed! rc = %d\n", __func__, rc);
return rc;
}
static int msm_eeprom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
uint32_t temp = 0;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
struct device_node *of_node = client->dev.of_node;
CDBG("%s E\n", __func__);
if (!of_node) {
pr_err("%s of_node NULL\n", __func__);
return -EINVAL;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("%s i2c_check_functionality failed\n", __func__);
goto probe_failure;
}
e_ctrl = kzalloc(sizeof(struct msm_eeprom_ctrl_t), GFP_KERNEL);
if (!e_ctrl) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
e_ctrl->eeprom_v4l2_subdev_ops = &msm_eeprom_subdev_ops;
e_ctrl->eeprom_mutex = &msm_eeprom_mutex;
CDBG("%s client = %x\n", __func__, (unsigned int)client);
e_ctrl->eboard_info = kzalloc(sizeof(
struct msm_eeprom_board_info), GFP_KERNEL);
if (!e_ctrl->eboard_info) {
pr_err("%s:%d board info NULL\n", __func__, __LINE__);
return -EINVAL;
}
rc = of_property_read_u32(of_node, "qcom,slave-addr", &temp);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
return rc;
}
power_info = &e_ctrl->eboard_info->power_info;
e_ctrl->eboard_info->i2c_slaveaddr = temp;
e_ctrl->i2c_client.client = client;
e_ctrl->is_supported = 0;
e_ctrl->eeprom_device_type = MSM_CAMERA_I2C_DEVICE;
e_ctrl->i2c_client.i2c_func_tbl = &msm_eeprom_qup_func_tbl;
if (e_ctrl->eboard_info->i2c_slaveaddr != 0)
e_ctrl->i2c_client.client->addr =
e_ctrl->eboard_info->i2c_slaveaddr;
power_info->clk_info = cam_8960_clk_info;
power_info->clk_info_size = ARRAY_SIZE(cam_8960_clk_info);
power_info->dev = &client->dev;
rc = of_property_read_string(of_node, "qcom,eeprom-name",
&e_ctrl->eboard_info->eeprom_name);
CDBG("%s qcom,eeprom-name %s, rc %d\n", __func__,
e_ctrl->eboard_info->eeprom_name, rc);
if (rc < 0) {
pr_err("%s failed %d\n", __func__, __LINE__);
goto board_free;
}
rc = msm_eeprom_get_dt_data(e_ctrl);
if (rc)
goto board_free;
rc = msm_eeprom_parse_memory_map(of_node, "cal",
&e_ctrl->cal_data);
if (rc < 0)
pr_warn("%s: no cal memory map\n", __func__);
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("%s failed power up %d\n", __func__, __LINE__);
goto memdata_free;
}
if (e_ctrl->cal_data.map) {
rc = read_eeprom_memory(e_ctrl, &e_ctrl->cal_data);
if (rc < 0) {
pr_err("%s: read cal data failed\n", __func__);
goto power_down;
}
e_ctrl->is_supported |= msm_eeprom_match_crc(
&e_ctrl->cal_data);
#ifdef EEPROM_CAM_FW
if (e_ctrl->cal_data.mapdata)
memcpy(eeprom_fw, e_ctrl->cal_data.mapdata + EEPROM_FW_OFFSET, EEPROM_FW_SIZE);
pr_err("%s:%d cam_fw[%s]", __func__, __LINE__, eeprom_fw);
#endif
}
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc) {
pr_err("failed rc %d\n", rc);
goto power_down;
}
v4l2_i2c_subdev_init(&e_ctrl->msm_sd.sd,
e_ctrl->i2c_client.client,
e_ctrl->eeprom_v4l2_subdev_ops);
v4l2_set_subdevdata(&e_ctrl->msm_sd.sd, e_ctrl);
e_ctrl->msm_sd.sd.internal_ops = &msm_eeprom_internal_ops;
e_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&e_ctrl->msm_sd.sd.entity, 0, NULL, 0);
e_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
e_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_EEPROM;
msm_sd_register(&e_ctrl->msm_sd);
e_ctrl->is_supported = (e_ctrl->is_supported << 1) | 1;
CDBG("%s success result=%d X\n", __func__, rc);
return rc;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
memdata_free:
kfree(e_ctrl);
board_free:
kfree(e_ctrl->eboard_info);
probe_failure:
pr_err("%s failed! rc = %d\n", __func__, rc);
return rc;
}
