static int __init msm_sensor_init_module(void)
{
/* Allocate memory for msm_sensor_init control structure */
s_init = kzalloc(sizeof(struct msm_sensor_init_t), GFP_KERNEL);
if (!s_init) {
pr_err("failed: no memory s_init %p", NULL);
return -ENOMEM;
}
CDBG("MSM_SENSOR_INIT_MODULE %p", NULL);
/* Initialize mutex */
mutex_init(&s_init->imutex);
/* Create /dev/v4l-subdevX for msm_sensor_init */
v4l2_subdev_init(&s_init->msm_sd.sd, &msm_sensor_init_subdev_ops);
snprintf(s_init->msm_sd.sd.name, sizeof(s_init->msm_sd.sd.name), "%s",
"msm_sensor_init");
v4l2_set_subdevdata(&s_init->msm_sd.sd, s_init);
s_init->msm_sd.sd.internal_ops = &msm_sensor_init_internal_ops;
s_init->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_init->msm_sd.sd.entity, 0, NULL, 0);
s_init->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_init->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR_INIT;
s_init->msm_sd.sd.entity.name = s_init->msm_sd.sd.name;
s_init->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x6;
msm_sd_register(&s_init->msm_sd);
init_waitqueue_head(&s_init->state_wait);
return 0;
}
static int32_t msm_sensor_driver_create_i2c_v4l_subdev
(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
uint32_t session_id = 0;
struct i2c_client *client = s_ctrl->sensor_i2c_client->client;
CDBG("%s %s I2c probe succeeded\n", __func__, client->name);
rc = camera_init_v4l2(&client->dev, &session_id);
if (rc < 0) {
pr_err("failed: camera_init_i2c_v4l2 rc %d", rc);
return rc;
}
CDBG("%s rc %d session_id %d\n", __func__, rc, session_id);
snprintf(s_ctrl->msm_sd.sd.name,
sizeof(s_ctrl->msm_sd.sd.name), "%s",
s_ctrl->sensordata->sensor_name);
v4l2_i2c_subdev_init(&s_ctrl->msm_sd.sd, client,
s_ctrl->sensor_v4l2_subdev_ops);
v4l2_set_subdevdata(&s_ctrl->msm_sd.sd, client);
s_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->msm_sd.sd.entity, 0, NULL, 0);
s_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR;
s_ctrl->msm_sd.sd.entity.name = s_ctrl->msm_sd.sd.name;
s_ctrl->sensordata->sensor_info->session_id = session_id;
s_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x3;
msm_sd_register(&s_ctrl->msm_sd);
CDBG("%s:%d\n", __func__, __LINE__);
return rc;
}
static int32_t msm_led_cci_create_v4lsubdev(struct platform_device *pdev, void *data)
{
struct msm_led_cci_ctrl_t *fctrl =
(struct msm_led_cci_ctrl_t *)data;
CDBG("Enter\n");
if (!fctrl) {
pr_err("fctrl NULL\n");
return -EINVAL;
}
/* Initialize sub device */
v4l2_subdev_init(&fctrl->msm_sd.sd, &msm_led_cci_subdev_ops);
v4l2_set_subdevdata(&fctrl->msm_sd.sd, fctrl);
fctrl->pdev = pdev;
fctrl->msm_sd.sd.internal_ops = &msm_led_cci_internal_ops;
fctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(fctrl->msm_sd.sd.name, ARRAY_SIZE(fctrl->msm_sd.sd.name),
"msm_flash");
media_entity_init(&fctrl->msm_sd.sd.entity, 0, NULL, 0);
fctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
fctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_LED_FLASH;
fctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x1;
msm_sd_register(&fctrl->msm_sd);
CDBG("probe success\n");
return 0;
}
static int32_t msm_sensor_driver_create_v4l_subdev
(struct msm_sensor_ctrl_t *s_ctrl)
{
int32_t rc = 0;
uint32_t session_id = 0;
rc = camera_init_v4l2(&s_ctrl->pdev->dev, &session_id);
if (rc < 0) {
pr_err("failed: camera_init_v4l2 rc %d", rc);
return rc;
}
CDBG("rc %d session_id %d", rc, session_id);
s_ctrl->sensordata->sensor_info->session_id = session_id;
/* Create /dev/v4l-subdevX device */
v4l2_subdev_init(&s_ctrl->msm_sd.sd, s_ctrl->sensor_v4l2_subdev_ops);
snprintf(s_ctrl->msm_sd.sd.name, sizeof(s_ctrl->msm_sd.sd.name), "%s",
s_ctrl->sensordata->sensor_name);
v4l2_set_subdevdata(&s_ctrl->msm_sd.sd, s_ctrl->pdev);
s_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->msm_sd.sd.entity, 0, NULL, 0);
s_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR;
s_ctrl->msm_sd.sd.entity.name = s_ctrl->msm_sd.sd.name;
s_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x3;
msm_sd_register(&s_ctrl->msm_sd);
return rc;
}
int32_t msm_led_i2c_flash_create_v4lsubdev(void *data)
{
struct msm_led_flash_ctrl_t *fctrl =
(struct msm_led_flash_ctrl_t *)data;
CDBG("Enter\n");
if (!fctrl) {
pr_err("fctrl NULL\n");
return -EINVAL;
}
/* Initialize sub device */
v4l2_subdev_init(&fctrl->msm_sd.sd, &msm_flash_subdev_ops);
v4l2_set_subdevdata(&fctrl->msm_sd.sd, fctrl);
fctrl->msm_sd.sd.internal_ops = &msm_flash_internal_ops;
fctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(fctrl->msm_sd.sd.name, ARRAY_SIZE(fctrl->msm_sd.sd.name),
"msm_flash");
media_entity_init(&fctrl->msm_sd.sd.entity, 0, NULL, 0);
fctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
fctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_LED_FLASH;
msm_sd_register(&fctrl->msm_sd);
msm_led_flash_v4l2_subdev_fops = v4l2_subdev_fops;
fctrl->msm_sd.sd.devnode->fops = &msm_led_flash_v4l2_subdev_fops;
CDBG("probe success\n");
return 0;
}
int32_t msm_eeprom_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id) {
int rc = 0;
struct msm_eeprom_ctrl_t *e_ctrl = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
CDBG("%s E\n", __func__);
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 = (struct msm_eeprom_board_info *)(id->driver_data);
if (!e_ctrl->eboard_info) {
pr_err("%s:%d board info NULL\n", __func__, __LINE__);
return -EINVAL;
}
power_info = &e_ctrl->eboard_info->power_info;
e_ctrl->i2c_client.client = client;
/* 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;
/*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);
CDBG("%s success result=%d X\n", __func__, rc);
return rc;
probe_failure:
pr_err("%s failed! rc = %d\n", __func__, rc);
return rc;
}
static int stmvl6180_cci_init(struct cci_data *data)
{
int rc = 0;
struct msm_camera_cci_client *cci_client = data->client->cci_client;
if (FALSE == data->subdev_initialized) {
data->client->i2c_func_tbl = &msm_sensor_cci_func_tbl;
data->client->cci_client = kzalloc(sizeof(struct msm_camera_cci_client), GFP_KERNEL);
if (!data->client->cci_client) {
vl6180_errmsg("%d, failed no memory\n", __LINE__);
return -ENOMEM;
}
cci_client = data->client->cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = data->cci_master;
v4l2_subdev_init(&data->msm_sd.sd, data->subdev_ops);
v4l2_set_subdevdata(&data->msm_sd.sd, data);
data->msm_sd.sd.internal_ops = &msm_tof_internal_ops;
data->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(data->msm_sd.sd.name, ARRAY_SIZE(data->msm_sd.sd.name), "msm_tof");
media_entity_init(&data->msm_sd.sd.entity, 0, NULL, 0);
data->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
data->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_TOF;
data->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x2;
msm_sd_register(&data->msm_sd);
msm_tof_v4l2_subdev_fops = v4l2_subdev_fops;
/*
#ifdef CONFIG_COMPAT
msm_tof_v4l2_subdev_fops.compat_ioctl32 = msm_tof_subdev_fops_ioctl;
#endif
*/
data->msm_sd.sd.devnode->fops = &msm_tof_v4l2_subdev_fops;
data->subdev_initialized = TRUE;
}
cci_client->sid = data->slave_addr;
cci_client->i2c_freq_mode = data->i2c_freq_mode;
cci_client->retries = 3;
cci_client->id_map = 0;
cci_client->cci_i2c_master = data->cci_master;
rc = data->client->i2c_func_tbl->i2c_util(data->client, MSM_CCI_INIT);
if (rc < 0) {
vl6180_errmsg("%d: CCI Init failed\n", __LINE__);
return rc;
}
vl6180_dbgmsg("CCI Init Succeeded\n");
data->client->addr_type = MSM_CAMERA_I2C_WORD_ADDR;
return 0;
}
static int32_t msm_ois_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_ois_ctrl_t *act_ctrl_t = NULL;
pr_err("Enter\n");
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
act_ctrl_t = (struct msm_ois_ctrl_t *)(id->driver_data);
CDBG("client = %x\n", (unsigned int) client);
act_ctrl_t->i2c_client.client = client;
/* Set device type as I2C */
act_ctrl_t->act_device_type = MSM_CAMERA_I2C_DEVICE;
act_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl;
/* Assign name for sub device */
snprintf(act_ctrl_t->msm_sd.sd.name, sizeof(act_ctrl_t->msm_sd.sd.name),
"%s", act_ctrl_t->i2c_driver->driver.name);
/* Initialize sub device */
v4l2_i2c_subdev_init(&act_ctrl_t->msm_sd.sd,
act_ctrl_t->i2c_client.client,
act_ctrl_t->act_v4l2_subdev_ops);
v4l2_set_subdevdata(&act_ctrl_t->msm_sd.sd, act_ctrl_t);
act_ctrl_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
act_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&act_ctrl_t->msm_sd.sd.entity, 0, NULL, 0);
act_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
act_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
msm_sd_register(&act_ctrl_t->msm_sd);
CDBG("succeeded\n");
pr_err("Exit\n");
probe_failure:
return rc;
}
static int __devinit csid_probe(struct platform_device *pdev)
{
struct csid_device *new_csid_dev;
uint32_t csi_vdd_voltage = 0;
int rc = 0;
new_csid_dev = kzalloc(sizeof(struct csid_device), GFP_KERNEL);
if (!new_csid_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&new_csid_dev->msm_sd.sd, &msm_csid_subdev_ops);
v4l2_set_subdevdata(&new_csid_dev->msm_sd.sd, new_csid_dev);
platform_set_drvdata(pdev, &new_csid_dev->msm_sd.sd);
mutex_init(&new_csid_dev->mutex);
if (pdev->dev.of_node) {
rc = of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
if (rc < 0) {
pr_err("%s:%d failed to read cell-index\n", __func__,
__LINE__);
goto csid_no_resource;
}
CDBG("%s device id %d\n", __func__, pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,csi-vdd-voltage", &csi_vdd_voltage);
if (rc < 0) {
pr_err("%s:%d failed to read qcom,csi-vdd-voltage\n",
__func__, __LINE__);
goto csid_no_resource;
}
CDBG("%s:%d reading mipi_csi_vdd is %d\n", __func__, __LINE__,
csi_vdd_voltage);
csid_vreg_info[0].min_voltage = csi_vdd_voltage;
csid_vreg_info[0].max_voltage = csi_vdd_voltage;
}
new_csid_dev->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csid");
if (!new_csid_dev->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "csid");
if (!new_csid_dev->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->io = request_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem), pdev->name);
if (!new_csid_dev->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
new_csid_dev->pdev = pdev;
new_csid_dev->msm_sd.sd.internal_ops = &msm_csid_internal_ops;
new_csid_dev->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(new_csid_dev->msm_sd.sd.name,
ARRAY_SIZE(new_csid_dev->msm_sd.sd.name), "msm_csid");
media_entity_init(&new_csid_dev->msm_sd.sd.entity, 0, NULL, 0);
new_csid_dev->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
new_csid_dev->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_CSID;
new_csid_dev->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x5;
msm_sd_register(&new_csid_dev->msm_sd);
rc = request_irq(new_csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
disable_irq(new_csid_dev->irq->start);
new_csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
csid_no_resource:
mutex_destroy(&new_csid_dev->mutex);
kfree(new_csid_dev);
return rc;
}
static int __init msm_sensor_init_module(void)
{
struct msm_sensor_init_t *s_init = NULL;
struct device *cam_dev_back;
struct device *cam_dev_front;
int rc = 0;
camera_class = class_create(THIS_MODULE, "camera");
if (IS_ERR(camera_class))
pr_err("failed to create device cam_dev_rear!\n");
/* Allocate memory for msm_sensor_init control structure */
s_init = kzalloc(sizeof(struct msm_sensor_init_t), GFP_KERNEL);
if (!s_init) {
class_destroy(camera_class);
pr_err("failed: no memory s_init %p", NULL);
return -ENOMEM;
}
pr_err("MSM_SENSOR_INIT_MODULE %p", NULL);
/* Initialize mutex */
mutex_init(&s_init->imutex);
/* Create /dev/v4l-subdevX for msm_sensor_init */
v4l2_subdev_init(&s_init->msm_sd.sd, &msm_sensor_init_subdev_ops);
snprintf(s_init->msm_sd.sd.name, sizeof(s_init->msm_sd.sd.name), "%s",
"msm_sensor_init");
v4l2_set_subdevdata(&s_init->msm_sd.sd, s_init);
s_init->msm_sd.sd.internal_ops = &msm_sensor_init_internal_ops;
s_init->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
rc = media_entity_init(&s_init->msm_sd.sd.entity, 0, NULL, 0);
if (rc < 0)
goto entity_fail;
s_init->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_init->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR_INIT;
s_init->msm_sd.sd.entity.name = s_init->msm_sd.sd.name;
s_init->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x6;
rc = msm_sd_register(&s_init->msm_sd);
if (rc < 0)
goto msm_sd_register_fail;
cam_dev_back = device_create(camera_class, NULL,
1, NULL, "rear");
if (IS_ERR(cam_dev_back)) {
printk("Failed to create cam_dev_back device!\n");
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camtype) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camtype.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camfw) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_checkfw_user) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_checkfw_user.attr.name);
rc = -ENODEV;
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_checkfw_factory) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_checkfw_factory.attr.name);
rc = -ENODEV;
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_isp_core) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_isp_core.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camfw_load) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw_load.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camfw_full) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw_full.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_back, &dev_attr_rear_vendorid) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_vendorid.attr.name);
goto device_create_fail;
}
cam_dev_front = device_create(camera_class, NULL,
2, NULL, "front");
if (IS_ERR(cam_dev_front)) {
printk("Failed to create cam_dev_front device!");
goto device_create_fail;
}
if (device_create_file(cam_dev_front, &dev_attr_front_camtype) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_front_camtype.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_front, &dev_attr_front_camfw) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_front_camfw.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_front, &dev_attr_front_camfw_load) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw_load.attr.name);
goto device_create_fail;
}
if (device_create_file(cam_dev_front, &dev_attr_front_camfw_full) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw_full.attr.name);
goto device_create_fail;
}
init_waitqueue_head(&s_init->state_wait);
return 0;
device_create_fail:
msm_sd_unregister(&s_init->msm_sd);
msm_sd_register_fail:
media_entity_cleanup(&s_init->msm_sd.sd.entity);
entity_fail:
mutex_destroy(&s_init->imutex);
kfree(s_init);
class_destroy(camera_class);
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 int32_t msm_tcs_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_cci_client *cci_client = NULL;
CDBG("Enter\n");
if (!pdev->dev.of_node) {
CDBG("of_node NULL : %d\n", EINVAL);
return -EINVAL;
}
rc = of_property_read_u32((&pdev->dev)->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);
return rc;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,cci-master",
&msm_tcs_t.cci_master);
CDBG("qcom,cci-master %d, rc %d\n", msm_tcs_t.cci_master, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
msm_tcs_t.tcs_mutex = &msm_tcs_mutex;
msm_tcs_t.pdev = pdev;
msm_tcs_t.tcs_device_type = MSM_CAMERA_PLATFORM_DEVICE;
msm_tcs_t.i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
msm_tcs_t.i2c_client.cci_client = kzalloc(sizeof(struct msm_camera_cci_client), GFP_KERNEL);
if (!msm_tcs_t.i2c_client.cci_client) {
pr_err("failed no memory\n");
return -ENOMEM;
}
msm_tcs_t.i2c_client.cci_client->sid = 0x39; //Slave address
msm_tcs_t.i2c_client.cci_client->retries = 3;
msm_tcs_t.i2c_client.cci_client->id_map = 0;
msm_tcs_t.i2c_client.cci_client->cci_i2c_master = MASTER_0;
msm_tcs_t.i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
cci_client = msm_tcs_t.i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
v4l2_subdev_init(&msm_tcs_t.msm_sd.sd,
msm_tcs_t.tcs_v4l2_subdev_ops);
v4l2_set_subdevdata(&msm_tcs_t.msm_sd.sd, &msm_tcs_t);
msm_tcs_t.msm_sd.sd.internal_ops = &msm_tcs_internal_ops;
msm_tcs_t.msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(msm_tcs_t.msm_sd.sd.name,
ARRAY_SIZE(msm_tcs_t.msm_sd.sd.name), "msm_tcs");
media_entity_init(&msm_tcs_t.msm_sd.sd.entity, 0, NULL, 0);
msm_tcs_t.msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
msm_tcs_t.msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_TCS;
msm_tcs_t.msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x2;
msm_sd_register(&msm_tcs_t.msm_sd);
msm_tcs_t.tcs_state = TCS_POWER_DOWN;
msm_tcs_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_tcs_v4l2_subdev_fops.compat_ioctl32 = msm_tcs_subdev_fops_ioctl;
#endif
msm_tcs_t.msm_sd.sd.devnode->fops = &msm_tcs_v4l2_subdev_fops;
msm_tcs_t.sid_tcs = msm_tcs_t.i2c_client.cci_client->sid;
msm_tcs_t.tcs_func_tbl = NULL;
msm_tcs_t.exit_workqueue = 1;
msm_tcs_t.pause_workqueue = 0;
msm_tcs_t.max_i2c_fail_thres = 5;
msm_tcs_t.i2c_fail_cnt = 0;
CDBG("Exit\n");
return rc;
}
static int __init msm_sensor_init_module(void)
{
int ret = 0;
struct device_node *of_node = NULL;
of_node = of_find_compatible_node(NULL, NULL, "qcom,hw-camera-board-id");
if (of_property_read_string(of_node, "qcom,product-name",
&dt_product_name) < 0) {
dt_product_name = NULL;
pr_err("%s: don't define support product name.\n",__func__);
}
else{
pr_info("%s product_name = %s\n", __func__, dt_product_name);
}
/* Allocate memory for msm_sensor_init control structure */
s_init = kzalloc(sizeof(struct msm_sensor_init_t), GFP_KERNEL);
if (!s_init) {
pr_err("failed: no memory s_init %p", NULL);
return -ENOMEM;
}
CDBG("MSM_SENSOR_INIT_MODULE %p", NULL);
/* Initialize mutex */
mutex_init(&s_init->imutex);
/* Create /dev/v4l-subdevX for msm_sensor_init */
v4l2_subdev_init(&s_init->msm_sd.sd, &msm_sensor_init_subdev_ops);
snprintf(s_init->msm_sd.sd.name, sizeof(s_init->msm_sd.sd.name), "%s",
"msm_sensor_init");
v4l2_set_subdevdata(&s_init->msm_sd.sd, s_init);
s_init->msm_sd.sd.internal_ops = &msm_sensor_init_internal_ops;
s_init->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_init->msm_sd.sd.entity, 0, NULL, 0);
s_init->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_init->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR_INIT;
s_init->msm_sd.sd.entity.name = s_init->msm_sd.sd.name;
s_init->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x6;
ret = msm_sd_register(&s_init->msm_sd);
if (ret) {
CDBG("%s: msm_sd_register error = %d\n", __func__, ret);
goto error;
}
msm_sensor_init_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_sensor_init_v4l2_subdev_fops.compat_ioctl32 =
msm_sensor_init_subdev_fops_ioctl;
#endif
s_init->msm_sd.sd.devnode->fops =
&msm_sensor_init_v4l2_subdev_fops;
init_waitqueue_head(&s_init->state_wait);
return 0;
error:
mutex_destroy(&s_init->imutex);
kfree(s_init);
return ret;
}
static int csid_probe(struct platform_device *pdev)
{
struct csid_device *new_csid_dev;
uint32_t csi_vdd_voltage = 0;
int rc = 0;
new_csid_dev = kzalloc(sizeof(struct csid_device), GFP_KERNEL);
if (!new_csid_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
new_csid_dev->ctrl_reg = NULL;
new_csid_dev->ctrl_reg = kzalloc(sizeof(struct csid_ctrl_t),
GFP_KERNEL);
if (!new_csid_dev->ctrl_reg) {
pr_err("%s:%d kzalloc failed\n", __func__, __LINE__);
return -ENOMEM;
}
v4l2_subdev_init(&new_csid_dev->msm_sd.sd, &msm_csid_subdev_ops);
v4l2_set_subdevdata(&new_csid_dev->msm_sd.sd, new_csid_dev);
platform_set_drvdata(pdev, &new_csid_dev->msm_sd.sd);
mutex_init(&new_csid_dev->mutex);
if (pdev->dev.of_node) {
rc = of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
if (rc < 0) {
pr_err("%s:%d failed to read cell-index\n", __func__,
__LINE__);
goto csid_no_resource;
}
CDBG("%s device id %d\n", __func__, pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,csi-vdd-voltage", &csi_vdd_voltage);
if (rc < 0) {
pr_err("%s:%d failed to read qcom,csi-vdd-voltage\n",
__func__, __LINE__);
goto csid_no_resource;
}
CDBG("%s:%d reading mipi_csi_vdd is %d\n", __func__, __LINE__,
csi_vdd_voltage);
csid_vreg_info[0].min_voltage = csi_vdd_voltage;
csid_vreg_info[0].max_voltage = csi_vdd_voltage;
}
rc = msm_csid_get_clk_info(new_csid_dev, pdev);
if (rc < 0) {
pr_err("%s: msm_csid_get_clk_info() failed", __func__);
return -EFAULT;
}
new_csid_dev->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csid");
if (!new_csid_dev->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "csid");
if (!new_csid_dev->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto csid_no_resource;
}
new_csid_dev->io = request_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem), pdev->name);
if (!new_csid_dev->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
new_csid_dev->pdev = pdev;
new_csid_dev->msm_sd.sd.internal_ops = &msm_csid_internal_ops;
new_csid_dev->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(new_csid_dev->msm_sd.sd.name,
ARRAY_SIZE(new_csid_dev->msm_sd.sd.name), "msm_csid");
media_entity_init(&new_csid_dev->msm_sd.sd.entity, 0, NULL, 0);
new_csid_dev->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
new_csid_dev->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_CSID;
new_csid_dev->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x5;
msm_sd_register(&new_csid_dev->msm_sd);
#ifdef CONFIG_COMPAT
msm_csid_v4l2_subdev_fops = v4l2_subdev_fops;
msm_csid_v4l2_subdev_fops.compat_ioctl32 = msm_csid_subdev_fops_ioctl32;
new_csid_dev->msm_sd.sd.devnode->fops = &msm_csid_v4l2_subdev_fops;
#endif
rc = request_irq(new_csid_dev->irq->start, msm_csid_irq,
IRQF_TRIGGER_RISING, "csid", new_csid_dev);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s: irq request fail\n", __func__);
rc = -EBUSY;
goto csid_no_resource;
}
disable_irq(new_csid_dev->irq->start);
if (rc < 0) {
release_mem_region(new_csid_dev->mem->start,
resource_size(new_csid_dev->mem));
pr_err("%s Error registering irq ", __func__);
goto csid_no_resource;
}
if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v2.0")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v2_0;
new_csid_dev->hw_dts_version = CSID_VERSION_V20;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v2.2")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v2_2;
new_csid_dev->hw_dts_version = CSID_VERSION_V22;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v3.0")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_0;
new_csid_dev->hw_dts_version = CSID_VERSION_V30;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v4.0")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_0;
new_csid_dev->hw_dts_version = CSID_VERSION_V40;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v3.1")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_1;
new_csid_dev->hw_dts_version = CSID_VERSION_V31;
} else if (of_device_is_compatible(new_csid_dev->pdev->dev.of_node,
"qcom,csid-v3.2")) {
new_csid_dev->ctrl_reg->csid_reg = csid_v3_2;
new_csid_dev->hw_dts_version = CSID_VERSION_V32;
} else {
pr_err("%s:%d, invalid hw version : 0x%x", __func__, __LINE__,
new_csid_dev->hw_dts_version);
return -EINVAL;
}
new_csid_dev->csid_state = CSID_POWER_DOWN;
return 0;
csid_no_resource:
mutex_destroy(&new_csid_dev->mutex);
kfree(new_csid_dev->ctrl_reg);
kfree(new_csid_dev);
return 0;
}
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 int __devinit ispif_probe(struct platform_device *pdev)
{
int rc;
struct ispif_device *ispif;
ispif = kzalloc(sizeof(struct ispif_device), GFP_KERNEL);
if (!ispif) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
add_debugfs_entry(ispif);
INIT_WORK(&ispif->fem.async_work, async_frame_event_do_work);
mutex_init(&ispif->fem.sync_mutex);
v4l2_subdev_init(&ispif->msm_sd.sd, &msm_ispif_subdev_ops);
ispif->msm_sd.sd.internal_ops = &msm_ispif_internal_ops;
ispif->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(ispif->msm_sd.sd.name,
ARRAY_SIZE(ispif->msm_sd.sd.name), MSM_ISPIF_DRV_NAME);
v4l2_set_subdevdata(&ispif->msm_sd.sd, ispif);
platform_set_drvdata(pdev, &ispif->msm_sd.sd);
mutex_init(&ispif->mutex);
media_entity_init(&ispif->msm_sd.sd.entity, 0, NULL, 0);
ispif->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ispif->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_ISPIF;
ispif->msm_sd.sd.entity.name = pdev->name;
ispif->msm_sd.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x1;
rc = msm_sd_register(&ispif->msm_sd);
if (rc) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto error_sd_register;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,num-isps", &ispif->hw_num_isps);
if (rc)
/* backward compatibility */
ispif->hw_num_isps = 1;
/* not an error condition */
rc = 0;
}
ispif->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "ispif");
if (!ispif->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "ispif");
if (!ispif->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->io = request_mem_region(ispif->mem->start,
resource_size(ispif->mem), pdev->name);
if (!ispif->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto error;
}
ispif->clk_mux_mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csi_clk_mux");
if (ispif->clk_mux_mem) {
ispif->clk_mux_io = request_mem_region(
ispif->clk_mux_mem->start,
resource_size(ispif->clk_mux_mem),
ispif->clk_mux_mem->name);
if (!ispif->clk_mux_io)
pr_err("%s: no valid csi_mux region\n", __func__);
}
ispif->pdev = pdev;
ispif->ispif_state = ISPIF_POWER_DOWN;
ispif->open_cnt = 0;
return 0;
error:
msm_sd_unregister(&ispif->msm_sd);
error_sd_register:
mutex_destroy(&ispif->mutex);
mutex_destroy(&ispif->fem.sync_mutex);
kfree(ispif);
return rc;
}
static int vfe_probe(struct platform_device *pdev)
{
struct vfe_device *vfe_dev;
/*struct msm_cam_subdev_info sd_info;*/
const struct of_device_id *match_dev;
int rc = 0;
struct msm_iova_partition vfe_partition = {
.start = SZ_128K,
.size = SZ_2G - SZ_128K,
};
struct msm_iova_layout vfe_layout = {
.partitions = &vfe_partition,
.npartitions = 1,
.client_name = "vfe",
.domain_flags = 0,
};
vfe_dev = kzalloc(sizeof(struct vfe_device), GFP_KERNEL);
if (!vfe_dev) {
pr_err("%s: no enough memory\n", __func__);
rc = -ENOMEM;
goto end;
}
vfe_dev->stats = kzalloc(sizeof(struct msm_isp_statistics), GFP_KERNEL);
if (!vfe_dev->stats) {
pr_err("%s: no enough memory\n", __func__);
rc = -ENOMEM;
goto probe_fail1;
}
vfe_dev->ub_info = kzalloc(sizeof(struct msm_isp_ub_info), GFP_KERNEL);
if (!vfe_dev->ub_info) {
pr_err("%s: no enough memory\n", __func__);
rc = -ENOMEM;
goto probe_fail2;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
match_dev = of_match_device(msm_vfe_dt_match, &pdev->dev);
if (!match_dev) {
pr_err("%s: No vfe hardware info\n", __func__);
rc = -EINVAL;
goto probe_fail3;
}
vfe_dev->hw_info =
(struct msm_vfe_hardware_info *) match_dev->data;
} else {
vfe_dev->hw_info = (struct msm_vfe_hardware_info *)
platform_get_device_id(pdev)->driver_data;
}
if (!vfe_dev->hw_info) {
pr_err("%s: No vfe hardware info\n", __func__);
rc = -EINVAL;
goto probe_fail3;
}
ISP_DBG("%s: device id = %d\n", __func__, pdev->id);
vfe_dev->pdev = pdev;
vfe_dev->dual_vfe_res = &dualvfe;
vfe_dev->dual_vfe_res->axi_data[vfe_dev->pdev->id] =
&vfe_dev->axi_data;
vfe_dev->dual_vfe_res->stats_data[vfe_dev->pdev->id] =
&vfe_dev->stats_data;
rc = vfe_dev->hw_info->vfe_ops.core_ops.get_platform_data(vfe_dev);
if (rc < 0) {
pr_err("%s: failed to get platform resources\n", __func__);
rc = -ENOMEM;
goto probe_fail3;
}
INIT_LIST_HEAD(&vfe_dev->tasklet_q);
tasklet_init(&vfe_dev->vfe_tasklet,
msm_isp_do_tasklet, (unsigned long)vfe_dev);
/* init hardware will enable it back */
tasklet_disable(&vfe_dev->vfe_tasklet);
v4l2_subdev_init(&vfe_dev->subdev.sd, vfe_dev->hw_info->subdev_ops);
vfe_dev->subdev.sd.internal_ops =
vfe_dev->hw_info->subdev_internal_ops;
snprintf(vfe_dev->subdev.sd.name,
ARRAY_SIZE(vfe_dev->subdev.sd.name),
"vfe");
vfe_dev->subdev.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
vfe_dev->subdev.sd.flags |= V4L2_SUBDEV_FL_HAS_EVENTS;
v4l2_set_subdevdata(&vfe_dev->subdev.sd, vfe_dev);
platform_set_drvdata(pdev, &vfe_dev->subdev.sd);
mutex_init(&vfe_dev->realtime_mutex);
mutex_init(&vfe_dev->core_mutex);
mutex_init(&vfe_dev->buf_mgr_mutex);
spin_lock_init(&vfe_dev->tasklet_lock);
spin_lock_init(&vfe_dev->shared_data_lock);
spin_lock_init(&vfe_dev->reg_update_lock);
spin_lock_init(&vfe_dev->shared_cfg_reg_lock); //LGE_CHANGE, 20150609, Change spin_lock for watchodog case using shard_data_lock, changhwan.kang.kang
spin_lock_init(&req_history_lock);
media_entity_init(&vfe_dev->subdev.sd.entity, 0, NULL, 0);
vfe_dev->subdev.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
vfe_dev->subdev.sd.entity.group_id = MSM_CAMERA_SUBDEV_VFE;
vfe_dev->subdev.sd.entity.name = pdev->name;
vfe_dev->subdev.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x2;
rc = msm_sd_register(&vfe_dev->subdev);
if (rc != 0) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto probe_fail3;
}
msm_isp_v4l2_subdev_fops.owner = v4l2_subdev_fops.owner;
msm_isp_v4l2_subdev_fops.open = v4l2_subdev_fops.open;
msm_isp_v4l2_subdev_fops.release = v4l2_subdev_fops.release;
msm_isp_v4l2_subdev_fops.poll = v4l2_subdev_fops.poll;
vfe_dev->subdev.sd.devnode->fops = &msm_isp_v4l2_subdev_fops;
vfe_dev->buf_mgr = &vfe_buf_mgr;
v4l2_subdev_notify(&vfe_dev->subdev.sd,
MSM_SD_NOTIFY_REQ_CB, &vfe_vb2_ops);
rc = msm_isp_create_isp_buf_mgr(vfe_dev->buf_mgr,
&vfe_vb2_ops, &vfe_layout);
if (rc < 0) {
pr_err("%s: Unable to create buffer manager\n", __func__);
rc = -EINVAL;
goto probe_fail3;
}
/* create secure context banks*/
if (vfe_dev->hw_info->num_iommu_secure_ctx) {
/*secure vfe layout*/
struct msm_iova_layout vfe_secure_layout = {
.partitions = &vfe_partition,
.npartitions = 1,
.client_name = "vfe_secure",
.domain_flags = 0,
.is_secure = MSM_IOMMU_DOMAIN_SECURE,
};
rc = msm_isp_create_secure_domain(vfe_dev->buf_mgr,
&vfe_secure_layout);
if (rc < 0) {
pr_err("%s: fail to create secure domain\n", __func__);
msm_sd_unregister(&vfe_dev->subdev);
rc = -EINVAL;
goto probe_fail3;
}
}
msm_isp_enable_debugfs(vfe_dev, msm_isp_bw_request_history);
vfe_dev->buf_mgr->ops->register_ctx(vfe_dev->buf_mgr,
&vfe_dev->iommu_ctx[0], &vfe_dev->iommu_secure_ctx[0],
vfe_dev->hw_info->num_iommu_ctx,
vfe_dev->hw_info->num_iommu_secure_ctx);
vfe_dev->buf_mgr->init_done = 1;
vfe_dev->vfe_open_cnt = 0;
return rc;
probe_fail3:
kfree(vfe_dev->ub_info);
probe_fail2:
kfree(vfe_dev->stats);
probe_fail1:
kfree(vfe_dev);
end:
return rc;
}
static struct platform_driver vfe_driver = {
.probe = vfe_probe,
.driver = {
.name = "msm_vfe",
.owner = THIS_MODULE,
.of_match_table = msm_vfe_dt_match,
},
.id_table = msm_vfe_dev_id,
};
static int __init msm_vfe_init_module(void)
{
return platform_driver_register(&vfe_driver);
}
static void __exit msm_vfe_exit_module(void)
{
platform_driver_unregister(&vfe_driver);
}
module_init(msm_vfe_init_module);
module_exit(msm_vfe_exit_module);
MODULE_DESCRIPTION("MSM VFE driver");
MODULE_LICENSE("GPL v2");
static int __devinit ispif_probe(struct platform_device *pdev)
{
int rc;
struct ispif_device *ispif;
ispif = kzalloc(sizeof(struct ispif_device), GFP_KERNEL);
if (!ispif) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
v4l2_subdev_init(&ispif->msm_sd.sd, &msm_ispif_subdev_ops);
ispif->msm_sd.sd.internal_ops = &msm_ispif_internal_ops;
ispif->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(ispif->msm_sd.sd.name,
ARRAY_SIZE(ispif->msm_sd.sd.name), MSM_ISPIF_DRV_NAME);
v4l2_set_subdevdata(&ispif->msm_sd.sd, ispif);
platform_set_drvdata(pdev, &ispif->msm_sd.sd);
mutex_init(&ispif->mutex);
media_entity_init(&ispif->msm_sd.sd.entity, 0, NULL, 0);
ispif->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ispif->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_ISPIF;
ispif->msm_sd.sd.entity.name = pdev->name;
ispif->msm_sd.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x1;
rc = msm_sd_register(&ispif->msm_sd);
if (rc) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto error_sd_register;
}
if (pdev->dev.of_node)
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
ispif->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "ispif");
if (!ispif->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "ispif");
if (!ispif->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->io = request_mem_region(ispif->mem->start,
resource_size(ispif->mem), pdev->name);
if (!ispif->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto error;
}
ispif->clk_mux_mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csi_clk_mux");
if (ispif->clk_mux_mem) {
ispif->clk_mux_io = request_mem_region(
ispif->clk_mux_mem->start,
resource_size(ispif->clk_mux_mem),
ispif->clk_mux_mem->name);
if (!ispif->clk_mux_io)
pr_err("%s: no valid csi_mux region\n", __func__);
}
ispif->pdev = pdev;
ispif->ispif_state = ISPIF_POWER_DOWN;
ispif->open_cnt = 0;
pr_err(" %s:%d ISPIF_POWER_DOWN %d \n",__func__,__LINE__,ispif->ispif_state);
/* */
wake_lock_init(&ispif->camera_wake_lock, WAKE_LOCK_SUSPEND, "camera_wake_lock");
/* */
return 0;
error:
msm_sd_unregister(&ispif->msm_sd);
error_sd_register:
mutex_destroy(&ispif->mutex);
kfree(ispif);
return rc;
}
static int __init msm_sensor_init_module(void)
{
struct msm_sensor_init_t *s_init = NULL;
struct device *cam_dev_back;
struct device *cam_dev_front;
camera_class = class_create(THIS_MODULE, "camera");
if (IS_ERR(camera_class))
pr_err("failed to create device cam_dev_rear!\n");
/* Allocate memory for msm_sensor_init control structure */
s_init = kzalloc(sizeof(struct msm_sensor_init_t), GFP_KERNEL);
if (!s_init) {
pr_err("failed: no memory s_init %p", NULL);
return -ENOMEM;
}
/* Initialize mutex */
mutex_init(&s_init->imutex);
/* Create /dev/v4l-subdevX for msm_sensor_init */
v4l2_subdev_init(&s_init->msm_sd.sd, &msm_sensor_init_subdev_ops);
snprintf(s_init->msm_sd.sd.name, sizeof(s_init->msm_sd.sd.name), "%s",
"msm_sensor_init");
v4l2_set_subdevdata(&s_init->msm_sd.sd, s_init);
s_init->msm_sd.sd.internal_ops = &msm_sensor_init_internal_ops;
s_init->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_init->msm_sd.sd.entity, 0, NULL, 0);
s_init->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_init->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR_INIT;
s_init->msm_sd.sd.entity.name = s_init->msm_sd.sd.name;
s_init->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x6;
msm_sd_register(&s_init->msm_sd);
cam_dev_back = device_create(camera_class, NULL,
1, NULL, "rear");
if (IS_ERR(cam_dev_back)) {
printk("Failed to create cam_dev_back device!\n");
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camtype) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camtype.attr.name);
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camfw) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw.attr.name);
}
if (device_create_file(cam_dev_back, &dev_attr_rear_camfw_load) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_rear_camfw_load.attr.name);
}
cam_dev_front = device_create(camera_class, NULL,
2, NULL, "front");
if (IS_ERR(cam_dev_front)) {
printk("Failed to create cam_dev_front device!");
}
if (device_create_file(cam_dev_front, &dev_attr_front_camtype) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_front_camtype.attr.name);
}
if (device_create_file(cam_dev_front, &dev_attr_front_camfw) < 0) {
printk("Failed to create device file!(%s)!\n",
dev_attr_front_camfw.attr.name);
}
return 0;
}
static int32_t msm_ois_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_cci_client *cci_client = NULL;
pr_err("Enter\n");
if (!pdev->dev.of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
rc = of_property_read_u32((&pdev->dev)->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);
return rc;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,cci-master",
&msm_ois_t.cci_master);
CDBG("qcom,cci-master %d, rc %d\n", msm_ois_t.cci_master, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
/* Set platform device handle */
msm_ois_t.pdev = pdev;
/* Set device type as platform device */
msm_ois_t.act_device_type = MSM_CAMERA_PLATFORM_DEVICE;
msm_ois_t.i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
msm_ois_t.i2c_client.cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!msm_ois_t.i2c_client.cci_client) {
pr_err("failed no memory\n");
return -ENOMEM;
}
/* ois initial settings */
msm_ois_t.i2c_client.cci_client->sid = 0x7C >> 1; //0x48 >> 1;
msm_ois_t.i2c_client.cci_client->retries = 3;
msm_ois_t.i2c_client.cci_client->id_map = 0;
msm_ois_t.i2c_client.cci_client->cci_i2c_master = MASTER_0;
/* Update sensor address type */
msm_ois_t.i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
cci_client = msm_ois_t.i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
v4l2_subdev_init(&msm_ois_t.msm_sd.sd,
msm_ois_t.act_v4l2_subdev_ops);
v4l2_set_subdevdata(&msm_ois_t.msm_sd.sd, &msm_ois_t);
msm_ois_t.msm_sd.sd.internal_ops = &msm_ois_internal_ops;
msm_ois_t.msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(msm_ois_t.msm_sd.sd.name,
ARRAY_SIZE(msm_ois_t.msm_sd.sd.name), "msm_ois");
media_entity_init(&msm_ois_t.msm_sd.sd.entity, 0, NULL, 0);
msm_ois_t.msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
msm_ois_t.msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
msm_sd_register(&msm_ois_t.msm_sd);
msm_ois_t.sid_ois = msm_ois_t.i2c_client.cci_client->sid;
msm_ois_t.ois_func_tbl = NULL;
CDBG("Exit\n");
return rc;
}
static int32_t msm_flash_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_flash_ctrl_t *flash_ctrl = NULL;
struct msm_camera_cci_client *cci_client = NULL;
CDBG("Enter");
if (!pdev->dev.of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
flash_ctrl = kzalloc(sizeof(struct msm_flash_ctrl_t), GFP_KERNEL);
if (!flash_ctrl) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
memset(flash_ctrl, 0, sizeof(struct msm_flash_ctrl_t));
flash_ctrl->pdev = pdev;
rc = msm_flash_get_dt_data(pdev->dev.of_node, flash_ctrl);
if (rc < 0) {
pr_err("%s:%d msm_flash_get_dt_data failed\n",
__func__, __LINE__);
return -EINVAL;
}
flash_ctrl->flash_state = MSM_CAMERA_FLASH_RELEASE;
flash_ctrl->power_info.dev = &flash_ctrl->pdev->dev;
flash_ctrl->flash_device_type = MSM_CAMERA_PLATFORM_DEVICE;
flash_ctrl->flash_mutex = &msm_flash_mutex;
flash_ctrl->flash_i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
flash_ctrl->flash_i2c_client.cci_client = kzalloc(
sizeof(struct msm_camera_cci_client), GFP_KERNEL);
if (!flash_ctrl->flash_i2c_client.cci_client) {
kfree(flash_ctrl);
pr_err("failed no memory\n");
return -ENOMEM;
}
cci_client = flash_ctrl->flash_i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = flash_ctrl->cci_i2c_master;
/* Initialize sub device */
v4l2_subdev_init(&flash_ctrl->msm_sd.sd, &msm_flash_subdev_ops);
v4l2_set_subdevdata(&flash_ctrl->msm_sd.sd, flash_ctrl);
flash_ctrl->msm_sd.sd.internal_ops = &msm_flash_internal_ops;
flash_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(flash_ctrl->msm_sd.sd.name,
ARRAY_SIZE(flash_ctrl->msm_sd.sd.name),
"msm_camera_flash");
media_entity_init(&flash_ctrl->msm_sd.sd.entity, 0, NULL, 0);
flash_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
flash_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_FLASH;
flash_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x1;
msm_sd_register(&flash_ctrl->msm_sd);
CDBG("%s:%d flash sd name = %s", __func__, __LINE__,
flash_ctrl->msm_sd.sd.entity.name);
msm_flash_v4l2_subdev_fops = v4l2_subdev_fops;
#ifdef CONFIG_COMPAT
msm_flash_v4l2_subdev_fops.compat_ioctl32 =
msm_flash_subdev_fops_ioctl;
#endif
flash_ctrl->msm_sd.sd.devnode->fops = &msm_flash_v4l2_subdev_fops;
if (flash_ctrl->flash_driver_type == FLASH_DRIVER_PMIC)
rc = msm_torch_create_classdev(pdev, &flash_ctrl);
CDBG("probe success\n");
return rc;
}
static int32_t msm_ois_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_ois_ctrl_t *msm_ois_t = NULL;
struct msm_ois_vreg *vreg_cfg;
CDBG_I("Enter\n");
if (!pdev->dev.of_node) {
pr_err("of_node NULL\n");
return -EINVAL;
}
msm_ois_t = kzalloc(sizeof(struct msm_ois_ctrl_t),
GFP_KERNEL);
if (!msm_ois_t) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
rc = of_property_read_u32((&pdev->dev)->of_node, "cell-index",
&pdev->id);
CDBG("cell-index %d, rc %d\n", pdev->id, rc);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
msm_ois_t->subdev_id = pdev->id;
rc = of_property_read_u32((&pdev->dev)->of_node, "qcom,cci-master",
&msm_ois_t->cci_master);
CDBG("qcom,cci-master %d, rc %d\n", msm_ois_t->cci_master, rc);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
if (of_find_property((&pdev->dev)->of_node,
"qcom,cam-vreg-name", NULL)) {
vreg_cfg = &msm_ois_t->vreg_cfg;
rc = msm_camera_get_dt_vreg_data((&pdev->dev)->of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
kfree(msm_ois_t);
pr_err("failed rc %d\n", rc);
return rc;
}
}
msm_ois_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
msm_ois_t->ois_mutex = &msm_ois_mutex;
msm_ois_t->cam_name = pdev->id;
/* Set platform device handle */
msm_ois_t->pdev = pdev;
/* Set device type as platform device */
msm_ois_t->ois_device_type = MSM_CAMERA_PLATFORM_DEVICE;
msm_ois_t->i2c_client.i2c_func_tbl = &msm_sensor_cci_func_tbl;
msm_ois_t->i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
msm_ois_t->i2c_client.cci_client = kzalloc(sizeof(
struct msm_camera_cci_client), GFP_KERNEL);
if (!msm_ois_t->i2c_client.cci_client) {
kfree(msm_ois_t->vreg_cfg.cam_vreg);
kfree(msm_ois_t);
pr_err("failed no memory\n");
return -ENOMEM;
}
cci_client = msm_ois_t->i2c_client.cci_client;
cci_client->cci_subdev = msm_cci_get_subdev();
cci_client->cci_i2c_master = MASTER_MAX;
v4l2_subdev_init(&msm_ois_t->msm_sd.sd,
msm_ois_t->ois_v4l2_subdev_ops);
v4l2_set_subdevdata(&msm_ois_t->msm_sd.sd, msm_ois_t);
msm_ois_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
msm_ois_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(msm_ois_t->msm_sd.sd.name,
ARRAY_SIZE(msm_ois_t->msm_sd.sd.name), "msm_ois");
media_entity_init(&msm_ois_t->msm_sd.sd.entity, 0, NULL, 0);
msm_ois_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
msm_ois_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
msm_ois_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0xB;
rc = msm_sd_register(&msm_ois_t->msm_sd);
//g_ois_i2c_client.cci_client = msm_ois_t->i2c_client.cci_client;
CDBG("Exit[rc::%d]\n", rc);
return rc;
}
static int32_t msm_tcs_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_tcs_ctrl_t *tcs_ctrl_t = NULL;
CDBG("Enter\n");
if (client == NULL) {
pr_err("msm_ois_i2c_probe: client is null\n");
rc = -EINVAL;
goto probe_failure;
}
tcs_ctrl_t = kzalloc(sizeof(struct msm_tcs_ctrl_t),
GFP_KERNEL);
if (!tcs_ctrl_t) {
pr_err("%s:%d failed no memory\n", __func__, __LINE__);
return -ENOMEM;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
CDBG("client = 0x%p\n", client);
rc = of_property_read_u32(client->dev.of_node, "cell-index",
&tcs_ctrl_t->subdev_id);
CDBG("cell-index %d, rc %d\n", tcs_ctrl_t->subdev_id, rc);
if (rc < 0) {
pr_err("failed rc %d\n", rc);
return rc;
}
tcs_ctrl_t->i2c_driver = &msm_tcs_i2c_driver;
tcs_ctrl_t->i2c_client.client = client;
tcs_ctrl_t->tcs_device_type = MSM_CAMERA_I2C_DEVICE;
tcs_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl;
tcs_ctrl_t->tcs_v4l2_subdev_ops = &msm_tcs_subdev_ops;
tcs_ctrl_t->tcs_mutex = &msm_tcs_mutex;
snprintf(tcs_ctrl_t->msm_sd.sd.name, sizeof(tcs_ctrl_t->msm_sd.sd.name),
"%s", tcs_ctrl_t->i2c_driver->driver.name);
v4l2_i2c_subdev_init(&tcs_ctrl_t->msm_sd.sd,
tcs_ctrl_t->i2c_client.client,
tcs_ctrl_t->tcs_v4l2_subdev_ops);
v4l2_set_subdevdata(&tcs_ctrl_t->msm_sd.sd, tcs_ctrl_t);
tcs_ctrl_t->msm_sd.sd.internal_ops = &msm_tcs_internal_ops;
tcs_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&tcs_ctrl_t->msm_sd.sd.entity, 0, NULL, 0);
tcs_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
tcs_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_TCS;
tcs_ctrl_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x2;
msm_sd_register(&tcs_ctrl_t->msm_sd);
tcs_ctrl_t->tcs_state = TCS_POWER_DOWN;
CDBG("succeeded\n");
CDBG("Exit\n");
probe_failure:
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;
}
static int32_t msm_eeprom_platform_probe(struct platform_device *pdev)
{
int32_t rc = 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__);
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);
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);
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);
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__);
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;
}
if (e_ctrl->eeprom_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_util(
&e_ctrl->i2c_client, MSM_CCI_INIT);
if (rc < 0)
pr_err("%s cci_init failed\n", __func__);
}
rc = msm_eeprom_alloc_memory_map(e_ctrl, of_node);
if (rc)
goto board_free;
/* [LGE_CHANGE_S] [email protected], 2013-05-16
* extern import eeprom read function */
global_e_ctrl = e_ctrl;
global_eb_info = eb_info;
/* [LGE_CHANGE_S] [email protected], 2013-05-16
* extern import eeprom read function */
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);
if (e_ctrl->eeprom_device_type == MSM_CAMERA_PLATFORM_DEVICE) {
rc = e_ctrl->i2c_client.i2c_func_tbl->i2c_util(
&e_ctrl->i2c_client, MSM_CCI_RELEASE);
if (rc < 0)
pr_err("%s cci_init failed\n", __func__);
}
e_ctrl->is_supported = 1;
CDBG("%s X\n", __func__);
return rc;
/* [LGE_CHANGE_S] [email protected], 2013-05-16
* extern import eeprom read function */
#if 0
memdata_free:
kfree(e_ctrl->memory_data);
kfree(eb_info->eeprom_map);
#endif
/* [LGE_CHANGE_S] [email protected], 2013-05-16
* extern import eeprom read function */
board_free:
kfree(e_ctrl->eboard_info);
cciclient_free:
kfree(e_ctrl->i2c_client.cci_client);
return rc;
}
static int msm_eeprom_platform_probe(struct platform_device *pdev)
{
int rc = 0;
int 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(*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;
e_ctrl->is_supported = 0;
if (!of_node) {
pr_err("%s dev.of_node NULL\n", __func__);
rc = -EINVAL;
goto e_ctrl_free;
}
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);
goto e_ctrl_free;
}
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);
goto e_ctrl_free;
}
rc = of_property_read_u32(of_node, "qcom,slave-addr",
&temp);
if (rc < 0) {
pr_err("%s failed rc %d\n", __func__, rc);
goto e_ctrl_free;
}
/* 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__);
rc = -ENOMEM;
goto e_ctrl_free;
}
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_parse_memory_map(of_node, "cal", &e_ctrl->cal_data);
if (rc < 0)
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, &e_ctrl->cal_data);
if (rc < 0) {
pr_err("%s read_eeprom_memory failed\n", __func__);
goto power_down;
}
for (j = 0; j < e_ctrl->cal_data.num_data; j++)
CDBG("memory_data[%d] = 0x%X\n", j,
e_ctrl->cal_data.mapdata[j]);
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) {
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 = (e_ctrl->is_supported << 1) | 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->cal_data.mapdata);
kfree(e_ctrl->cal_data.map);
board_free:
kfree(e_ctrl->eboard_info);
cciclient_free:
kfree(e_ctrl->i2c_client.cci_client);
e_ctrl_free:
kfree(e_ctrl);
return rc;
}
static int vfe_probe(struct platform_device *pdev)
{
struct vfe_device *vfe_dev;
/*struct msm_cam_subdev_info sd_info;*/
const struct of_device_id *match_dev;
int rc = 0;
struct msm_iova_partition vfe_partition = {
.start = SZ_128K,
.size = SZ_2G - SZ_128K,
};
struct msm_iova_layout vfe_layout = {
.partitions = &vfe_partition,
.npartitions = 1,
.client_name = "vfe",
.domain_flags = 0,
};
vfe_dev = kzalloc(sizeof(struct vfe_device), GFP_KERNEL);
if (!vfe_dev) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
match_dev = of_match_device(msm_vfe_dt_match, &pdev->dev);
vfe_dev->hw_info =
(struct msm_vfe_hardware_info *) match_dev->data;
} else {
vfe_dev->hw_info = (struct msm_vfe_hardware_info *)
platform_get_device_id(pdev)->driver_data;
}
if (!vfe_dev->hw_info) {
pr_err("%s: No vfe hardware info\n", __func__);
return -EINVAL;
}
ISP_DBG("%s: device id = %d\n", __func__, pdev->id);
vfe_dev->pdev = pdev;
rc = vfe_dev->hw_info->vfe_ops.core_ops.get_platform_data(vfe_dev);
if (rc < 0) {
pr_err("%s: failed to get platform resources\n", __func__);
kfree(vfe_dev);
return -ENOMEM;
}
INIT_LIST_HEAD(&vfe_dev->tasklet_q);
tasklet_init(&vfe_dev->vfe_tasklet,
msm_isp_do_tasklet, (unsigned long)vfe_dev);
v4l2_subdev_init(&vfe_dev->subdev.sd, vfe_dev->hw_info->subdev_ops);
vfe_dev->subdev.sd.internal_ops =
vfe_dev->hw_info->subdev_internal_ops;
snprintf(vfe_dev->subdev.sd.name,
ARRAY_SIZE(vfe_dev->subdev.sd.name),
"vfe");
vfe_dev->subdev.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
vfe_dev->subdev.sd.flags |= V4L2_SUBDEV_FL_HAS_EVENTS;
v4l2_set_subdevdata(&vfe_dev->subdev.sd, vfe_dev);
platform_set_drvdata(pdev, &vfe_dev->subdev.sd);
mutex_init(&vfe_dev->realtime_mutex);
mutex_init(&vfe_dev->core_mutex);
spin_lock_init(&vfe_dev->tasklet_lock);
spin_lock_init(&vfe_dev->shared_data_lock);
media_entity_init(&vfe_dev->subdev.sd.entity, 0, NULL, 0);
vfe_dev->subdev.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
vfe_dev->subdev.sd.entity.group_id = MSM_CAMERA_SUBDEV_VFE;
vfe_dev->subdev.sd.entity.name = pdev->name;
vfe_dev->subdev.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x2;
rc = msm_sd_register(&vfe_dev->subdev);
if (rc != 0) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
kfree(vfe_dev);
goto end;
}
msm_isp_v4l2_subdev_fops.owner = v4l2_subdev_fops.owner;
msm_isp_v4l2_subdev_fops.open = v4l2_subdev_fops.open;
msm_isp_v4l2_subdev_fops.release = v4l2_subdev_fops.release;
msm_isp_v4l2_subdev_fops.poll = v4l2_subdev_fops.poll;
vfe_dev->subdev.sd.devnode->fops = &msm_isp_v4l2_subdev_fops;
vfe_dev->buf_mgr = &vfe_buf_mgr;
v4l2_subdev_notify(&vfe_dev->subdev.sd,
MSM_SD_NOTIFY_REQ_CB, &vfe_vb2_ops);
rc = msm_isp_create_isp_buf_mgr(vfe_dev->buf_mgr,
&vfe_vb2_ops, &vfe_layout);
if (rc < 0) {
pr_err("%s: Unable to create buffer manager\n", __func__);
kfree(vfe_dev);
return -EINVAL;
}
vfe_dev->buf_mgr->ops->register_ctx(vfe_dev->buf_mgr,
&vfe_dev->iommu_ctx[0], vfe_dev->hw_info->num_iommu_ctx);
vfe_dev->vfe_open_cnt = 0;
end:
return rc;
}
static struct platform_driver vfe_driver = {
.probe = vfe_probe,
.driver = {
.name = "msm_vfe",
.owner = THIS_MODULE,
.of_match_table = msm_vfe_dt_match,
},
.id_table = msm_vfe_dev_id,
};
static int __init msm_vfe_init_module(void)
{
return platform_driver_register(&vfe_driver);
}
static void __exit msm_vfe_exit_module(void)
{
platform_driver_unregister(&vfe_driver);
}
static int ispif_probe(struct platform_device *pdev)
{
int rc;
struct ispif_device *ispif;
ispif = kzalloc(sizeof(struct ispif_device), GFP_KERNEL);
if (!ispif) {
pr_err("%s: no enough memory\n", __func__);
return -ENOMEM;
}
if (pdev->dev.of_node) {
of_property_read_u32((&pdev->dev)->of_node,
"cell-index", &pdev->id);
rc = of_property_read_u32((&pdev->dev)->of_node,
"qcom,num-isps", &ispif->hw_num_isps);
if (rc)
/* backward compatibility */
ispif->hw_num_isps = 1;
/* not an error condition */
rc = 0;
}
rc = msm_ispif_get_clk_info(ispif, pdev,
ispif_ahb_clk_info, ispif_clk_info);
if (rc < 0) {
pr_err("%s: msm_isp_get_clk_info() failed", __func__);
return -EFAULT;
}
mutex_init(&ispif->mutex);
ispif->mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "ispif");
if (!ispif->mem) {
pr_err("%s: no mem resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->irq = platform_get_resource_byname(pdev,
IORESOURCE_IRQ, "ispif");
if (!ispif->irq) {
pr_err("%s: no irq resource?\n", __func__);
rc = -ENODEV;
goto error;
}
ispif->io = request_mem_region(ispif->mem->start,
resource_size(ispif->mem), pdev->name);
if (!ispif->io) {
pr_err("%s: no valid mem region\n", __func__);
rc = -EBUSY;
goto error;
}
ispif->clk_mux_mem = platform_get_resource_byname(pdev,
IORESOURCE_MEM, "csi_clk_mux");
if (ispif->clk_mux_mem) {
ispif->clk_mux_io = request_mem_region(
ispif->clk_mux_mem->start,
resource_size(ispif->clk_mux_mem),
ispif->clk_mux_mem->name);
if (!ispif->clk_mux_io)
pr_err("%s: no valid csi_mux region\n", __func__);
}
v4l2_subdev_init(&ispif->msm_sd.sd, &msm_ispif_subdev_ops);
ispif->msm_sd.sd.internal_ops = &msm_ispif_internal_ops;
ispif->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
snprintf(ispif->msm_sd.sd.name,
ARRAY_SIZE(ispif->msm_sd.sd.name), MSM_ISPIF_DRV_NAME);
v4l2_set_subdevdata(&ispif->msm_sd.sd, ispif);
platform_set_drvdata(pdev, &ispif->msm_sd.sd);
media_entity_init(&ispif->msm_sd.sd.entity, 0, NULL, 0);
ispif->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ispif->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_ISPIF;
ispif->msm_sd.sd.entity.name = pdev->name;
ispif->msm_sd.close_seq = MSM_SD_CLOSE_1ST_CATEGORY | 0x1;
rc = msm_sd_register(&ispif->msm_sd);
if (rc) {
pr_err("%s: msm_sd_register error = %d\n", __func__, rc);
goto error;
}
msm_ispif_v4l2_subdev_fops.owner = v4l2_subdev_fops.owner;
msm_ispif_v4l2_subdev_fops.open = v4l2_subdev_fops.open;
msm_ispif_v4l2_subdev_fops.unlocked_ioctl = msm_ispif_subdev_fops_ioctl;
msm_ispif_v4l2_subdev_fops.release = v4l2_subdev_fops.release;
msm_ispif_v4l2_subdev_fops.poll = v4l2_subdev_fops.poll;
#ifdef CONFIG_COMPAT
msm_ispif_v4l2_subdev_fops.compat_ioctl32 = msm_ispif_subdev_fops_ioctl;
#endif
ispif->msm_sd.sd.devnode->fops = &msm_ispif_v4l2_subdev_fops;
ispif->pdev = pdev;
ispif->ispif_state = ISPIF_POWER_DOWN;
ispif->open_cnt = 0;
return 0;
error:
mutex_destroy(&ispif->mutex);
kfree(ispif);
return rc;
}
/* static function definition */
int32_t msm_sensor_driver_probe(void *setting)
{
int32_t rc = 0;
int32_t is_power_off = 0;
uint16_t i = 0, size = 0, off_size = 0;
uint32_t session_id = 0;
struct msm_sensor_ctrl_t *s_ctrl = NULL;
struct msm_camera_cci_client *cci_client = NULL;
struct msm_camera_sensor_slave_info *slave_info = NULL;
struct msm_sensor_power_setting *power_setting = NULL;
struct msm_sensor_power_setting *power_off_setting = NULL;
struct msm_camera_slave_info *camera_info = NULL;
struct msm_camera_power_ctrl_t *power_info = NULL;
/* Validate input parameters */
if (!setting) {
pr_err("failed: slave_info %p", setting);
return -EINVAL;
}
/* Allocate memory for slave info */
slave_info = kzalloc(sizeof(*slave_info), GFP_KERNEL);
if (!slave_info) {
pr_err("failed: no memory slave_info %p", slave_info);
return -ENOMEM;
}
if (copy_from_user(slave_info, (void *)setting, sizeof(*slave_info))) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto FREE_SLAVE_INFO;
}
/* Print slave info */
pr_err("camera id %d", slave_info->camera_id);
pr_err("slave_addr %x", slave_info->slave_addr);
CDBG("addr_type %d", slave_info->addr_type);
CDBG("sensor_id_reg_addr %x",
slave_info->sensor_id_info.sensor_id_reg_addr);
CDBG("sensor_id %x", slave_info->sensor_id_info.sensor_id);
CDBG("size %x", slave_info->power_setting_array.size);
/* Validate camera id */
if (slave_info->camera_id >= MAX_CAMERAS) {
pr_err("failed: invalid camera id %d max %d",
slave_info->camera_id, MAX_CAMERAS);
rc = -EINVAL;
goto FREE_SLAVE_INFO;
}
/* Extract s_ctrl from camera id */
s_ctrl = g_sctrl[slave_info->camera_id];
if (!s_ctrl) {
pr_err("failed: s_ctrl %p for camera_id %d", s_ctrl,
slave_info->camera_id);
rc = -EINVAL;
goto FREE_SLAVE_INFO;
}
#if defined (CONFIG_SEC_MILLET_PROJECT) || defined(CONFIG_SEC_MATISSE_PROJECT) \
|| defined(CONFIG_SEC_DEGAS_PROJECT) || defined (CONFIG_SEC_T8_PROJECT) \
|| defined (CONFIG_SEC_T10_PROJECT) \
|| defined (CONFIG_MACH_VICTOR3GDSDTV_LTN) \
|| defined (CONFIG_SEC_RUBENS_PROJECT)
if(slave_info->camera_id == CAMERA_2) {
#if defined(CONFIG_SR130PC20)
s_ctrl->func_tbl = &sr130pc20_sensor_func_tbl ;
sr130pc20_set_default_settings();
#endif
} else if (slave_info->camera_id == CAMERA_0) {
#if defined(CONFIG_SR352)
s_ctrl->func_tbl = &sr352_sensor_func_tbl ;
sr352_set_default_settings();
#endif
#if defined(CONFIG_SR200PC20)
s_ctrl->func_tbl = &sr200pc20_sensor_func_tbl ;
sr200pc20_set_default_settings();
#endif
}
#elif defined(CONFIG_MACH_AFYONLTE_TMO) || defined(CONFIG_MACH_AFYONLTE_CAN) \
|| defined (CONFIG_MACH_AFYONLTE_MTR)
if(slave_info->camera_id == CAMERA_2) {
#if defined(CONFIG_S5K4ECGX)
s_ctrl->func_tbl = &sr030pc50_sensor_func_tbl;
#endif
} else if (slave_info->camera_id == CAMERA_0) {
#if defined(CONFIG_SR030PC50)
s_ctrl->func_tbl = &s5k4ecgx_sensor_func_tbl;
#endif
}
#elif defined(CONFIG_MACH_CRATERQ_CHN_OPEN)
if(slave_info->camera_id == CAMERA_2) {
s_ctrl->func_tbl = &sr200pc20_sensor_func_tbl ;
}
#elif defined(CONFIG_MACH_VICTORLTE_CTC)
if (slave_info->camera_id == CAMERA_0) {
s_ctrl->func_tbl = &s5k4ecgx_sensor_func_tbl;
}
#endif
CDBG("s_ctrl[%d] %p", slave_info->camera_id, s_ctrl);
if (s_ctrl->is_probe_succeed == 1) {
/*
* Different sensor on this camera slot has been connected
* and probe already succeeded for that sensor. Ignore this
* probe
*/
pr_err("slot %d has some other sensor", slave_info->camera_id);
kfree(slave_info);
return 0;
}
size = slave_info->power_setting_array.size;
/* Allocate memory for power setting */
power_setting = kzalloc(sizeof(*power_setting) * size, GFP_KERNEL);
if (!power_setting) {
pr_err("failed: no memory power_setting %p", power_setting);
rc = -ENOMEM;
goto FREE_SLAVE_INFO;
}
if (copy_from_user(power_setting,
(void *)slave_info->power_setting_array.power_setting,
sizeof(*power_setting) * size)) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto FREE_POWER_SETTING;
}
/* Print power setting */
for (i = 0; i < size; i++) {
CDBG("seq_type %d seq_val %d config_val %ld delay %d",
power_setting[i].seq_type, power_setting[i].seq_val,
power_setting[i].config_val, power_setting[i].delay);
}
off_size = slave_info->power_setting_array.off_size;
if (off_size > 0) {
/* Allocate memory for power setting */
power_off_setting = kzalloc(sizeof(*power_off_setting) * off_size, GFP_KERNEL);
if (!power_off_setting) {
pr_err("failed: no memory power_setting %p", power_off_setting);
rc = -ENOMEM;
goto FREE_POWER_SETTING;
}
if (copy_from_user(power_off_setting,
(void *)slave_info->power_setting_array.power_off_setting,
sizeof(*power_off_setting) * off_size)) {
pr_err("failed: copy_from_user");
rc = -EFAULT;
goto FREE_POWER_OFF_SETTING;
}
/* Print power setting */
for (i = 0; i < off_size; i++) {
CDBG("seq_type %d seq_val %d config_val %ld delay %d",
power_off_setting[i].seq_type, power_off_setting[i].seq_val,
power_off_setting[i].config_val, power_off_setting[i].delay);
}
is_power_off = 1;
}
camera_info = kzalloc(sizeof(struct msm_camera_slave_info), GFP_KERNEL);
if (!camera_info) {
pr_err("failed: no memory slave_info %p", camera_info);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
/* Fill power up setting and power up setting size */
power_info = &s_ctrl->sensordata->power_info;
power_info->power_setting = power_setting;
power_info->power_setting_size = size;
power_info->power_off_setting = power_off_setting;
power_info->power_off_setting_size = off_size;
s_ctrl->sensordata->slave_info = camera_info;
/* Fill sensor slave info */
camera_info->sensor_slave_addr = slave_info->slave_addr;
camera_info->sensor_id_reg_addr =
slave_info->sensor_id_info.sensor_id_reg_addr;
camera_info->sensor_id = slave_info->sensor_id_info.sensor_id;
pr_err(" %s line %d camera_info->sensor_id = 0x%X = 0x%X\n",
__func__, __LINE__, camera_info->sensor_id, s_ctrl->sensordata->slave_info->sensor_id);
/* Fill CCI master, slave address and CCI default params */
if (!s_ctrl->sensor_i2c_client) {
pr_err("failed: sensor_i2c_client %p",
s_ctrl->sensor_i2c_client);
rc = -EINVAL;
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
/* Fill sensor address type */
s_ctrl->sensor_i2c_client->addr_type = slave_info->addr_type;
s_ctrl->sensor_i2c_client->data_type = slave_info->data_type;
cci_client = s_ctrl->sensor_i2c_client->cci_client;
if (!cci_client) {
pr_err("failed: cci_client %p", cci_client);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
cci_client->cci_i2c_master = s_ctrl->cci_i2c_master;
cci_client->sid = slave_info->slave_addr >> 1;
cci_client->retries = 3;
cci_client->id_map = 0;
/* Parse and fill vreg params */
rc = msm_camera_fill_vreg_params(
power_info->cam_vreg,
power_info->num_vreg,
power_info->power_setting,
power_info->power_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_power_setting_data rc %d",
rc);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
#if !defined (CONFIG_SEC_MILLET_PROJECT) && !defined (CONFIG_SEC_MATISSE_PROJECT) \
&& !defined(CONFIG_MACH_AFYONLTE_TMO) && !defined(CONFIG_MACH_AFYONLTE_CAN) && !defined (CONFIG_MACH_VICTORLTE_CTC) \
&& !defined(CONFIG_SEC_DEGAS_PROJECT) && !defined (CONFIG_SEC_T8_PROJECT) \
&& !defined (CONFIG_SEC_T10_PROJECT) && !defined (CONFIG_MACH_VICTOR3GDSDTV_LTN) \
&& !defined (CONFIG_MACH_AFYONLTE_MTR) \
&& !defined (CONFIG_SEC_RUBENS_PROJECT) //Commenting for Millet, Matisse
if (power_info->power_off_setting && (power_info->power_off_setting_size > 0)) {
/* Parse and fill vreg params */
rc = msm_camera_fill_vreg_params(
power_info->cam_vreg,
power_info->num_vreg,
power_info->power_off_setting,
power_info->power_off_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_power_setting_data rc %d",
rc);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
}
#endif
/* remove this code for DFMS test for MS01 */
#if defined(CONFIG_MACH_ULC83G_EUR) || defined (CONFIG_SEC_MILLET_PROJECT) \
|| defined(CONFIG_SEC_MATISSE_PROJECT)|| defined(CONFIG_MACH_CRATERQ_CHN_OPEN) \
|| defined(CONFIG_MACH_AFYONLTE_TMO) || defined(CONFIG_MACH_AFYONLTE_CAN) \
|| defined (CONFIG_MACH_VICTORLTE_CTC) || defined(CONFIG_SEC_DEGAS_PROJECT) \
|| defined (CONFIG_SEC_T8_PROJECT) || defined (CONFIG_SEC_T10_PROJECT) \
|| defined (CONFIG_MACH_AFYONLTE_MTR) \
|| defined (CONFIG_SEC_RUBENS_PROJECT) // Added for YUV bringup
/* Power up and probe sensor */
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl,
&s_ctrl->sensordata->power_info,
s_ctrl->sensor_i2c_client,
s_ctrl->sensordata->slave_info,
slave_info->sensor_name);
if (rc < 0) {
pr_err("%s power up failed", slave_info->sensor_name);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
#endif
#if defined (CONFIG_MACH_VICTOR3GDSDTV_LTN)
if(slave_info->camera_id == CAMERA_2) {
/* Power up and probe sensor */
rc = s_ctrl->func_tbl->sensor_power_up(s_ctrl,
&s_ctrl->sensordata->power_info,
s_ctrl->sensor_i2c_client,
s_ctrl->sensordata->slave_info,
slave_info->sensor_name);
if (rc < 0) {
pr_err("%s power up failed", slave_info->sensor_name);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
} else {
if (power_info->power_off_setting && (power_info->power_off_setting_size > 0)) {
/* Parse and fill vreg params */
rc = msm_camera_fill_vreg_params(
power_info->cam_vreg,
power_info->num_vreg,
power_info->power_off_setting,
power_info->power_off_setting_size);
if (rc < 0) {
pr_err("failed: msm_camera_get_dt_power_setting_data rc %d",
rc);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
}
}
#endif
/* Update sensor name in sensor control structure */
s_ctrl->sensordata->sensor_name = slave_info->sensor_name;
/*
Set probe succeeded flag to 1 so that no other camera shall
* probed on this slot
*/
s_ctrl->is_probe_succeed = 1;
/*
* Create /dev/videoX node, comment for now until dummy /dev/videoX
* node is created and used by HAL
*/
rc = camera_init_v4l2(&s_ctrl->pdev->dev, &session_id);
if (rc < 0) {
pr_err("failed: camera_init_v4l2 rc %d", rc);
if (is_power_off)
goto FREE_POWER_OFF_SETTING;
else
goto FREE_POWER_SETTING;
}
s_ctrl->sensordata->sensor_info->session_id = session_id;
/* Create /dev/v4l-subdevX device */
v4l2_subdev_init(&s_ctrl->msm_sd.sd, s_ctrl->sensor_v4l2_subdev_ops);
snprintf(s_ctrl->msm_sd.sd.name, sizeof(s_ctrl->msm_sd.sd.name), "%s",
s_ctrl->sensordata->sensor_name);
v4l2_set_subdevdata(&s_ctrl->msm_sd.sd, s_ctrl->pdev);
s_ctrl->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->msm_sd.sd.entity, 0, NULL, 0);
s_ctrl->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_SENSOR;
s_ctrl->msm_sd.sd.entity.name = s_ctrl->msm_sd.sd.name;
pr_err("%s: name : %s, type = %d group_id = %d\n", __func__, s_ctrl->msm_sd.sd.entity.name, s_ctrl->msm_sd.sd.entity.type, s_ctrl->msm_sd.sd.entity.group_id);
s_ctrl->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0x3;
pr_err("FAILED- 3: %d\n", msm_sd_register(&s_ctrl->msm_sd));
memcpy(slave_info->subdev_name, s_ctrl->msm_sd.sd.entity.name,
sizeof(slave_info->subdev_name));
slave_info->is_probe_succeed = 1;
slave_info->sensor_info.session_id =
s_ctrl->sensordata->sensor_info->session_id;
for (i = 0; i < SUB_MODULE_MAX; i++)
slave_info->sensor_info.subdev_id[i] =
s_ctrl->sensordata->sensor_info->subdev_id[i];
slave_info->sensor_info.is_mount_angle_valid =
s_ctrl->sensordata->sensor_info->is_mount_angle_valid;
slave_info->sensor_info.sensor_mount_angle =
s_ctrl->sensordata->sensor_info->sensor_mount_angle;
CDBG("%s:%d sensor name %s\n", __func__, __LINE__,
slave_info->sensor_info.sensor_name);
CDBG("%s:%d session id %d\n", __func__, __LINE__,
slave_info->sensor_info.session_id);
for (i = 0; i < SUB_MODULE_MAX; i++)
CDBG("%s:%d subdev_id[%d] %d\n", __func__, __LINE__, i,
slave_info->sensor_info.subdev_id[i]);
CDBG("%s:%d mount angle valid %d value %d\n", __func__,
__LINE__, slave_info->sensor_info.is_mount_angle_valid,
slave_info->sensor_info.sensor_mount_angle);
if (copy_to_user((void __user *)setting,
(void *)slave_info, sizeof(*slave_info))) {
pr_err("%s:%d copy failed\n", __func__, __LINE__);
rc = -EFAULT;
}
pr_warn("rc %d session_id %d", rc, session_id);
pr_warn("%s probe succeeded", slave_info->sensor_name);
/* remove this code for DFMS test for MS01*/
#if defined(CONFIG_MACH_ULC83G_EUR) || defined (CONFIG_SEC_MILLET_PROJECT) \
|| defined(CONFIG_SEC_MATISSE_PROJECT) || defined(CONFIG_MACH_CRATERQ_CHN_OPEN) \
|| defined(CONFIG_MACH_AFYONLTE_TMO) || defined(CONFIG_MACH_AFYONLTE_CAN) \
|| defined(CONFIG_MACH_VICTORLTE_CTC) || defined(CONFIG_SEC_DEGAS_PROJECT) \
|| defined (CONFIG_SEC_T8_PROJECT) || defined (CONFIG_SEC_T10_PROJECT) \
|| defined (CONFIG_MACH_AFYONLTE_MTR) \
|| defined (CONFIG_SEC_RUBENS_PROJECT) // Added for YUV bringup ToDo
/* Power down */
s_ctrl->func_tbl->sensor_power_down(
s_ctrl,
&s_ctrl->sensordata->power_info,
s_ctrl->sensor_device_type,
s_ctrl->sensor_i2c_client);
#elif defined (CONFIG_MACH_VICTOR3GDSDTV_LTN)
if(slave_info->camera_id == CAMERA_2) {
/* Power down */
s_ctrl->func_tbl->sensor_power_down(
s_ctrl,
&s_ctrl->sensordata->power_info,
s_ctrl->sensor_device_type,
s_ctrl->sensor_i2c_client);
}
#endif
return rc;
FREE_POWER_OFF_SETTING:
kfree(power_off_setting);
FREE_POWER_SETTING:
kfree(power_setting);
FREE_SLAVE_INFO:
kfree(slave_info);
return rc;
}
static int32_t msm_ois_i2c_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
int rc = 0;
struct msm_ois_ctrl_t *ois_ctrl_t = NULL;
struct msm_ois_vreg *vreg_cfg;
bool check_use_gpios;
CDBG_I("Enter\n");
if (client == NULL) {
pr_err("msm_ois_i2c_probe: client is null\n");
rc = -EINVAL;
goto probe_failure;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
if (!client->dev.of_node) {
ois_ctrl_t = (struct msm_ois_ctrl_t *)(id->driver_data);
} else {
ois_ctrl_t = kzalloc(sizeof(struct msm_ois_ctrl_t),
GFP_KERNEL);
if (!ois_ctrl_t) {
pr_err("%s:%d no memory\n", __func__, __LINE__);
return -ENOMEM;
}
if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
pr_err("i2c_check_functionality failed\n");
goto probe_failure;
}
CDBG("client = 0x%p\n", client);
rc = of_property_read_u32(client->dev.of_node, "cell-index",
&ois_ctrl_t->subdev_id);
CDBG("cell-index %d, rc %d\n", ois_ctrl_t->subdev_id, rc);
ois_ctrl_t->cam_name = ois_ctrl_t->subdev_id;
if (rc < 0) {
pr_err("failed rc %d\n", rc);
kfree(ois_ctrl_t);//prevent
return rc;
}
check_use_gpios = of_property_read_bool(client->dev.of_node, "unuse-gpios");
CDBG("%s: check unuse-gpio flag(%d)\n",
__FUNCTION__, check_use_gpios);
if (!check_use_gpios) {
rc = msm_ois_get_gpio_data(ois_ctrl_t,
client->dev.of_node);
}
}
if (of_find_property(client->dev.of_node,
"qcom,cam-vreg-name", NULL)) {
vreg_cfg = &ois_ctrl_t->vreg_cfg;
rc = msm_camera_get_dt_vreg_data(client->dev.of_node,
&vreg_cfg->cam_vreg, &vreg_cfg->num_vreg);
if (rc < 0) {
kfree(ois_ctrl_t);
pr_err("failed rc %d\n", rc);
return rc;
}
}
ois_ctrl_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
ois_ctrl_t->ois_mutex = &msm_ois_mutex;
ois_ctrl_t->i2c_driver = &msm_ois_i2c_driver;
CDBG("client = %x\n", (unsigned int) client);
ois_ctrl_t->i2c_client.client = client;
ois_ctrl_t->i2c_client.addr_type = MSM_CAMERA_I2C_WORD_ADDR;
/* Set device type as I2C */
ois_ctrl_t->ois_device_type = MSM_CAMERA_I2C_DEVICE;
ois_ctrl_t->i2c_client.i2c_func_tbl = &msm_sensor_qup_func_tbl;
ois_ctrl_t->ois_v4l2_subdev_ops = &msm_ois_subdev_ops;
ois_ctrl_t->ois_mutex = &msm_ois_mutex;
ois_ctrl_t->cam_name = ois_ctrl_t->subdev_id;
CDBG("ois_ctrl_t->cam_name: %d", ois_ctrl_t->cam_name);
/* Assign name for sub device */
snprintf(ois_ctrl_t->msm_sd.sd.name, sizeof(ois_ctrl_t->msm_sd.sd.name),
"%s", ois_ctrl_t->i2c_driver->driver.name);
/* Initialize sub device */
v4l2_i2c_subdev_init(&ois_ctrl_t->msm_sd.sd,
ois_ctrl_t->i2c_client.client,
ois_ctrl_t->ois_v4l2_subdev_ops);
v4l2_set_subdevdata(&ois_ctrl_t->msm_sd.sd, ois_ctrl_t);
ois_ctrl_t->msm_sd.sd.internal_ops = &msm_ois_internal_ops;
ois_ctrl_t->msm_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&ois_ctrl_t->msm_sd.sd.entity, 0, NULL, 0);
ois_ctrl_t->msm_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
ois_ctrl_t->msm_sd.sd.entity.group_id = MSM_CAMERA_SUBDEV_OIS;
ois_ctrl_t->msm_sd.close_seq = MSM_SD_CLOSE_2ND_CATEGORY | 0xB;
msm_sd_register(&ois_ctrl_t->msm_sd);
//g_ois_i2c_client.client = ois_ctrl_t->i2c_client.client;
CDBG("Succeded Exit\n");
return rc;
probe_failure:
if (ois_ctrl_t)
kfree(ois_ctrl_t);
return rc;
}
