static int32_t msm_eeprom_read_eeprom_data(struct msm_eeprom_ctrl_t *e_ctrl)
{
int32_t rc = 0;
CDBG("%s:%d Enter\n", __func__, __LINE__);
/* check eeprom id */
if (e_ctrl->eeprom_device_type == MSM_CAMERA_SPI_DEVICE) {
rc = msm_eeprom_match_id(e_ctrl);
if (rc < 0) {
CDBG("%s: eeprom not matching %d\n", __func__, rc);
return rc;
}
}
/* read eeprom */
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__);
return rc;
}
e_ctrl->is_supported |= msm_eeprom_match_crc(
&e_ctrl->cal_data);
}
e_ctrl->is_supported = (e_ctrl->is_supported << 1) | 1;
CDBG("%s:%d Exit\n", __func__, __LINE__);
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;
}
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(*e_ctrl), 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 < 0) {
pr_err("failed rc %d\n", rc);
goto spi_free;
}
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) {
pr_err("%s : eb_info is NULL", __func__);
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 < 0) {
pr_err("%s : msm_eeprom_get_dt_data", __func__);
goto board_free;
}
/* set spi instruction info */
spi_client->retry_delay = 1;
spi_client->retries = 0;
rc = msm_eeprom_spi_parse_of(spi_client);
if (rc < 0) {
dev_err(&spi->dev,
"%s: Error parsing device properties\n", __func__);
goto board_free;
}
/* prepare memory buffer */
rc = msm_eeprom_parse_memory_map(spi->dev.of_node, "cal",
&e_ctrl->cal_data);
if (rc < 0)
pr_warn("%s: no cal memory map\n", __func__);
/* power up eeprom for reading */
rc = msm_camera_power_up(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
goto caldata_free;
}
/* check eeprom id */
rc = msm_eeprom_match_id(e_ctrl);
if (rc < 0) {
pr_err("%s: eeprom not matching %d\n", __func__, rc);
goto power_down;
}
/* read eeprom */
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);
}
rc = msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
goto caldata_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 = (e_ctrl->is_supported << 1) | 1;
pr_warn("%s success result=%d supported=%x X\n", __func__, rc,
e_ctrl->is_supported);
return 0;
power_down:
msm_camera_power_down(power_info, e_ctrl->eeprom_device_type,
&e_ctrl->i2c_client);
caldata_free:
kfree(e_ctrl->cal_data.mapdata);
kfree(e_ctrl->cal_data.map);
board_free:
kfree(e_ctrl->eboard_info);
spi_free:
kfree(spi_client);
kfree(e_ctrl);
return rc;
}
