C++ (Cpp) msm_camera_i2c_write Examples

Example #1

/*=============================================================*/
int32_t msm_sensor_adjust_frame_lines(struct msm_sensor_ctrl_t *s_ctrl,
	uint16_t res)
{
	uint16_t cur_line = 0;
	uint16_t exp_fl_lines = 0;
	if (s_ctrl->sensor_exp_gain_info) {
		if (s_ctrl->prev_gain && s_ctrl->prev_line &&
			s_ctrl->func_tbl->sensor_write_exp_gain)
			s_ctrl->func_tbl->sensor_write_exp_gain(
				s_ctrl,
				s_ctrl->prev_gain,
				s_ctrl->prev_line);

		msm_camera_i2c_read(s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_exp_gain_info->coarse_int_time_addr,
			&cur_line,
			MSM_CAMERA_I2C_WORD_DATA);
		exp_fl_lines = cur_line +
			s_ctrl->sensor_exp_gain_info->vert_offset;
		if (exp_fl_lines > s_ctrl->msm_sensor_reg->
			output_settings[res].frame_length_lines)
			msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_output_reg_addr->
				frame_length_lines,
				exp_fl_lines,
				MSM_CAMERA_I2C_WORD_DATA);
		CDBG("%s cur_fl_lines %d, exp_fl_lines %d\n", __func__,
			s_ctrl->msm_sensor_reg->
			output_settings[res].frame_length_lines,
			exp_fl_lines);
	}
	return 0;
}

Example #2

File: imx111.c Project: AmperificSuperKANG/android_kernel_mako

int32_t imx111_sensor_set_fps(struct msm_sensor_ctrl_t *s_ctrl,
						struct fps_cfg *fps)
{
	uint16_t total_lines_per_frame;
	int32_t rc = 0;
	s_ctrl->fps_divider = fps->fps_div;

	if (s_ctrl->curr_res != MSM_SENSOR_INVALID_RES) {
		uint16_t fl_read = 0;
		total_lines_per_frame = (uint16_t)
			((s_ctrl->curr_frame_length_lines) *
			s_ctrl->fps_divider/Q10);

		rc = msm_camera_i2c_read(s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_output_reg_addr->frame_length_lines,
			&fl_read, MSM_CAMERA_I2C_WORD_DATA);

		CDBG("%s: before_fl = %d, new_fl = %d", __func__, fl_read, total_lines_per_frame);

		if(fl_read < total_lines_per_frame) {
			pr_err("%s: Write new_fl (before_fl = %d, new_fl = %d)", __func__, fl_read, total_lines_per_frame);
			rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_output_reg_addr->frame_length_lines,
				total_lines_per_frame, MSM_CAMERA_I2C_WORD_DATA);
		}
	}
	return rc;
}

Example #3

static int32_t s5k4e5yx_wrapper_i2c_write(struct msm_actuator_ctrl_t *a_ctrl,
	int16_t next_lens_position, void *params)
{
	int32_t rc = 0;

	rc = msm_camera_i2c_write(&a_ctrl->i2c_client,
		REG_VCM_CODE_MSB,
		((next_lens_position & 0x0300) >> 8),
		MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("%s VCM_CODE_MSB i2c write failed (%d)\n", __func__, rc);
		return rc;
	}

	rc = msm_camera_i2c_write(&a_ctrl->i2c_client,
		REG_VCM_CODE_LSB,
		(next_lens_position & 0x00FF),
		MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("%s VCM_CODE_LSB i2c write failed (%d)\n", __func__, rc);
		return rc;
	}

	return rc;
}

Example #4

File: msm_sensor.c Project: phuthinh100/Kernel-JB--sky-A830L

int32_t msm_sensor_set_fps(struct msm_sensor_ctrl_t *s_ctrl,
						struct fps_cfg *fps)
{
#if 0//wsyang_temp
	uint16_t total_lines_per_frame;
	int32_t rc = 0;
	s_ctrl->fps_divider = fps->fps_div;

