static int s5k5bbgx_set_preview_stop(struct v4l2_subdev *sd) { int err = 0; cam_info("do nothing.\n"); return err; }
static int s5k5bbgx_set_capture_start(struct v4l2_subdev *sd) { struct s5k5bbgx_state *state = to_state(sd); int err = -EINVAL; u16 val = 1, retry = 0; /* set initial regster value */ #ifdef CONFIG_LOAD_FILE err = s5k5bbgx_write_regs_from_sd(sd, "s5k5bbgx_capture"); #else err = s5k5bbgx_write_regs(sd, s5k5bbgx_capture, sizeof(s5k5bbgx_capture) / sizeof(s5k5bbgx_capture[0])); #endif if (unlikely(err)) { cam_err("failed to make capture\n"); return err; } s5k5bbgx_get_exif(sd); cam_info("Capture ConfigSync\n"); do { msleep(20); err = s5k5bbgx_read_reg(sd, REG_PAGE_CAPTURE_STATUS, REG_ADDR_CAPTURE_STATUS, &val); CHECK_ERR(err); cam_dbg("val = %d\n", val); if (val == 0) break; retry++; } while (retry <= S5K5BBGX_READ_STATUS_RETRIES); return err; }
static ssize_t altel6045_firmware_show(struct device_driver *drv, char *buf) { strncpy(buf, misp_firmware_path, strlen(misp_firmware_path)+1); cam_info("%s extisp_firmware(%s),count(%u)", __func__, misp_firmware_path,strlen(misp_firmware_path)); return (strlen(misp_firmware_path)); }
int hw_vcm_get_dt_data(struct platform_device *pdev, vcm_t *vcm) { struct device_node *of_node = pdev->dev.of_node; struct hw_vcm_info *vcm_info = NULL; int rc = 0; vcm_info = kzalloc(sizeof(struct hw_vcm_info), GFP_KERNEL); if (!vcm_info) { cam_err("%s failed %d\n", __func__, __LINE__); return -ENOMEM; } vcm->vcm_info = vcm_info; rc = of_property_read_string(of_node, "hisi,vcm-name", &vcm_info->vcm_name); cam_info("%s hisi,vcm-name %s, rc %d\n", __func__, vcm_info->vcm_name, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } rc = of_property_read_u32(of_node, "hisi,vcm-index", &vcm_info->index); cam_info("%s hisi,vcm-index %d, rc %d\n", __func__, vcm_info->index, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } rc = of_property_read_u32(of_node, "hisi,slave-addr", &vcm_info->slave_address); cam_info("%s hisi,slave-addr 0x%x, rc %d\n", __func__, vcm_info->slave_address, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } rc = of_property_read_u32(of_node, "hisi,data-type", &vcm_info->data_type); cam_info("%s hisi,data-type 0x%x, rc %d\n", __func__, vcm_info->data_type, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } return rc; fail: cam_err("%s can not read vcm info exit.\n", __func__); kfree(vcm_info); vcm_info = NULL; return rc; }
static int db8131m_init(struct v4l2_subdev *sd, u32 val) { /* struct i2c_client *client = v4l2_get_subdevdata(sd); */ struct db8131m_state *state = to_state(sd); int err = -EINVAL; cam_dbg("E\n"); /* set initial regster value */ if (state->sensor_mode == SENSOR_CAMERA) { cam_info("load camera common setting\n"); err = db8131m_write_regs(sd, db8131m_common_1, sizeof(db8131m_common_1) / \ sizeof(db8131m_common_1[0])); msleep(150); err |= db8131m_write_regs(sd, db8131m_common_2, sizeof(db8131m_common_2) / \ sizeof(db8131m_common_2[0])); } else { cam_info("load recording setting\n"); err = db8131m_write_regs(sd, db8131m_common_1, sizeof(db8131m_common_1) / \ sizeof(db8131m_common_1[0])); msleep(150); err = db8131m_write_regs(sd, db8131m_common_2, sizeof(db8131m_common_2) / \ sizeof(db8131m_common_2[0])); } if (unlikely(err)) { cam_err("failed to init\n"); return err; } /* We stop stream-output from sensor when starting camera. */ err = db8131m_control_stream(sd, 0); if (unlikely(err < 0)) return err; msleep(150); state->initialized = 1; return 0; }
static int ov8865_rear_match_id( hwsensor_intf_t* si, void * data) { sensor_t* sensor = I2S(si); hwsensor_board_info_t *board_info = sensor->board_info; struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data; int sensor_index = CAMERA_SENSOR_INVALID; int ret = 0; int camif_id = -1; cam_info("%s TODO.", __func__); if(0 == board_info->gpios[FSIN].gpio) { cam_err("%s gpio type[FSIN] is not actived.", __func__); ret = -1; goto out; } ret = gpio_request(board_info->gpios[FSIN].gpio, "camif_id"); if(ret < 0) { cam_err("failed to request gpio[%d]", board_info->gpios[FSIN].gpio); goto out; } ret = gpio_direction_input(board_info->gpios[FSIN].gpio); if(ret < 0) { cam_err("failed to control gpio[%d]", board_info->gpios[FSIN].gpio); goto out_gpio; } ret = gpio_get_value(board_info->gpios[FSIN].gpio); if(ret < 0) { cam_err("failed to get gpio[%d]", board_info->gpios[FSIN].gpio); goto out_gpio; } else { camif_id = ret; cam_notice("%s camif id = %d.", __func__, camif_id); } if (camif_id != board_info->camif_id) { cam_notice("%s camera[%s] module is not match.", __func__, board_info->name); board_info->sensor_index = CAMERA_SENSOR_INVALID; ret = -1; } else { cam_notice("%s camera[%s] match successfully.", __func__, board_info->name); sensor_index = board_info->sensor_index; ret = 0; } out_gpio: gpio_free(board_info->gpios[FSIN].gpio); out: memset(cdata->cfg.name, 0, sizeof(cdata->cfg.name)); cdata->data = sensor_index; if (ret == 0) hwsensor_writefile(sensor->board_info->sensor_index, sensor->board_info->name); return ret; }
static int sr200_set_preview_size(struct v4l2_subdev *subdev) { struct sr200_state *state = to_state(subdev); int err = 0; u32 width, height; if (!state->preview.update_frmsize) return 0; if (unlikely(!state->preview.frmsize)) { cam_warn("warning, preview resolution not set\n"); state->preview.frmsize = sr200_get_framesize( sr200_preview_frmsizes, ARRAY_SIZE(sr200_preview_frmsizes), PREVIEW_SZ_SVGA); } width = state->preview.frmsize->width; height = state->preview.frmsize->height; cam_info("set preview size(%dx%d)\n", width, height); if (state->sensor_mode == SENSOR_MOVIE) { if(width == 352 && height == 288) { err = sensor_sr200_apply_set(subdev, "sr200_resol_352_288", &sr200_regset_table.resol_352_288); } else { /*err = sensor_sr200_apply_set(subdev, "sr200_resol_640_480", &sr200_regset_table.resol_640_480);*/ /*CHECK_ERR_MSG(err, "fail to set preview size\n");*/ cam_info("MOVIE Mode : skip preview size\n"); } } else { if(width == 352 && height == 288) { /* VT Preview size */ err = sensor_sr200_apply_set(subdev, "sr200_Init_VT_Reg", &sr200_regset_table.init_vt); CHECK_ERR_MSG(err, "fail to set VT init\n"); err = sensor_sr200_apply_set(subdev, "sr200_resol_352_288", &sr200_regset_table.resol_352_288); } else { err = sensor_sr200_apply_set(subdev, "sr200_resol_800_600", &sr200_regset_table.resol_800_600); } } CHECK_ERR_MSG(err, "fail to set preview size\n"); state->preview.update_frmsize = 0; return 0; }
int sensor_sr200_s_again(struct v4l2_subdev *subdev, u64 sensitivity) { int ret = 0; cam_info("%s\n", __func__); return ret; }
static int hw_lm3642_flash_mode(struct hw_flash_ctrl_t *flash_ctrl, int data) { struct hw_flash_i2c_client *i2c_client; struct hw_flash_i2c_fn_t *i2c_func; struct hw_lm3642_private_data_t *pdata; unsigned char val; cam_debug("%s data=%d.\n", __func__, data); cam_info("%s 220250 data=%d.\n", __func__, data); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } i2c_client = flash_ctrl->flash_i2c_client; i2c_func = flash_ctrl->flash_i2c_client->i2c_func_tbl; pdata = flash_ctrl->pdata; /* clear error flag,resume chip */ i2c_func->i2c_read(i2c_client, REG_FLAGS, &val); i2c_func->i2c_read(i2c_client, REG_CURRENT_CONTROL, &val); /* set LED Flash current value */ if (data < pdata->flash_led_num) { cam_info("%s flash_led=0x%x.", __func__, pdata->flash_led[data]); /* REG_CURRENT_CONTROL[3:0] control flash current */ val = ((val & 0xf0) | (pdata->flash_led[data] & 0x0f)); } else { cam_warn("%s data(%d) > flash_led_num(%d).", __func__, data, pdata->flash_led_num); /* REG_CURRENT_CONTROL[3:0] control flash current */ val = ((val & 0xf0) | (pdata->flash_led[pdata->flash_led_num-1] & 0x0f)); } i2c_func->i2c_write(i2c_client, REG_CURRENT_CONTROL, val); if (flash_ctrl->flash_mask_enable) { i2c_func->i2c_write(i2c_client, REG_ENABLE, MODE_FLASH|TX_PIN); } else { i2c_func->i2c_write(i2c_client, REG_ENABLE, MODE_FLASH); } return 0; }
void altek6045_notify_ois_done( uint32_t id) { hwextisp_event_t extisp_ev; extisp_ev.kind = HWEXTISP_INFO_OIS_DONE; extisp_ev.data.error.id = id; cam_info("%s id = %x",__func__,id); hwextisp_intf_notify_error(s_altek6045.notify, &extisp_ev); }
static ssize_t imx278_carrera_powerctrl_show(struct device *dev, struct device_attribute *attr,char *buf) { int rc=0; cam_info("enter %s", __func__); return rc; }
void altek6045_notify_dump( uint32_t type) { hwextisp_event_t extisp_ev; extisp_ev.kind = HWEXTISP_INFO_DUMP; extisp_ev.data.dump.type = type; cam_info("%s dump type = %x",__func__,type); hwextisp_intf_notify_error(s_altek6045.notify, &extisp_ev); }
static int sensor_sr200_s_capture_mode(struct v4l2_subdev *subdev, int value) { struct sr200_state *state = to_state(subdev); int ret = 0; cam_info("%s : value(%d) - E\n",__func__, value); if ((SENSOR_CAMERA == state->sensor_mode) && value) { cam_info("s_ctrl : Capture Mode!\n"); state->format_mode = V4L2_PIX_FMT_MODE_CAPTURE; } else { cam_info("s_ctrl : Preview Mode!\n"); state->format_mode = V4L2_PIX_FMT_MODE_PREVIEW; } return ret; }
ssize_t sr200pc20_camera_type_show(struct device *dev, struct device_attribute *attr, char *buf) { char *cam_type = "SILICONFILE_SR200PC20"; cam_info("%s\n", __func__); return sprintf(buf, "%s\n", cam_type); }
static int hw_lm3646_front_flash_mode(struct hw_flash_ctrl_t *flash_ctrl, int data) { struct hw_flash_i2c_client *i2c_client; struct hw_flash_i2c_fn_t *i2c_func; struct hw_lm3646_front_private_data_t *pdata; unsigned char val; cam_info("%s data=%d.\n", __func__, data); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } i2c_client = flash_ctrl->flash_i2c_client; i2c_func = flash_ctrl->flash_i2c_client->i2c_func_tbl; pdata = flash_ctrl->pdata; /* clear error flag,resume chip */ i2c_func->i2c_read(i2c_client, REG_FLAGS1, &val); i2c_func->i2c_read(i2c_client, REG_FLAGS2, &val); i2c_func->i2c_read(i2c_client, REG_LED1_FLASH_CURRENT_CONTROL, &val); /* set LED Flash current value */ if (data < FLASH_LED_MAX) { cam_info("%s flash_led=0x%x.", __func__, pdata->flash_led[data]); /* REG_CURRENT_CONTROL[3:0] control flash current */ val = ((val & 0x80) | (data & 0x7f)); } else { cam_warn("%s data(%d) > flash_led_num(%d).", __func__, data, pdata->flash_led_num); /* REG_CURRENT_CONTROL[3:0] control flash current */ val = ((val & 0x80) | (0x7f)); } i2c_func->i2c_write(i2c_client, REG_MAX_CURRENT, 0x7c); i2c_func->i2c_write(i2c_client, REG_LED1_FLASH_CURRENT_CONTROL, 0x22); if (flash_ctrl->flash_mask_enable) { i2c_func->i2c_write(i2c_client, REG_ENABLE, 0xd3); } else { i2c_func->i2c_write(i2c_client, REG_ENABLE, 0xd3); } return 0; }
int hisi_sensor_apply_bshutter_expo_gain(struct hisi_sensor_ctrl_t *s_ctrl, void *data) { struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data; struct bshutter_expo_gain_seq host_ae_seq = cdata->cfg.bshutter_seq; struct hisi_sensor_t *sensor = s_ctrl->sensor; int i; cam_info("%s enter,eof_bshutter_trigger(%d)", __func__,host_ae_seq.eof_bshutter_trigger); for(i=0; i<host_ae_seq.seq_size; i++) { cam_info("%s enter, bshutter_seq[%d],expo_time(%u),expo(%u),gain(%u),vts(%u),hts(%u)", __func__, i, host_ae_seq.expo_time[i],host_ae_seq.expo[i],host_ae_seq.gain[i],host_ae_seq.vts[i],host_ae_seq.hts[i]); } return setup_eof_bshutter_tasklet(sensor, &host_ae_seq); }
static int32_t ad5823_platform_probe(struct platform_device *pdev) { int32_t rc = 0; const struct of_device_id *match; match = of_match_device(hisi_ad5823_dt_match, &pdev->dev); cam_info("%s compatible=%s.\n", __func__, match->compatible); rc = ad5823_vcm_probe(pdev); return rc; }
int hisi_pmic_get_dt_data(struct hisi_pmic_ctrl_t *pmic_ctrl) { struct device_node *of_node; struct hisi_pmic_info *pmic_info; int rc = -1; cam_info("%s enter.\n", __func__); if (NULL == pmic_ctrl) { cam_err("%s pmic_ctrl is NULL.", __func__); return rc; } of_node = pmic_ctrl->dev->of_node; pmic_info = &pmic_ctrl->pmic_info; rc = of_property_read_string(of_node, "hisi,pmic_name", &pmic_info->name); cam_info("%s hisi,pmic_name %s, rc %d\n", __func__, pmic_info->name, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } rc = of_property_read_u32(of_node, "hisi,pmic_index", &pmic_info->index); cam_info("%s hisi,pmic_index %d, rc %d\n", __func__, pmic_info->index, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } rc = of_property_read_u32(of_node, "hisi,slave_address", &pmic_info->slave_address); cam_info("%s slave_address %d, rc %d\n", __func__, pmic_info->slave_address, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); goto fail; } fail: return rc; }
static int ncp6925_seq_config(struct hisi_pmic_ctrl_t *pmic_ctrl, pmic_seq_index_t seq_index, u32 voltage, int state) { u8 chx_enable_tmp = 0; u8 chx_enable = 0; u8 voltage_reg = 0; u8 voltage_val = 0; struct hisi_pmic_i2c_client *i2c_client; struct hisi_pmic_i2c_fn_t *i2c_func; int ret = 0; cam_info("%s enter.", __func__); if (NULL == pmic_ctrl) { cam_err("%s pmic_ctrl is NULL.", __func__); return -1; } i2c_client = pmic_ctrl->pmic_i2c_client; i2c_func = pmic_ctrl->pmic_i2c_client->i2c_func_tbl; chx_enable = voltage_map[seq_index].chx_enable; voltage_reg = voltage_map[seq_index].vout_reg; i2c_func->i2c_read(i2c_client, CHX_EN, &chx_enable_tmp); if (state == 1) { if (seq_index >= VOUT_BUCK_1) calc_buck_vlotage(voltage, &voltage_val); else calc_ldo_vlotage(voltage, &voltage_val); i2c_func->i2c_write(i2c_client, voltage_reg, voltage_val); msleep(1); i2c_func->i2c_write(i2c_client, CHX_EN, chx_enable_tmp | chx_enable); cam_info("%s chx_enable 0x%x, voltage_reg 0x%x, voltage_val 0x%x", __func__, chx_enable, voltage_reg, voltage_val); } else { i2c_func->i2c_write(i2c_client, CHX_EN, chx_enable_tmp & (~chx_enable)); //i2c_func->i2c_write(i2c_client, voltage_reg, state); } i2c_func->i2c_read(i2c_client, CHX_ERR, &chx_enable_tmp); return ret; }
int hisi_vcm_i2c_read(struct hisi_vcm_ctrl_t *vcm_ctrl, void *data) { struct vcm_cfg_data *cdata = (struct vcm_cfg_data *)data; //struct vcm_i2c_reg reg; int rc = 0; cam_info("%s: address=0x%x\n", __func__, cdata->cfg.reg.address); cdata->cfg.reg.value = 0x5823; return rc; }
static void sr200_set_framesize(struct v4l2_subdev *subdev, const struct sr200_framesize *frmsizes, u32 num_frmsize, bool preview) { struct sr200_state *state = to_state(subdev); const struct sr200_framesize **found_frmsize = NULL; u32 width = state->req_fmt.width; u32 height = state->req_fmt.height; int i = 0; cam_info("%s: Requested Res %dx%d\n", __func__, width, height); found_frmsize = preview ? &state->preview.frmsize : &state->capture.frmsize; for (i = 0; i < num_frmsize; i++) { if ((frmsizes[i].width == width) && (frmsizes[i].height == height)) { *found_frmsize = &frmsizes[i]; break; } } if (*found_frmsize == NULL) { cam_err("%s: error, invalid frame size %dx%d\n", __func__, width, height); *found_frmsize = preview ? sr200_get_framesize(frmsizes, num_frmsize, PREVIEW_SZ_SVGA) : sr200_get_framesize(frmsizes, num_frmsize, CAPTURE_SZ_1MP); //BUG_ON(!(*found_frmsize)); } if (preview) cam_info("Preview Res Set: %dx%d, index %d\n", (*found_frmsize)->width, (*found_frmsize)->height, (*found_frmsize)->index); else cam_info("Capture Res Set: %dx%d, index %d\n", (*found_frmsize)->width, (*found_frmsize)->height, (*found_frmsize)->index); }
static int sensor_sr200_apply_set(struct v4l2_subdev *sd, const char * setting_name, const struct sensor_regset *table) { int ret = 0; cam_info("%s : E, setting_name : %s\n", __func__, setting_name); #ifdef CONFIG_LOAD_FILE cam_info("COFIG_LOAD_FILE feature is enabled\n"); ret = sr200_write_regs_from_sd(sd, setting_name); CHECK_ERR_MSG(ret, "[COFIG_LOAD_FILE]regs set apply is fail\n"); #else ret = sr200_write_regs(sd, table->reg, table->size); CHECK_ERR_MSG(ret, "regs set apply is fail\n"); #endif cam_info("%s : X\n", __func__); return ret; }
int sensor_sr200_stream_on(struct v4l2_subdev *subdev) { int ret = 0; cam_info("stream on\n"); ret = sensor_sr200_apply_set(subdev, "sr200_start_stream", &sr200_regset_table.start_stream); return ret; }
static ssize_t ncp6925_reg_show(struct device *dev, struct device_attribute *attr,char *buf) { int rc=0; cam_info("enter %s", __func__); snprintf(buf, MAX_ATTRIBUTE_BUFFER_SIZE, "reg=%d, val=%d.\n", reg, val); rc = strlen(buf)+1; return rc; }
static int __find_resolution(struct v4l2_subdev *subdev, struct v4l2_mbus_framefmt *mf, enum sr200_oprmode *type, u32 *resolution) { struct sr200_state *state = to_state(subdev); const struct sr200_resolution *fsize = &sr200_resolutions[0]; const struct sr200_resolution *match = NULL; enum sr200_oprmode stype = state->oprmode; int i = ARRAY_SIZE(sr200_resolutions); unsigned int min_err = ~0; int err; while (i--) { if (stype == fsize->type) { err = abs(fsize->width - mf->width) + abs(fsize->height - mf->height); if (err < min_err) { min_err = err; match = fsize; stype = fsize->type; } } fsize++; } cam_info("LINE(%d): mf width: %d, mf height: %d, mf code: %d\n", __LINE__, mf->width, mf->height, stype); cam_info("LINE(%d): match width: %d, match height: %d, match code: %d\n", __LINE__, match->width, match->height, stype); if (match) { mf->width = match->width; mf->height = match->height; *resolution = match->value; *type = stype; return 0; } cam_info("LINE(%d): mf width: %d, mf height: %d, mf code: %d\n", __LINE__, mf->width, mf->height, stype); return -EINVAL; }
static ssize_t ncp6925_show(struct device *dev, struct device_attribute *attr,char *buf) { int rc=0; cam_info("enter %s", __func__); snprintf(buf, MAX_ATTRIBUTE_BUFFER_SIZE, "mode=%d, data=%d.\n", cdata.mode, cdata.data); rc = strlen(buf)+1; return rc; }
static int ncp6925_get_dt_data(struct hisi_pmic_ctrl_t *pmic_ctrl) { struct ncp6925_private_data_t *pdata; struct device_node *of_node; int i; int rc = -1; cam_info("%s enter.\n", __func__); if (NULL == pmic_ctrl) { cam_err("%s pmic_ctrl is NULL.", __func__); return rc; } pdata = (struct ncp6925_private_data_t *)pmic_ctrl->pdata; of_node = pmic_ctrl->dev->of_node; rc = of_property_read_u32_array(of_node, "hisi,pmic-pin", pdata->pin, MAX_PIN); if (rc < 0) { cam_err("%s failed line %d\n", __func__, __LINE__); return rc; } else { for (i=0; i<MAX_PIN; i++) { cam_info("%s pin[%d]=%d.\n", __func__, i, pdata->pin[i]); } } rc = of_property_read_u32_array(of_node, "hisi,pmic-voltage", pdata->voltage, VOUT_MAX); if (rc < 0) { cam_err("%s failed line %d\n", __func__, __LINE__); return rc; } else { for (i=0; i<VOUT_MAX; i++) { cam_info("%s voltage[%d]=%d.\n", __func__, i, pdata->voltage[i]); } } return 0; }
static int hw_lm3646_front_match(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_flash_i2c_client *i2c_client; struct hw_flash_i2c_fn_t *i2c_func; struct hw_lm3646_front_private_data_t *pdata; unsigned char id; unsigned short slave_address = 0; cam_debug("%s enter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } i2c_client = flash_ctrl->flash_i2c_client; i2c_func = flash_ctrl->flash_i2c_client->i2c_func_tbl; pdata = (struct hw_lm3646_front_private_data_t *)flash_ctrl->pdata; /* front LM3646's i2c address need to be re-adjusted to avoid conflict as workaround, 0x68->0x67 */ slave_address = (unsigned short)flash_ctrl->flash_info.slave_address; cam_info("%s real i2c address = 0x%x, fake i2c address = 0x%x.", __func__, slave_address, i2c_client->client->addr); i2c_client->client->addr = slave_address; //Enable lm3646_front switch to standby current is 10ua hw_lm3646_front_set_pin_reset(flash_ctrl,HIGH); i2c_func->i2c_read(i2c_client, REG_CHIPID, &id); cam_info("%s id=0x%x.\n", __func__, id); id = id & CHIP_ID; if (id != CHIP_ID) { cam_err("%s match error, id(0x%x) != 0x%x.", __func__, id, CHIP_ID); return -1; } //Enable lm3646_front switch to shutdown current is 1.3ua hw_lm3646_front_set_pin_reset(flash_ctrl, LOW); register_camerafs_attr(&hw_lm3646_front_dual_leds); //add for debug only register_camerafs_attr(&hw_lm3646_front_lightness); return 0; }
static int imx214_match_id( hwsensor_intf_t* si, void * data) { sensor_t* sensor = I2S(si); struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data; #if 0 struct sensor_cfg_data cdata_h; struct sensor_cfg_data cdata_l; u16 id_h = 0; u16 id_l = 0; u16 sensor_id = 0; cam_info("%s TODO.", __func__); cdata_h.cfg.reg.subaddr = 0x0016; cdata_h.cfg.reg.value = 0; cdata_l.cfg.reg.subaddr = 0x0017; cdata_l.cfg.reg.value = 0; imx214_i2c_read(sensor, &cdata_h); imx214_i2c_read(sensor, &cdata_l); sensor_id = (cdata_h.cfg.reg.value) << 8 | (cdata_l.cfg.reg.value); cam_notice( "%s, line %d, sensor id: 0x%x", __func__, __LINE__, sensor_id); id = read_i2c(); if (id == chipid) { cam_info("%s succeed to match id.", __func__); } else { cam_info("%s failed to match id.", __func__); sensor->board_info->sensor_index = CAMERA_SENSOR_INVALID; } #endif cdata->data = sensor->board_info->sensor_index; hwsensor_writefile(sensor->board_info->sensor_index, sensor->board_info->name); return 0; }
int ad5823_i2c_read(struct hisi_vcm_ctrl_t *vcm_ctrl, void *data) { struct vcm_cfg_data *cdata = (struct vcm_cfg_data *)data; //struct vcm_i2c_reg reg; int rc = -1; cam_info("%s: address=0x%x\n", __func__, cdata->cfg.reg.address); //todo ... cdata->cfg.reg.value = VCM_ID_CODE; return rc; }