TX2 driver will check the frame size more than the TX1.
I attached a setting is working form me for you to try. Please use the v4l2-ctl check first.
/*
* imx290_tables.h - sensor mode tables for imx290 HDR sensor.
*
* Copyright (c) 2015-2016, NVIDIA CORPORATION, All Rights Reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef IMX290_I2C_TABLES
#define IMX290_I2C_TABLES
#define IMX290_TABLE_WAIT_MS 0
#define IMX290_TABLE_END 1
#define IMX290_MAX_RETRIES 3
#define IMX290_WAIT_MS 3
static struct reg_8 mode_1920x1080[] = {
{IMX290_TABLE_WAIT_MS, 10},
/* software reset */
{0x3003, 0x01},
{IMX290_TABLE_WAIT_MS, 50},
{0x3000, 0x01},
{0x3002, 0x00},
{0x3002, 0x01},
{IMX290_TABLE_WAIT_MS, 50},
/* global settings */
//ID2
{0x3004,0x10},// FIXED
{0x3005,0x01},// AD 12BIT, NO SHIFT
{0x3006,0x00},// DRIVE MODE = ALL PIXEL SCAN MODE
{0x3007,0x00},// NO H,V REVERSE , WIN MODE =FULL 1080p mode
{0x3008,0xA0},// FIXED
{0x3009,0x02},// Middle Speed FRAME RATE = 30 FPS
{0x300A,0xF0},// 12BIT BLACK LEVEL[0:7]
{0x300B,0x00},// 12BIT BLACK LEVEL[8]
{0x300C,0x00},// FIXED
{0x300D,0x00},// FIXED
{0x300E,0x01},// FIXED
{0x300F,0x00},// FIXED
{0x3010,0x21},// FIXED
{0x3011,0x00},// FIXED
{0x3012,0x64},// FIXED
{0x3013,0x00},// FIXED
{0x3014,0x00},// GAIN = 0 DB
{0x3015,0x00},// FIXED
{0x3016,0x09},// FIXED
{0x3017,0x00},// FIXED
{0x3018,0x65},// VMAX[0:7]
{0x3019,0x04},// VMAX[8:15] ==>1125
{0x301A,0x00},// VMAX[16]
{0x301B,0x00},
{0x301C,0x98},// HMAX[0:7]
{0x301D,0x08},// HMAX[8:15] ==>4400
{0x301E,0xB2},// FIXED
{0x301F,0x01},// FIXED
{0x3020,0x00},// SUB CONTROL [0:7]
{0x3021,0x00},// SUB CONTROL [8:15]
{0x3022,0x00},// SUB CONTROL [16]
{0x303E,0x48},// WINWH[0:7] , H CROPPING SIZE
{0x303F,0x04},// WINWH[8:10]
{0x3040,0x00},// FIXED
{0x3041,0x00},// FIXED
{0x3046,0x01},// CSI-2 fixed 0x1
{0x3047,0x01},
{0x3070, 0x02},
{0x3071, 0x11},
{0x309B, 0x10},
{0x309C, 0x22},
{0x30A2, 0x02},
{0x30A6, 0x20},
{0x30A8, 0x20},
{0x30AA, 0x20},
{0x30AC, 0x20},
{0x30b0, 0x43},
//ID3
{0x3119, 0x9E},
{0x311C, 0x1E},
{0x311E, 0x08},
{0x3128, 0x05},
{0x3129, 0x1D},
{0x313D, 0x83},
{0x3150, 0x03},
{0x315E, 0x1A},
{0x3164, 0x1A},
{0x317C, 0x00},
{0x317E, 0x00},
{0x317F,0x50},
//ID4
{0x32B8,0x50},
{0x32B9,0x10},
{0x32BA,0x00},
{0x32BB,0x04},
{0x32C8,0x50},
{0x32C9,0x10},
{0x32CA,0x00},
{0x32CB,0x04},
//ID5
{0x332C,0xD3},
{0x332D,0x10},
{0x332E,0x0D},
{0x3358,0x06},
{0x3359,0xE1},
{0x335A,0x11},
{0x3360,0x1E},
{0x3361,0x61},
{0x3362,0x10},
{0x33B0,0x50},
{0x33B1,0x1A},
{0x33B3,0x04},
//ID6
{0x3405,0x10}, // frame rate 30
{0x3407,0x03}, // 4 Lane
{0x3414,0x0A}, // OB size
{0x3418,0x48}, // Y OUT SIZE
{0x3419,0x04},
{0x3441,0x0C}, // RAW12
{0x3442,0x0C},
{0x3443,0x03}, // CSI LANE MODE
{0x3444,0x20}, // EXTCLK 37.125M
{0x3445,0x25},
{0x3446,0x57},
{0x3447,0x00},
{0x3448,0x37},
{0x3449,0x00},
{0x344a,0x1F},
{0x344b,0x00},
{0x344c,0x1F},
{0x344d,0x00},
{0x344e,0x1F},
{0x344f,0x00},
{0x3450,0x77},
{0x3451,0x00},
{0x3452,0x1F},
{0x3453,0x00},
{0x3454,0x17},
{0x3455,0x00},
{0x3472,0x9C}, // X OUT SIZE
{0x3473,0x07},
//MISC
// LVDS 4CH CSI2 , 1080p Mode
{0x305C,0x18},// INCKSEL1
{0x305D,0x03},// INCKSEL2
{0x305E,0x20},// INCKSEL3
{0x305F,0x01},// INCKSEL4
{0x315E,0x1A},// INCKSEL5
{0x3164,0x1A},// INCKSEL6
{0x3480,0x49},// INCKSEL7
{0x3048,0x00},// XVS PULSE WIDTH=8H
{0x3049,0x00},// XHS PULSE max
{0x3005,0x01},// AD bit 12
/* stream on */
{0x3000, 0x00},// STANDBY CANCEL
{IMX290_TABLE_WAIT_MS, 30},
{0x3002, 0x00},// Master mode start
{0x304B, 0x0A},// XVS Abd XHS O/P
{IMX290_TABLE_WAIT_MS, 240},
{IMX290_TABLE_END, 0x00}
};
enum {
IMX290_MODE_1920x1080,
};
static struct reg_8 *mode_table[] = {
[IMX290_MODE_1920x1080] = mode_1920x1080,
};
static const int imx290_30fps[] = {
30,
};
static const struct camera_common_frmfmt imx290_frmfmt[] = {
{{1948, 1096}, imx290_30fps, 1, 0, IMX290_MODE_1920x1080},
};
#endif
/*
* imx290.c - imx290 sensor driver
*
* Copyright (c) 2015-2016, NVIDIA CORPORATION. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include <dt-bindings/gpio/tegra-gpio.h>
#include <linux/slab.h>
#include <linux/uaccess.h>
#include <linux/gpio.h>
#include <linux/module.h>
#include <linux/seq_file.h>
#include <linux/of.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <media/camera_common.h>
#include <media/soc_camera.h>
#include <media/imx290.h>
#include "imx290_mode_tbls.h"
#define IMX290_MAX_COARSE_DIFF 1
//#define IMX290_GAIN_SHIFT 8
#define IMX290_MIN_GAIN (0)//(0 * FIXED_POINT_SCALING_FACTOR)
#define IMX290_MAX_GAIN (72 * FIXED_POINT_SCALING_FACTOR)
#define IMX290_MIN_FRAME_LENGTH (0x465)
#define IMX290_MAX_FRAME_LENGTH (0xFFFF)
#define IMX290_MIN_EXPOSURE_COARSE (0x0001)
#define IMX290_MAX_EXPOSURE_COARSE \
(IMX290_MAX_FRAME_LENGTH-IMX290_MAX_COARSE_DIFF)
#define IMX290_DEFAULT_GAIN (6 * FIXED_POINT_SCALING_FACTOR)
#define IMX290_DEFAULT_FRAME_LENGTH (0x0465)
#define IMX290_DEFAULT_EXPOSURE_COARSE \
(IMX290_DEFAULT_FRAME_LENGTH-IMX290_MAX_COARSE_DIFF)
#define IMX290_DEFAULT_MODE IMX290_MODE_1920x1080
#define IMX290_DEFAULT_WIDTH 1948
#define IMX290_DEFAULT_HEIGHT 1096
//#define IMX290_DEFAULT_DATAFMT V4L2_MBUS_FMT_SRGGB12_1X12
#define IMX290_DEFAULT_DATAFMT MEDIA_BUS_FMT_SRGGB12_1X12
#define IMX290_DEFAULT_CLK_FREQ 74250000
struct imx290 {
struct mutex imx290_camera_lock;
struct camera_common_power_rail power;
int num_ctrls;
struct v4l2_ctrl_handler ctrl_handler;
struct i2c_client *i2c_client;
struct v4l2_subdev *subdev;
struct media_pad pad;
struct regmap *regmap;
struct camera_common_data *s_data;
struct camera_common_pdata *pdata;
struct v4l2_ctrl *ctrls[];
};
static const struct regmap_config sensor_regmap_config = {
.reg_bits = 16,
.val_bits = 8,
.cache_type = REGCACHE_RBTREE,
.use_single_rw = true,
};
static int imx290_g_volatile_ctrl(struct v4l2_ctrl *ctrl);
static int imx290_s_ctrl(struct v4l2_ctrl *ctrl);
static const struct v4l2_ctrl_ops imx290_ctrl_ops = {
.g_volatile_ctrl = imx290_g_volatile_ctrl,
.s_ctrl = imx290_s_ctrl,
};
static struct v4l2_ctrl_config ctrl_config_list[] = {
/* Do not change the name field for the controls! */
{
.ops = &imx290_ctrl_ops,
.id = V4L2_CID_GAIN,
.name = "Gain",
.type = V4L2_CTRL_TYPE_INTEGER64,
.flags = V4L2_CTRL_FLAG_SLIDER,
.min = IMX290_MIN_GAIN,
.max = IMX290_MAX_GAIN,
.def = IMX290_DEFAULT_GAIN,
.step = 1,
},
{
.ops = &imx290_ctrl_ops,
.id = V4L2_CID_FRAME_LENGTH,
.name = "Frame Length",
.type = V4L2_CTRL_TYPE_INTEGER,
.flags = V4L2_CTRL_FLAG_SLIDER,
.min = IMX290_MIN_FRAME_LENGTH,
.max = IMX290_MAX_FRAME_LENGTH,
.def = IMX290_DEFAULT_FRAME_LENGTH,
.step = 1,
},
{
.ops = &imx290_ctrl_ops,
.id = V4L2_CID_COARSE_TIME,
.name = "Coarse Time",
.type = V4L2_CTRL_TYPE_INTEGER,
.flags = V4L2_CTRL_FLAG_SLIDER,
.min = IMX290_MIN_EXPOSURE_COARSE,
.max = IMX290_MAX_EXPOSURE_COARSE,
.def = IMX290_DEFAULT_EXPOSURE_COARSE,
.step = 1,
},
{
.ops = &imx290_ctrl_ops,
.id = V4L2_CID_GROUP_HOLD,
.name = "Group Hold",
.type = V4L2_CTRL_TYPE_INTEGER_MENU,
.min = 0,
.max = ARRAY_SIZE(switch_ctrl_qmenu) - 1,
.menu_skip_mask = 0,
.def = 0,
.qmenu_int = switch_ctrl_qmenu,
},
{
.ops = &imx290_ctrl_ops,
.id = V4L2_CID_HDR_EN,
.name = "HDR enable",
.type = V4L2_CTRL_TYPE_INTEGER_MENU,
.min = 0,
.max = ARRAY_SIZE(switch_ctrl_qmenu) - 1,
.menu_skip_mask = 0,
.def = 0,
.qmenu_int = switch_ctrl_qmenu,
},
{
.ops = &imx290_ctrl_ops,
.id = V4L2_CID_FUSE_ID,
.name = "Fuse ID",
.type = V4L2_CTRL_TYPE_STRING,
.flags = V4L2_CTRL_FLAG_READ_ONLY,
.min = 0,
.max = IMX290_FUSE_ID_STR_SIZE,
.step = 2,
},
};
static inline void imx290_get_frame_length_regs(struct reg_8 *regs,
u16 frame_length)
{
regs->addr = IMX290_FRAME_LENGTH_ADDR_MSB;
regs->val = (frame_length >> 8) & 0xff;
(regs + 1)->addr = IMX290_FRAME_LENGTH_ADDR_LSB;
(regs + 1)->val = (frame_length) & 0xff;
}
static inline void imx290_get_coarse_time_regs(struct reg_8 *regs,
u16 coarse_time)
{
regs->addr = IMX290_COARSE_TIME_ADDR_MSB;
regs->val = (coarse_time >> 8) & 0xff;
(regs + 1)->addr = IMX290_COARSE_TIME_ADDR_LSB;
(regs + 1)->val = (coarse_time) & 0xff;
}
static inline void imx290_get_gain_reg(struct reg_8 *regs,
u16 gain)
{
regs->addr = IMX290_GAIN_ADDR;
regs->val = gain & 0xff;
}
static inline void imx290_get_hold_reg(struct reg_8 *regs,
u16 hold)
{
regs->addr = IMX290_REGHOLD_ADDR;
regs->val = hold & 0xff;
}
static int test_mode;
module_param(test_mode, int, 0644);
static inline int imx290_read_reg(struct camera_common_data *s_data,
u16 addr, u8 *val)
{
struct imx290 *priv = (struct imx290 *)s_data->priv;
return regmap_read(priv->regmap, addr, (unsigned int *) val);
}
static int imx290_write_reg(struct camera_common_data *s_data, u16 addr, u8 val)
{
int err;
struct imx290 *priv = (struct imx290 *)s_data->priv;
err = regmap_write(priv->regmap, addr, val);
if (err)
pr_err("%s:i2c write failed, %x = %x\n",
__func__, addr, val);
return err;
}
static int imx290_write_table(struct imx290 *priv,
const struct reg_8 table[])
{
return regmap_util_write_table_8(priv->regmap,
table,
NULL, 0,
IMX290_TABLE_WAIT_MS,
IMX290_TABLE_END);
}
static void imx290_mclk_disable(struct camera_common_power_rail *pw)
{
clk_disable_unprepare(pw->mclk);
}
static void imx290_mclk_enable(struct camera_common_power_rail *pw)
{
clk_set_rate(pw->mclk, IMX290_DEFAULT_CLK_FREQ);
clk_prepare_enable(pw->mclk);
}
static int imx290_power_on(struct camera_common_data *s_data)
{
int err = 0;
struct imx290 *priv = (struct imx290 *)s_data->priv;
struct camera_common_power_rail *pw = &priv->power;
//dev_err(&priv->i2c_client->dev, "%s: power on\n", __func__);
if (gpio_cansleep(pw->reset_gpio))
gpio_set_value_cansleep(pw->reset_gpio, 0);
else
gpio_set_value(pw->reset_gpio, 0);
usleep_range(10, 20);
if (pw->avdd)
err = regulator_enable(pw->avdd);
if (err)
goto imx290_avdd_fail;
if (pw->iovdd)
err = regulator_enable(pw->iovdd);
if (err)
goto imx290_iovdd_fail;
if (pw->dvdd)
err = regulator_enable(pw->dvdd);
if (err)
goto imx290_dvdd_fail;
usleep_range(1, 2);
if (gpio_cansleep(pw->reset_gpio))
gpio_set_value_cansleep(pw->reset_gpio, 1);
else
gpio_set_value(pw->reset_gpio, 1);
usleep_range(1, 2);
imx290_mclk_enable(pw);
/* Need to wait for t4 + t5 + t9 time as per the data sheet */
/* t4 - 200us, t5 - 6ms, t9 - 1.2ms */
usleep_range(7400, 7410);
pw->state = SWITCH_ON;
return 0;
imx290_dvdd_fail:
regulator_disable(pw->iovdd);
imx290_iovdd_fail:
regulator_disable(pw->avdd);
imx290_avdd_fail:
return -ENODEV;
}
static int imx290_power_off(struct camera_common_data *s_data)
{
struct imx290 *priv = (struct imx290 *)s_data->priv;
struct camera_common_power_rail *pw = &priv->power;
//dev_err(&priv->i2c_client->dev, "%s: power off\n", __func__);
usleep_range(1, 2);
if (gpio_cansleep(pw->reset_gpio))
gpio_set_value_cansleep(pw->reset_gpio, 0);
else
gpio_set_value(pw->reset_gpio, 0);
usleep_range(1, 2);
if (pw->dvdd)
regulator_disable(pw->dvdd);
if (pw->iovdd)
regulator_disable(pw->iovdd);
if (pw->avdd)
regulator_disable(pw->avdd);
imx290_mclk_disable(pw);
pw->state = SWITCH_OFF;
return 0;
}
static int imx290_power_put(struct imx290 *priv)
{
struct camera_common_power_rail *pw = &priv->power;
if (unlikely(!pw))
return -EFAULT;
if (likely(pw->avdd))
regulator_put(pw->avdd);
if (likely(pw->iovdd))
regulator_put(pw->iovdd);
if (likely(pw->dvdd))
regulator_put(pw->dvdd);
pw->avdd = NULL;
pw->iovdd = NULL;
pw->dvdd = NULL;
return 0;
}
static int imx290_power_get(struct imx290 *priv)
{
struct camera_common_power_rail *pw = &priv->power;
struct camera_common_pdata *pdata = priv->pdata;
const char *mclk_name;
int err = 0;
mclk_name = priv->pdata->mclk_name ?
priv->pdata->mclk_name : "cam_mclk1";
pw->mclk = devm_clk_get(&priv->i2c_client->dev, mclk_name);
if (IS_ERR(pw->mclk)) {
dev_err(&priv->i2c_client->dev,
"unable to get clock %s\n", mclk_name);
return PTR_ERR(pw->mclk);
}
/* ananlog 2.7v */
err |= camera_common_regulator_get(priv->i2c_client,
&pw->avdd, pdata->regulators.avdd);
/* digital 1.2v */
err |= camera_common_regulator_get(priv->i2c_client,
&pw->dvdd, pdata->regulators.dvdd);
/* IO 1.8v */
err |= camera_common_regulator_get(priv->i2c_client,
&pw->iovdd, pdata->regulators.iovdd);
if (!err)
pw->reset_gpio = pdata->reset_gpio;
pw->state = SWITCH_OFF;
return err;
}
static int imx290_set_gain(struct imx290 *priv, s64 val);
static int imx290_set_frame_length(struct imx290 *priv, s32 val);
static int imx290_set_coarse_time(struct imx290 *priv, s32 val);
static int imx290_s_stream(struct v4l2_subdev *sd, int enable)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct camera_common_data *s_data = to_camera_common_data(client);
struct imx290 *priv = (struct imx290 *)s_data->priv;
int err;
struct v4l2_control control;
dev_dbg(&client->dev, "%s\n", __func__);
if (!enable)
return 0;
#if 1
err = imx290_write_table(priv, mode_table[s_data->mode]);
if (err)
goto exit;
/* write list of override regs for the asking frame length,
* coarse integration time, and gain. Failures to write
* overrides are non-fatal */
printk(KERN_DEBUG "\n Start set V4L2_CID_GAIN \n");
control.id = V4L2_CID_GAIN;
err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
control.value = IMX290_MIN_GAIN;
printk(KERN_DEBUG "\n Start set V4L2_CID_FRAME_LENGTH \n");
control.id = V4L2_CID_FRAME_LENGTH;
err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
control.value = IMX290_DEFAULT_FRAME_LENGTH;
printk(KERN_DEBUG "\n Start set V4L2_CID_COARSE_TIME \n");
control.id = V4L2_CID_COARSE_TIME;
err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
control.value = IMX290_DEFAULT_EXPOSURE_COARSE;
#endif
return 0;
exit:
dev_dbg(&client->dev, "%s: error setting stream\n", __func__);
return err;
}
static int imx290_g_input_status(struct v4l2_subdev *sd, u32 *status)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
struct camera_common_data *s_data = to_camera_common_data(client);
struct imx290 *priv = (struct imx290 *)s_data->priv;
struct camera_common_power_rail *pw = &priv->power;
*status = pw->state == SWITCH_ON;
return 0;
}
static int imx290_get_fmt(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_format *format)
{
return camera_common_g_fmt(sd, &format->format);
}
static int imx290_set_fmt(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_format *format)
{
int ret;
if (format->which == V4L2_SUBDEV_FORMAT_TRY)
ret = camera_common_try_fmt(sd, &format->format);
else
ret = camera_common_s_fmt(sd, &format->format);
return ret;
}
static struct v4l2_subdev_video_ops imx290_subdev_video_ops = {
.s_stream = imx290_s_stream,
//.s_mbus_fmt = camera_common_s_fmt,
//.g_mbus_fmt = camera_common_g_fmt,
//.try_mbus_fmt = camera_common_try_fmt,
//.enum_mbus_fmt = camera_common_enum_fmt,
.g_mbus_config = camera_common_g_mbus_config,
.g_input_status = imx290_g_input_status,
//.enum_framesizes = camera_common_enum_framesizes,
//.enum_frameintervals = camera_common_enum_frameintervals,
};
static struct v4l2_subdev_core_ops imx290_subdev_core_ops = {
.s_power = camera_common_s_power,
};
static struct v4l2_subdev_pad_ops imx290_subdev_pad_ops = {
//.enum_mbus_code = camera_common_enum_mbus_code,
.set_fmt = imx290_set_fmt,
.get_fmt = imx290_get_fmt,
.enum_mbus_code = camera_common_enum_mbus_code,
.enum_frame_size = camera_common_enum_framesizes,
.enum_frame_interval = camera_common_enum_frameintervals,
};
static struct v4l2_subdev_ops imx290_subdev_ops = {
.core = &imx290_subdev_core_ops,
.video = &imx290_subdev_video_ops,
.pad = &imx290_subdev_pad_ops,
};
static struct of_device_id imx290_of_match[] = {
{ .compatible = "nvidia,imx290", },
{ },
};
static struct camera_common_sensor_ops imx290_common_ops = {
.power_on = imx290_power_on,
.power_off = imx290_power_off,
.write_reg = imx290_write_reg,
.read_reg = imx290_read_reg,
};
static int imx290_set_group_hold(struct imx290 *priv, s32 val)
{
struct reg_8 reg_list[1];
int err;
int i = 0;
imx290_get_hold_reg(reg_list, val);
err = imx290_write_reg(priv->s_data, reg_list[i].addr,
reg_list[i].val);
if (err)
goto fail;
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: REGHOLD error\n", __func__);
return err;
}
static int imx290_set_gain(struct imx290 *priv, s64 val)
{
struct reg_8 reg_list[2];
int err;
u32 gain;
s64 gain64;
int i = 0;
/* translate value */
gain64 = (s64)(val / FIXED_POINT_SCALING_FACTOR);
//gain = (u8)(gain64 * 240 / 72);
gain = (u8)((val * 240) / (72*FIXED_POINT_SCALING_FACTOR));
//dev_err(&priv->i2c_client->dev,
//"%s: gain reg: %d, db: %lld\n", __func__, gain, gain64);
imx290_get_gain_reg(reg_list, gain);
err = imx290_write_reg(priv->s_data, reg_list[i].addr,
reg_list[i].val);
if (err)
goto fail;
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: GAIN control error\n", __func__);
return err;
}
static int imx290_set_frame_length(struct imx290 *priv, s32 val)
{
struct reg_8 reg_list[2];
int err;
u16 frame_length = (u16) val;
int i = 0;
frame_length = val;
//dev_err(&priv->i2c_client->dev,
// "%s: val: %d\n", __func__, frame_length);
imx290_get_frame_length_regs(reg_list, frame_length);
for (i = 0; i < 2; i++) {
err = imx290_write_reg(priv->s_data, reg_list[i].addr,
reg_list[i].val);
if (err)
goto fail;
}
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: FRAME_LENGTH control error\n", __func__);
return err;
}
static int imx290_set_coarse_time(struct imx290 *priv, s32 val)
{
struct reg_8 reg_list[2];
int err;
u16 coarse_time = (u16) val;
int i = 0;
if(val < IMX290_DEFAULT_FRAME_LENGTH )
{
coarse_time = IMX290_DEFAULT_FRAME_LENGTH - val - 1;
}else{
coarse_time = 0;
}
if(coarse_time < IMX290_MIN_EXPOSURE_COARSE)
{
coarse_time = IMX290_MIN_EXPOSURE_COARSE;
}
//dev_err(&priv->i2c_client->dev,
// "%s: val: %d ,%d\n", __func__, coarse_time,val);
imx290_get_coarse_time_regs(reg_list, coarse_time);
for (i = 0; i < 2; i++) {
err = imx290_write_reg(priv->s_data, reg_list[i].addr,
reg_list[i].val);
if (err)
goto fail;
}
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: COARSE_TIME control error\n", __func__);
return err;
}
/*static int imx290_verify_streaming(struct imx290 *priv)
{
int err = 0;
err = camera_common_s_power(priv->subdev, true);
if (err)
return err;
err = imx290_s_stream(priv->subdev, true);
if (err)
goto error;
error:
imx290_s_stream(priv->subdev, false);
camera_common_s_power(priv->subdev, false);
return err;
}
*/
static int imx290_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
{
struct imx290 *priv =
container_of(ctrl->handler, struct imx290, ctrl_handler);
int err = 0;
if (priv->power.state == SWITCH_OFF)
return 0;
switch (ctrl->id) {
default:
pr_err("%s: unknown ctrl id.\n", __func__);
return -EINVAL;
}
return err;
}
static int imx290_s_ctrl(struct v4l2_ctrl *ctrl)
{
struct imx290 *priv =
container_of(ctrl->handler, struct imx290, ctrl_handler);
int err = 0;
if (priv->power.state == SWITCH_OFF)
return 0;
//dev_err(&priv->i2c_client->dev,
// "%s: 0x%X \n", __func__, ctrl->id);
switch (ctrl->id) {
case V4L2_CID_GAIN:
err = imx290_set_gain(priv, *ctrl->p_new.p_s64);
break;
case V4L2_CID_FRAME_LENGTH:
err = imx290_set_frame_length(priv, ctrl->val);
break;
case V4L2_CID_COARSE_TIME:
err = imx290_set_coarse_time(priv, ctrl->val);
break;
case V4L2_CID_GROUP_HOLD:
err = imx290_set_group_hold(priv, ctrl->val);
break;
case V4L2_CID_HDR_EN:
break;
case V4L2_CID_FUSE_ID:
break;
default:
pr_err("%s: unknown ctrl id.\n", __func__);
return -EINVAL;
}
return err;
}
static int imx290_ctrls_init(struct imx290 *priv)
{
struct i2c_client *client = priv->i2c_client;
struct v4l2_ctrl *ctrl;
int num_ctrls;
int err;
int i;
dev_info(&client->dev, "%s++\n", __func__);
num_ctrls = ARRAY_SIZE(ctrl_config_list);
v4l2_ctrl_handler_init(&priv->ctrl_handler, num_ctrls);
for (i = 0; i < num_ctrls; i++) {
ctrl = v4l2_ctrl_new_custom(&priv->ctrl_handler,
&ctrl_config_list[i], NULL);
if (ctrl == NULL) {
dev_err(&client->dev, "Failed to init %s ctrl\n",
ctrl_config_list[i].name);
continue;
}
if (ctrl_config_list[i].type == V4L2_CTRL_TYPE_STRING &&
ctrl_config_list[i].flags & V4L2_CTRL_FLAG_READ_ONLY) {
ctrl->p_new.p_char = devm_kzalloc(&client->dev,
ctrl_config_list[i].max + 1, GFP_KERNEL);
if (!ctrl->p_new.p_char) {
dev_err(&client->dev,
"Failed to allocate otp data\n");
return -ENOMEM;
}
}
priv->ctrls[i] = ctrl;
}
priv->num_ctrls = num_ctrls;
priv->subdev->ctrl_handler = &priv->ctrl_handler;
if (priv->ctrl_handler.error) {
dev_err(&client->dev, "Error %d adding controls\n",
priv->ctrl_handler.error);
err = priv->ctrl_handler.error;
goto error;
}
err = v4l2_ctrl_handler_setup(&priv->ctrl_handler);
if (err) {
dev_err(&client->dev,
"Error %d setting default controls\n", err);
goto error;
}
return 0;
error:
v4l2_ctrl_handler_free(&priv->ctrl_handler);
return err;
}
MODULE_DEVICE_TABLE(of, imx290_of_match);
static struct camera_common_pdata *imx290_parse_dt(struct i2c_client *client)
{
struct device_node *np = client->dev.of_node;
struct camera_common_pdata *board_priv_pdata;
const struct of_device_id *match;
int gpio, err;
match = of_match_device(imx290_of_match, &client->dev);
if (!match) {
dev_err(&client->dev, "Failed to find matching dt id\n");
return NULL;
}
board_priv_pdata = devm_kzalloc(&client->dev,
sizeof(*board_priv_pdata), GFP_KERNEL);
if (!board_priv_pdata) {
dev_err(&client->dev, "Failed to allocate pdata\n");
return NULL;
}
err = of_property_read_string(np, "mclk", &board_priv_pdata->mclk_name);
if (err) {
dev_err(&client->dev, "mclk not in DT\n");
goto error;
}
gpio = of_get_named_gpio(np, "reset-gpios", 0);
if (gpio < 0) {
dev_err(&client->dev, "reset gpios not in DT\n");
goto error;
}
board_priv_pdata->reset_gpio = (unsigned int)gpio;
err = of_property_read_string(np, "avdd-reg",
&board_priv_pdata->regulators.avdd);
if (err) {
dev_err(&client->dev, "avdd-reg not in DT\n");
goto error;
}
err = of_property_read_string(np, "dvdd-reg",
&board_priv_pdata->regulators.dvdd);
if (err) {
dev_err(&client->dev, "dvdd-reg not in DT\n");
goto error;
}
err = of_property_read_string(np, "iovdd-reg",
&board_priv_pdata->regulators.iovdd);
if (err) {
dev_err(&client->dev, "iovdd-reg not in DT\n");
goto error;
}
return board_priv_pdata;
error:
devm_kfree(&client->dev, board_priv_pdata);
return NULL;
}
static int imx290_open(struct v4l2_subdev *sd, struct v4l2_subdev_fh *fh)
{
struct i2c_client *client = v4l2_get_subdevdata(sd);
dev_dbg(&client->dev, "%s:\n", __func__);
return 0;
}
static const struct v4l2_subdev_internal_ops imx290_subdev_internal_ops = {
.open = imx290_open,
};
static const struct media_entity_operations imx290_media_ops = {
.link_validate = v4l2_subdev_link_validate,
};
static int imx290_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct camera_common_data *common_data;
struct device_node *node = client->dev.of_node;
//struct soc_camera_link *imx290_iclink;
struct imx290 *priv;
char node_name[10];
int err;
if (!IS_ENABLED(CONFIG_OF) || !node)
return -EINVAL;
common_data = devm_kzalloc(&client->dev,
sizeof(struct camera_common_data), GFP_KERNEL);
if (!common_data) {
dev_err(&client->dev, "unable to allocate memory!\n");
return -ENOMEM;
}
priv = devm_kzalloc(&client->dev,
sizeof(struct imx290) + sizeof(struct v4l2_ctrl *) *
ARRAY_SIZE(ctrl_config_list),
GFP_KERNEL);
if (!priv) {
dev_err(&client->dev, "unable to allocate memory!\n");
return -ENOMEM;
}
priv->regmap = devm_regmap_init_i2c(client, &sensor_regmap_config);
if (IS_ERR(priv->regmap)) {
dev_err(&client->dev,
"regmap init failed: %ld\n", PTR_ERR(priv->regmap));
return -ENODEV;
}
/* HACK: use DT for parsing platform data when we are using */
sprintf(node_name, "imx290_%c", 'c' + (client->adapter->nr - 30)*2);
client->dev.of_node = of_find_node_by_name(NULL, node_name);
#if 0
if (client->dev.of_node)
priv->pdata = imx290_parse_dt(client);
else {
imx290_iclink = client->dev.platform_data;
priv->pdata = imx290_iclink->dev_priv;
}
#else
priv->pdata = imx290_parse_dt(client);
if (PTR_ERR(priv->pdata) == -EPROBE_DEFER) {
devm_kfree(&client->dev, priv);
return -EPROBE_DEFER;
}
#endif
#if 1
if (!priv->pdata) {
dev_err(&client->dev, "unable to get platform data\n");
return -EFAULT;
}
common_data->ops = &imx290_common_ops;
common_data->ctrl_handler = &priv->ctrl_handler;
common_data->i2c_client = client;
common_data->frmfmt = &imx290_frmfmt[0];
common_data->colorfmt = camera_common_find_datafmt(
IMX290_DEFAULT_DATAFMT);
common_data->power = &priv->power;
common_data->priv = (void *)priv;
//common_data->ident = V4L2_IDENT_IMX290;
common_data->numctrls = ARRAY_SIZE(ctrl_config_list);
common_data->numfmts = ARRAY_SIZE(imx290_frmfmt);
common_data->def_mode = IMX290_DEFAULT_MODE;
common_data->def_width = IMX290_DEFAULT_WIDTH;
common_data->def_height = IMX290_DEFAULT_HEIGHT;
common_data->fmt_width = common_data->def_width;
common_data->fmt_height = common_data->def_height;
common_data->def_clk_freq = IMX290_DEFAULT_CLK_FREQ;
priv->i2c_client = client;
priv->s_data = common_data;
priv->subdev = &common_data->subdev;
priv->subdev->dev = &client->dev;
err = imx290_power_get(priv);
if (err)
return err;
camera_common_create_debugfs(common_data, "imx290");
v4l2_i2c_subdev_init(&common_data->subdev, client, &imx290_subdev_ops);
err = imx290_ctrls_init(priv);
if (err)
return err;
gpio_request(priv->pdata->reset_gpio, "cam_reset_gpio");
gpio_direction_output(priv->pdata->reset_gpio,1);
//err = imx290_verify_streaming(priv);
//if (err)
//return err;
priv->subdev->internal_ops = &imx290_subdev_internal_ops;
priv->subdev->flags |= V4L2_SUBDEV_FL_HAS_DEVNODE |
V4L2_SUBDEV_FL_HAS_EVENTS;
#if defined(CONFIG_MEDIA_CONTROLLER)
priv->pad.flags = MEDIA_PAD_FL_SOURCE;
priv->subdev->entity.type = MEDIA_ENT_T_V4L2_SUBDEV_SENSOR;
priv->subdev->entity.ops = &imx290_media_ops;
err = media_entity_init(&priv->subdev->entity, 1, &priv->pad, 0);
if (err < 0) {
dev_err(&client->dev, "unable to init media entity\n");
return err;
}
#endif
err = v4l2_async_register_subdev(priv->subdev);
if (err)
return err;
#endif
dev_info(&client->dev, "Detected IMX290 sensor\n");
return 0;
}
static int
imx290_remove(struct i2c_client *client)
{
struct camera_common_data *s_data = to_camera_common_data(client);
struct imx290 *priv = (struct imx290 *)s_data->priv;
v4l2_async_unregister_subdev(priv->subdev);
#if defined(CONFIG_MEDIA_CONTROLLER)
media_entity_cleanup(&priv->subdev->entity);
#endif
v4l2_ctrl_handler_free(&priv->ctrl_handler);
imx290_power_put(priv);
camera_common_remove_debugfs(s_data);
return 0;
}
static const struct i2c_device_id imx290_id[] = {
{ "imx290", 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, imx290_id);
static struct i2c_driver imx290_i2c_driver = {
.driver = {
.name = "imx290",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(imx290_of_match),
},
.probe = imx290_probe,
.remove = imx290_remove,
.id_table = imx290_id,
};
module_i2c_driver(imx290_i2c_driver);
MODULE_DESCRIPTION("SoC Camera driver for Sony IMX290");
MODULE_AUTHOR("Bryan Wu <pengw@nvidia.com>");
MODULE_LICENSE("GPL v2");