	if (s_ctrl->curr_res != MSM_SENSOR_INVALID_RES) {
		total_lines_per_frame = (uint16_t)
			((s_ctrl->curr_frame_length_lines) *
			s_ctrl->fps_divider/Q10);

#if 1//def F_PANTECH_CAMERA_OV8820	
	//if(strcmp(s_ctrl->sensordata->sensor_name, "ov8820") == 0) {
	if(s_ctrl->sensor_id_info->sensor_id == OV8820_ID) {
		
		pr_err("%s: -- OV8820 : %d %d %d\n", __func__, total_lines_per_frame,s_ctrl->curr_frame_length_lines,s_ctrl->fps_divider);

		////////////////////////////////////////////
		//total_lines_per_frame = 2800;//0xE00; // It will be remove after patch.
		////////////////////////////////////////////	
		rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			0x380E, ((total_lines_per_frame & 0xFF00) >> 8),MSM_CAMERA_I2C_BYTE_DATA);

		rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			0x380F, (total_lines_per_frame & 0x00FF),MSM_CAMERA_I2C_BYTE_DATA);
		
	}

Example #5

File: ov10820_v4l2.c Project: ReflexBow/android_kernel_motorola_ghost

static int32_t ov10820_ctrl_strobe(struct msm_sensor_ctrl_t *s_ctrl,
			uint8_t enable_strobe)
{
	int32_t rc = 0;
	pr_debug("%s : 0x%x", __func__, enable_strobe);
	if (enable_strobe) {
		rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x3b00,
				0x83, MSM_CAMERA_I2C_BYTE_DATA);
	} else {
		rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x3b00,
				0x00, MSM_CAMERA_I2C_BYTE_DATA);
	}
	if (rc < 0)
		pr_err("%s: Unable to toggle the strobe line\n", __func__);
	return rc;
}

Example #6

File: imx111.c Project: estiko/android_kernel_lenovo_armani

void imx111_sensor_reset_stream(struct msm_sensor_ctrl_t *s_ctrl)
{
	msm_camera_i2c_write(
		s_ctrl->sensor_i2c_client,
		0x103, 0x1,
		MSM_CAMERA_I2C_BYTE_DATA);
}

Example #7

File: flash.c Project: Zoldyck07/SXDNickiSS

static int lm3642_init( enum lm3642_pin_enable torch_pin_en, 
                         enum lm3642_pin_enable strobe_pin_en, 
                         enum lm3642_pin_enable tx_pin_en)
{
    int rc = 0;
    uint16_t reg_val = 0;

	/*set enable register */
    rc = msm_camera_i2c_read(&i2c_client, REG_ENABLE, &reg_val, MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("lm3642_init: msm_camera_i2c_read(0x%x) failed! rc = %d\n", REG_ENABLE, rc);
		goto error;
	}
    CDBG("lm3642_init: msm_camera_i2c_read(0x%x) = 0x%x .\n", REG_ENABLE, reg_val);

	reg_val &= (~EX_PIN_ENABLE_MASK);
	reg_val |= ((torch_pin_en & 0x01) << TORCH_PIN_EN_SHIFT);
	reg_val |= ((strobe_pin_en & 0x01) << STROBE_PIN_EN_SHIFT);
	reg_val |= ((tx_pin_en & 0x01) << TX_PIN_EN_SHIFT);

    rc = msm_camera_i2c_write(&i2c_client, REG_ENABLE, reg_val, MSM_CAMERA_I2C_BYTE_DATA);
    if (rc < 0) {
        pr_err("lm3642_init: msm_camera_i2c_write(0x%x) failed! rc = %d\n", REG_ENABLE, rc);
        goto error;
    }
    CDBG("lm3642_init: Set reg_0x%x = 0x%x .\n", REG_ENABLE, reg_val);

error:
    return rc;

}

Example #8

File: s5k5ca_v4l2_yuv.c Project: Zoldyck07/android_kernel_sony_msm7x27a

