int hisi_sensor_apply_expo_gain(struct hisi_sensor_ctrl_t *s_ctrl, void *data)
{
struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data;
struct expo_gain_seq me_seq = cdata->cfg.me_seq;
struct hisi_sensor_t *sensor = s_ctrl->sensor;
int i;
cam_notice("seq_size[%d]", me_seq.seq_size);
for(i = 0; i < me_seq.seq_size; i++) {
cam_notice("expo[0x%04x], gain[0x%02x]", me_seq.expo[i], me_seq.gain[i]);
}
cam_notice("eof trigger[%d]\n", me_seq.eof_trigger);
if(sensor->sensor_info->sensor_type == 1) {/*ov sensor*/
memmove(me_seq.gain + 1, me_seq.gain, sizeof(u32) * me_seq.seq_size);
me_seq.expo[me_seq.seq_size] = me_seq.expo[me_seq.seq_size - 1];
me_seq.seq_size++;
}
for(i = 0; i < me_seq.seq_size; i++) {
cam_notice("expo[0x%04x], gain[0x%02x], hts[0x%02x], vts[0x%02x]",
me_seq.expo[i], me_seq.gain[i], me_seq.hts, me_seq.vts);
}
return hw_setup_eof_tasklet(sensor, &me_seq);
}
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;
}
int hisi_sensor_suspend_eg_task(struct hisi_sensor_ctrl_t *s_ctrl, void *data)
{
struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data;
struct expo_gain_seq ori_state = cdata->cfg.host_ae_seq;
cam_notice("enter %s", __func__);
cam_notice("expo[0x%04x], gain[0x%02x], hts[0x%02x], vts[0x%02x]",
ori_state.expo[0], ori_state.gain[0], ori_state.hts, ori_state.vts);
return teardown_eof_tasklet(s_ctrl->sensor, &ori_state);
}
static int __init
imx214_sunny_init_module(void)
{
cam_notice("enter %s",__func__);
return platform_driver_probe(&s_imx214_sunny_driver,
imx214_sunny_platform_probe);
}
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;
}
static int32_t
altek6045_platform_probe(
struct platform_device* pdev)
{
cam_notice("%s enter", __func__);
return hwextisp_register(pdev, &s_altek6045.intf);
}
static int __init
ov8865_rear_init_module(void)
{
cam_notice("enter %s",__func__);
return platform_driver_probe(&s_ov8865_rear_driver,
ov8865_rear_platform_probe);
}
int altek6045_power_off(const hwextisp_intf_t* i)
{
return misp_exit();
#if 0
altek6045_private_data_t* pdata = NULL;
altek6045_t* mini_isp = NULL;
cam_notice("enter %s.", __func__);
mini_isp = I2A(i);
pdata = (altek6045_private_data_t *)mini_isp->pdata;
if (ncp6925_ctrl.func_tbl->pmic_seq_config) {
ret = ncp6925_ctrl.func_tbl->pmic_seq_config(&ncp6925_ctrl, VOUT_LDO_4, VOLTAGE_1P8V, MINI_ISP_POWER_OFF);
}
udelay(5);
if (ncp6925_ctrl.func_tbl->pmic_seq_config) {
ret = ncp6925_ctrl.func_tbl->pmic_seq_config(&ncp6925_ctrl, VOUT_LDO_5, VOLTAGE_1P1V, MINI_ISP_POWER_OFF);
}
udelay(5);
gpio_direction_output(pdata->pin[ISP_DVDD], MINI_ISP_POWER_OFF);
msleep(2);
#endif
}
/*
0x300A chipid 0x00 chipid[23:16]
0x300B chipid 0x88 chipid[15:8]
0x300C chipid 0x65 chipid[7:0]
*/
static int
ov8858_match_id(
hwsensor_intf_t* si, void * data)
{
sensor_t* sensor = I2S(si);
struct sensor_cfg_data *cdata = (struct sensor_cfg_data *)data;
struct sensor_cfg_data cdata_h;
struct sensor_cfg_data cdata_l;
u16 sensor_id = 0;
cdata_h.cfg.reg.subaddr = 0x300B;
cdata_h.cfg.reg.value = 0;
cdata_l.cfg.reg.subaddr = 0x300C;
cdata_l.cfg.reg.value = 0;
ov8858_i2c_read(si, &cdata_h);
ov8858_i2c_read(si, &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);
if (0x8858 == sensor_id) {
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;
}
cdata->data = sensor->board_info->sensor_index;
hwsensor_writefile(sensor->board_info->sensor_index,
sensor->board_info->name);
return 0;
}
static int __init
altek6045_init_module(void)
{
int ret = 0;
cam_notice("%s enter", __func__);
ret = platform_driver_probe(&s_altek6045_driver,
altek6045_platform_probe);
/* NOTE: use driver attribute */
if (ret == 0) {
if (driver_create_file(&s_altek6045_driver.driver, &driver_attr_test_pipe))
cam_warn("%s create driver attr failed", __func__);
if (driver_create_file(&s_altek6045_driver.driver, &driver_attr_ois_pixel))
cam_warn("%s create driver attr failed", __func__);
if (driver_create_file(&s_altek6045_driver.driver, &driver_attr_test_ois))
cam_warn("%s create driver attr failed", __func__);
if (driver_create_file(&s_altek6045_driver.driver, &driver_attr_check_ois))
cam_warn("%s create driver attr failed", __func__);
if (driver_create_file(&s_altek6045_driver.driver, &driver_attr_firmware))
cam_warn("%s create driver attr firmware failed", __func__);
}
//init queue
init_waitqueue_head(&ois_queue);
return ret;
}
static int32_t
imx230_plk_platform_probe(
struct platform_device* pdev)
{
int rc = 0;
cam_notice("enter %s",__func__);
if (pdev->dev.of_node) {
rc = hw_sensor_get_dt_data(pdev, &s_imx230_plk);
if (rc < 0) {
cam_err("%s failed line %d\n", __func__, __LINE__);
goto imx230_plk_sensor_probe_fail;
}
if (s_imx230_plk.board_info->gpios[SUSPEND].gpio == 0) {
s_imx230_plk.power_setting_array.power_setting = hw_imx230_plk_power_setting_va;
s_imx230_plk.power_setting_array.size = ARRAY_SIZE(hw_imx230_plk_power_setting_va);
}
} else {
cam_err("%s imx230_plk of_node is NULL.\n", __func__);
goto imx230_plk_sensor_probe_fail;
}
rc = hwsensor_register(pdev, &s_imx230_plk.intf);
imx230_plk_sensor_probe_fail:
return rc;
}
int
ov8865_carrera_power_down(
hwsensor_intf_t* si)
{
int ret = 0;
sensor_t* sensor = NULL;
sensor = I2S(si);
if(is_poweron) {
ret = hw_sensor_power_down(sensor);
cam_notice("---ov8865_carrera power off!---");
is_poweron = false;
} else {
cam_notice("---not power off---");
}
return ret;
}
int
ov8865_carrera_power_up(
hwsensor_intf_t* si)
{
int ret = 0;
sensor_t* sensor = NULL;
sensor = I2S(si);
if(!is_poweron) {
ret = hw_sensor_power_up(sensor);
cam_notice("+++ov8865_carrera power on!+++");
is_poweron = true;
} else {
cam_notice("+++not power on+++");
}
return ret;
}
static int __init
imx278_carrera_init_module(void)
{
cam_notice("enter %s",__func__);
return platform_driver_probe(&s_imx278_carrera_driver,
imx278_carrera_platform_probe);
}
int imx135_match_id(struct hisi_sensor_ctrl_t *s_ctrl)
{
int ret = 0;
u16 id_h = 0;
u16 id_l = 0;
u16 sensor_id = 0;
cam_info( "%s, sensor_chipid:0x%x\n",
__func__, s_ctrl->sensor->sensor_info->sensor_chipid);
ret = hisi_sensor_power_up(s_ctrl);
if(ret) {
cam_err("sensor[%s] power up failed.", s_ctrl->sensor->sensor_info->name);
ret = -1;
goto out;
}
/* check sensor id */
isp_read_sensor_byte(&s_ctrl->sensor->sensor_info->i2c_config, 0x0016, &id_h);
isp_read_sensor_byte(&s_ctrl->sensor->sensor_info->i2c_config, 0x0017, &id_l);
sensor_id = id_h << 8 | id_l;
cam_notice( "sensor id: 0x%x", sensor_id);
if (sensor_id != s_ctrl->sensor->sensor_info->sensor_chipid) {
ret = -1;
}
out:
hisi_sensor_power_down(s_ctrl);
return ret;
}
static int hw_vcm_subdev_open(
struct v4l2_subdev *sd,
struct v4l2_subdev_fh *fh)
{
cam_notice("hw_vcm_sbudev open! \n");
return 0;
}
static int
hw_vcm_subdev_close(
struct v4l2_subdev *sd,
struct v4l2_subdev_fh *fh)
{
cam_notice("hw_vcm_sbudev close! \n");
return 0;
}
static int __init
ar1335_init_module(void)
{
cam_notice("enter %s",__func__);
return platform_driver_probe(&s_ar1335_driver,
ar1335_platform_probe);
}
int altek6045_exec_cmd(const hwextisp_intf_t* i, hwcam_config_data_t *data)
{
int rc = 0;
u8 *in_buf = NULL, *out_buf = NULL;
u32 opcode, dir_type, block_response, out_len, in_len;
bool out_to_block;
cam_notice("enter %s cmd=0x%x.", __func__, data->cmd);
dir_type = data->cmd & EXTISP_CMD_DIR_FLAG_MASK;
block_response = data->cmd & EXTISP_CMD_RESP_FLAG_MASK;
out_len = in_len = (data->cmd & EXTISP_CMD_LEN_MASK)>>EXTISP_CMD_LEN_SHIT;
opcode = (data->cmd & EXTISP_CMD_OPCODE_MASK)>>EXTISP_CMD_OPCODE_SHIT;
out_buf = in_buf = data->u.buf;
out_to_block = (EXTISP_BLOCK_RESPONSE_CMD == block_response)? true: false;
/* allocate kernel buf: override out_buf out_len*/
if (out_to_block) {
out_len = data->ext_buf.user_buf_len;
if (out_len > 4096) {
cam_err("%s invalid ext_buf_len=%d", __func__, out_len);
return -EINVAL;
}
out_buf = kmalloc(out_len, GFP_KERNEL);
if (NULL == out_buf) {
cam_err("%s kmalloc failed", __func__);
return -ENOMEM;;
}
}
if (EXTISP_INOUT_CMD == dir_type) {
rc = misp_exec_bidir_cmd((u16)opcode, data->u.buf, in_len,
out_to_block, out_buf, out_len);
} else if (EXTISP_SET_CMD == dir_type) {
rc = misp_exec_unidir_cmd((u16)opcode, true,
out_to_block, in_buf, in_len);
} else if (EXTISP_GET_CMD == dir_type) {
rc = misp_exec_unidir_cmd((u16)opcode, false,
out_to_block, out_buf, out_len);
} else {
cam_err("%s unkown cmd direction", __func__);
rc = -EINVAL;
}
/* reclaimed kernel buf*/
if (out_to_block) {
if (copy_to_user(data->ext_buf.user_buf_ptr, out_buf, out_len)) {
cam_err("%s copy to user failed", __func__);
rc = -EFAULT;
}
kfree(out_buf);
}
return rc;
}
int hw_sensor_pmic_config(hwsensor_board_info_t *sensor_info,
struct sensor_power_setting *power_setting, int state)
{
int rc = 0;
cam_notice("%s enter.", __func__);
cam_notice("%s seq_val=%d, config_val=%d, state=%d",
__func__, power_setting->seq_val, power_setting->config_val, state);
//todo ...
//use wangzhengyong pmic interface
if (ncp6925_ctrl.func_tbl->pmic_seq_config) {
rc = ncp6925_ctrl.func_tbl->pmic_seq_config(&ncp6925_ctrl, power_setting->seq_val, power_setting->config_val, state);
}
if (0 != power_setting->delay) {
hw_camdrv_msleep(power_setting->delay);
}
return rc;
}
static int32_t imx135_platform_probe(struct platform_device *pdev)
{
int32_t rc = 0;
const struct of_device_id *match;
match = of_match_device(hisi_imx135_dt_match, &pdev->dev);
cam_notice("%s compatible=%s.\n", __func__, match->compatible);
rc = imx135_sensor_probe(pdev);
return rc;
}
static int32_t sensor_platform_probe(struct platform_device *pdev)
{
const struct of_device_id *match;
match = of_match_device(hisi_sensor_dt_match, &pdev->dev);
if(!match) {
cam_err("sensor match device failed");
return -1;
}
cam_notice("%s compatible=%s.\n", __func__, match->compatible);
return hisi_sensor_platform_probe(pdev, (void*)match->data);
}
int altek6045_load_firmware(const hwextisp_intf_t* i)
{
int rc = 0;
cam_notice("enter %s.", __func__);
rc = misp_load_fw();
if (rc < 0) {
cam_err("%s failed to load firmware for altek6045.", __func__);
return rc;
}
return 0;
}
static int __init hw_ad5816_module_init(void)
{
int rc = 0;
cam_debug("%s:%d\n", __func__, __LINE__);
rc = platform_driver_probe(&hw_ad5816_platform_driver,
ad5816_platform_probe);
if (rc < 0) {
cam_notice("%s platform_driver_probe error.\n", __func__);
}
return rc;
}
static int __init ov8830_module_init(void)
{
int rc = 0;
cam_debug("%s:%d\n", __func__, __LINE__);
rc = platform_driver_probe(&ov8830_platform_driver,
ov8830_platform_probe);
if (rc < 0) {
cam_notice("%s platform_driver_probe error(%d).\n", __func__, rc);
}
return rc;
}
int hisi_sensor_ldo_config(ldo_index_t ldo, struct hisi_sensor_info *sensor_info,
struct sensor_power_setting *power_setting, int state)
{
int index;
int rc = -1;
const char *ldo_names[LDO_MAX]
= {"dvdd", "dvdd2", "avdd", "avdd2", "vcm", "vcm2", "iopw"};
cam_debug("%s enter, ldo: %d", __func__, ldo);
if (is_fpga_board())
return 0;
for(index = 0; index < sensor_info->ldo_num; index++) {
if(!strcmp(sensor_info->ldo[index].supply, ldo_names[ldo]))
break;
}
if(index == sensor_info->ldo_num) {
cam_notice("ldo [%s] is not actived", ldo_names[ldo]);
return 0;
}
if (POWER_ON == state) {
if(LDO_IOPW != ldo) {
rc = regulator_set_voltage(sensor_info->ldo[index].consumer, power_setting->config_val, power_setting->config_val);
if(rc < 0) {
cam_err("failed to set ldo[%s] to %d V", ldo_names[ldo], power_setting->config_val);
return rc;
}
}
rc = regulator_bulk_enable(1, &sensor_info->ldo[index]);
if (rc) {
cam_err("failed to enable regulators %d\n", rc);
return rc;
}
if (0 != power_setting->delay) {
camdrv_msleep(power_setting->delay);
}
} else {
regulator_bulk_disable(1, &sensor_info->ldo[index]);
rc = 0;
}
return rc;
}
static int tps61310_off(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 int state;
unsigned char val;
cam_debug("%s ernter.\n", __func__);
if (NULL == flash_ctrl) {
cam_err("%s flash_ctrl is NULL.", __func__);
return -1;
}
if (STANDBY_MODE == flash_ctrl->state.mode) {
cam_notice("%s flash led has been powered off.", __func__);
return 0;
}
mutex_lock(flash_ctrl->hisi_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;
pdata = (struct tps61310_private_data_t *)flash_ctrl->pdata;
state = gpio_get_value(pdata->pin[RESET]);
if (state != LOW) {
/*************************************************
* set flash mode ctrl reg
* REGISTER1[7:6] & REGISTER2[7:6]:
* 00:shutdown mode
*************************************************/
i2c_func->i2c_read(i2c_client, REGISTER1, &val);
i2c_func->i2c_write(i2c_client, REGISTER1, val & SHUTDOWN_MODE);
i2c_func->i2c_read(i2c_client, REGISTER2, &val);
i2c_func->i2c_write(i2c_client, REGISTER2, val & SHUTDOWN_MODE);
}
tps61310_set_strobe0(flash_ctrl, LOW);
tps61310_set_strobe1(flash_ctrl, HIGH);
tps61310_set_reset(flash_ctrl, LOW);
mutex_unlock(flash_ctrl->hisi_flash_mutex);
return 0;
}
static int hw_scharger_off(struct hw_flash_ctrl_t *flash_ctrl)
{
struct hw_scharger_private_data_t *pdata;
cam_debug("%s enter.\n", __func__);
if (NULL == flash_ctrl) {
cam_err("%s flash_ctrl is NULL.", __func__);
return -1;
}
if (STANDBY_MODE == flash_ctrl->state.mode) {
cam_notice("%s flash led has been powered off.", __func__);
return 0;
}
pdata = (struct hw_scharger_private_data_t *)flash_ctrl->pdata;
if ((NULL == pdata->flash_inter_ldo)
|| (NULL == pdata->flash_mode_ldo)
|| (NULL == pdata->torch_mode_ldo)) {
cam_err("%s regulator is NULL", __func__);
return -1;
}
mutex_lock(flash_ctrl->hw_flash_mutex);
if (BIT(TORCH_MODE) & pdata->status) {
regulator_disable(pdata->torch_mode_ldo);
regulator_disable(pdata->flash_inter_ldo);
pdata->status &= ~BIT(TORCH_MODE);
}
if (BIT(FLASH_MODE) & pdata->status) {
regulator_disable(pdata->flash_mode_ldo);
regulator_disable(pdata->flash_inter_ldo);
pdata->status &= ~BIT(FLASH_MODE);
}
flash_ctrl->state.mode = STANDBY_MODE;
flash_ctrl->state.data = 0;
mutex_unlock(flash_ctrl->hw_flash_mutex);
return 0;
}
static int32_t hisi_sensor_platform_probe(struct platform_device *pdev,
void *data)
{
int32_t rc = 0;
uint32_t group_id;
struct hisi_sensor_ctrl_t *s_ctrl =
(struct hisi_sensor_ctrl_t *)data;
const char *sd_name = NULL;
s_ctrl->pdev = pdev;
s_ctrl->dev = &pdev->dev;
group_id = s_ctrl->index ? HISI_CAMERA_SUBDEV_SENSOR1
: HISI_CAMERA_SUBDEV_SENSOR0;
if (!s_ctrl->sensor_v4l2_subdev_ops)
s_ctrl->sensor_v4l2_subdev_ops = &hisi_sensor_subdev_ops;
s_ctrl->hisi_sd.sd.internal_ops = &hisi_sensor_subdev_internal_ops;
v4l2_subdev_init(&s_ctrl->hisi_sd.sd,
s_ctrl->sensor_v4l2_subdev_ops);
rc = of_property_read_string(pdev->dev.of_node, "hisi,sensor-name",
&sd_name);
cam_notice("%s name %s, rc %d\n", __func__, sd_name, rc);
if (rc < 0) {
cam_err("%s failed %d\n", __func__, __LINE__);
}
snprintf(s_ctrl->hisi_sd.sd.name,
sizeof(s_ctrl->hisi_sd.sd.name), "%s",
sd_name);
cam_debug("%s sd.name is %s.\n", __func__, s_ctrl->hisi_sd.sd.name);
v4l2_set_subdevdata(&s_ctrl->hisi_sd.sd, pdev);
s_ctrl->hisi_sd.sd.flags |= V4L2_SUBDEV_FL_HAS_DEVNODE;
media_entity_init(&s_ctrl->hisi_sd.sd.entity, 0, NULL, 0);
s_ctrl->hisi_sd.sd.entity.type = MEDIA_ENT_T_V4L2_SUBDEV;
s_ctrl->hisi_sd.sd.entity.group_id = group_id;
s_ctrl->hisi_sd.sd.entity.name = s_ctrl->hisi_sd.sd.name;
hisi_sd_register(&s_ctrl->hisi_sd);
return rc;
}
static int __init
altek6045_init_module(void)
{
int ret = 0;
cam_notice("%s enter", __func__);
ret = platform_driver_probe(&s_altek6045_driver,
altek6045_platform_probe);
/* NOTE: use driver attribute */
if (ret == 0) {
if (driver_create_file(&s_altek6045_driver.driver, &driver_attr_test_pipe))
cam_warn("%s create driver attr failed", __func__);
}
return ret;
}
