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; }