static int s5k5ca_set_exposure(struct msm_sensor_ctrl_t *s_ctrl,
		struct msm_sensor_v4l2_ctrl_info_t *ctrl_info, int value)
{
	int32_t rc = -EINVAL;
	//printk(" s5k5ca_set_exposure() value:%x\n",value);
	value >>= 16;
	if((value>=-12) && (value <=12))
	{
		rc=msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x0028, 0x7000, MSM_CAMERA_I2C_WORD_DATA);
		rc|=msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x002a, 0x020C, MSM_CAMERA_I2C_WORD_DATA);
		rc|=msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x0F12, (value*10), MSM_CAMERA_I2C_WORD_DATA);
	}
		
	return rc;

}

Example #9

File: flash.c Project: Zoldyck07/SXDNickiSS

static int lm3642_write_bits(uint8_t reg, uint8_t val, uint8_t mask, uint8_t shift)
{
    int rc = 0;
    uint16_t reg_val = 0;
    
    rc = msm_camera_i2c_read(&i2c_client, reg, &reg_val, MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("lm3642_write_bits: msm_camera_i2c_read(0x%x) failed! rc = %d\n", reg, rc);
		goto error;
	}
    CDBG("lm3642_write_bits: Before: msm_camera_i2c_read(0x%x) = 0x%x .\n", reg, reg_val);

    reg_val &= (~(mask << shift));
    reg_val |= ((val & mask) << shift);

    printk("lm3642_write_bits: Set reg_0x%x = 0x%x .\n", reg, reg_val);
    rc = msm_camera_i2c_write(&i2c_client, reg, reg_val, MSM_CAMERA_I2C_BYTE_DATA);
    if (rc < 0) {
        pr_err("lm3642_write_bits: msm_camera_i2c_write(0x%x) failed! rc = %d\n", reg, rc);
        goto error;
    }

    rc = msm_camera_i2c_read(&i2c_client, reg, &reg_val, MSM_CAMERA_I2C_BYTE_DATA);
    if (rc < 0) {
        pr_err("lm3642_write_bits: msm_camera_i2c_read(0x%x) failed! rc = %d\n", reg, rc);
        goto error;
    }
    CDBG("lm3642_write_bits: After: msm_camera_i2c_read(0x%x) = 0x%x .\n", reg, reg_val);

error:
    return rc;
}

Example #10

File: ov5648_truly_cm8352_v4l2_PIP.c Project: weritos666/ARCHOS_50_Platinum

void ov5648_truly_cm8352_sensor_reset_stream(struct msm_sensor_ctrl_t *s_ctrl)
{
	msm_camera_i2c_write(
		s_ctrl->sensor_i2c_client,
		0x103, 0x1,
		MSM_CAMERA_I2C_BYTE_DATA);
}

Example #11

static int32_t imx135_sensor_otp_prepare_read(struct msm_sensor_ctrl_t *s_ctrl,uint16_t page)
{
    int32_t i=0;
	uint16_t check_status;
	
	msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x3B02, page, MSM_CAMERA_I2C_BYTE_DATA);
	
	msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x3B00, 0x01, MSM_CAMERA_I2C_BYTE_DATA);
	
	do{
		msleep(10);
		msm_camera_i2c_read(s_ctrl->sensor_i2c_client, 0x3B01, &check_status,MSM_CAMERA_I2C_BYTE_DATA);

	}while(check_status != 0x01 && i++ < 5);
	return  ((check_status == 0x01)? 0 :-1);
}

Example #12

File: ov5647_v4l2.c Project: AbdulrahmanAmir/Dorimanx-LG-G2-D802-Kernel

