static inline int sr200_get_exif_exptime(struct v4l2_subdev *subdev, u32 *exp_time)
{
struct i2c_client *client = to_client(subdev);
int err = 0;
u8 read_value1 = 0;
u8 read_value2 = 0;
u8 read_value3 = 0;
int OPCLK = 26000000;
err = fimc_is_sr200_write8(client, 0x03, 0x20);
CHECK_ERR_COND(err < 0, -ENODEV);
fimc_is_sr200_read8(client, 0x80, &read_value1);
fimc_is_sr200_read8(client, 0x81, &read_value2);
fimc_is_sr200_read8(client, 0x82, &read_value3);
cam_dbg("exposure time read_value %d, %d, %d\n",
read_value1, read_value2, read_value3);
if(read_value1 == 0 && read_value2 == 0 && read_value3 == 0)
{
*exp_time = 0;
err = -EFAULT;
} else {
*exp_time = OPCLK / ((read_value1 << 19) + (read_value2 << 11) + (read_value3 << 3));
cam_dbg("exposure time %u\n", *exp_time);
}
return err;
}
static int sr130pc10_check_dataline_stop(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct sr130pc10_state *state = to_state(sd);
int err = -EINVAL;
extern int sr130pc10_power_reset(void);
cam_warn("Warning: do nothing!!\n");
return err;
//sr130pc10_write(client, 0xFCFCD000);
//sr130pc10_write(client, 0x0028D000);
//sr130pc10_write(client, 0x002A3100);
//sr130pc10_write(client, 0x0F120000);
// err = sr130pc10_write_regs(sd, sr130pc10_pattern_off, sizeof(sr130pc10_pattern_off) / sizeof(sr130pc10_pattern_off[0]));
cam_dbg("sensor reset\n");
#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_TARGET_LOCALE_EUR) || defined(CONFIG_TARGET_LOCALE_HKTW) || defined(CONFIG_TARGET_LOCALE_HKTW_FET) || defined(CONFIG_TARGET_LOCALE_USAGSM)
// dont't know where this code came from - comment out for compile error
// sr130pc10_power_reset();
#endif
cam_dbg("load camera init setting\n");
err = sr130pc10_i2c_set_config_register(client,
front_init_regs,
INIT_NUM_OF_REGS,
"front_init_regs");
state->check_dataline = 0;
/* mdelay(100); */
return err;
}
int sensor_sr200_stream_off(struct v4l2_subdev *subdev)
{
int ret = 0;
struct sr200_state *state = to_state(subdev);
cam_info("stream off\n");
ret = sensor_sr200_apply_set(subdev, "sr200_stop_stream", &sr200_regset_table.stop_stream);
state->preview.update_frmsize = 1;
switch (state->runmode) {
case RUNMODE_CAPTURING:
cam_dbg("Capture Stop!\n");
state->runmode = RUNMODE_CAPTURING_STOP;
break;
case RUNMODE_RUNNING:
cam_dbg("Preview Stop!\n");
state->runmode = RUNMODE_RUNNING_STOP;
break;
case RUNMODE_RECORDING:
cam_dbg("Recording Stop!\n");
state->runmode = RUNMODE_RECORDING_STOP;
break;
default:
break;
}
return ret;
}
static int sr130pc10_check_dataline(struct v4l2_subdev *sd, s32 val)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int err = 0;
cam_info("DTP %s\n", val ? "ON" : "OFF");
if (val) {
cam_dbg("load sr130pc10_pattern_on\n");
err = sr130pc10_i2c_set_config_register(client,
front_pattern_on_regs,
PATTERN_ON_NUM_OF_REGS,
"front_pattern_on_regs");
} else {
cam_dbg("load sr130pc10_pattern_off\n");
err = sr130pc10_i2c_set_config_register(client,
front_pattern_off_regs,
PATTERN_OFF_NUM_OF_REGS,
"front_pattern_off_regs");
}
if (unlikely(err)) {
cam_err("fail to DTP setting\n");
return err;
}
return 0;
}
/*
* sr200pc20_probe
* Fetching platform data is being done with s_config subdev call.
* In probe routine, we just register subdev device
*/
static int sr200pc20_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct sr200pc20_state *state = NULL;
struct v4l2_subdev *sd = NULL;
int err = 0;
cam_dbg("E\n");
state = kzalloc(sizeof(struct sr200pc20_state), GFP_KERNEL);
if (state == NULL)
return -ENOMEM;
sd = &state->sd;
strcpy(sd->name, SR200PC20_DRIVER_NAME);
/* Registering subdev */
v4l2_i2c_subdev_init(sd, client, &sr200pc20_ops);
err = sr200pc20_s_config(sd, 0, client->dev.platform_data);
CHECK_ERR_MSG(err, "fail to s_config\n");
if (device_create_file(&client->dev, &dev_attr_camera_type) < 0) {
cam_warn("failed to create device file, %s\n",
dev_attr_camera_type.attr.name);
}
cam_dbg("probed!!\n");
return 0;
}
static inline int sr200_get_exif_iso(struct v4l2_subdev *subdev, u16 *iso)
{
struct i2c_client *client = to_client(subdev);
int err = 0;
u8 read_value = 0;
unsigned short gain_value = 0;
err = fimc_is_sr200_write8(client, 0x03, 0x20);
CHECK_ERR_COND(err < 0, -ENODEV);
fimc_is_sr200_read8(client, 0xb0, &read_value);
gain_value = ((read_value * 100) / 32) + 50;
cam_dbg("iso : gain_value=%d, read_value=%d\n", gain_value, read_value);
if (gain_value < 114)
*iso = 50;
else if (gain_value < 214)
*iso = 100;
else if (gain_value < 264)
*iso = 200;
else if (gain_value < 752)
*iso = 400;
else
*iso = 800;
cam_dbg("ISO=%d\n", *iso);
return 0;
}
void sr130pc10_regs_table_exit(void)
{
cam_dbg(" start\n");
if(front_regs_buf_ptr) {
vfree(front_regs_buf_ptr);
front_regs_buf_ptr = NULL;
}
cam_dbg(" done\n");
}
/*
* s_config subdev ops
* With camera device, we need to re-initialize
* every single opening time therefor,
* it is not necessary to be initialized on probe time.
* except for version checking
* NOTE: version checking is optional
*/
static int sr130pc10_s_config(struct v4l2_subdev *sd,
int irq, void *platform_data)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct sr130pc10_state *state = to_state(sd);
struct sr130pc10_platform_data *pdata;
cam_dbg("E\n");
state->initialized = 0;
state->req_fps = state->set_fps = 8;
state->sensor_mode = SENSOR_CAMERA;
pdata = client->dev.platform_data;
if (!pdata) {
cam_err("no platform data\n");
return -ENODEV;
}
/*
* Assign default format and resolution
* Use configured default information in platform data
* or without them, use default information in driver
*/
if (!(pdata->default_width && pdata->default_height)) {
state->preview_frmsizes.width = DEFAULT_PREVIEW_WIDTH;
state->preview_frmsizes.height = DEFAULT_PREVIEW_HEIGHT;
} else {
state->preview_frmsizes.width = pdata->default_width;
state->preview_frmsizes.height = pdata->default_height;
}
state->capture_frmsizes.width = DEFAULT_CAPTURE_WIDTH;
state->capture_frmsizes.height = DEFAULT_CAPTURE_HEIGHT;
cam_dbg("preview_width: %d , preview_height: %d, "
"capture_width: %d, capture_height: %d",
state->preview_frmsizes.width, state->preview_frmsizes.height,
state->capture_frmsizes.width, state->capture_frmsizes.height);
state->req_fmt.width = state->preview_frmsizes.width;
state->req_fmt.height = state->preview_frmsizes.height;
if (!pdata->pixelformat)
state->req_fmt.pixelformat = DEFAULT_FMT;
else
state->req_fmt.pixelformat = pdata->pixelformat;
return 0;
}
static int sr130pc10_s_stream(struct v4l2_subdev *sd, int enable)
{
struct sr130pc10_state *state = to_state(sd);
/* struct i2c_client *client = v4l2_get_subdevdata(sd); */
int err = 0;
cam_info("stream mode = %d\n", enable);
switch (enable) {
case STREAM_MODE_CAM_OFF:
if (state->sensor_mode == SENSOR_CAMERA) {
if (state->check_dataline)
err = sr130pc10_check_dataline(sd, 0);
else
err = sr130pc10_control_stream(sd, STREAM_STOP);
}
break;
case STREAM_MODE_CAM_ON:
/* The position of this code need to be adjusted later */
if (state->sensor_mode == SENSOR_CAMERA) {
if (state->req_fmt.priv == V4L2_PIX_FMT_MODE_CAPTURE)
err = sr130pc10_set_capture_start(sd);
else
err = sr130pc10_set_preview_start(sd);
}
break;
case STREAM_MODE_MOVIE_ON:
cam_dbg("do nothing(movie on)!!\n");
break;
case STREAM_MODE_MOVIE_OFF:
cam_dbg("do nothing(movie off)!!\n");
break;
default:
cam_err("ERR: Invalid stream mode\n");
break;
}
if (unlikely(err < 0)) {
cam_err("ERR: faild\n");
return err;
}
return 0;
}
static int sr200_set_effect(struct v4l2_subdev *subdev, int effect)
{
struct sr200_state *state = to_state(subdev);
int ret = 0;
cam_info("%s( %d ) : E\n",__func__, effect);
switch (effect) {
case V4L2_IMAGE_EFFECT_BASE :
case V4L2_IMAGE_EFFECT_NONE :
ret = sensor_sr200_apply_set(subdev, "sr200_Effect_Normal", &sr200_regset_table.effect_none);
break;
case V4L2_IMAGE_EFFECT_BNW :
ret = sensor_sr200_apply_set(subdev, "sr200_Effect_Gray", &sr200_regset_table.effect_gray);
break;
case V4L2_IMAGE_EFFECT_SEPIA :
ret = sensor_sr200_apply_set(subdev, "sr200_Effect_Sepia", &sr200_regset_table.effect_sepia);
break;
case V4L2_IMAGE_EFFECT_NEGATIVE :
ret = sensor_sr200_apply_set(subdev, "sr200_Effect_Negative", &sr200_regset_table.effect_negative);
break;
default:
cam_dbg("%s: Not support.(%d)\n", __func__, effect);
break;
}
state->effect = effect;
return ret;
}
static int sr200pc20_set_preview_start(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct sr200pc20_state *state = to_state(sd);
int err = -EINVAL;
cam_info("reset preview\n");
cam_dbg("load sr200pc20_preview\n");
if(state->anti_banding == ANTI_BANDING_50HZ) {
err = sr200pc20_i2c_set_config_register(client,
front_preview_camera_50hz_regs,
PREVIEW_CAMERA_NUM_OF_REGS,
"front_preview_camera_50hz_regs");
} else {
err = sr200pc20_i2c_set_config_register(client,
front_preview_camera_60hz_regs,
PREVIEW_CAMERA_NUM_OF_REGS,
"front_preview_camera_60hz_regs");
}
if (state->check_dataline)
err = sr200pc20_check_dataline(sd, 1);
if (unlikely(err)) {
cam_err("fail to make preview\n");
return err;
}
return 0;
}
static int sr200pc20_get_iso_speed_rate(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
unsigned short read_value;
int gain;
int isospeedrating = 0;
sr200pc20_i2c_write_byte(client, 0x03, 0x20);
sr200pc20_i2c_read_byte(client, 0xb0, &read_value);
gain = ((int)read_value * 100 / 32) + 50;
if (read_value < 125)
isospeedrating = 50;
else if (read_value < 175)
isospeedrating = 100;
else if (read_value < 250)
isospeedrating = 200;
else if (read_value < 375)
isospeedrating = 400;
else if (read_value < 550)
isospeedrating = 800;
else
isospeedrating = 1600;
cam_dbg("get iso = %d\n", isospeedrating);
return isospeedrating;
}
static int s5k5bbgx_control_stream(struct v4l2_subdev *sd, stream_cmd_t cmd)
{
int err = 0;
switch (cmd) {
case STREAM_START:
cam_warn("WARN: do nothing\n");
break;
case STREAM_STOP:
cam_dbg("stream stop!!!\n");
#if 0
#ifdef CONFIG_LOAD_FILE
err = s5k5bbgx_write_regs_from_sd(sd, "s5k5bbgx_stream_stop");
#else
err = s5k5bbgx_write_regs(sd, s5k5bbgx_stream_stop,
sizeof(s5k5bbgx_stream_stop) / \
sizeof(s5k5bbgx_stream_stop[0]));
#endif
#endif
break;
default:
cam_err("ERR: Invalid cmd\n");
break;
}
if (unlikely(err))
cam_err("failed to stream start(stop)\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 int db8131m_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
int err = 0;
u32 fps = 0;
struct db8131m_state *state = to_state(sd);
if (!state->vt_mode)
return 0;
cam_dbg("E\n");
fps = parms->parm.capture.timeperframe.denominator /
parms->parm.capture.timeperframe.numerator;
if (fps != state->set_fps) {
if (fps < 0 && fps > 30) {
cam_err("invalid frame rate %d\n", fps);
fps = 30;
}
state->req_fps = fps;
if (state->initialized) {
err = db8131m_set_frame_rate(sd, state->req_fps);
if (err >= 0)
state->set_fps = state->req_fps;
}
}
return err;
}
static int sr130pc10_i2c_set_data_burst(struct i2c_client *client,
regs_short_t reg_buffer[],
int num_of_regs)
{
unsigned short subaddr, data_value;
int i, err = 0;
for(i = 0; i < num_of_regs; i++) {
subaddr = reg_buffer[i].subaddr;
data_value = reg_buffer[i].value;
switch(subaddr) {
case DELAY_SEQ:
cam_dbg("delay = %d\n",data_value*10);
msleep(data_value * 10);
break;
default:
err = sr130pc10_i2c_write_byte(client, subaddr, data_value);
if(err < 0) {
cam_err("i2c write fail\n");
return -EIO;
}
break;
}
}
return 0;
}
static int s5k5bbgx_check_dataline_stop(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k5bbgx_state *state = to_state(sd);
int err = -EINVAL;
extern int s5k5bbgx_power_reset(void);
cam_warn("Warning: do nothing!!\n");
return err;
//s5k5bbgx_write(client, 0xFCFCD000);
//s5k5bbgx_write(client, 0x0028D000);
//s5k5bbgx_write(client, 0x002A3100);
//s5k5bbgx_write(client, 0x0F120000);
// err = s5k5bbgx_write_regs(sd, s5k5bbgx_pattern_off, sizeof(s5k5bbgx_pattern_off) / sizeof(s5k5bbgx_pattern_off[0]));
printk("%s: sensor reset\n", __func__);
#if defined(CONFIG_TARGET_LOCALE_KOR) || defined(CONFIG_TARGET_LOCALE_EUR) || defined(CONFIG_TARGET_LOCALE_HKTW) || defined(CONFIG_TARGET_LOCALE_HKTW_FET) || defined(CONFIG_TARGET_LOCALE_USAGSM)
// dont't know where this code came from - comment out for compile error
// s5k5bbgx_power_reset();
#endif
cam_dbg("load camera init setting\n");
err = s5k5bbgx_write_regs(sd, s5k5bbgx_common, sizeof(s5k5bbgx_common) / sizeof(s5k5bbgx_common[0]));
state->check_dataline = 0;
/* mdelay(100); */
return err;
}
static int sr200pc20_check_sensor_status(struct v4l2_subdev *sd)
{
/*struct i2c_client *client = v4l2_get_subdevdata(sd);*/
/*u16 val_1 = 0, val_2 = 0;
int err = -EINVAL; */
#if 1 /* DSLIM */
cam_warn("check_sensor_status: WARNING, Not implemented!!\n\n");
return 0;
#else
err = sr200pc20_read_reg(sd, 0x7000, 0x0132, &val_1);
CHECK_ERR(err);
err = sr200pc20_read_reg(sd, 0xD000, 0x1002, &val_2);
CHECK_ERR(err);
cam_dbg("read val1=0x%x, val2=0x%x\n", val_1, val_2);
if ((val_1 != 0xAAAA) || (val_2 != 0))
goto error_occur;
cam_info("Sensor ESD Check: not detected\n");
return 0;
#endif
error_occur:
cam_err("%s: ERROR, ESD Shock detected!\n\n", __func__);
return -ERESTART;
}
static inline int sr200pc20_get_iso(struct v4l2_subdev *sd, u16 *iso)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
/* u16 iso_gain_table[] = {10, 18, 23, 28};
u16 iso_table[] = {0, 50, 100, 200, 400}; */
u16 read_value = 0, gain = 0;
sr200pc20_i2c_write_byte(client, 0x03, 0x20);
sr200pc20_i2c_read_byte(client, 0xb0, &read_value);
gain = (read_value * 100 / 32) + 50;
if (read_value < 125)
*iso = 50;
else if (read_value < 175)
*iso = 100;
else if (read_value < 250)
*iso = 200;
else if (read_value < 375)
*iso = 400;
else if (read_value < 550)
*iso = 800;
else
*iso = 1600;
cam_dbg("gain=%d, ISO=%d\n", gain, *iso);
return 0;
}
static int db8131m_g_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
int err = 0;
cam_dbg("E\n");
return err;
}
static int sr130pc10_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
{
int err = 0;
cam_dbg("E\n");
return err;
}
static int sr200pc20_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
#endif
{
int err = 0;
cam_dbg("E\n");
return err;
}
static int sr200pc20_get_exif(struct v4l2_subdev *sd)
{
struct sr200pc20_state *state = to_state(sd);
u32 exposure_time = 0;
/* Get exposure-time */
state->exif.exp_time_den = 0;
sr200pc20_get_expousretime(sd, &exposure_time);
state->exif.exp_time_den = 1000000 / exposure_time;
cam_dbg("exposure time=%dus\n", exposure_time);
/* Get ISO */
state->exif.iso = 0;
sr200pc20_get_iso(sd, &state->exif.iso);
cam_dbg("get_exif: exp_time_den=%d, ISO=%d\n",
state->exif.exp_time_den, state->exif.iso);
return 0;
}
static int sr130pc10_set_frame_rate(struct v4l2_subdev *sd, u32 fps)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int err = 0;
cam_info("frame rate %d\n\n", fps);
switch (fps) {
case 7:
cam_dbg("load sr130pc10_vt_7fps\n");
err = sr130pc10_i2c_set_config_register(client,
front_fps_7_regs,
FPS_7_NUM_OF_REGS,
"front_fps_7_regs");
break;
case 10:
cam_dbg("load sr130pc10_vt_10fps\n");
err = sr130pc10_i2c_set_config_register(client,
front_fps_10_regs,
FPS_10_NUM_OF_REGS,
"front_fps_10_regs");
break;
case 15:
cam_dbg("load sr130pc10_vt_15fps\n");
err = sr130pc10_i2c_set_config_register(client,
front_fps_15_regs,
FPS_15_NUM_OF_REGS,
"front_fps_15_regs");
break;
default:
err = sr130pc10_i2c_set_config_register(client,
front_fps_auto_regs,
FPS_AUTO_NUM_OF_REGS,
"front_fps_auto_regs");
break;
}
if (unlikely(err < 0)) {
cam_err("i2c_write for set framerate\n");
return -EIO;
}
return err;
}
int sr200_regs_table_init(void)
{
struct file *filp;
char *dp;
long size;
loff_t pos;
int ret;
mm_segment_t fs = get_fs();
cam_info("%s : E\n", __func__);
set_fs(get_ds());
filp = filp_open(LOAD_FILE_PATH, O_RDONLY, 0);
if (IS_ERR_OR_NULL(filp)) {
cam_err("file open error\n");
return PTR_ERR(filp);
}
size = filp->f_path.dentry->d_inode->i_size;
cam_dbg("size = %ld\n", size);
//dp = kmalloc(size, GFP_KERNEL);
dp = vmalloc(size);
if (unlikely(!dp)) {
cam_err("Out of Memory\n");
filp_close(filp, current->files);
return -ENOMEM;
}
pos = 0;
memset(dp, 0, size);
ret = vfs_read(filp, (char __user *)dp, size, &pos);
if (unlikely(ret != size)) {
cam_err("Failed to read file ret = %d\n", ret);
/*kfree(dp);*/
vfree(dp);
filp_close(filp, current->files);
return -EINVAL;
}
filp_close(filp, current->files);
set_fs(fs);
sr200_regs_table = dp;
sr200_regs_table_size = size;
*((sr200_regs_table + sr200_regs_table_size) - 1) = '\0';
cam_info("%s : X\n", __func__);
return 0;
}
static int sr130pc10_remove(struct i2c_client *client)
{
struct v4l2_subdev *sd = i2c_get_clientdata(client);
struct sr130pc10_state *state = to_state(sd);
cam_dbg("E\n");
state->initialized = 0;
v4l2_device_unregister_subdev(sd);
kfree(to_state(sd));
return 0;
}
/*
* sr130pc10_probe
* Fetching platform data is being done with s_config subdev call.
* In probe routine, we just register subdev device
*/
static int sr130pc10_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct sr130pc10_state *state = NULL;
struct v4l2_subdev *sd = NULL;
cam_dbg("E\n");
state = kzalloc(sizeof(struct sr130pc10_state), GFP_KERNEL);
if (state == NULL)
return -ENOMEM;
sd = &state->sd;
strcpy(sd->name, SR130PC10_DRIVER_NAME);
/* Registering subdev */
v4l2_i2c_subdev_init(sd, client, &sr130pc10_ops);
cam_dbg("probed!!\n");
return 0;
}
static int sr200pc20_remove(struct i2c_client *client)
{
struct v4l2_subdev *sd = i2c_get_clientdata(client);
struct sr200pc20_state *state = to_state(sd);
cam_dbg("E\n");
state->initialized = 0;
device_remove_file(&client->dev, &dev_attr_camera_type);
v4l2_device_unregister_subdev(sd);
kfree(to_state(sd));
return 0;
}
static int s5k5bbgx_check_sensor_status(struct v4l2_subdev *sd)
{
/*struct i2c_client *client = v4l2_get_subdevdata(sd);*/
u16 val_1 = 0, val_2 = 0;
int err = -EINVAL;
err = s5k5bbgx_read_reg(sd, 0x7000, 0x00BC, &val_1);
CHECK_ERR(err);
err = s5k5bbgx_read_reg(sd, 0xD000, 0x1002, &val_2);
CHECK_ERR(err);
cam_dbg("read val1=0x%x, val2=0x%x\n", val_1, val_2);
if ((val_1 != 0xAAAA) || (val_2 != 0))
goto error_occur;
cam_dbg("Sensor error is not detected\n");
return 0;
error_occur:
cam_err("ERR: Sensor error occurs\n\n");
return -EIO;
}
static int sensor_sr200_g_ctrl(struct v4l2_subdev *subdev, struct v4l2_control *ctrl)
{
struct sr200_state *state = to_state(subdev);
int ret = 0;
switch (ctrl->id) {
case V4L2_CID_EXIF_EXPOSURE_TIME_DEN:
if (state->sensor_mode == SENSOR_CAMERA) {
ctrl->value = state->exif.exp_time_den;
} else {
ctrl->value = 26;
}
cam_dbg("V4L2_CID_CAMERA_EXIF_EXPTIME :%d\n", ctrl->value);
break;
case V4L2_CID_EXIF_EXPOSURE_TIME_NUM:
ctrl->value = 1;
cam_dbg("V4L2_CID_EXIF_EXPOSURE_TIME_NUM :%d\n", ctrl->value);
break;
case V4L2_CID_CAMERA_EXIF_FLASH:
ctrl->value = state->exif.flash;
cam_dbg("V4L2_CID_CAMERA_EXIF_FLASH :%d\n", ctrl->value);
break;
case V4L2_CID_CAMERA_EXIF_ISO:
if (state->sensor_mode == SENSOR_CAMERA) {
ctrl->value = state->exif.iso;
} else {
ctrl->value = 100;
}
cam_dbg("V4L2_CID_CAMERA_EXIF_ISO :%d\n", ctrl->value);
break;
default:
cam_warn("g_ctrl : invalid ioctl(0x%08X) is requested", ctrl->id);
break;
}
return ret;
}
