int ov13850_config( hwsensor_intf_t* si, void *argp) { struct sensor_cfg_data *data; int ret =0; static bool ov13850_power_on = false; static bool csi_enable = false; data = (struct sensor_cfg_data *)argp; cam_debug("ov13850 cfgtype = %d",data->cfgtype); switch(data->cfgtype){ case SEN_CONFIG_POWER_ON: if (!ov13850_power_on) { ret = si->vtbl->power_up(si); ov13850_power_on = true; } break; case SEN_CONFIG_POWER_OFF: if (ov13850_power_on) { ret = si->vtbl->power_down(si); ov13850_power_on = false; } break; case SEN_CONFIG_WRITE_REG: break; case SEN_CONFIG_READ_REG: break; case SEN_CONFIG_WRITE_REG_SETTINGS: break; case SEN_CONFIG_READ_REG_SETTINGS: break; case SEN_CONFIG_ENABLE_CSI: if(ov13850_power_on && !csi_enable) { ret = si->vtbl->csi_enable(si); csi_enable = true; } break; case SEN_CONFIG_DISABLE_CSI: if(ov13850_power_on && csi_enable) { ret = si->vtbl->csi_disable(si); csi_enable = false; } break; case SEN_CONFIG_MATCH_ID: ret = si->vtbl->match_id(si,argp); break; default: break; } cam_debug("%s exit",__func__); return ret; }
int hw_flash_i2c_read(struct hw_flash_i2c_client *client, u8 reg, u8 *data) { int rc = 0; struct i2c_msg msgs[2]; cam_debug("%s enter.\n", __func__); msgs[0].addr = client->client->addr; msgs[0].flags = 0; msgs[0].len = 1; msgs[0].buf = ® msgs[1].addr = client->client->addr; msgs[1].flags = I2C_M_RD; msgs[1].len = 1; msgs[1].buf = data; rc = i2c_transfer(client->client->adapter, msgs, 2); if (rc < 0) { cam_err("%s transfer error, reg=0x%x, data=0x%x.", __func__, reg, *data); } else { cam_debug("%s reg=0x%x, data=0x%x.\n", __func__, reg, *data); } return rc; }
static int hisi_sensor_get_pos(int index) { mm_segment_t fs; struct file *filp = NULL; char file_name[FILE_NAME_LEN]={0}; int pos=-1; snprintf(file_name, FILE_NAME_LEN, "/data/camera/hisi_sensor%d", index); cam_debug("%s index=%d.sensor name:%s\n", __func__, index, file_name); filp = filp_open(file_name, O_RDONLY, 0444); if (IS_ERR_OR_NULL(filp)) { cam_err("%s, fail to open file.\n", __func__); return pos; } fs = get_fs(); set_fs(KERNEL_DS); if (sizeof(pos) != vfs_read(filp, (char*)&pos, sizeof(pos), &filp->f_pos)) { cam_err("%s, fail to read file.\n", __func__); pos=-EFAULT; } else { cam_debug("%s pos=%d.\n", __func__, pos); } set_fs(fs); filp_close(filp, NULL); return pos; }
int hw_vcm_config(hw_vcm_t *hw_vcm, void *arg) { int rc = 0; struct hw_vcm_cfg_data *cdata = (struct hw_vcm_cfg_data *)arg; if (NULL == cdata) { cam_debug("%s, arg is NULL.\n", __func__); return -EINVAL; } cam_debug("%s enter cfgtype=%d.\n", __func__, cdata->cfgtype); mutex_lock(&hw_vcm->lock); switch (cdata->cfgtype) { case CFG_VCM_I2C_READ: rc = hw_vcm->intf->vtbl->vcm_i2c_read(hw_vcm->intf, arg); break; case CFG_VCM_I2C_WRITE: rc = hw_vcm->intf->vtbl->vcm_i2c_write(hw_vcm->intf, arg); break; case CFG_VCM_GET_VCM_NAME: strncpy(cdata->cfg.name, hw_vcm->vcm_info->vcm_name, sizeof(cdata->cfg.name) - 1); break; default: rc = hw_vcm->intf->vtbl->vcm_ioctl(hw_vcm->intf, arg); break; } mutex_unlock(&hw_vcm->lock); return rc; }
static int hw_scharger_get_dt_data(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_scharger_private_data_t *pdata; struct device_node *of_node; int i; int rc = -1; cam_debug("%s enter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return rc; } pdata = (struct hw_scharger_private_data_t *)flash_ctrl->pdata; of_node = flash_ctrl->dev->of_node; rc = of_property_read_u32(of_node, "huawei,flash_led_num", &pdata->flash_led_num); cam_debug("%s hisi,flash_led_num %d, rc %d\n", __func__, pdata->flash_led_num, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); return rc; } rc = of_property_read_u32(of_node, "huawei,torch_led_num", &pdata->torch_led_num); cam_debug("%s hisi,torch_led_num %d, rc %d\n", __func__, pdata->torch_led_num, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); return rc; } rc = of_property_read_u32_array(of_node, "huawei,flash_led", pdata->flash_led, pdata->flash_led_num); if (rc < 0) { cam_err("%s failed line %d\n", __func__, __LINE__); return rc; } else { for (i=0; i< pdata->flash_led_num; i++) { cam_debug("%s flash_led[%d]=0x%x.\n", __func__, i, pdata->flash_led[i]); } } rc = of_property_read_u32_array(of_node, "huawei,torch_led", pdata->torch_led, pdata->torch_led_num); if (rc < 0) { cam_err("%s failed line %d\n", __func__, __LINE__); return rc; } else { for (i = 0; i < pdata->torch_led_num; i++) { cam_debug("%s torch_led[%d]=0x%x.\n", __func__, i, pdata->torch_led[i]); } } return rc; }
int imx278_config( hwsensor_intf_t* si, void *argp) { if (NULL == si || NULL == argp){ cam_err("%s si or argp is null.\n", __func__); return -1; } struct sensor_cfg_data *data; int ret =0; static bool imx278_power_on = false; data = (struct sensor_cfg_data *)argp; cam_debug("imx278 cfgtype = %d",data->cfgtype); switch(data->cfgtype){ case SEN_CONFIG_POWER_ON: if (!imx278_power_on) { ret = si->vtbl->power_up(si); imx278_power_on = true; } break; case SEN_CONFIG_POWER_OFF: if (imx278_power_on) { ret = si->vtbl->power_down(si); imx278_power_on = false; } break; case SEN_CONFIG_WRITE_REG: break; case SEN_CONFIG_READ_REG: break; case SEN_CONFIG_WRITE_REG_SETTINGS: break; case SEN_CONFIG_READ_REG_SETTINGS: break; case SEN_CONFIG_ENABLE_CSI: break; case SEN_CONFIG_DISABLE_CSI: break; case SEN_CONFIG_MATCH_ID: ret = si->vtbl->match_id(si,argp); break; default: cam_err("%s cfgtype(%d) is error", __func__, data->cfgtype); break; } cam_debug("%s exit",__func__); return ret; }
int hisi_sensor_i2c_read_seq(struct hisi_sensor_ctrl_t *s_ctrl, void *data) { struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data; struct sensor_i2c_setting setting; int size = sizeof(struct sensor_i2c_reg)*cdata->cfg.setting.size; long rc = 0; cam_debug("%s: enter.\n", __func__); if (cdata->cfg.setting.size > MAX_WRITE_READ_SEQ_SIZE) { cam_err("%s, the size of read req(%d) exceeds the maximum range.", __func__, cdata->cfg.setting.size); return -EFAULT; } setting.setting = (struct sensor_i2c_reg*)kzalloc(size, GFP_KERNEL); if (NULL == setting.setting) { cam_err("%s kmalloc error.\n", __func__); return -ENOMEM; } if (copy_from_user(setting.setting, (void __user *)cdata->cfg.setting.setting, size)) { cam_err("%s copy_from_user error.\n", __func__); rc = -EFAULT; goto fail; } /* test */ { int i=0; for(i=0; i<cdata->cfg.setting.size; i++) { cam_debug("%s subaddr=0x%x.\n", __func__, setting.setting[i].subaddr); setting.setting[i].value = i; } } if (copy_to_user((void __user *)cdata->cfg.setting.setting, setting.setting, size)) { cam_err("%s copy_to_user error.\n", __func__); rc = -EFAULT; goto fail; } fail: kfree(setting.setting); return rc; }
static int tps61310_match(struct hisi_flash_ctrl_t *flash_ctrl) { struct hisi_flash_i2c_client *i2c_client; struct hisi_flash_i2c_fn_t *i2c_func; struct tps61310_private_data_t *pdata; unsigned char id; cam_debug("%s ernter.\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 tps61310_private_data_t *)flash_ctrl->pdata; tps61310_set_reset(flash_ctrl, HIGH); i2c_func->i2c_read(i2c_client, REGISTER7, &id); cam_info("%s id=0x%x.\n", __func__, id); if ((id&0x7) != pdata->chipid) { cam_err("%s match error, id&0x7(0x%x) != 0x%x.", __func__, (id&0x7), pdata->chipid); return -1; } tps61310_set_reset(flash_ctrl, LOW); return 0; }
static int tps61310_on(struct hisi_flash_ctrl_t *flash_ctrl, void *data) { struct flash_cfg_data *cdata = (struct flash_cfg_data *)data; int rc=-1; if ((NULL == flash_ctrl) || (NULL == cdata)) { cam_err("%s flash_ctrl or cdata is NULL.", __func__); return -1; } cam_debug("%s mode=%d, level=%d.\n", __func__, cdata->mode, cdata->data); mutex_lock(flash_ctrl->hisi_flash_mutex); rc = tps61310_led_enable(flash_ctrl, cdata); if (rc < 0) { cam_err("%s failed to enable tps61310 led.", __func__); mutex_unlock(flash_ctrl->hisi_flash_mutex); return rc; } if (FLASH_MODE == cdata->mode) { rc = tps61310_flash_mode(flash_ctrl, cdata->data); } else { rc = tps61310_torch_mode(flash_ctrl, cdata->data); } flash_ctrl->state.mode = cdata->mode; flash_ctrl->state.data = cdata->data; mutex_unlock(flash_ctrl->hisi_flash_mutex); return rc; }
int dw9714_get_otp_af(struct hisi_vcm_ctrl_t *vcm_ctrl, void *data) { struct vcm_cfg_data *cdata = (struct vcm_cfg_data *)data; struct hisi_sd_req_sd vcm_req_sd = {0}; char sd_name[DEV_NAME_SIZE]={0}; struct hisi_sensor_ctrl_t *s_ctrl; int rc = 0; cam_debug("%s enter.", __func__); snprintf(sd_name, sizeof(sd_name), "hisi_sensor_%d", vcm_ctrl->index); vcm_req_sd.name = sd_name; v4l2_subdev_notify(&vcm_ctrl->hisi_sd.sd, HISI_SD_NOTIFY_GET_SD, &vcm_req_sd); s_ctrl = container_of(container_of(vcm_req_sd.subdev, struct hisi_sd_subdev, sd), struct hisi_sensor_ctrl_t, hisi_sd); if (s_ctrl->sensor->sensor_otp.af_otp.af_otp_succeed) { cam_info("%s succeed to get otp af.", __func__); memcpy(&cdata->cfg.af_otp, &s_ctrl->sensor->sensor_otp.af_otp, sizeof(struct hisi_sensor_af_otp)); rc = 0; } else { cam_err("%s failed to get otp af.", __func__); memset(&cdata->cfg.af_otp, 0, sizeof(struct hisi_sensor_af_otp)); rc = -1; } return rc; }
static int hw_lm3646_front_init(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_lm3646_front_private_data_t *pdata; int rc = 0; cam_debug("%s enter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } pdata = (struct hw_lm3646_front_private_data_t *)flash_ctrl->pdata; flash_ctrl->pctrl = devm_pinctrl_get_select(flash_ctrl->dev, PINCTRL_STATE_DEFAULT); if (NULL == flash_ctrl->pctrl) { cam_err("%s failed to set pin.", __func__); return -EIO; } rc = gpio_request(pdata->pin[RESET], "flash-reset"); if (rc < 0) { cam_err("%s failed to request reset pin.", __func__); return -EIO; } hw_lm3646_front_set_pin_reset(flash_ctrl,LOW); msleep(LM3646_RESET_HOLD_TIME); return rc; }
int imx214_ioctl(struct hisi_sensor_ctrl_t *s_ctrl, void *data) { struct sensor_cfg_data *cdata = (struct sensor_cfg_data*)data; int rc = 0; cam_debug("%s enter.\n", __func__); switch (cdata->cfgtype) { case CFG_SENSOR_SET_VTS: cam_info("%s set vts.\n", __func__); break; case CFG_SENSOR_GET_OTP_AWB: //TODO... break; case CFG_SENSOR_GET_OTP_VCM: #ifdef IMX214_OTP_FEATURE rc = imx214_get_otp_af(s_ctrl, data); #endif break; default: rc = -EFAULT; break; } return rc; }
static int hw_lm3642_off(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_flash_i2c_client *i2c_client; struct hw_flash_i2c_fn_t *i2c_func; unsigned char val; cam_debug("%s ernter.\n", __func__); cam_info("%s 220250 ernter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } mutex_lock(flash_ctrl->hw_flash_mutex); flash_ctrl->state.mode = STANDBY_MODE; flash_ctrl->state.data = 0; i2c_client = flash_ctrl->flash_i2c_client; i2c_func = flash_ctrl->flash_i2c_client->i2c_func_tbl; i2c_func->i2c_read(i2c_client, REG_FLAGS, &val); i2c_func->i2c_write(i2c_client, REG_ENABLE, MODE_STANDBY); mutex_unlock(flash_ctrl->hw_flash_mutex); return 0; }
int hw_mclk_config(sensor_t *s_ctrl, struct sensor_power_setting *power_setting, int state) { int sensor_index; cam_debug("%s enter.state:%d", __func__, state); if (!is_ovisp23_poweron()) { cam_notice("%s the ovisp has powered down.", __func__); return 0; } if (SENSOR_INDEX_INVALID != power_setting->sensor_index) { sensor_index = power_setting->sensor_index; } else { sensor_index = s_ctrl->board_info->sensor_index; } if (hw_is_fpga_board()) return 0; hwcam_mclk_enable(sensor_index, state); if (0 != power_setting->delay) { hw_camdrv_msleep(power_setting->delay); } return 0; }
void hisi_mclk_config(struct hisi_sensor_ctrl_t *s_ctrl, struct sensor_power_setting *power_setting, int state) { int sensor_index; cam_debug("%s enter.state:%d", __func__, state); if (SENSOR_INDEX_INVALID != power_setting->sensor_index) { sensor_index = power_setting->sensor_index; } else { sensor_index = s_ctrl->sensor->sensor_info->sensor_index; } if (is_fpga_board()) return; if (POWER_ON == state) { /* mclk */ if (CAMERA_SENSOR_PRIMARY == sensor_index) { SETREG8(REG_ISP_CLK_DIVIDER, 0x44); } else { SETREG8(REG_ISP_CLK_DIVIDER, 0x44); } } else { //SETREG8(REG_ISP_CLK_DIVIDER, 0); } if (0 != power_setting->delay) { camdrv_msleep(power_setting->delay); } return; }
static long hw_vcm_subdev_ioctl( struct v4l2_subdev *sd, unsigned int cmd, void *arg) { long rc = -EINVAL; hw_vcm_t* s = NULL; if (arg == NULL) { cam_err("%s, the parameters is a null pointer!", __func__); } s = SD2Vcm(sd); cam_debug("hw vcm cmd = %x",cmd); switch (cmd) { case VIDIOC_HISI_VCM_CFG: rc = s->intf->vtbl->vcm_config(s, arg); break; default: cam_err("%s, invalid IOCTL CMD(%d)! \n", __func__, cmd); break; } return rc; }
static int hw_lm3642_init(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_lm3642_private_data_t *pdata; int rc = 0; cam_debug("%s ernter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } pdata = (struct hw_lm3642_private_data_t *)flash_ctrl->pdata; #if 1 flash_ctrl->pctrl = devm_pinctrl_get_select(flash_ctrl->dev, PINCTRL_STATE_DEFAULT); rc = gpio_request(pdata->strobe, "flash-strobe"); if (rc < 0) { cam_err("%s failed to request strobe pin.", __func__); return -EIO; } #endif return rc; }
int altel6045_get_dt_data(const hwextisp_intf_t *i, struct device_node *of_node) { int ret = 0; int index = 0; altek6045_private_data_t* pdata = NULL; altek6045_t* mini_isp = NULL; mini_isp = I2A(i); pdata = (altek6045_private_data_t *)mini_isp->pdata; ret = of_property_read_u32_array(of_node, "hisi,isp-pin", pdata->pin, ISP_MAX); if (ret < 0) { cam_err("%s failed line %d\n", __func__, __LINE__); return ret; } else { for (index = 0; index < ISP_MAX; index++) { cam_debug("%s pin[%d]=%d.\n", __func__, index, pdata->pin[index]); } } #if 0 ret = gpio_request(pdata->pin[ISP_DVDD], "isp-dcdc"); if (ret < 0) { cam_err("%s failed to request isp-dvdd pin.", __func__); return ret; } #endif return ret; }
static int hw_lm3642_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_lm3642_private_data_t *pdata; unsigned char id; cam_debug("%s ernter.\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_lm3642_private_data_t *)flash_ctrl->pdata; i2c_func->i2c_read(i2c_client, REG_FLASH_FEATURES, &id); cam_info("%s id=0x%x.\n", __func__, id); if (id != pdata->chipid) { cam_err("%s match error, id(0x%x) != 0x%x.", __func__, (id&0x7), pdata->chipid); return -1; } i2c_func->i2c_write(i2c_client, REG_IVFM, 0x00); return 0; }
static int hw_lm3646_front_off(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_flash_i2c_client *i2c_client; struct hw_flash_i2c_fn_t *i2c_func; unsigned char val; cam_debug("%s enter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } mutex_lock(flash_ctrl->hw_flash_mutex); if(flash_ctrl->state.mode == STANDBY_MODE){ mutex_unlock(flash_ctrl->hw_flash_mutex); return 0; } flash_ctrl->state.mode = STANDBY_MODE; flash_ctrl->state.data = 0; i2c_client = flash_ctrl->flash_i2c_client; i2c_func = flash_ctrl->flash_i2c_client->i2c_func_tbl; i2c_func->i2c_read(i2c_client, REG_FLAGS1, &val); i2c_func->i2c_read(i2c_client, REG_FLAGS2, &val); i2c_func->i2c_write(i2c_client, REG_ENABLE, MODE_STANDBY); //Enable lm3646_front switch to shutdown current is 1.3ua hw_lm3646_front_set_pin_reset(flash_ctrl,LOW); cam_info("%s end", __func__); mutex_unlock(flash_ctrl->hw_flash_mutex); return 0; }
static int hw_scharger_on(struct hw_flash_ctrl_t *flash_ctrl, void *data) { struct hw_flash_cfg_data *cdata = (struct hw_flash_cfg_data *)data; int rc = -1; if ((NULL == flash_ctrl) || (NULL == cdata)) { cam_err("%s flash_ctrl or cdata is NULL.", __func__); return rc; } cam_debug("%s mode=%d, level=%d.\n", __func__, cdata->mode, cdata->data); mutex_lock(flash_ctrl->hw_flash_mutex); if (FLASH_MODE == cdata->mode) { rc = hw_scharger_flash_mode(flash_ctrl, cdata->data); } else { rc = hw_scharger_torch_mode(flash_ctrl, cdata->data); } flash_ctrl->state.mode = cdata->mode; flash_ctrl->state.data = cdata->data; mutex_unlock(flash_ctrl->hw_flash_mutex); return rc; }
static int hw_lm3646_front_brightness(struct hw_flash_ctrl_t *flash_ctrl, void *data) { struct hw_flash_cfg_data *cdata = (struct hw_flash_cfg_data *)data; int rc = -1; if ((NULL == flash_ctrl) || (NULL == cdata)) { cam_err("%s flash_ctrl or cdata is NULL.", __func__); return -1; } cam_debug("%s mode=%d, level=%d.\n", __func__, cdata->mode, cdata->data); cam_info("%s enter.\n", __func__); mutex_lock(flash_ctrl->hw_flash_mutex); //Enable lm3646_front switch to standby current is 10ua hw_lm3646_front_set_pin_reset(flash_ctrl,HIGH); if (FLASH_MODE == cdata->mode) { rc = hw_lm3646_front_flash_mode(flash_ctrl, cdata->data); } else { rc = hw_lm3646_front_torch_mode_mmi(flash_ctrl, cdata->mode, cdata->data); } flash_ctrl->state.mode = cdata->mode; flash_ctrl->state.data = cdata->data; mutex_unlock(flash_ctrl->hw_flash_mutex); return rc; }
int ad5823_i2c_write(struct hisi_vcm_ctrl_t *vcm_ctrl, void *data) { struct vcm_cfg_data *cdata = (struct vcm_cfg_data *)data; int rc = 0; cam_debug("%s enter.\n", __func__); cam_debug("%s: address=0x%x, value=0x%x\n", __func__, cdata->cfg.reg.address, cdata->cfg.reg.value); rc = isp_write_vcm(vcm_ctrl->vcm->vcm_info->slave_address, (u16)cdata->cfg.reg.address, (u16)cdata->cfg.reg.value, vcm_ctrl->vcm->vcm_info->data_type); return rc; }
static int hw_lm3646_front_get_dt_data(struct hw_flash_ctrl_t *flash_ctrl) { struct hw_lm3646_front_private_data_t *pdata; struct device_node *of_node; int i; int rc = -1; cam_debug("%s enter.\n", __func__); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return rc; } pdata = (struct hw_lm3646_front_private_data_t *)flash_ctrl->pdata; of_node = flash_ctrl->dev->of_node; rc = of_property_read_u32_array(of_node, "huawei,flash-pin", pdata->pin, MAX_PIN); if (rc < 0) { cam_err("%s bbbb 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(of_node, "huawei,flash-chipid", &pdata->chipid); cam_info("%s hisi,chipid 0x%x, rc %d\n", __func__, pdata->chipid, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); return rc; } rc = of_property_read_u32(of_node, "huawei,flash_led_num", &pdata->flash_led_num); cam_info("%s hisi,flash_led_num %d, rc %d\n", __func__, pdata->flash_led_num, rc); if (rc < 0) { cam_err("%s failed %d\n", __func__, __LINE__); return rc; } rc = of_property_read_u32(of_node, "huawei,torch_led_num", &pdata->torch_led_num); cam_info("%s hisi,torch_led_num %d, rc %d\n", __func__, pdata->torch_led_num, rc); if (rc < 0) { cam_err("%s aaa failed %d\n", __func__, __LINE__); return rc; } return rc; }
static int pmu_led_flash_mode(struct hisi_flash_ctrl_t *flash_ctrl, int data) { struct pmu_led_private_data_t *pdata; cam_debug("%s data=%d.\n", __func__, data); if (NULL == flash_ctrl) { cam_err("%s flash_ctrl is NULL.", __func__); return -1; } pum_led_flash_on = true; //hi6401_set_gain_for_flashlight(true); pdata = (struct pmu_led_private_data_t *)flash_ctrl->pdata; pmu_led_write(LED_CTRL1, pdata->led_ctrl_flash[LED_CTRL_1]); pmu_led_write(LED_CTRL2, pdata->led_ctrl_flash[LED_CTRL_2]); pmu_led_write(LED_CTRL3, pdata->led_ctrl_flash[LED_CTRL_3]); /* set LED Flash current value */ if (data < pdata->flash_led_num) { cam_debug("%s flash_led=0x%x.", __func__, pdata->flash_led[data]); pmu_led_write(LED_CTRL4, (pdata->flash_led[data] & 0x0f)); } else { cam_warn("%s data(%d) > flash_led_num(%d).", __func__, data, pdata->flash_led_num); pmu_led_write(LED_CTRL4, (pdata->flash_led[pdata->flash_led_num-1] & 0x0f)); } pmu_led_write(LED_CTRL5, pdata->led_ctrl_flash[LED_CTRL_5]); if (flash_ctrl->flash_mask_enable) { pmu_led_write(LED_CTRL6, (pdata->led_ctrl_flash[LED_CTRL_6] & 0xf7)); } else { pmu_led_write(LED_CTRL6, (pdata->led_ctrl_flash[LED_CTRL_6] | 0x8)); } pmu_led_write(LED_CTRL7, pdata->led_ctrl_flash[LED_CTRL_7]); pmu_led_write(LED_CTRL2, LED_FLASH_ENABLE); return 0; }
int hw_sensor_gpio_config(gpio_t pin_type, hwsensor_board_info_t *sensor_info, struct sensor_power_setting *power_setting, int state) { int rc = -1; cam_debug("%s enter, pin_type: %d", __func__, pin_type); if (hw_is_fpga_board()) return 0; if(0 == sensor_info->gpios[pin_type].gpio) { cam_err("gpio type[%d] is not actived", pin_type); return rc; } rc = gpio_request(sensor_info->gpios[pin_type].gpio, NULL); if(rc < 0) { cam_err("failed to request gpio[%d]", sensor_info->gpios[pin_type].gpio); return rc; } if(pin_type == FSIN) { cam_info("pin_level: %d", gpio_get_value(sensor_info->gpios[pin_type].gpio)); rc = 0; } else { rc = gpio_direction_output(sensor_info->gpios[pin_type].gpio, state ? (power_setting->config_val + 1) % 2 : power_setting->config_val); if(rc < 0) { cam_err("failed to control gpio[%d]", sensor_info->gpios[pin_type].gpio); } else { cam_debug("%s config gpio[%d] output[%d].", __func__, sensor_info->gpios[pin_type].gpio, (state ? (power_setting->config_val + 1) % 2 : power_setting->config_val)); } } gpio_free(sensor_info->gpios[pin_type].gpio); if (0 != power_setting->delay) { hw_camdrv_msleep(power_setting->delay); } return rc; }
static int tps61310_remove(struct i2c_client *client) { cam_debug("%s enter.", __func__); tps61310_ctrl.func_tbl->flash_exit(&tps61310_ctrl); client->adapter = NULL; return 0; }
static int hw_lm3642_remove(struct i2c_client *client) { cam_debug("%s enter.", __func__); hw_lm3642_ctrl.func_tbl->flash_exit(&hw_lm3642_ctrl); client->adapter = NULL; return 0; }
static void pmu_led_write(unsigned int reg, unsigned int val) { struct pmu_led_private_data_t *pdata; cam_debug("%s reg=0x%x, val=0x%x.", __func__, reg, val); pdata = (struct pmu_led_private_data_t *)pmu_led_ctrl.pdata; writel(val, (pdata->pmu_base + (reg<<2))); }
void altek6045_notify_cmd_done( uint32_t cmd, uint32_t result) { hwextisp_event_t extisp_ev; extisp_ev.kind = HWEXTISP_INFO_CMD_FINISH; extisp_ev.data.cmd_finish.cmd = cmd; extisp_ev.data.cmd_finish.result = result; cam_debug("%s cmd = %x result = %d",__func__,cmd, result); hwextisp_intf_notify_error(s_altek6045.notify,&extisp_ev); }