static int32_t ov5647_write_pict_exp_gain(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t gain, uint32_t line)
{

	static uint16_t max_line = 1964;
	uint8_t gain_lsb, gain_hsb;
	u8 intg_time_hsb, intg_time_msb, intg_time_lsb;

	gain_lsb = (uint8_t) (gain);
	gain_hsb = (uint8_t)((gain & 0x300)>>8);

	CDBG(KERN_ERR "snapshot exposure seting 0x%x, 0x%x, %d"
		, gain, line, line);
	s_ctrl->func_tbl->sensor_group_hold_on(s_ctrl);
	if (line > 1964) {
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_output_reg_addr->frame_length_lines,
			(uint8_t)((line+4) >> 8),
			MSM_CAMERA_I2C_BYTE_DATA);

		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_output_reg_addr->frame_length_lines + 1,
			(uint8_t)((line+4) & 0x00FF),
			MSM_CAMERA_I2C_BYTE_DATA);
		max_line = line + 4;
	} else if (max_line > 1968) {

Example #13

File: s5k4e5yx_act.c Project: dummie999/android_kernel_htc_z4u

static int s5k4e5yx_i2c_add_driver_table(
	void)
{
	int32_t rc = 0;

	LINFO("%s called\n", __func__);

	rc = s5k4e5yx_poweron_af();
	if (rc < 0) {
		pr_err("%s power on failed\n", __func__);
		return (int) rc;
	}

	s5k4e5yx_act_t.step_position_table = NULL;
	rc = s5k4e5yx_act_t.func_tbl.actuator_init_table(&s5k4e5yx_act_t);
	if (rc < 0) {
		pr_err("%s init table failed\n", __func__);
		return (int) rc;
	}

	rc = msm_camera_i2c_write(&(s5k4e5yx_act_t.i2c_client),
		0x0001, 0x01,
		MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("%s i2c write failed\n", __func__);
		return (int) rc;
	}

	return (int) rc;
}

Example #14

File: hi351_v4l2.c Project: F4uzan/skernel_u0

int32_t hi351_match_id(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	uint16_t chipid = 0;

	rc = msm_camera_i2c_write(
			s_ctrl->sensor_i2c_client,
			SENSOR_REG_PAGE_ADDR,
			SENSOR_REG_PAGE_0,
			MSM_CAMERA_I2C_BYTE_DATA);

	rc = msm_camera_i2c_read(
			s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_id_info->sensor_id_reg_addr, &chipid,
			MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("%s: %s: read id failed\n", __func__,
			s_ctrl->sensordata->sensor_name);
		return rc;
	}

	CDBG("hi351_sensor id: %d\n", chipid);
	if (chipid != s_ctrl->sensor_id_info->sensor_id) {
		pr_err("hi351_match chip id doesnot match\n");
		return -ENODEV;
	}
	return rc;
}

Example #15

void ov5647_sunny_p5v02s_sensor_reset_stream(struct msm_sensor_ctrl_t *s_ctrl)
{
	msm_camera_i2c_write(
		s_ctrl->sensor_i2c_client,
		0x103, 0x1,
		MSM_CAMERA_I2C_BYTE_DATA);
}

Example #16

static int32_t ov7736_set_gamma(struct msm_sensor_ctrl_t *s_ctrl, uint8_t unity)
{
	int32_t rc = 0;
	uint16_t readdata;
	uint8_t data;

	rc = msm_camera_i2c_read(
			s_ctrl->sensor_i2c_client,
			0x5000, &readdata,
			MSM_CAMERA_I2C_BYTE_DATA);

	if (rc < 0) {
		pr_err("%s: read gamma register failed\n", __func__);
		return rc;
	}

	data = (uint8_t)readdata;

	if (unity)
		data |= 0x40;
	else
		data &= 0xBF;

	rc = msm_camera_i2c_write(
			s_ctrl->sensor_i2c_client,
			0x5000, data,
			MSM_CAMERA_I2C_BYTE_DATA);

	if (rc < 0) {
		pr_err("%s: write gamma register failed\n", __func__);
		return rc;
	}

	return rc;
}

Example #17

File: flash.c Project: LiquidSmooth-Devices/Deathly_Kernel_D2

static int tps61310_i2c_probe(struct i2c_client *client,
		const struct i2c_device_id *id)
{
	int rc = 0;
	CDBG("%s enter\n", __func__);

	if (!i2c_check_functionality(client->adapter, I2C_FUNC_I2C)) {
		pr_err("i2c_check_functionality failed\n");
		goto probe_failure;
	}

	tps61310_client = client;
	i2c_client.client = tps61310_client;
	i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
	rc = msm_camera_i2c_write(&i2c_client, 0x01, 0x00,
		MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		tps61310_client = NULL;
		goto probe_failure;
	}

	CDBG("%s success! rc = %d\n", __func__, rc);
	return 0;

probe_failure:
	pr_err("%s failed! rc = %d\n", __func__, rc);
	return rc;
}

Example #18

int32_t imx175_set_dig_gain(struct msm_sensor_ctrl_t *s_ctrl, uint16_t dig_gain)
{
    msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
                         REG_DIGITAL_GAIN_GREEN_R, dig_gain,
                         MSM_CAMERA_I2C_WORD_DATA);
    msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
                         REG_DIGITAL_GAIN_RED, dig_gain,
                         MSM_CAMERA_I2C_WORD_DATA);
    msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
                         REG_DIGITAL_GAIN_BLUE, dig_gain,
                         MSM_CAMERA_I2C_WORD_DATA);
    msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
                         REG_DIGITAL_GAIN_GREEN_B, dig_gain,
                         MSM_CAMERA_I2C_WORD_DATA);

    return 0;
}

