/* * A V4L2 driver for IMX214 Raw cameras. * * Copyright (c) 2017 by Allwinnertech Co., Ltd. http://www.allwinnertech.com * * Authors: Zhao Wei * Yang Feng * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as * published by the Free Software Foundation. */ #include #include #include #include #include #include #include #include #include #include #include "camera.h" #include "sensor_helper.h" MODULE_AUTHOR("lwj"); MODULE_DESCRIPTION("A low-level driver for IMX214 sensors"); MODULE_LICENSE("GPL"); #define MCLK (24*1000*1000) #define V4L2_IDENT_SENSOR 0x0214 #define DGAIN_R 0x100 #define DGAIN_G 0x100 #define DGAIN_B 0x100 /* * Our nominal (default) frame rate. */ #define SENSOR_FRAME_RATE 30 /* * The IMX214 sits on i2c with ID 0x6c */ #define I2C_ADDR 0x20 #define SENSOR_NAME "imx214" int imx214_sensor_vts; struct cfg_array { /* coming later */ struct regval_list *regs; int size; }; /* * The default register settings * */ static struct regval_list sensor_default_regs[] = { {0x0101, 0x03}, {0x0105, 0x01}, {0x0106, 0x01}, {0x4550, 0x02}, {0x4601, 0x04}, {0x4642, 0x01}, {0x6227, 0x11}, {0x6276, 0x00}, {0x900E, 0x06}, {0xA802, 0x90}, {0xA803, 0x11}, {0xA804, 0x62}, {0xA805, 0x77}, {0xA806, 0xAE}, {0xA807, 0x34}, {0xA808, 0xAE}, {0xA809, 0x35}, {0xA80A, 0x62}, {0xA80B, 0x83}, {0xAE33, 0x00}, {0x4174, 0x00}, {0x4175, 0x11}, {0x4612, 0x29}, {0x461B, 0x2C}, {0x461F, 0x06}, {0x4635, 0x07}, {0x4637, 0x30}, {0x463F, 0x18}, {0x4641, 0x0D}, {0x465B, 0x2C}, {0x465F, 0x2B}, {0x4663, 0x2B}, {0x4667, 0x24}, {0x466F, 0x24}, {0x470E, 0x09}, {0x4909, 0xAB}, {0x490B, 0x95}, {0x4915, 0x5D}, {0x4A5F, 0xFF}, {0x4A61, 0xFF}, {0x4A73, 0x62}, {0x4A85, 0x00}, {0x4A87, 0xFF}, {0x583C, 0x04}, {0x620E, 0x04}, {0x6EB2, 0x01}, {0x6EB3, 0x00}, {0x9300, 0x02}, {0x080b, 119}, {0x080d, 55}, {0x080f, 103}, {0x0811, 55}, {0x0813, 55}, {0x0815, 55}, {0x0817, 223}, {0x0819, 47}, {0x4601, 0x04}, {0x4642, 0x01}, {0x461B, 0x2C}, {0x465B, 0x2C}, {0x465F, 0x2B}, {0x4663, 0x2B}, {0x4667, 0x24}, {0x466F, 0x24}, }; static struct regval_list sensor_13mega_regs[] = { {0x0114, 0x03}, {0x0220, 0x00}, {0x0221, 0x11}, {0x0222, 0x01}, {0x0340, 0x0C}, {0x0341, 0x7A}, {0x0342, 0x13}, {0x0343, 0x90}, {0x0344, 0x00}, {0x0345, 0x00}, {0x0346, 0x00}, {0x0347, 0x00}, {0x0348, 0x10}, {0x0349, 0x6F}, {0x034A, 0x0C}, {0x034B, 0x2F}, {0x0381, 0x01}, {0x0383, 0x01}, {0x0385, 0x01}, {0x0387, 0x01}, {0x0900, 0x00}, {0x0901, 0x00}, {0x0902, 0x00}, {0x3000, 0x35}, {0x3054, 0x01}, {0x305C, 0x11}, {0x0112, 0x0A}, {0x0113, 0x0A}, {0x034C, 0x10}, {0x034D, 0x70}, {0x034E, 0x0C}, {0x034F, 0x30}, {0x0401, 0x00}, {0x0404, 0x00}, {0x0405, 0x10}, {0x0408, 0x00}, {0x0409, 0x00}, {0x040A, 0x00}, {0x040B, 0x00}, {0x040C, 0x10}, {0x040D, 0x70}, {0x040E, 0x0C}, {0x040F, 0x30}, {0x0301, 0x05}, {0x0303, 0x02}, {0x0305, 0x03}, {0x0306, 0x00}, {0x0307, 0x64}, {0x0309, 0x0A}, {0x030B, 0x01}, {0x0310, 0x00}, {0x0820, 0x0C}, {0x0821, 0x80}, {0x0822, 0x00}, {0x0823, 0x00}, {0x3A03, 0x08}, {0x3A04, 0xD0}, {0x3A05, 0x02}, {0x0B06, 0x01}, {0x30A2, 0x00}, {0x30B4, 0x00}, {0x3A02, 0xFF}, {0x3011, 0x00}, {0x3013, 0x01}, {0x0202, 0x0C}, {0x0203, 0x70}, {0x0224, 0x01}, {0x0225, 0xF4}, {0x0204, 0x00}, {0x0205, 0x00}, {0x020E, 0x01}, {0x020F, 0x00}, {0x0210, 0x01}, {0x0211, 0x00}, {0x0212, 0x01}, {0x0213, 0x00}, {0x0214, 0x01}, {0x0215, 0x00}, {0x0216, 0x00}, {0x0217, 0x00}, {0x4170, 0x00}, {0x4171, 0x10}, {0x4176, 0x00}, {0x4177, 0x3C}, {0xAE20, 0x04}, {0xAE21, 0x5C}, {0x0138, 0x01}, {0x0100, 0x01}, }; static struct regval_list sensor_4k_videos[] = { {0x0114, 0x03}, {0x0220, 0x00}, {0x0221, 0x11}, {0x0222, 0x01}, {0x0340, 0x09}, {0x0341, 0x3C}, {0x0342, 0x13}, {0x0343, 0x90}, {0x0344, 0x00}, {0x0345, 0xB8}, {0x0346, 0x01}, {0x0347, 0xE0}, {0x0348, 0x0F}, {0x0349, 0xB7}, {0x034A, 0x0A}, {0x034B, 0x4F}, {0x0381, 0x01}, {0x0383, 0x01}, {0x0385, 0x01}, {0x0387, 0x01}, {0x0900, 0x00}, {0x0901, 0x00}, {0x0902, 0x00}, {0x3000, 0x35}, {0x3054, 0x01}, {0x305C, 0x11}, {0x0112, 0x0A}, {0x0113, 0x0A}, {0x034C, 0x0F}, {0x034D, 0x00}, {0x034E, 0x08}, {0x034F, 0x70}, {0x0401, 0x00}, {0x0404, 0x00}, {0x0405, 0x10}, {0x0408, 0x00}, {0x0409, 0x00}, {0x040A, 0x00}, {0x040B, 0x00}, {0x040C, 0x0F}, {0x040D, 0x00}, {0x040E, 0x08}, {0x040F, 0x70}, {0x0301, 0x05}, {0x0303, 0x02}, {0x0305, 0x01}, {0x0306, 0x00}, {0x0307, 0x25}, {0x0309, 0x0A}, {0x030B, 0x01}, {0x0310, 0x00}, {0x0820, 0x0D}, {0x0821, 0xE0}, {0x0822, 0x00}, {0x0823, 0x00}, {0x3A03, 0x09}, {0x3A04, 0xA0}, {0x3A05, 0x04}, {0x0B06, 0x01}, {0x30A2, 0x00}, {0x30B4, 0x00}, {0x3A02, 0xFF}, {0x3011, 0x00}, {0x3013, 0x01}, {0x0202, 0x09}, {0x0203, 0x32}, {0x0224, 0x01}, {0x0225, 0xF4}, {0x0204, 0x00}, {0x0205, 0x00}, {0x020E, 0x01}, {0x020F, 0x00}, {0x0210, 0x01}, {0x0211, 0x00}, {0x0212, 0x01}, {0x0213, 0x00}, {0x0214, 0x01}, {0x0215, 0x00}, {0x0216, 0x00}, {0x0217, 0x00}, {0x4170, 0x00}, {0x4171, 0x10}, {0x4176, 0x00}, {0x4177, 0x3C}, {0xAE20, 0x04}, {0xAE21, 0x5C}, }; static struct regval_list sensor_1080p_regs[] = { {0x0114, 0x03}, {0x0220, 0x00}, {0x0221, 0x11}, {0x0222, 0x01}, {0x0340, 0x08}, {0x0341, 0x50}, {0x0342, 0x13}, {0x0343, 0x90}, {0x0344, 0x00}, {0x0345, 0xB8}, {0x0346, 0x01}, {0x0347, 0xE0}, {0x0348, 0x0F}, {0x0349, 0xB7}, {0x034A, 0x0A}, {0x034B, 0x4F}, {0x0381, 0x01}, {0x0383, 0x01}, {0x0385, 0x01}, {0x0387, 0x01}, {0x0900, 0x01}, {0x0901, 0x22}, {0x0902, 0x02}, {0x3000, 0x35}, {0x3054, 0x01}, {0x305C, 0x11}, {0x0112, 0x0A}, {0x0113, 0x0A}, {0x034C, 0x07}, {0x034D, 0x80}, {0x034E, 0x04}, {0x034F, 0x38}, {0x0401, 0x00}, {0x0404, 0x00}, {0x0405, 0x10}, {0x0408, 0x00}, {0x0409, 0x00}, {0x040A, 0x00}, {0x040B, 0x00}, {0x040C, 0x07}, {0x040D, 0x80}, {0x040E, 0x04}, {0x040F, 0x38}, {0x0301, 0x05}, {0x0303, 0x02}, {0x0305, 0x03}, {0x0306, 0x00}, {0x0307, 0x64}, {0x0309, 0x0A}, {0x030B, 0x01}, {0x0310, 0x00}, {0x0820, 0x0C}, {0x0821, 0x80}, {0x0822, 0x00}, {0x0823, 0x00}, {0x3A03, 0x06}, {0x3A04, 0x28}, {0x3A05, 0x04}, {0x0B06, 0x01}, {0x30A2, 0x00}, {0x30B4, 0x00}, {0x3A02, 0xFF}, {0x3011, 0x00}, {0x3013, 0x01}, {0x0202, 0x08}, {0x0203, 0x46}, {0x0224, 0x01}, {0x0225, 0xF4}, {0x0204, 0x00}, {0x0205, 0x00}, {0x020E, 0x01}, {0x020F, 0x00}, {0x0210, 0x01}, {0x0211, 0x00}, {0x0212, 0x01}, {0x0213, 0x00}, {0x0214, 0x01}, {0x0215, 0x00}, {0x0216, 0x00}, {0x0217, 0x00}, {0x4170, 0x00}, {0x4171, 0x10}, {0x4176, 0x00}, {0x4177, 0x3C}, {0xAE20, 0x04}, {0xAE21, 0x5C}, {0x0138, 0x01}, {0x0100, 0x01}, }; /* * Here we'll try to encapsulate the changes for just the output * video format. * */ static struct regval_list sensor_fmt_raw[] = { }; static int sensor_g_exp(struct v4l2_subdev *sd, __s32 *value) { struct sensor_info *info = to_state(sd); *value = info->exp; sensor_dbg("sensor_get_exposure = %d\n", info->exp); return 0; } static int sensor_s_exp(struct v4l2_subdev *sd, unsigned int exp_val) { unsigned char explow, exphigh; struct sensor_info *info = to_state(sd); if (exp_val > 0xffffff) exp_val = 0xfffff0; if (exp_val < 16) exp_val = 16; exp_val = (exp_val + 8) >> 4; exphigh = (unsigned char)((0xff00 & exp_val) >> 8); explow = (unsigned char)((0x00ff & exp_val)); sensor_write(sd, 0x0203, explow); sensor_write(sd, 0x0202, exphigh); info->exp = exp_val; return 0; } static int sensor_g_gain(struct v4l2_subdev *sd, __s32 *value) { struct sensor_info *info = to_state(sd); *value = info->gain; sensor_dbg("sensor_get_gain = %d\n", info->gain); return 0; } static int sensor_s_gain(struct v4l2_subdev *sd, int gain_val) { struct sensor_info *info = to_state(sd); unsigned char gainlow = 0; unsigned char gainhigh = 0; int gainana = 512 - 8192 / gain_val; gainlow = (unsigned char)(gainana & 0xff); gainhigh = (unsigned char)((gainana >> 8) & 0xff); sensor_write(sd, 0x0205, gainlow); sensor_write(sd, 0x0204, gainhigh); info->gain = gain_val; return 0; } static int sensor_s_exp_gain(struct v4l2_subdev *sd, struct sensor_exp_gain *exp_gain) { int exp_val, gain_val, shutter, frame_length; struct sensor_info *info = to_state(sd); exp_val = exp_gain->exp_val; gain_val = exp_gain->gain_val; if (gain_val < 1 * 16) gain_val = 16; if (gain_val > 64 * 16 - 1) gain_val = 64 * 16 - 1; if (exp_val > 0xfffff) exp_val = 0xfffff; shutter = exp_val / 16; if (shutter > imx214_sensor_vts) frame_length = shutter; else frame_length = imx214_sensor_vts; sensor_write(sd, 0x0104, 0x01); sensor_s_exp(sd, exp_val); sensor_s_gain(sd, gain_val); sensor_write(sd, 0x0104, 0x00); if (gain_val > 64) { sensor_write(sd, 0x30a2, 0x03); sensor_write(sd, 0x9706, (gain_val - 64) / 12); sensor_write(sd, 0x9e25, (gain_val - 64)); } else { sensor_write(sd, 0x30a2, 0x00); } info->exp = exp_val; info->gain = gain_val; return 0; } /* * Stuff that knows about the sensor. */ static int sensor_power(struct v4l2_subdev *sd, int on) { int ret; ret = 0; switch (on) { case STBY_ON: sensor_dbg("STBY_ON!\n"); cci_lock(sd); vin_gpio_write(sd, RESET, CSI_GPIO_LOW); cci_unlock(sd); vin_set_mclk(sd, OFF); break; case STBY_OFF: sensor_dbg("STBY_OFF!\n"); cci_lock(sd); vin_set_mclk_freq(sd, MCLK); vin_set_mclk(sd, ON); msleep(20); cci_unlock(sd); vin_gpio_write(sd, RESET, CSI_GPIO_HIGH); break; case PWR_ON: sensor_dbg("PWR_ON!\n"); cci_lock(sd); vin_gpio_set_status(sd, PWDN, 1); vin_gpio_set_status(sd, RESET, 1); vin_gpio_write(sd, PWDN, CSI_GPIO_LOW); vin_gpio_write(sd, RESET, CSI_GPIO_LOW); usleep_range(1000, 1200); vin_set_mclk_freq(sd, MCLK); vin_set_mclk(sd, ON); usleep_range(10000, 12000); vin_gpio_write(sd, POWER_EN, CSI_GPIO_HIGH); vin_set_pmu_channel(sd, IOVDD, ON); vin_set_pmu_channel(sd, AVDD, ON); vin_set_pmu_channel(sd, DVDD, ON); vin_set_pmu_channel(sd, AFVDD, ON); usleep_range(10000, 12000); vin_gpio_write(sd, PWDN, CSI_GPIO_HIGH); vin_gpio_write(sd, RESET, CSI_GPIO_HIGH); usleep_range(30000, 31000); cci_unlock(sd); break; case PWR_OFF: sensor_dbg("PWR_OFF!\n"); cci_lock(sd); vin_set_mclk(sd, OFF); vin_gpio_write(sd, POWER_EN, CSI_GPIO_LOW); vin_set_pmu_channel(sd, AFVDD, OFF); vin_set_pmu_channel(sd, DVDD, OFF); vin_set_pmu_channel(sd, AVDD, OFF); vin_set_pmu_channel(sd, IOVDD, OFF); usleep_range(10000, 12000); vin_gpio_write(sd, PWDN, CSI_GPIO_LOW); vin_gpio_write(sd, RESET, CSI_GPIO_LOW); vin_gpio_set_status(sd, RESET, 0); vin_gpio_set_status(sd, PWDN, 0); cci_unlock(sd); break; default: return -EINVAL; } return 0; } static int sensor_reset(struct v4l2_subdev *sd, u32 val) { switch (val) { case 0: vin_gpio_write(sd, RESET, CSI_GPIO_HIGH); usleep_range(10000, 12000); break; case 1: vin_gpio_write(sd, RESET, CSI_GPIO_LOW); usleep_range(10000, 12000); break; default: return -EINVAL; } return 0; } static int sensor_detect(struct v4l2_subdev *sd) { data_type rdval; sensor_read(sd, 0x0000, &rdval); sensor_read(sd, 0x0001, &rdval); sensor_print("find the sony IMX214 ***********\n"); return 0; } static int sensor_init(struct v4l2_subdev *sd, u32 val) { int ret; struct sensor_info *info = to_state(sd); sensor_dbg("sensor_init\n"); /*Make sure it is a target sensor */ ret = sensor_detect(sd); if (ret) { sensor_err("chip found is not an target chip.\n"); return ret; } info->focus_status = 0; info->low_speed = 0; info->width = 4208; info->height = 3120; info->hflip = 0; info->vflip = 0; info->gain = 0; info->tpf.numerator = 1; info->tpf.denominator = 30; /* 30fps */ info->preview_first_flag = 1; return 0; } static long sensor_ioctl(struct v4l2_subdev *sd, unsigned int cmd, void *arg) { int ret = 0; struct sensor_info *info = to_state(sd); switch (cmd) { case GET_CURRENT_WIN_CFG: if (info->current_wins != NULL) { memcpy(arg, info->current_wins, sizeof(struct sensor_win_size)); ret = 0; } else { sensor_err("empty wins!\n"); ret = -1; } break; case SET_FPS: break; case VIDIOC_VIN_SENSOR_EXP_GAIN: ret = sensor_s_exp_gain(sd, (struct sensor_exp_gain *)arg); break; case VIDIOC_VIN_SENSOR_CFG_REQ: sensor_cfg_req(sd, (struct sensor_config *)arg); break; default: return -EINVAL; } return ret; } /* * Store information about the video data format. */ static struct sensor_format_struct sensor_formats[] = { { .desc = "Raw RGB Bayer", .mbus_code = MEDIA_BUS_FMT_SBGGR10_1X10, .regs = sensor_fmt_raw, .regs_size = ARRAY_SIZE(sensor_fmt_raw), .bpp = 1 }, }; #define N_FMTS ARRAY_SIZE(sensor_formats) /* * Then there is the issue of window sizes. Try to capture the info here. */ static struct sensor_win_size sensor_win_sizes[] = { #if 1 /* Fullsize: 4208*3120 */ { .width = 4208, .height = 3120, .hoffset = 0, .voffset = 0, .hts = 5008, .vts = 3194, .pclk = 320 * 1000 * 1000, .mipi_bps = 800 * 1000 * 1000, .fps_fixed = 2, .bin_factor = 1, .intg_min = 16, .intg_max = (3194 - 10) << 4, .gain_min = 16, .gain_max = (16 << 4), .regs = sensor_13mega_regs, .regs_size = ARRAY_SIZE(sensor_13mega_regs), .set_size = NULL, }, #endif #if 1 /*4k video */ { .width = 3840, .height = 2160, .hoffset = 0, .voffset = 0, .hts = 5008, .vts = 2362, .pclk = 355 * 1000 * 1000, .mipi_bps = 888 * 1000 * 1000, .fps_fixed = 2, .bin_factor = 1, .intg_min = 16, .intg_max = (2362 - 10) << 4, .gain_min = 16, .gain_max = (16 << 4), .regs = sensor_4k_videos, .regs_size = ARRAY_SIZE(sensor_4k_videos), .set_size = NULL, }, /* 1080p */ { .width = 1920, .height = 1080, .hoffset = 0, .voffset = 0, .hts = 5008, .vts = 2128, .pclk = 320 * 1000 * 1000, .mipi_bps = 800 * 1000 * 1000, .fps_fixed = 1, .bin_factor = 1, .intg_min = 16, .intg_max = (2128 - 10) << 4, .gain_min = 16, .gain_max = (16 << 4), .regs = sensor_1080p_regs, .regs_size = ARRAY_SIZE(sensor_1080p_regs), .set_size = NULL, }, #endif }; #define N_WIN_SIZES (ARRAY_SIZE(sensor_win_sizes)) static int sensor_reg_init(struct sensor_info *info) { int ret = 0; struct v4l2_subdev *sd = &info->sd; struct sensor_format_struct *sensor_fmt = info->fmt; struct sensor_win_size *wsize = info->current_wins; ret = sensor_write_array(sd, sensor_default_regs, ARRAY_SIZE(sensor_default_regs)); if (ret < 0) { sensor_err("write sensor_default_regs error\n"); return ret; } sensor_write_array(sd, sensor_fmt->regs, sensor_fmt->regs_size); if (wsize->regs) sensor_write_array(sd, wsize->regs, wsize->regs_size); if (wsize->set_size) wsize->set_size(sd); info->width = wsize->width; info->height = wsize->height; imx214_sensor_vts = wsize->vts; sensor_print("s_fmt set width = %d, height = %d\n", wsize->width, wsize->height); return 0; } static int sensor_s_stream(struct v4l2_subdev *sd, int enable) { struct sensor_info *info = to_state(sd); sensor_print("%s on = %d, %d*%d %x\n", __func__, enable, info->current_wins->width, info->current_wins->height, info->fmt->mbus_code); if (!enable) return 0; return sensor_reg_init(info); } static int sensor_g_mbus_config(struct v4l2_subdev *sd, unsigned int pad, struct v4l2_mbus_config *cfg) { cfg->type = V4L2_MBUS_CSI2_DPHY; cfg->flags = 0 | V4L2_MBUS_CSI2_4_LANE | V4L2_MBUS_CSI2_CHANNEL_0; return 0; } static int sensor_g_ctrl(struct v4l2_ctrl *ctrl) { struct sensor_info *info = container_of(ctrl->handler, struct sensor_info, handler); struct v4l2_subdev *sd = &info->sd; switch (ctrl->id) { case V4L2_CID_GAIN: return sensor_g_gain(sd, &ctrl->val); case V4L2_CID_EXPOSURE: return sensor_g_exp(sd, &ctrl->val); } return -EINVAL; } static int sensor_s_ctrl(struct v4l2_ctrl *ctrl) { struct sensor_info *info = container_of(ctrl->handler, struct sensor_info, handler); struct v4l2_subdev *sd = &info->sd; switch (ctrl->id) { case V4L2_CID_GAIN: return sensor_s_gain(sd, ctrl->val); case V4L2_CID_EXPOSURE: return sensor_s_exp(sd, ctrl->val); } return -EINVAL; } /* ----------------------------------------------------------------------- */ static const struct v4l2_ctrl_ops sensor_ctrl_ops = { .g_volatile_ctrl = sensor_g_ctrl, .s_ctrl = sensor_s_ctrl, }; static const struct v4l2_subdev_core_ops sensor_core_ops = { .reset = sensor_reset, .init = sensor_init, .s_power = sensor_power, .ioctl = sensor_ioctl, #ifdef CONFIG_COMPAT .compat_ioctl32 = sensor_compat_ioctl32, #endif }; static const struct v4l2_subdev_video_ops sensor_video_ops = { .s_stream = sensor_s_stream, }; static const struct v4l2_subdev_pad_ops sensor_pad_ops = { .enum_mbus_code = sensor_enum_mbus_code, .enum_frame_size = sensor_enum_frame_size, .get_fmt = sensor_get_fmt, .set_fmt = sensor_set_fmt, .get_mbus_config = sensor_g_mbus_config, }; static const struct v4l2_subdev_ops sensor_ops = { .core = &sensor_core_ops, .video = &sensor_video_ops, .pad = &sensor_pad_ops, }; /* ----------------------------------------------------------------------- */ static struct cci_driver cci_drv = { .name = SENSOR_NAME, .addr_width = CCI_BITS_16, .data_width = CCI_BITS_8, }; static const struct v4l2_ctrl_config sensor_custom_ctrls[] = { { .ops = &sensor_ctrl_ops, .id = V4L2_CID_FRAME_RATE, .name = "frame rate", .type = V4L2_CTRL_TYPE_INTEGER, .min = 15, .max = 120, .step = 1, .def = 120, }, }; static int sensor_init_controls(struct v4l2_subdev *sd, const struct v4l2_ctrl_ops *ops) { struct sensor_info *info = to_state(sd); struct v4l2_ctrl_handler *handler = &info->handler; struct v4l2_ctrl *ctrl; int i; int ret = 0; v4l2_ctrl_handler_init(handler, 2 + ARRAY_SIZE(sensor_custom_ctrls)); ctrl = v4l2_ctrl_new_std(handler, ops, V4L2_CID_EXPOSURE, 0, 65536 * 16, 1, 0); if (ctrl != NULL) ctrl->flags |= V4L2_CTRL_FLAG_VOLATILE; v4l2_ctrl_new_std(handler, ops, V4L2_CID_GAIN, 1 * 1600, 256 * 1600, 1, 1 * 1600); for (i = 0; i < ARRAY_SIZE(sensor_custom_ctrls); i++) v4l2_ctrl_new_custom(handler, &sensor_custom_ctrls[i], NULL); if (handler->error) { ret = handler->error; v4l2_ctrl_handler_free(handler); } sd->ctrl_handler = handler; return ret; } static int sensor_probe(struct i2c_client *client, const struct i2c_device_id *id) { struct v4l2_subdev *sd; struct sensor_info *info; info = kzalloc(sizeof(struct sensor_info), GFP_KERNEL); if (info == NULL) return -ENOMEM; sd = &info->sd; cci_dev_probe_helper(sd, client, &sensor_ops, &cci_drv); sensor_init_controls(sd, &sensor_ctrl_ops); mutex_init(&info->lock); #ifdef CONFIG_SAME_I2C info->sensor_i2c_addr = I2C_ADDR >> 1; #endif info->fmt = &sensor_formats[0]; info->fmt_pt = &sensor_formats[0]; info->win_pt = &sensor_win_sizes[0]; info->fmt_num = N_FMTS; info->win_size_num = N_WIN_SIZES; info->sensor_field = V4L2_FIELD_NONE; info->af_first_flag = 1; return 0; } static int sensor_remove(struct i2c_client *client) { struct v4l2_subdev *sd; sd = cci_dev_remove_helper(client, &cci_drv); kfree(to_state(sd)); return 0; } static const struct i2c_device_id sensor_id[] = { {SENSOR_NAME, 0}, {} }; MODULE_DEVICE_TABLE(i2c, sensor_id); static struct i2c_driver sensor_driver = { .driver = { .owner = THIS_MODULE, .name = SENSOR_NAME, }, .probe = sensor_probe, .remove = sensor_remove, .id_table = sensor_id, }; static __init int init_sensor(void) { return cci_dev_init_helper(&sensor_driver); } static __exit void exit_sensor(void) { cci_dev_exit_helper(&sensor_driver); } module_init(init_sensor); module_exit(exit_sensor);