/*
* s5k6aafx_probe
* Fetching platform data is being done with s_config subdev call.
* In probe routine, we just register subdev device
*/
static int s5k6aafx_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct s5k6aafx_state *state;
struct v4l2_subdev *sd;
FUNC_ENTR();
state = kzalloc(sizeof(struct s5k6aafx_state), GFP_KERNEL);
if (state == NULL)
return -ENOMEM;
state->runmode = S5K6AAFX_RUNMODE_NOTREADY;
state->set_vhflip = 0;
sd = &state->sd;
strcpy(sd->name, S5K6AAFX_DRIVER_NAME);
/* Registering subdev */
v4l2_i2c_subdev_init(sd, client, &s5k6aafx_ops);
dev_info(&client->dev, "s5k6aafx has been probed\n");
return 0;
}
//latin_cam VT CAM Antibanding
static int s5k6aafx_set_60hz_antibanding(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
FUNC_ENTR();
unsigned long s5k6aafx_antibanding60hz[] = {
0xFCFCD000,
0x00287000,
// Anti-Flicker //
// End user init script
0x002A0400,
0x0F12005F, //REG_TC_DBG_AutoAlgEnBits //Auto Anti-Flicker is enabled bit[5] = 1.
0x002A03DC,
0x0F120002, //02 REG_SF_USER_FlickerQuant //Set flicker quantization(0: no AFC, 1: 50Hz, 2: 60 Hz)
0x0F120001,
};
err = s5k6aafx_write_regs(sd, s5k6aafx_antibanding60hz,
sizeof(s5k6aafx_antibanding60hz) / sizeof(s5k6aafx_antibanding60hz[0]));
printk("%s: setting 60hz antibanding \n", __func__);
if (unlikely(err))
{
printk("%s: failed to set 60hz antibanding \n", __func__);
return err;
}
return 0;
}
static int s5k6aafx_set_frame_rate(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
int err = 0;
struct i2c_client *client = v4l2_get_subdevdata(sd);
FUNC_ENTR();
switch(ctrl->value)
{
case 7:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_7fps,
sizeof(s5k6aafx_vt_7fps) / sizeof(s5k6aafx_vt_7fps[0]));
break;
case 10:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_10fps,
sizeof(s5k6aafx_vt_10fps) / sizeof(s5k6aafx_vt_10fps[0]));
break;
case 12:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_12fps,
sizeof(s5k6aafx_vt_12fps) / sizeof(s5k6aafx_vt_12fps[0]));
break;
case 15:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_13fps,
sizeof(s5k6aafx_vt_13fps) / sizeof(s5k6aafx_vt_13fps[0]));
break;
case 30:
printk("frame rate is 30\n");
break;
default:
dev_err(&client->dev, "%s: no such framerate\n", __func__);
break;
}
return 0;
}
static int s5k6aafx_set_flip(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = 0;
FUNC_ENTR();
if(state->runmode != S5K6AAFX_RUNMODE_RUNNING)
{
return 0;
}
if(state->set_vhflip == 1)
{
err = s5k6aafx_write_regs(sd, s5k6aafx_vhflip_on,
sizeof(s5k6aafx_vhflip_on) / sizeof(s5k6aafx_vhflip_on[0]));
}
else
{
err = s5k6aafx_write_regs(sd, s5k6aafx_vhflip_off,
sizeof(s5k6aafx_vhflip_off) / sizeof(s5k6aafx_vhflip_off[0]));
}
return err;
}
static int s5k6aafx_enum_fmt(struct v4l2_subdev *sd, struct v4l2_fmtdesc *fmtdesc)
{
int err = 0;
FUNC_ENTR();
return err;
}
static int s5k6aafx_s_crystal_freq(struct v4l2_subdev *sd, u32 freq, u32 flags)
{
int err = -EINVAL;
FUNC_ENTR();
return err;
}
static int s5k6aafx_enum_frameintervals(struct v4l2_subdev *sd,
struct v4l2_frmivalenum *fival)
{
int err = 0;
FUNC_ENTR();
return err;
}
static int s5k6aafx_s_parm(struct v4l2_subdev *sd, struct v4l2_streamparm *parms)
{
int err = 0;
FUNC_ENTR();
return err;
}
static int s5k6aafx_try_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
{
int err = 0;
FUNC_ENTR();
return err;
}
static int s5k6aafx_remove(struct i2c_client *client)
{
struct v4l2_subdev *sd = i2c_get_clientdata(client);
FUNC_ENTR();
v4l2_device_unregister_subdev(sd);
kfree(to_state(sd));
return 0;
}
static int s5k6aafx_enum_framesizes(struct v4l2_subdev *sd, \
struct v4l2_frmsizeenum *fsize)
{
struct s5k6aafx_state *state = to_state(sd);
FUNC_ENTR();
/*
* Return the actual output settings programmed to the camera
*/
fsize->discrete.width = state->set_fmt.width;
fsize->discrete.height = state->set_fmt.height;
printk("%s : width - %d , height - %d\n", __func__, fsize->discrete.width, fsize->discrete.height);
return 0;
}
/*
* 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 s5k6aafx_s_config(struct v4l2_subdev *sd,
int irq, void *platform_data)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
struct s5k6aafx_platform_data *pdata;
FUNC_ENTR();
pdata = client->dev.platform_data;
if (!pdata) {
dev_err(&client->dev, "%s: no platform data\n", __func__);
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->req_fmt.width = DEFAULT_WIDTH;
state->req_fmt.height = DEFAULT_HEIGHT;
}
else
{
state->req_fmt.width = pdata->default_width;
state->req_fmt.height = pdata->default_height;
printk("%s : width - %d , height - %d\n", __func__, state->req_fmt.width, state->req_fmt.height);
}
if (!pdata->pixelformat)
{
state->req_fmt.pixelformat = DEFAULT_FMT;
}
else
{
state->req_fmt.pixelformat = pdata->pixelformat;
}
return 0;
}
static int s5k6aafx_s_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
{
struct s5k6aafx_state *state = to_state(sd);
FUNC_ENTR();
/*
* Just copying the requested format as of now.
* We need to check here what are the formats the camera support, and
* set the most appropriate one according to the request from FIMC
*/
state->req_fmt.width = fmt->fmt.pix.width;
state->req_fmt.height = fmt->fmt.pix.height;
state->set_fmt.width = fmt->fmt.pix.width;
state->set_fmt.height = fmt->fmt.pix.height;
state->req_fmt.pixelformat = fmt->fmt.pix.pixelformat;
printk("%s : width - %d , height - %d\n", __func__, state->req_fmt.width, state->req_fmt.height);
return 0;
}
static int s5k6aafx_set_blur(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int err = -EINVAL;
FUNC_ENTR();
#ifdef CONFIG_LOAD_FILE
switch (ctrl->value)
{
case BLUR_LEVEL_0:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_pretty_default");
break;
case BLUR_LEVEL_1:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_pretty_1");
break;
case BLUR_LEVEL_2:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_pretty_2");
break;
case BLUR_LEVEL_3:
case BLUR_LEVEL_MAX:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_pretty_3");
break;
default:
dev_err(&client->dev, "%s : there's no blur value with [%d]\n", __func__,ctrl->value);
return err;
break;
}
#else
switch (ctrl->value)
{
case BLUR_LEVEL_0:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_pretty_default, \
sizeof(s5k6aafx_vt_pretty_default) / sizeof(s5k6aafx_vt_pretty_default[0]));
break;
case BLUR_LEVEL_1:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_pretty_1, \
sizeof(s5k6aafx_vt_pretty_1) / sizeof(s5k6aafx_vt_pretty_1[0]));
break;
case BLUR_LEVEL_2:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_pretty_2, \
sizeof(s5k6aafx_vt_pretty_2) / sizeof(s5k6aafx_vt_pretty_2[0]));
break;
case BLUR_LEVEL_3:
case BLUR_LEVEL_MAX:
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_pretty_3, \
sizeof(s5k6aafx_vt_pretty_3) / sizeof(s5k6aafx_vt_pretty_3[0]));
break;
default:
dev_err(&client->dev, "%s : there's no blur value with [%d]\n", __func__,ctrl->value);
return err;
break;
}
#endif
if (err < 0)
{
dev_err(&client->dev, "%s : i2c_write for set blur\n", __func__);
return -EIO;
}
return err;
}
static int s5k6aafx_set_brightness(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int err = -EINVAL;
FUNC_ENTR();
#ifdef CONFIG_LOAD_FILE
switch (ctrl->value)
{
case EV_MINUS_4:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_m4");
break;
case EV_MINUS_3:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_m3");
break;
case EV_MINUS_2:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_m2");
break;
case EV_MINUS_1:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_m1");
break;
case EV_DEFAULT:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_default");
break;
case EV_PLUS_1:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_p1");
break;
case EV_PLUS_2:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_p2");
break;
case EV_PLUS_3:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_p3");
break;
case EV_PLUS_4:
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_bright_p4");
break;
default:
dev_err(&client->dev, "%s : there's no brightness value with [%d]\n", __func__,ctrl->value);
return err;
break;
}
#else
switch (ctrl->value)
{
case EV_MINUS_4:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_m4, \
sizeof(s5k6aafx_bright_m4) / sizeof(s5k6aafx_bright_m4[0]));
break;
case EV_MINUS_3:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_m3, \
sizeof(s5k6aafx_bright_m3) / sizeof(s5k6aafx_bright_m3[0]));
break;
case EV_MINUS_2:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_m2, \
sizeof(s5k6aafx_bright_m2) / sizeof(s5k6aafx_bright_m2[0]));
break;
case EV_MINUS_1:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_m1, \
sizeof(s5k6aafx_bright_m1) / sizeof(s5k6aafx_bright_m1[0]));
break;
case EV_DEFAULT:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_default, \
sizeof(s5k6aafx_bright_default) / sizeof(s5k6aafx_bright_default[0]));
break;
case EV_PLUS_1:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_p1, \
sizeof(s5k6aafx_bright_p1) / sizeof(s5k6aafx_bright_p1[0]));
break;
case EV_PLUS_2:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_p2, \
sizeof(s5k6aafx_bright_p2) / sizeof(s5k6aafx_bright_p2[0]));
break;
case EV_PLUS_3:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_p3, \
sizeof(s5k6aafx_bright_p3) / sizeof(s5k6aafx_bright_p3[0]));
break;
case EV_PLUS_4:
err = s5k6aafx_write_regs(sd, s5k6aafx_bright_p4, \
sizeof(s5k6aafx_bright_p4) / sizeof(s5k6aafx_bright_p4[0]));
break;
default:
dev_err(&client->dev, "%s : there's no brightness value with [%d]\n", __func__,ctrl->value);
return err;
break;
}
#endif
if (err < 0)
{
dev_err(&client->dev, "%s : i2c_write for set brightness\n", __func__);
return -EIO;
}
return err;
}
static int s5k6aafx_g_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
FUNC_ENTR();
printk("ctrl->id : %d \n", ctrl->id - V4L2_CID_PRIVATE_BASE);
return 0;
}
static int s5k6aafx_querymenu(struct v4l2_subdev *sd, struct v4l2_querymenu *qm)
{
FUNC_ENTR();
return 0;
}
static int s5k6aafx_queryctrl(struct v4l2_subdev *sd, struct v4l2_queryctrl *qc)
{
FUNC_ENTR();
return 0;
}
static int s5k6aafx_init(struct v4l2_subdev *sd, u32 val)
{
//struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
FUNC_ENTR();
#ifdef CONFIG_LOAD_FILE
err = loadFile();
if (unlikely(err)) {
printk("%s: failed to init\n", __func__);
return err;
}
#endif
/* set initial regster value */
if (state->vt_mode == 0)
{
printk("%s: load camera common setting \n", __func__);
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_common");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_common, sizeof(s5k6aafx_common) / sizeof(s5k6aafx_common[0]));
#endif
}
else
{
printk("%s: load camera VT call setting \n", __func__);
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_common");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_common, sizeof(s5k6aafx_vt_common) / sizeof(s5k6aafx_vt_common[0]));
#endif
}
if (unlikely(err))
{
printk("%s: failed to init\n", __func__);
return err;
}
#if defined(CONFIG_TARGET_LOCALE_LTN)
//latin_cam VT Cam Antibanding
if (state->anti_banding == ANTI_BANDING_60HZ)
{
err = s5k6aafx_set_60hz_antibanding(sd);
if (unlikely(err))
{
printk("%s: failed to s5k6aafx_set_60hz_antibanding \n", __func__);
return err;
}
}
//hmin84.park -10.07.06
#endif
state->set_fmt.width = DEFAULT_WIDTH;
state->set_fmt.height = DEFAULT_HEIGHT;
return 0;
}
static int s5k6aafx_s_ctrl(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = 0;
FUNC_ENTR();
printk("ctrl->id : %d \n", ctrl->id - V4L2_CID_PRIVATE_BASE);
if(state->check_dataline)
{
if( ( ctrl->id != V4L2_CID_CAM_PREVIEW_ONOFF ) &&
( ctrl->id != V4L2_CID_CAMERA_CHECK_DATALINE_STOP ) &&
( ctrl->id != V4L2_CID_CAMERA_CHECK_DATALINE ) )
{
return 0;
}
}
switch (ctrl->id) {
case V4L2_CID_CAM_PREVIEW_ONOFF:
if (ctrl->value)
{
err = s5k6aafx_set_preview_start(sd);
}
else
{
err = s5k6aafx_set_preview_stop(sd);
}
printk("V4L2_CID_CAM_PREVIEW_ONOFF [%d] \n", ctrl->value);
break;
case V4L2_CID_CAM_CAPTURE:
err = s5k6aafx_set_capture_start(sd, ctrl);
printk("V4L2_CID_CAM_CAPTURE [%d] \n", ctrl->value);
break;
//add capture mode and separate preview mode
case V4L2_CID_CAMERA_VT_MODE:
state->vt_mode = ctrl->value;
err = 0;
printk("V4L2_CID_CAMERA_VT_MODE [%d] \n", ctrl->value);
break;
//add vt mode for read vt settings
case V4L2_CID_CAMERA_BRIGHTNESS:
err = s5k6aafx_set_brightness(sd, ctrl);
printk("V4L2_CID_CAMERA_BRIGHTNESS [%d] \n", ctrl->value);
break;
case V4L2_CID_CAMERA_VGA_BLUR:
err = s5k6aafx_set_blur(sd, ctrl);
printk("V4L2_CID_CAMERA_VGA_BLUR [%d] \n", ctrl->value);
break;
//CID_CAMERA_VGA_BLUR
#if defined(CONFIG_TARGET_LOCALE_LTN)
//latin_cam VT Camera Antibanding
case V4L2_CID_CAMERA_ANTI_BANDING:
state->anti_banding = ctrl->value;
printk("V4L2_CID_CAMERA_ANTI_BANDING [%d],[%d]\n",state->anti_banding,ctrl->value);
err = 0;
break;
//hmin84.park - 10.07.06
#endif
case V4L2_CID_CAMERA_CHECK_DATALINE:
state->check_dataline = ctrl->value;
err = 0;
break;
case V4L2_CID_CAMERA_CHECK_DATALINE_STOP:
err = s5k6aafx_check_dataline_stop(sd);
break;
case V4L2_CID_CAMERA_FRAME_RATE:
err = s5k6aafx_set_frame_rate(sd, ctrl);
state->fps = ctrl->value;
break;
case V4L2_CID_CAMERA_APP_CHECK:
err = 0;
break;
case V4L2_CID_CAM_JPEG_QUALITY:
err = 0;
break;
case V4L2_CID_CAMERA_SENSOR_MODE:
err = 0;
break;
case V4L2_CID_CAMERA_CHECK_FLIP:
state->set_vhflip = ctrl->value;
err = s5k6aafx_set_flip(sd, ctrl);
break;
default:
dev_err(&client->dev, "%s: no such control\n", __func__);
break;
}
return err;
}
static int s5k6aafx_init(struct v4l2_subdev *sd, u32 val)
{
//struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
static int lock_level = -1;
FUNC_ENTR();
#ifdef CONFIG_LOAD_FILE
err = loadFile();
if (unlikely(err)) {
printk("%s: failed to init\n", __func__);
return err;
}
#endif
#if defined(CONFIG_CPU_FREQ)
if (lock_level < 0)
lock_level = s5pv310_cpufreq_round_idx(CPUFREQ_1200MHZ);
if (s5pv310_cpufreq_lock(DVFS_LOCK_ID_CAM, lock_level))
printk(KERN_ERR "%s: error : failed lock DVFS\n", __func__);
#endif
/* set initial regster value */
if (state->vt_mode == 0)
{
printk("%s: load camera common setting \n", __func__);
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_common");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_common, sizeof(s5k6aafx_common) / sizeof(s5k6aafx_common[0]));
#endif
}
else
{
printk("%s: load camera VT call setting \n", __func__);
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_vt_common");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_vt_common, sizeof(s5k6aafx_vt_common) / sizeof(s5k6aafx_vt_common[0]));
#endif
}
#if defined(CONFIG_CPU_FREQ)
s5pv310_cpufreq_lock_free(DVFS_LOCK_ID_CAM);
#endif
if (unlikely(err))
{
printk("%s: failed to init\n", __func__);
return err;
}
#if defined(CONFIG_TARGET_LOCALE_LTN)
//latin_cam VT Cam Antibanding
if (state->anti_banding == ANTI_BANDING_60HZ)
{
err = s5k6aafx_set_60hz_antibanding(sd);
if (unlikely(err))
{
printk("%s: failed to s5k6aafx_set_60hz_antibanding \n", __func__);
return err;
}
}
//hmin84.park -10.07.06
#endif
state->set_fmt.width = DEFAULT_WIDTH;
state->set_fmt.height = DEFAULT_HEIGHT;
return 0;
}
static int s5k6aafx_g_fmt(struct v4l2_subdev *sd, struct v4l2_format *fmt)
{
FUNC_ENTR();
return 0;
}
static inline int s5k6aafx_write(struct i2c_client *client,
unsigned long packet)
{
unsigned char buf[4];
int err = 0;
int retry_count = 5;
struct i2c_msg msg =
{
.addr = client->addr,
.flags = 0,
.buf = buf,
.len = 4,
};
if (!client->adapter)
{
dev_err(&client->dev, "%s: can't search i2c client adapter\n", __func__);
return -EIO;
}
while(retry_count--)
{
*(unsigned long *)buf = cpu_to_be32(packet);
err = i2c_transfer(client->adapter, &msg, 1);
if (likely(err == 1))
break;
mdelay(10);
}
if (unlikely(err < 0))
{
dev_err(&client->dev, "%s: 0x%08x write failed\n", __func__, (unsigned int)packet);
return err;
}
return (err != 1) ? -1 : 0;
}
#ifdef CONFIG_LOAD_FILE
static int s5k6aafx_write_regs_from_sd(struct v4l2_subdev *sd, char s_name[])
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct test *tempData;
int ret = -EAGAIN;
unsigned long temp;
char delay = 0;
char data[11];
int searched = 0;
int size = strlen(s_name);
int i;
FUNC_ENTR();
printk("size = %d, string = %s\n", size, s_name);
tempData = &testBuf[0];
while(!searched)
{
searched = 1;
for (i = 0; i < size; i++)
{
if (tempData->data != s_name[i])
{
searched = 0;
break;
}
tempData = tempData->nextBuf;
}
tempData = tempData->nextBuf;
}
//structure is get..
while(1)
{
if (tempData->data == '{')
{
break;
}
else
{
tempData = tempData->nextBuf;
}
}
while (1)
{
searched = 0;
while (1)
{
if (tempData->data == 'x')
{
//get 10 strings
data[0] = '0';
for (i = 1; i < 11; i++)
{
data[i] = tempData->data;
tempData = tempData->nextBuf;
}
//printk("%s\n", data);
temp = simple_strtoul(data, NULL, 16);
break;
}
else if (tempData->data == '}')
{
searched = 1;
break;
}
else
{
tempData = tempData->nextBuf;
}
if (tempData->nextBuf == NULL)
{
return -1;
}
}
if (searched)
{
break;
}
//let search...
if ((temp & S5K6AAFX_DELAY) == S5K6AAFX_DELAY)
{
delay = temp & 0xFFFF;
//printk("func(%s):line(%d):delay(0x%x):delay(%d)\n",__func__,__LINE__,delay,delay);
msleep(delay);
continue;
}
ret = s5k6aafx_write(client, temp);
/* In error circumstances */
/* Give second shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry one more time\n");
ret = s5k6aafx_write(client, temp);
/* Give it one more shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry twice\n");
ret = s5k6aafx_write(client, temp);
}
}
}
return ret;
}
#endif
/* program multiple registers */
static int s5k6aafx_write_regs(struct v4l2_subdev *sd,
unsigned long *packet, unsigned int num)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
int ret = -EAGAIN; /* FIXME */
unsigned long temp;
char delay = 0;
while (num--)
{
temp = *packet++;
/*
if ((temp & S5K6AAFX_DELAY) == S5K6AAFX_DELAY)
{
if (temp & 0x1)
{
dev_info(&client->dev, "delay for 100msec\n");
msleep(100);
continue;
}
else
{
dev_info(&client->dev, "delay for 10msec\n");
msleep(10);
continue;
}
}
*/
#if 1
if ((temp & S5K6AAFX_DELAY) == S5K6AAFX_DELAY)
{
delay = temp & 0xFFFF;
//printk("func(%s):line(%d):delay(0x%x):delay(%d)\n",__func__,__LINE__,delay,delay);
msleep(delay);
continue;
}
#endif
ret = s5k6aafx_write(client, temp);
/* In error circumstances */
/* Give second shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry one more time\n");
ret = s5k6aafx_write(client, temp);
/* Give it one more shot */
if (unlikely(ret))
{
dev_info(&client->dev,
"s5k6aafx i2c retry twice\n");
ret = s5k6aafx_write(client, temp);
break;
}
}
}
dev_info(&client->dev, "S5K6AAFX register programming ends up\n");
if( ret < 0)
return -EIO;
return ret; /* FIXME */
}
static int s5k6aafx_set_capture_start(struct v4l2_subdev *sd, struct v4l2_control *ctrl)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
unsigned short lvalue = 0;
FUNC_ENTR();
s5k6aafx_write(client, 0x002C7000);
s5k6aafx_write(client, 0x002E1AAA); //read light value
s5k6aafx_read(client, 0x0F12, &lvalue);
printk("%s : light value is %x\n", __func__, lvalue);
/* set initial regster value */
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_capture");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_capture,
sizeof(s5k6aafx_capture) / sizeof(s5k6aafx_capture[0]));
#endif
if (lvalue < 0x40)
{
printk("\n----- low light -----\n\n");
mdelay(100);//add 100 ms delay for capture sequence
}
else
{
printk("\n----- normal light -----\n\n");
mdelay(50);
}
if (unlikely(err))
{
printk("%s: failed to make capture\n", __func__);
return err;
}
state->runmode = S5K6AAFX_RUNMODE_IDLE;
return err;
}
static int s5k6aafx_set_preview_start(struct v4l2_subdev *sd)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct s5k6aafx_state *state = to_state(sd);
int err = -EINVAL;
FUNC_ENTR();
dev_info(&client->dev, "%s: set_Preview_start\n", __func__);
if(state->check_dataline) // Output Test Pattern from VGA sensor
{
printk(" pattern on setting~~~~~~~~~~~\n");
err = s5k6aafx_write_regs(sd, s5k6aafx_pattern_on, sizeof(s5k6aafx_pattern_on) / sizeof(s5k6aafx_pattern_on[0]));
// mdelay(200);
}
else
{
/* set initial regster value */
#ifdef CONFIG_LOAD_FILE
err = s5k6aafx_write_regs_from_sd(sd, "s5k6aafx_preview");
#else
err = s5k6aafx_write_regs(sd, s5k6aafx_preview,
sizeof(s5k6aafx_preview) / sizeof(s5k6aafx_preview[0]));
#endif
if (unlikely(err)) {
printk("%s: failed to make preview\n", __func__);
return err;
}
}
if(state->set_vhflip == 1)
{
err = s5k6aafx_write_regs(sd, s5k6aafx_vhflip_on,
sizeof(s5k6aafx_vhflip_on) / sizeof(s5k6aafx_vhflip_on[0]));
}
state->runmode = S5K6AAFX_RUNMODE_RUNNING;
// mdelay(200); // add 200 ms for displaying preview
return err;
}
static int s5k6aafx_set_preview_stop(struct v4l2_subdev *sd)
{
struct s5k6aafx_state *state = to_state(sd);
int err = 0;
state->runmode = S5K6AAFX_RUNMODE_IDLE;
return err;
}
#if 0
static int s5k6aafx_s_crystal_freq(struct v4l2_subdev *sd, u32 freq, u32 flags)
{
int err = -EINVAL;
FUNC_ENTR();
return err;
}