Example #19

File: ov10820_v4l2.c Project: ReflexBow/android_kernel_motorola_ghost

/* TBD: Need to revisit*/
static int32_t ov10820_write_exp_gain(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t gain, uint32_t line, int32_t luma_avg, uint16_t fgain)
{
	uint32_t fl_lines, offset;
	uint8_t int_time[3];

	fl_lines =
		(s_ctrl->curr_frame_length_lines * s_ctrl->fps_divider) / Q10;
	offset = s_ctrl->sensor_exp_gain_info->vert_offset;
	if (line > (fl_lines - offset))
		fl_lines = line + offset;

	fl_lines += (fl_lines & 0x1);

	int_time[0] = line >> 12;
	int_time[1] = line >> 4;
	int_time[2] = line << 4;

	if (allow_asic_control) {
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_output_reg_addr->
				frame_length_lines, fl_lines,
				MSM_CAMERA_I2C_WORD_DATA);
		ov660_set_i2c_bypass(0);
		ov660_set_exposure_gain(gain, line);
		ov660_set_i2c_bypass(1);
	} else {
		s_ctrl->func_tbl->sensor_group_hold_on(s_ctrl);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_output_reg_addr->
				frame_length_lines, fl_lines,
				MSM_CAMERA_I2C_WORD_DATA);
		msm_camera_i2c_write_seq(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_exp_gain_info->
				coarse_int_time_addr, &int_time[0], 3);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_exp_gain_info->
				global_gain_addr, gain,
				MSM_CAMERA_I2C_BYTE_DATA);
		s_ctrl->func_tbl->sensor_group_hold_off(s_ctrl);
		if (update_ov660_gain)
			ov660_set_exposure_gain2(gain, line);
	}

	return 0;
}

Example #20

File: s5k5b3g_v4l2.c Project: gustavosss/android_kernel_motorola_ghost

