static int sensor_sr200_init(struct v4l2_subdev *subdev, u32 val)
{
int ret = 0;
u8 id;
struct sr200_state *state = to_state(subdev);
struct i2c_client *client = to_client(subdev);
cam_info("%s : E \n", __func__);
state->system_clock = 146 * 1000 * 1000;
state->line_length_pck = 146 * 1000 * 1000;
#ifdef CONFIG_LOAD_FILE
ret = sr200_regs_table_init();
CHECK_ERR_MSG(ret, "[CONFIG_LOAD_FILE] init fail \n");
#endif
sensor_sr200_apply_set(subdev, "sr200_Init_Reg", &sr200_regset_table.init);
sensor_sr200_apply_set(subdev, "sr200_stop_stream", &sr200_regset_table.stop_stream);
fimc_is_sr200_read8(client, 0x4, &id);
state->initialized = 1;
state->power_on = SR200_HW_POWER_ON;
state->runmode = RUNMODE_INIT;
state->preview.update_frmsize = 1;
cam_info("%s(id : %X) : X \n", __func__, id);
return ret;
}
static int sr200_start_preview(struct v4l2_subdev *subdev)
{
struct sr200_state *state = to_state(subdev);
int err = 0;
cam_info("Camera Preview start : E - runmode = %d\n", state->runmode);
if ((state->runmode == RUNMODE_NOTREADY) ||
(state->runmode == RUNMODE_CAPTURING)) {
cam_err("%s: error - Invalid runmode\n", __func__);
return -EPERM;
}
/* Check pending fps */
if (state->req_fps >= 0) {
err = sr200_set_frame_rate(subdev, state->req_fps);
CHECK_ERR(err);
}
/* Set preview size */
err = sr200_set_preview_size(subdev);
CHECK_ERR_MSG(err, "failed to set preview size(%d)\n", err);
err = sensor_sr200_stream_on(subdev);
CHECK_ERR(err);
if (RUNMODE_INIT == state->runmode)
msleep(100);
state->runmode = (state->sensor_mode == SENSOR_CAMERA) ?
RUNMODE_RUNNING : RUNMODE_RECORDING;
cam_info("Camera Preview start : X - runmode = %d\n", state->runmode);
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 int sr200_set_preview_size(struct v4l2_subdev *subdev)
{
struct sr200_state *state = to_state(subdev);
int err = 0;
u32 width, height;
if (!state->preview.update_frmsize)
return 0;
if (unlikely(!state->preview.frmsize)) {
cam_warn("warning, preview resolution not set\n");
state->preview.frmsize = sr200_get_framesize(
sr200_preview_frmsizes,
ARRAY_SIZE(sr200_preview_frmsizes),
PREVIEW_SZ_SVGA);
}
width = state->preview.frmsize->width;
height = state->preview.frmsize->height;
cam_info("set preview size(%dx%d)\n", width, height);
if (state->sensor_mode == SENSOR_MOVIE) {
if(width == 352 && height == 288) {
err = sensor_sr200_apply_set(subdev, "sr200_resol_352_288", &sr200_regset_table.resol_352_288);
} else {
/*err = sensor_sr200_apply_set(subdev, "sr200_resol_640_480", &sr200_regset_table.resol_640_480);*/
/*CHECK_ERR_MSG(err, "fail to set preview size\n");*/
cam_info("MOVIE Mode : skip preview size\n");
}
} else {
if(width == 352 && height == 288) { /* VT Preview size */
err = sensor_sr200_apply_set(subdev, "sr200_Init_VT_Reg", &sr200_regset_table.init_vt);
CHECK_ERR_MSG(err, "fail to set VT init\n");
err = sensor_sr200_apply_set(subdev, "sr200_resol_352_288", &sr200_regset_table.resol_352_288);
} else {
err = sensor_sr200_apply_set(subdev, "sr200_resol_800_600", &sr200_regset_table.resol_800_600);
}
}
CHECK_ERR_MSG(err, "fail to set preview size\n");
state->preview.update_frmsize = 0;
return 0;
}
static int sensor_sr200_apply_set(struct v4l2_subdev *sd,
const char * setting_name, const struct sensor_regset *table)
{
int ret = 0;
cam_info("%s : E, setting_name : %s\n", __func__, setting_name);
#ifdef CONFIG_LOAD_FILE
cam_info("COFIG_LOAD_FILE feature is enabled\n");
ret = sr200_write_regs_from_sd(sd, setting_name);
CHECK_ERR_MSG(ret, "[COFIG_LOAD_FILE]regs set apply is fail\n");
#else
ret = sr200_write_regs(sd, table->reg, table->size);
CHECK_ERR_MSG(ret, "regs set apply is fail\n");
#endif
cam_info("%s : X\n", __func__);
return ret;
}
static int sr200_write_regs(struct v4l2_subdev *sd, const struct sensor_reg regs[], int size)
{
int err = 0, i;
struct i2c_client *client = to_client(sd);
for (i = 0; i < size; i++) {
err = fimc_is_sr200_write8(client, regs[i].addr, regs[i].data);
CHECK_ERR_MSG(err, "register set failed\n");
}
return 0;
}
static int sr200pc20_set_capture_start(struct v4l2_subdev *sd)
{
struct sr200pc20_state *state = to_state(sd);
int err = -EINVAL;
cam_info("set_capture_start\n");
err = sr200pc20_set_from_table(sd, "capture_start",
&state->regs->capture_start, 1, 0);
CHECK_ERR_MSG(err, "failed to make capture\n");
sr200pc20_get_exif(sd);
return err;
}
static int sr200pc20_check_dataline(struct v4l2_subdev *sd, s32 val)
{
struct sr200pc20_state *state = to_state(sd);
int err = -EIO;
if (state->pdata->is_mipi)
return 0;
cam_info("DTP %s\n", val ? "ON" : "OFF");
if (val)
err = sr200pc20_set_from_table(sd, "dtp_on",
&state->regs->dtp_on, 1, 0);
else
err = sr200pc20_set_from_table(sd, "dtp_off",
&state->regs->dtp_off, 1, 0);
CHECK_ERR_MSG(err, "fail to DTP setting\n");
return 0;
}
static int sr200_set_capture_size(struct v4l2_subdev *subdev)
{
struct sr200_state *state = to_state(subdev);
u32 width, height;
int err = 0;
cam_info("%s - E\n",__func__);
if (unlikely(!state->capture.frmsize)) {
cam_warn("warning, capture resolution not set\n");
state->capture.frmsize = sr200_get_framesize(
sr200_capture_frmsizes,
ARRAY_SIZE(sr200_capture_frmsizes),
CAPTURE_SZ_1MP);
}
width = state->capture.frmsize->width;
height = state->capture.frmsize->height;
state->preview.update_frmsize = 1;
/* Transit to capture mode */
if (state->capture.lowlux_night) {
cam_info("capture_mode: night lowlux\n");
/* err = sensor_sr200_apply_set(client, &sr200_regset_table.lowcapture);*/
}
cam_info("%s - width * height = %d * %d \n",__func__, width, height);
if(width == 1600 && height == 1200)
err = sensor_sr200_apply_set(subdev, "sr200_resol_1600_1200", &sr200_regset_table.resol_1600_1200);
else if(width == 1280 && height == 960)
err = sensor_sr200_apply_set(subdev, "sr200_resol_1280_960", &sr200_regset_table.resol_1280_960);
else
err = sensor_sr200_apply_set(subdev, "sr200_resol_640_480", &sr200_regset_table.resol_640_480);
CHECK_ERR_MSG(err, "fail to capture_mode (%d)\n", err);
cam_info("%s - X\n",__func__);
return err;
}
static int sr200_set_frame_rate(struct v4l2_subdev *subdev, s32 fps)
{
struct sr200_state *state = to_state(subdev);
int min = FRAME_RATE_AUTO;
int max = FRAME_RATE_25;
int ret = 0;
int i=0, fps_index=-1;
cam_info("set frame rate %d\n", fps);
if (state->runmode == RUNMODE_INIT) {
cam_dbg("%s: skip fps setting \n", __func__);
return 0;
}
if ((fps < min) || (fps > max)) {
cam_warn("set_frame_rate: error, invalid frame rate %d\n", fps);
fps = (fps < min) ? min : max;
}
if (unlikely(!state->initialized)) {
cam_info("pending fps %d\n", fps);
state->req_fps = fps;
return 0;
}
for (i = 0; i < ARRAY_SIZE(sr200_framerates); i++) {
if (fps == sr200_framerates[i].fps) {
fps_index = sr200_framerates[i].index;
state->fps = fps;
state->req_fps = -1;
break;
}
}
if (unlikely(fps_index < 0)) {
cam_warn("set_fps: warning, not supported fps %d\n", fps);
return 0;
}
switch (fps) {
case FRAME_RATE_AUTO :
ret = sensor_sr200_apply_set(subdev, "sr200_fps_auto", &sr200_regset_table.fps_auto);
break;
case FRAME_RATE_7 :
ret = sensor_sr200_apply_set(subdev, "sr200_fps_7", &sr200_regset_table.fps_7);
break;
case FRAME_RATE_15 :
ret = sensor_sr200_apply_set(subdev, "sr200_fps_15", &sr200_regset_table.fps_15);
break;
case FRAME_RATE_25 :
ret = sensor_sr200_apply_set(subdev, "sr200_fps_25", &sr200_regset_table.fps_25);
break;
default:
cam_dbg("%s: Not supported fps (%d)\n", __func__, fps);
break;
}
CHECK_ERR_MSG(ret, "fail to set framerate\n");
return 0;
}
static int sr200_write_regs_from_sd(struct v4l2_subdev *sd, const char *name)
{
char *start = NULL, *end = NULL, *reg = NULL, *temp_start = NULL;
u8 addr = 0, value = 0;
u8 data = 0;
char data_buf[5] = {0, };
u32 len = 0;
int err = 0;
struct i2c_client *client = to_client(sd);
cam_info("%s : E, sr200_regs_table_size - %d\n", __func__, sr200_regs_table_size);
addr = value = 0;
*(data_buf + 4) = '\0';
start = strnstr(sr200_regs_table, name, sr200_regs_table_size);
CHECK_ERR_COND_MSG(start == NULL, -ENODATA, "start is NULL\n");
end = strnstr(start, "};", sr200_regs_table_size);
CHECK_ERR_COND_MSG(start == NULL, -ENODATA, "end is NULL\n");
while (1) {
len = end -start;
temp_start = strnstr(start, "{", len);
if (!temp_start || (temp_start > end)) {
cam_info("write end of %s\n", name);
break;
}
start = temp_start;
len = end -start;
/* Find Address */
reg = strnstr(start, "0x", len);
if (!reg || (reg > end)) {
cam_info("write end of %s\n", name);
break;
}
start = (reg + 4);
/* Write Value to Address */
memcpy(data_buf, reg, 4);
err = kstrtou8(data_buf, 16, &data);
CHECK_ERR_MSG(err, "kstrtou16 failed\n");
addr = data;
len = end -start;
/* Find Data */
reg = strnstr(start, "0x", len);
if (!reg || (reg > end)) {
cam_info("write end of %s\n", name);
break;
}
/* Write Value to Address */
memcpy(data_buf, reg, 4);
err = kstrtou8(data_buf, 16, &data);
CHECK_ERR_MSG(err, "kstrtou16 failed\n");
value = data;
err = fimc_is_sr200_write8(client, addr, value);
CHECK_ERR_MSG(err, "register set failed\n");
}
cam_info("%s : X\n", __func__);
return err;
}
