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);
}