static int32_t s5k5b3g_write_exp_gain(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t gain, uint32_t line, int32_t luma_avg, uint16_t fgain)
{
	uint32_t fl_lines, offset;
	int32_t rc = 0;

	fl_lines =
		(s_ctrl->curr_frame_length_lines * s_ctrl->fps_divider) / Q10;
	offset = s_ctrl->sensor_exp_gain_info->vert_offset;
	if (line > (fl_lines - offset))
		fl_lines = line + offset;

	s_ctrl->func_tbl->sensor_group_hold_on(s_ctrl);

	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_output_reg_addr->frame_length_lines, fl_lines,
		MSM_CAMERA_I2C_WORD_DATA);

	if (rc < 0) {
		pr_err("%s: write frame length register failed\n", __func__);
		return rc;
	}

	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->coarse_int_time_addr,
		line, MSM_CAMERA_I2C_WORD_DATA);

	if (rc < 0) {
		pr_err("%s: write coarse integration register failed\n",
			__func__);
		return rc;
	}

	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->global_gain_addr, gain,
		MSM_CAMERA_I2C_WORD_DATA);

	if (rc < 0) {
		pr_err("%s: write global gain register failed\n", __func__);
		return rc;
	}

	s_ctrl->func_tbl->sensor_group_hold_off(s_ctrl);

	return rc;
}

Example #21

File: mt9e013_v4l2.c Project: AnDr0id/SGH-I747

static int32_t mt9e013_write_exp_gain(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t gain, uint32_t line)
{
	uint32_t fl_lines;
	fl_lines =
		(s_ctrl->curr_frame_length_lines * s_ctrl->fps_divider) / Q10;

	s_ctrl->func_tbl->sensor_group_hold_on(s_ctrl);
	msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->global_gain_addr, gain | 0x1000,
		MSM_CAMERA_I2C_WORD_DATA);
	msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->coarse_int_time_addr, line,
		MSM_CAMERA_I2C_WORD_DATA);
	s_ctrl->func_tbl->sensor_group_hold_off(s_ctrl);
	return 0;
}

Example #22

File: ar0543_v4l2.c Project: Zoldyck07/SXDNickiSS

static int32_t ar0543_write_pict_exp_gain(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t gain, uint32_t line, int32_t luma_avg, uint16_t fgain)
{
  int32_t rc = 0;
  //rc = ar0543_write_prev_exp_gain(s_ctrl,gain,line);   //uriwei
  rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,0x301A,(0x065C|0x2),
    MSM_CAMERA_I2C_WORD_DATA);
  return rc;
}

Example #23

int32_t imx111_sensor_write_exp_gain1(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t gain, uint32_t line)
{
	int32_t rc = 0;
	uint32_t fl_lines;
	uint8_t offset;
	fl_lines = s_ctrl->curr_frame_length_lines;
	fl_lines = (fl_lines * s_ctrl->fps_divider) / Q10;
	offset = s_ctrl->sensor_exp_gain_info->vert_offset;
	if (line > (fl_lines - offset))
		fl_lines = line + offset;

	curr_frame_length_lines = fl_lines; 
	CDBG("\n%s:Gain:%d, Linecount:%d\n", __func__, gain, line);

	s_ctrl->func_tbl->sensor_group_hold_on(s_ctrl);
	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_output_reg_addr->frame_length_lines,
			fl_lines, MSM_CAMERA_I2C_WORD_DATA);

	if (rc < 0){
		return rc;
	}

	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_exp_gain_info->coarse_int_time_addr,
			line, MSM_CAMERA_I2C_WORD_DATA);

	if (rc < 0){
		return rc;
	}

	if (rc >= 0){
		rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
				s_ctrl->sensor_exp_gain_info->global_gain_addr, gain,
				MSM_CAMERA_I2C_WORD_DATA);

		if(rc < 0){
			return rc;
		}
	}
	s_ctrl->func_tbl->sensor_group_hold_off(s_ctrl);
	return rc;
}

Example #24

File: flash.c Project: kamarush/caf_kernel_mm

static void flash_wq_function(struct work_struct *work)
{
	if (tps61310_client) {
		i2c_client.client = tps61310_client;
		i2c_client.addr_type = MSM_CAMERA_I2C_BYTE_ADDR;
		msm_camera_i2c_write(&i2c_client, 0x01,
				0x46, MSM_CAMERA_I2C_BYTE_DATA);
	}
	return;
}

Example #25

