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_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 int32_t msm_led_cci_probe(struct platform_device *pdev) { int32_t rc = 0; struct device_node *of_node = pdev->dev.of_node; CDBG("called\n"); if (!of_node) { pr_err("of_node NULL\n"); return -EINVAL; } fctrl.pdev = pdev; rc = of_property_read_u32(of_node, "cell-index", &pdev->id); if (rc < 0) { pr_err("failed\n"); return -EINVAL; } CDBG("pdev id %d\n", pdev->id); fctrl.flash_i2c_client = kzalloc(sizeof( struct msm_camera_i2c_client), GFP_KERNEL); if (!fctrl.flash_i2c_client) { pr_err("failed no memory\n"); return -ENOMEM; } fctrl.flash_i2c_client->cci_client = kzalloc(sizeof( struct msm_camera_cci_client), GFP_KERNEL); if (!fctrl.flash_i2c_client->cci_client) { pr_err("failed no memory\n"); return -ENOMEM; } fctrl.flash_i2c_client->cci_client->cci_subdev = msm_cci_get_subdev(); fctrl.flash_i2c_client->cci_client->retries = 2; fctrl.flash_i2c_client->cci_client->id_map = 0; fctrl.flash_i2c_client->i2c_func_tbl = &msm_led_cci_i2c_func_tbl; fctrl.flash_i2c_client->addr_type = MSM_CAMERA_I2C_BYTE_ADDR; rc = msm_led_cci_query_ic(&fctrl, of_node); if (rc < 0) { pr_err("can not find matched flash IC\n"); return -ENODEV; } if (!strcmp(fctrl.led_info->name, "adp1660")) { fctrl.reg_setting = &adp1660_regs; } else { pr_err("can't find a known chip\n"); return -ENODEV; } pr_err("find a device"); rc = msm_led_cci_create_v4lsubdev(pdev, &fctrl); if (rc >= 0) rc = sysfs_create_group(&pdev->dev.kobj, &msm_led_cci_attr_group); 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; }
int msm_flash_probe(struct platform_device *pdev, const void *data) { int rc = 0; struct msm_led_flash_ctrl_t *fctrl = (struct msm_led_flash_ctrl_t *)data; struct device_node *of_node = pdev->dev.of_node; struct msm_camera_cci_client *cci_client = NULL; if (!of_node) { pr_err("of_node NULL\n"); goto probe_failure; } fctrl->pdev = pdev; rc = msm_led_get_dt_data(pdev->dev.of_node, fctrl); if (rc < 0) { pr_err("%s failed line %d rc = %d\n", __func__, __LINE__, rc); return rc; } /* Assign name for sub device */ snprintf(fctrl->msm_sd.sd.name, sizeof(fctrl->msm_sd.sd.name), "%s", fctrl->flashdata->sensor_name); /* Set device type as Platform*/ fctrl->flash_device_type = MSM_CAMERA_PLATFORM_DEVICE; if (NULL == fctrl->flash_i2c_client) { pr_err("%s flash_i2c_client NULL\n", __func__); rc = -EFAULT; goto probe_failure; } fctrl->flash_i2c_client->cci_client = kzalloc(sizeof( struct msm_camera_cci_client), GFP_KERNEL); if (!fctrl->flash_i2c_client->cci_client) { pr_err("%s failed line %d kzalloc failed\n", __func__, __LINE__); return rc; } cci_client = fctrl->flash_i2c_client->cci_client; cci_client->cci_subdev = msm_cci_get_subdev(); cci_client->cci_i2c_master = fctrl->cci_i2c_master; if (fctrl->flashdata->slave_info->sensor_slave_addr) cci_client->sid = fctrl->flashdata->slave_info->sensor_slave_addr >> 1; cci_client->retries = 3; cci_client->id_map = 0; if (!fctrl->flash_i2c_client->i2c_func_tbl) fctrl->flash_i2c_client->i2c_func_tbl = &msm_sensor_cci_func_tbl; rc = msm_led_flash_create_v4lsubdev(pdev, fctrl); CDBG("%s: probe success\n", __func__); return 0; probe_failure: CDBG("%s probe failed\n", __func__); return rc; }
int32_t msm_led_cci_trigger_probe(struct platform_device *pdev) { struct device_node *of_node = pdev->dev.of_node; struct msm_led_flash_ctrl_t *pfctrl = &fctrl_t; struct msm_camera_cci_client *cci_client = NULL; int32_t rc = 0; if (!of_node) { pr_err("%s: of_node NULL\n", __func__); return -EINVAL; } pfctrl->pdev = pdev; rc = msm_led_trigger_get_dt_data(of_node, pfctrl); if (rc < 0) { pr_err("%s: failed line %d\n", __func__, __LINE__); return rc; } pfctrl->flash_i2c_client->i2c_func_tbl = &msm_led_trigger_cci_func_tbl; pfctrl->flash_i2c_client->cci_client = kzalloc(sizeof(struct msm_camera_cci_client), GFP_KERNEL); if (!pfctrl->flash_i2c_client->cci_client) { pr_err("%s: failed line %d\n", __func__, __LINE__); return rc; } cci_client = pfctrl->flash_i2c_client->cci_client; cci_client->cci_subdev = msm_cci_get_subdev(); cci_client->cci_i2c_master = pfctrl->cci_i2c_master; cci_client->sid = pfctrl->board_info.slave_info->flash_slave_addr >> 1; cci_client->retries = 3; cci_client->id_map = 0; rc = msm_led_flash_create_v4lsubdev(pdev, pfctrl); if (rc < 0) { pr_err("%s: failed line %d\n", __func__, __LINE__); goto msm_led_trigger_probe_failed; } #if defined(CONFIG_MSM_CAMERA_EMODE) (void)msm_led_trigger_register_sysdev(pfctrl); #endif /* CONFIG_MSM_CAMERA_EMODE */ pr_info("%s %s probe succeeded\n", __func__, pfctrl->board_info.flash_name); return 0; msm_led_trigger_probe_failed: if (!cci_client) { kfree(cci_client); cci_client = NULL; } 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; 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 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 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 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; }
int msm_flash_probe(struct platform_device *pdev, const void *data) { int rc = 0; struct msm_led_flash_ctrl_t *fctrl = (struct msm_led_flash_ctrl_t *)data; struct device_node *of_node = pdev->dev.of_node; struct msm_camera_cci_client *cci_client = NULL; #ifdef CONFIG_DEBUG_FS struct dentry *dentry; #endif if (!of_node) { pr_err("of_node NULL\n"); goto probe_failure; } fctrl->pdev = pdev; /* Set device type as Platform*/ fctrl->flash_device_type = MSM_CAMERA_PLATFORM_DEVICE; rc = msm_led_get_dt_data(pdev->dev.of_node, fctrl); if (rc < 0) { pr_err("%s failed line %d\n", __func__, __LINE__); return rc; } /* Assign name for sub device */ snprintf(fctrl->msm_sd.sd.name, sizeof(fctrl->msm_sd.sd.name), "%s", fctrl->flashdata->sensor_name); if (NULL == fctrl->flash_i2c_client) { pr_err("%s flash_i2c_client NULL\n", __func__); rc = -EFAULT; } fctrl->flash_i2c_client->cci_client = kzalloc(sizeof( struct msm_camera_cci_client), GFP_KERNEL); if (!fctrl->flash_i2c_client->cci_client) { pr_err("%s failed line %d\n", __func__, __LINE__); return rc; } cci_client = fctrl->flash_i2c_client->cci_client; cci_client->cci_subdev = msm_cci_get_subdev(); cci_client->cci_i2c_master = fctrl->cci_i2c_master; if (fctrl->flashdata->slave_info->sensor_slave_addr) cci_client->sid = fctrl->flashdata->slave_info->sensor_slave_addr >> 1; cci_client->retries = 3; cci_client->id_map = 0; if (!fctrl->flash_i2c_client->i2c_func_tbl) fctrl->flash_i2c_client->i2c_func_tbl = &msm_sensor_cci_func_tbl; rc = msm_led_flash_create_v4lsubdev(pdev, fctrl); #ifdef CONFIG_DEBUG_FS dentry = debugfs_create_file("ledflash", S_IRUGO, NULL, (void *)fctrl, &ledflashdbg_fops); if (!dentry) pr_err("Failed to create the debugfs ledflash file"); #endif CDBG("%s:%d probe success\n", __func__, __LINE__); return 0; probe_failure: CDBG("%s:%d probe failed\n", __func__, __LINE__); return rc; }