void imx111_set_dev_addr(struct msm_camera_eeprom_client *eclient,
		uint16_t *reg_addr) {
	uint16_t eprom_addr = *reg_addr;
	if ((eprom_addr >= 0x3500) && (eprom_addr < 0x3508)) {
		msm_camera_i2c_write(eclient->i2c_client,
				IMX111_EEPROM_BANK_SEL_REG,
				0x00, MSM_CAMERA_I2C_BYTE_DATA);
	}
	if ((eprom_addr >= 0x3508) && (eprom_addr < 0x3510)) {
		msm_camera_i2c_write(eclient->i2c_client,
				IMX111_EEPROM_BANK_SEL_REG,
				0x01, MSM_CAMERA_I2C_BYTE_DATA);
	}
	if ((eprom_addr >= 0x3510) && (eprom_addr < 0x3518)) {
		msm_camera_i2c_write(eclient->i2c_client,
				IMX111_EEPROM_BANK_SEL_REG,
				0x02, MSM_CAMERA_I2C_BYTE_DATA);
	}
}

Example #26

File: ov8825_v4l2.c Project: hroark13/zte_msm8x30_cm11

int write_sccb16(uint32_t address, uint32_t value, struct msm_sensor_ctrl_t *s_ctrl)
{
int rc;


rc= msm_camera_i2c_write(
			s_ctrl->sensor_i2c_client,
			address, value,
			MSM_CAMERA_I2C_BYTE_DATA);
return rc;
}	

Example #27

File: ov8835_v4l2.c Project: ReflexBow/android_kernel_motorola_ghost

static int32_t ov8835_match_id(struct msm_sensor_ctrl_t *s_ctrl)
{
	int32_t rc = 0;
	uint16_t chipid = 0;

	/*Select Bank 0*/
	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			0x3D84, 0xC0, MSM_CAMERA_I2C_BYTE_DATA);
	/*Enable OTP READ*/
	rc = msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
			0x3D81, 0x01, MSM_CAMERA_I2C_BYTE_DATA);
	/*wait 10ms*/
	usleep(10000);
	/*Read sensor id*/
	rc = msm_camera_i2c_read(
			s_ctrl->sensor_i2c_client,
			s_ctrl->sensor_id_info->sensor_id_reg_addr, &chipid,
			MSM_CAMERA_I2C_BYTE_DATA);
	if (rc < 0) {
		pr_err("%s: read id failed\n", __func__);
		return rc;
	}

	if (chipid != s_ctrl->sensor_id_info->sensor_id) {
		pr_err("%s: chip id %x does not match expected %x\n", __func__,
				chipid, s_ctrl->sensor_id_info->sensor_id);
		return -ENODEV;
	}

	rc = ov8835_read_otp(s_ctrl);
	if (rc < 0) {
		pr_err("%s: unable to read otp data\n", __func__);
		ov8835_otp_info.size = 0;
	} else {
		ov8835_otp_info.otp_info = (uint8_t *)ov8835_otp;
		ov8835_otp_info.size = OV8835_OTP_SIZE;
	}

	pr_debug("ov8835: match_id success\n");
	return 0;
}

Example #28

File: ov5648_truly_cm8352_v4l2_PIP.c Project: weritos666/ARCHOS_50_Platinum

/*******************************************************************************
* R_gain, sensor red gain of AWB, 0x400 =1
* G_gain, sensor green gain of AWB, 0x400 =1
* B_gain, sensor blue gain of AWB, 0x400 =1
*******************************************************************************/
void ov5648_truly_cm8352_update_awb_gain(struct msm_sensor_ctrl_t *s_ctrl,
		uint16_t R_gain, uint16_t G_gain, uint16_t B_gain)
{
	CDBG("%s R_gain = 0x%04x\r\n", __func__, R_gain);
	CDBG("%s G_gain = 0x%04x\r\n", __func__, G_gain);
	CDBG("%s B_gain = 0x%04x\r\n", __func__, B_gain);
	if (R_gain > 0x400) {
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x5186,
				(R_gain>>8), MSM_CAMERA_I2C_BYTE_DATA);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client, 0x5187,
				(R_gain&0xff), MSM_CAMERA_I2C_BYTE_DATA);
	}

Example #29

File: ov5693_v4l2.c Project: ronasimi/LGF180-Optimus-G-_Android_KK_v30a_Kernel

static void ov5693_read_afcal(struct msm_sensor_ctrl_t *s_ctrl,
	struct msm_calib_af *af_pos)
{
	uint8_t data[2];
	uint16_t address;

	/* select otp bank 1 */
	msm_camera_i2c_write(s_ctrl->sensor_i2c_client, OTP_BANK_SELECT, 0xc1,
		MSM_CAMERA_I2C_BYTE_DATA);

	/* load otp */
	msm_camera_i2c_write(s_ctrl->sensor_i2c_client, OTP_LOAD_DUMP, 0x01,
		MSM_CAMERA_I2C_BYTE_DATA);

	/* read inf */
	address = OTP_BANK_START;
	msm_camera_i2c_read_seq(s_ctrl->sensor_i2c_client, address, data, 2);

	af_pos->inf_dac = data[0] << 8 | data[1];

	/* read 1m */
	address += 2;
//	msm_camera_i2c_read_seq(s_ctrl->sensor_i2c_client, address, data, 2);

	/* read mac */
	address += 2;
	msm_camera_i2c_read_seq(s_ctrl->sensor_i2c_client, address, data, 2);

	af_pos->macro_dac = data[0] << 8 | data[1];

	/* read start position */
	address += 2;
	msm_camera_i2c_read_seq(s_ctrl->sensor_i2c_client, address, data, 2);

	af_pos->start_dac = data[0] << 8 | data[1];

	pr_err("OTP inf = 0x%x", af_pos->inf_dac);
	pr_err("OTP mac = 0x%x", af_pos->macro_dac);
	pr_err("OTP start = 0x%x", af_pos->start_dac);
}

Example #30

File: s5k4e5ya_v4l2.c Project: Loller79/Solid_Kernel-STOCK-KK-CAF

static int32_t s5k4e5ya_sensor_write_exp_gain1(struct msm_sensor_ctrl_t *s_ctrl,
						uint16_t gain, uint32_t line, int32_t luma_avg, uint16_t fgain)
{
	uint32_t fl_lines;
	uint8_t offset;
	fl_lines = s_ctrl->curr_frame_length_lines;
	fl_lines = (fl_lines * s_ctrl->fps_divider) / Q10;
	offset = s_ctrl->sensor_exp_gain_info->vert_offset;
	if (line > (fl_lines - offset))
		fl_lines = line + offset;

		s_ctrl->func_tbl->sensor_group_hold_on(s_ctrl);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_output_reg_addr->frame_length_lines, s5k4e5ya_byte(fl_lines, 1),
			MSM_CAMERA_I2C_BYTE_DATA);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_output_reg_addr->frame_length_lines + 1, s5k4e5ya_byte(fl_lines, 0),
			MSM_CAMERA_I2C_BYTE_DATA);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->coarse_int_time_addr, s5k4e5ya_byte(line, 1),
			MSM_CAMERA_I2C_BYTE_DATA);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->coarse_int_time_addr + 1, s5k4e5ya_byte(line, 0),
			MSM_CAMERA_I2C_BYTE_DATA);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->global_gain_addr, s5k4e5ya_byte(gain, 1),
			MSM_CAMERA_I2C_BYTE_DATA);
		msm_camera_i2c_write(s_ctrl->sensor_i2c_client,
		s_ctrl->sensor_exp_gain_info->global_gain_addr + 1, s5k4e5ya_byte(gain, 0),
			MSM_CAMERA_I2C_BYTE_DATA);
		s_ctrl->func_tbl->sensor_group_hold_off(s_ctrl);
	return 0;
}