Hi,
I have been trying to write a driver for one of Omnivision’s newer image sensors, OS08A10, but I am stuck. I have a bare-bones (but I believe functional) I2C driver and I have also updated the device tree as appear the driver development guide.
The driver binds successfully and I am able to see /dev/video0. However when I use GStreamer to stream data from the sensor all I see is just a green or sometimes red screen. When I do a single capture with v4l2-ctl the raw file is empty. I can’t figure out where the problem would be. I will attach relevant files below. If it helps you help me I can also put up the kernel log from dmesg later.
nvidia@tegra-ubuntu:~$ v4l2-ctl -d /dev/video0 --stream-mmap --stream-count=1 --stream-to=test.raw
VIDIOC_DQBUF: failed: Input/output error
[ 31.651266] os08a10 30-0021: os08a10_s_stream: STREAM STARTING
[ 31.657176] os08a10 30-0021: os08a10_s_stream: write mode table 0
[ 31.716506] tegra-vi4 15700000.vi: Status: 2 channel:00 frame:0001
[ 31.722811] tegra-vi4 15700000.vi: timestamp sof 41338807744 eof 41353333184 data 0x000000a0
[ 31.732062] tegra-vi4 15700000.vi: capture_id 1 stream 0 vchan 0
[ 32.698920] tegra-vi4 15700000.vi: PXL_SOF syncpt timeout! err = -11
[ 33.702878] tegra-vi4 15700000.vi: ATOMP_FE syncpt timeout!
[ 273.542795] os08a10 30-0021: os08a10_s_stream: STREAM STARTING
[ 273.548656] os08a10 30-0021: os08a10_s_stream: write mode table 0
[ 273.610098] tegra-vi4 15700000.vi: Status: 2 channel:00 frame:0001
[ 273.616405] tegra-vi4 15700000.vi: timestamp sof 283232359200 eof 283246884640 data 0x000000a0
[ 273.625867] tegra-vi4 15700000.vi: capture_id 3 stream 0 vchan 0
[ 274.594351] tegra-vi4 15700000.vi: PXL_SOF syncpt timeout! err = -11
[ 275.598080] tegra-vi4 15700000.vi: ATOMP_FE syncpt timeout!
[ 275.604901] nvcsi 150c0000.nvcsi: csi4_stream_check_status (0) ERROR_STATUS2VI_VC0 = 0x0000000c
[ 275.613735] nvcsi 150c0000.nvcsi: csi4_stream_check_status (0) INTR_STATUS 0x0000000c
[ 275.621735] nvcsi 150c0000.nvcsi: csi4_stream_check_status (0) ERR_INTR_STATUS 0x0000000c
Driver:
/*
* os08a10.c - os08a10 sensor driver
*/
#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/tegra_v4l2_camera.h>
#include <media/camera_common.h>
#include "os08a10_mode_tbls.h"
#define DEBUG
//#define TPG
/* OS08A10 Registers */
#define OS08A10_DEFAULT_I2C_ADDR_0 0x21
#define OS08A10_DEFAULT_I2C_ADDR_1 0x6D
#define OS08A10_SC_MODE_SELECT_ADDR 0x0100
#define OS08A10_SC_MODE_SELECT_STREAMING 0x01
#define OS08A10_CHIP_ID_HIGH_ADDR 0x300A
#define OS08A10_CHIP_ID_MID_ADDR 0x300B
#define OS08A10_CHIP_ID_LOW_ADDR 0x300C
#define OS08A10_GROUP_HOLD_ADDR 0x3208
#define OS08A10_GROUP_HOLD_START 0x00
#define OS08A10_GROUP_HOLD_END 0x10
#define OS08A10_GROUP_HOLD_LAUNCH 0xA0
#define OS08A10_GROUP_HOLD_FAST_LAUNCH 0xE0
#define OS08A10_GROUP_HOLD_BANK_0 0x00
#define OS08A10_GROUP_HOLD_BANK_1 0x01
#define OS08A10_GROUP_HOLD_BANK_2 0x02
#define OS08A10_GROUP_HOLD_BANK_3 0x03
#define OS08A10_LONG_EXPO_HIGH_ADDR 0x3501
#define OS08A10_LONG_EXPO_LOW_ADDR 0x3502
#define OS08A10_SHORT_EXPO_HIGH_ADDR 0x3511
#define OS08A10_SHORT_EXPO_LOW_ADDR 0x3512
#define OS08A10_GAIN_SHIFT_ADDR 0x3507
#define OS08A10_LONG_GAIN_HIGH_ADDR 0x3508
#define OS08A10_LONG_GAIN_LOW_ADDR 0x3509
#define OS08A10_SHORT_GAIN_HIGH_ADDR 0x350C
#define OS08A10_SHORT_GAIN_LOW_ADDR 0x350D
#define OS08A10_TIMING_HTS_HIGH_ADDR 0x380C
#define OS08A10_TIMING_HTS_LOW_ADDR 0x380D
#define OS08A10_TIMING_VTS_HIGH_ADDR 0x380E
#define OS08A10_TIMING_VTS_LOW_ADDR 0x380F
#define OS08A10_TIMING_RST_FSIN_HIGH_ADDR 0x3826
#define OS08A10_TIMING_RST_FSIN_LOW_ADDR 0x3827
#define OS08A10_OTP_BUFFER_ADDR 0x6000
#define OS08A10_OTP_BUFFER_SIZE 1024
#define OS08A10_OTP_STR_SIZE (OS08A10_OTP_BUFFER_SIZE * 2)
#define OS08A10_FUSE_ID_OTP_BUFFER_ADDR 0x6000
#define OS08A10_FUSE_ID_OTP_BUFFER_SIZE 16
#define OS08A10_FUSE_ID_OTP_STR_SIZE (OS08A10_FUSE_ID_OTP_BUFFER_SIZE * 2)
#define OS08A10_OTP_PROGRAM_CTRL_ADDR 0x3D80
#define OS08A10_OTP_LOAD_CTRL_ADDR 0x3D81
#define OS08A10_OTP_LOAD_CTRL_OTP_RD 0x01
#define OS08A10_OTP_RD_BUSY_MASK 0x80
#define OS08A10_OTP_BIST_ERROR_MASK 0x20
#define OS08A10_TEST_PATTERN_ADDR 0x5081
#define OS08A10_TEST_PATTERN_EN (1 << 7)
#define OS08A10_DEFAULT_GAIN 0x0080
#define OS08A10_MIN_GAIN 0x0080
#define OS08A10_MAX_GAIN 0x07C0
#define OS08A10_DEFAULT_MODE OS08A10_MODE_3840X2160_EVAL
#define OS08A10_DEFAULT_WIDTH 3840
#define OS08A10_DEFAULT_HEIGHT 2160
#define OS08A10_DEFAULT_DATAFMT MEDIA_BUS_FMT_SBGGR10_1X10
#define OS08A10_DEFAULT_CLK_FREQ 26000000
/* OV9281 */
#define OV9281_DEFAULT_FRAME_LENGTH 0x038E
#define OV9281_MIN_FRAME_LENGTH 0x0001
#define OV9281_MAX_FRAME_LENGTH 0xFFFF
#define OV9281_MIN_EXPOSURE_COARSE 0x00000001
#define OV9281_MAX_EXPOSURE_COARSE 0x000FFFFF
#define OV9281_DEFAULT_EXPOSURE_COARSE 0x00002A90
struct os08a10 {
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;
s32 group_hold_prev;
bool group_hold_en;
struct regmap *regmap;
struct camera_common_data *s_data;
struct camera_common_pdata *pdata;
struct v4l2_ctrl *ctrls[];
};
static const struct of_device_id os08a10_of_match[] = {
{ .compatible = "nvidia,os08a10", },
{ },
};
/* Register/regmap stuff */
static int os08a10_read_reg(struct camera_common_data *s_data, u16 addr, u8 *val)
{
struct os08a10 *priv = (struct os08a10 *)s_data->priv;
int err = 0;
u32 reg_val = 0;
err = regmap_read(priv->regmap, addr, ®_val);
*val = reg_val & 0xFF;
return err;
}
static int os08a10_write_reg(struct camera_common_data *s_data, u16 addr, u8 val)
{
struct os08a10 *priv = (struct os08a10 *)s_data->priv;
int err;
err = regmap_write(priv->regmap, addr, val);
if (err)
dev_err(&priv->i2c_client->dev,
"%s:i2c write failed, %x = %x\n", __func__, addr, val);
return err;
}
static int os08a10_write_table(struct os08a10 *priv, const os08a10_reg table[])
{
return regmap_util_write_table_8(priv->regmap, table, NULL, 0,
OS08A10_TABLE_WAIT_MS,
OS08A10_TABLE_END);
}
static const struct regmap_config os08a10_regmap_config = {
.reg_bits = 16,
.val_bits = 8,
.cache_type = REGCACHE_RBTREE,
.use_single_rw = true,
};
/* NVIDIA camera_common stuff */
static int os08a10_power_on(struct camera_common_data *s_data)
{
struct os08a10 *priv = (struct os08a10 *)s_data->priv;
struct camera_common_power_rail *pw = &priv->power;
int err;
dev_dbg(&priv->i2c_client->dev, "%s: power on\n", __func__);
if (priv->pdata->power_on) {
err = priv->pdata->power_on(pw);
if (err)
dev_err(&priv->i2c_client->dev, "%s failed.\n",
__func__);
else
pw->state = SWITCH_ON;
return err;
}
usleep_range(5350, 5360);
pw->state = SWITCH_ON;
return 0;
}
static int os08a10_power_off(struct camera_common_data *s_data)
{
struct os08a10 *priv = (struct os08a10 *)s_data->priv;
struct camera_common_power_rail *pw = &priv->power;
int err = 0;
dev_dbg(&priv->i2c_client->dev, "%s: power off\n", __func__);
os08a10_write_table(priv, os08a10_mode_table[OS08A10_MODE_STOP_STREAM]);
if (priv->pdata->power_off) {
err = priv->pdata->power_off(pw);
if (err)
dev_err(&priv->i2c_client->dev, "%s failed.\n",
__func__);
else
goto power_off_done;
}
return err;
power_off_done:
pw->state = SWITCH_OFF;
return 0;
}
static int os08a10_power_put(struct os08a10 *priv)
{
return 0;
}
static int os08a10_power_get(struct os08a10 *priv)
{
struct camera_common_power_rail *pw = &priv->power;
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);
dev_info(&priv->i2c_client->dev, "%s\n", 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);
}
pw->state = SWITCH_OFF;
return err;
}
static struct camera_common_sensor_ops os08a10_common_ops = {
.power_on = os08a10_power_on,
.power_off = os08a10_power_off,
.write_reg = os08a10_write_reg,
.read_reg = os08a10_read_reg,
};
static int os08a10_set_group_hold(struct os08a10 *priv)
{
int gh_prev = switch_ctrl_qmenu[priv->group_hold_prev];
int err;
if (priv->group_hold_en == true && gh_prev == SWITCH_OFF) {
/* group hold start */
err = os08a10_write_reg(priv->s_data, OS08A10_GROUP_HOLD_ADDR,
(OS08A10_GROUP_HOLD_START |
OS08A10_GROUP_HOLD_BANK_0));
if (err)
goto fail;
priv->group_hold_prev = 1;
} else if (priv->group_hold_en == false && gh_prev == SWITCH_ON) {
/* group hold end */
err = os08a10_write_reg(priv->s_data, OS08A10_GROUP_HOLD_ADDR,
(OS08A10_GROUP_HOLD_END |
OS08A10_GROUP_HOLD_BANK_0));
/* quick launch */
err |= os08a10_write_reg(priv->s_data,
OS08A10_GROUP_HOLD_ADDR,
(OS08A10_GROUP_HOLD_LAUNCH |
OS08A10_GROUP_HOLD_BANK_0));
if (err)
goto fail;
priv->group_hold_prev = 0;
}
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: Group hold control error\n", __func__);
return err;
}
static int os08a10_set_gain(struct os08a10 *priv, s32 val)
{
os08a10_reg regs[4];
u16 gain;
int err;
if (val < OS08A10_MIN_GAIN)
gain = OS08A10_MIN_GAIN;
else if (val > OS08A10_MAX_GAIN)
gain = OS08A10_MAX_GAIN;
else
gain = val;
dev_dbg(&priv->i2c_client->dev, "%s: gain: %d\n", __func__, gain);
regs[0].addr = OS08A10_GAIN_SHIFT_ADDR;
regs[0].val = 0x03;
regs[1].addr = OS08A10_LONG_GAIN_HIGH_ADDR;
regs[1].val = gain >> 8;
regs[2].addr = OS08A10_LONG_GAIN_LOW_ADDR;
regs[2].val = gain & 0xff;
regs[3].addr = OS08A10_TABLE_END;
regs[3].val = 0;
os08a10_set_group_hold(priv);
err = os08a10_write_table(priv, regs);
if (err)
goto fail;
return 0;
fail:
dev_dbg(&priv->i2c_client->dev, "%s: GAIN control error\n", __func__);
return err;
}
static int os08a10_set_frame_length(struct os08a10 *priv, s32 val)
{
os08a10_reg regs[5];
u16 frame_length;
int err;
frame_length = (u16)val;
dev_dbg(&priv->i2c_client->dev,
"%s: frame_length: %d\n", __func__, frame_length);
regs[0].addr = OS08A10_TIMING_VTS_HIGH_ADDR;
regs[0].val = (frame_length >> 8) & 0xff;
regs[1].addr = OS08A10_TIMING_VTS_LOW_ADDR;
regs[1].val = (frame_length) & 0xff;
regs[2].addr = OS08A10_TABLE_END;
regs[2].val = 0;
os08a10_set_group_hold(priv);
err = os08a10_write_table(priv, regs);
if (err)
goto fail;
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: FRAME_LENGTH control error\n", __func__);
return err;
}
static int os08a10_set_coarse_time(struct os08a10 *priv, s32 val)
{
os08a10_reg regs[3];
u16 coarse_time;
int err;
coarse_time = (u16)val;
dev_dbg(&priv->i2c_client->dev,
"%s: coarse_time: %d\n", __func__, coarse_time);
regs[0].addr = OS08A10_LONG_EXPO_HIGH_ADDR;
regs[0].val = (coarse_time >> 8) & 0xff;
regs[1].addr = OS08A10_SHORT_EXPO_LOW_ADDR;
regs[1].val = (coarse_time & 0xff);
regs[2].addr = OS08A10_TABLE_END;
regs[2].val = 0;
os08a10_set_group_hold(priv);
err = os08a10_write_table(priv, regs);
if (err)
goto fail;
return 0;
fail:
dev_dbg(&priv->i2c_client->dev,
"%s: COARSE_TIME control error\n", __func__);
return err;
}
/* OTP stuff */
/*
static int os08a10_read_otp(struct os08a10 *priv, u8 *buf, u16 addr, int size)
{
int err;
int i;
err = os08a10_write_table(priv, os08a10_mode_table[OS08A10_MODE_START_STREAM]);
if (err)
return err;
for (i = 0; i < size; i++) {
err = os08a10_write_reg(priv->s_data, addr + i, 0x00);
if (err)
return err;
}
err = os08a10_write_reg(priv->s_data, OS08A10_OTP_LOAD_CTRL_ADDR,
OS08A10_OTP_LOAD_CTRL_OTP_RD);
if (err)
return err;
msleep(20);
return regmap_bulk_read(priv->regmap, addr, buf, size);
}
static int os08a10_otp_setup(struct os08a10 *priv)
{
struct v4l2_ctrl *ctrl;
u8 otp_buf[OS08A10_OTP_BUFFER_SIZE];
int i;
int err;
dev_info(&priv->i2c_client->dev, "%s\n", __func__);
err = camera_common_s_power(priv->subdev, true);
if (err)
return -ENODEV;
err = os08a10_read_otp(priv, otp_buf, OS08A10_OTP_BUFFER_ADDR,
OS08A10_OTP_BUFFER_SIZE);
if (err)
return err;
ctrl = v4l2_ctrl_find(&priv->ctrl_handler, V4L2_CID_OTP_DATA);
if (!ctrl) {
dev_err(&priv->i2c_client->dev,
"could not find device ctrl.\n");
return -EINVAL;
}
for (i = 0; i < OS08A10_OTP_BUFFER_SIZE; i++)
sprintf(&ctrl->p_new.p_char[i*2], "%02x", otp_buf[i]);
ctrl->p_cur.p_char = ctrl->p_new.p_char;
err = camera_common_s_power(priv->subdev, false);
if (err)
return -ENODEV;
return 0;
}
static int os08a10_fuse_id_setup(struct os08a10 *priv)
{
struct v4l2_ctrl *ctrl;
u8 fuse_id[OS08A10_FUSE_ID_OTP_BUFFER_SIZE];
int i;
int err;
dev_info(&priv->i2c_client->dev, "%s\n", __func__);
err = camera_common_s_power(priv->subdev, true);
if (err)
return -ENODEV;
err = os08a10_read_otp(priv, fuse_id, OS08A10_FUSE_ID_OTP_BUFFER_ADDR,
OS08A10_FUSE_ID_OTP_BUFFER_SIZE);
if (err)
return err;
ctrl = v4l2_ctrl_find(&priv->ctrl_handler, V4L2_CID_FUSE_ID);
if (!ctrl) {
dev_err(&priv->i2c_client->dev,
"could not find device ctrl.\n");
return -EINVAL;
}
for (i = 0; i < OS08A10_FUSE_ID_OTP_BUFFER_SIZE; i++)
sprintf(&ctrl->p_new.p_char[i*2], "%02x", fuse_id[i]);
ctrl->p_cur.p_char = ctrl->p_new.p_char;
err = camera_common_s_power(priv->subdev, false);
if (err)
return -ENODEV;
return 0;
}
*/
/* V4L2 subdev stuff */
static int os08a10_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 os08a10 *priv = (struct os08a10 *)s_data->priv;
// struct v4l2_control control;
int err;
if (!enable) {
dev_dbg(&client->dev, "%s: stream off\n", __func__);
return os08a10_write_table(priv,
os08a10_mode_table[OS08A10_MODE_STOP_STREAM]);
}
dev_info(&client->dev, "%s: STREAM STARTING\n", __func__);
dev_info(&client->dev, "%s: write mode table %d\n", __func__, s_data->mode);
err = os08a10_write_table(priv, os08a10_mode_table[s_data->mode]);
if (err)
goto exit;
// if (s_data->override_enable) {
/* write list of override regs for the asking frame length, */
/* coarse integration time, and gain. Failures to write */
/* overrides are non-fatal. */
// control.id = V4L2_CID_GAIN;
// err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
// err |= os08a10_set_gain(priv, control.value);
// if (err)
// dev_warn(&client->dev,
// "%s: error gain override\n", __func__);
// control.id = V4L2_CID_FRAME_LENGTH;
// err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
// err |= os08a10_set_frame_length(priv, control.value);
// if (err)
// dev_warn(&client->dev,
// "%s: error frame length override\n", __func__);
// control.id = V4L2_CID_COARSE_TIME;
// err = v4l2_g_ctrl(&priv->ctrl_handler, &control);
// err |= os08a10_set_coarse_time(priv, control.value);
// if (err)
// dev_warn(&client->dev,
// "%s: error coarse time override\n", __func__);
// }
#ifdef TPG
err = os08a10_write_reg(priv->s_data, OS08A10_TEST_PATTERN_ADDR,
OS08A10_TEST_PATTERN_EN);
if (err)
dev_warn(&client->dev, "%s: error enabling TPG\n", __func__);
#endif
dev_dbg(&client->dev, "%s: stream on\n", __func__);
err = os08a10_write_table(priv,
os08a10_mode_table[OS08A10_MODE_START_STREAM]);
if (err)
goto exit;
return 0;
exit:
dev_err(&client->dev, "%s: error setting stream\n", __func__);
return err;
}
static int os08a10_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 os08a10 *priv = (struct os08a10 *)s_data->priv;
struct camera_common_power_rail *pw = &priv->power;
*status = pw->state == SWITCH_ON;
return 0;
}
static int os08a10_set_fmt(struct v4l2_subdev *sd,
struct v4l2_subdev_pad_config *cfg,
struct v4l2_subdev_format *format)
{
int err;
if (format->which == V4L2_SUBDEV_FORMAT_TRY)
err = camera_common_try_fmt(sd, &format->format);
else
err = camera_common_s_fmt(sd, &format->format);
return err;
}
static int os08a10_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 struct v4l2_subdev_core_ops os08a10_subdev_core_ops = {
.s_power = camera_common_s_power,
};
static struct v4l2_subdev_video_ops os08a10_subdev_video_ops = {
.s_stream = os08a10_s_stream,
.g_mbus_config = camera_common_g_mbus_config,
.g_input_status = os08a10_g_input_status,
};
static struct v4l2_subdev_pad_ops os08a10_subdev_pad_ops = {
.set_fmt = os08a10_set_fmt,
.get_fmt = os08a10_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 os08a10_subdev_ops = {
.core = &os08a10_subdev_core_ops,
.video = &os08a10_subdev_video_ops,
.pad = &os08a10_subdev_pad_ops,
};
/* V4L2 controls stuff */
static int os08a10_g_volatile_ctrl(struct v4l2_ctrl *ctrl)
{
struct os08a10 *priv =
container_of(ctrl->handler, struct os08a10, ctrl_handler);
int err = 0;
if (priv->power.state == SWITCH_OFF)
return 0;
switch (ctrl->id) {
default:
dev_err(&priv->i2c_client->dev,
"%s: unknown ctrl id.\n", __func__);
return -EINVAL;
}
return err;
}
static int os08a10_s_ctrl(struct v4l2_ctrl *ctrl)
{
struct os08a10 *priv =
container_of(ctrl->handler, struct os08a10, ctrl_handler);
int err = 0;
if (priv->power.state == SWITCH_OFF)
return 0;
switch (ctrl->id) {
case V4L2_CID_GAIN:
err = os08a10_set_gain(priv, ctrl->val);
break;
case V4L2_CID_FRAME_LENGTH:
err = os08a10_set_frame_length(priv, ctrl->val);
break;
case V4L2_CID_COARSE_TIME:
err = os08a10_set_coarse_time(priv, ctrl->val);
break;
case V4L2_CID_GROUP_HOLD:
if (switch_ctrl_qmenu[ctrl->val] == SWITCH_ON) {
priv->group_hold_en = true;
} else {
priv->group_hold_en = false;
err = os08a10_set_group_hold(priv);
}
break;
case V4L2_CID_HDR_EN:
break;
default:
dev_err(&priv->i2c_client->dev, "%s: unknown ctrl id.\n",
__func__);
return -EINVAL;
}
return err;
}
static const struct v4l2_ctrl_ops os08a10_ctrl_ops = {
.g_volatile_ctrl = os08a10_g_volatile_ctrl,
.s_ctrl = os08a10_s_ctrl,
};
static struct v4l2_ctrl_config ctrl_config_list[] = {
/* Do not change the name field for the controls! */
{
.ops = &os08a10_ctrl_ops,
.id = V4L2_CID_GAIN,
.name = "Gain",
.type = V4L2_CTRL_TYPE_INTEGER,
.flags = V4L2_CTRL_FLAG_SLIDER,
.min = OS08A10_MIN_GAIN,
.max = OS08A10_MAX_GAIN,
.def = OS08A10_DEFAULT_GAIN,
.step = 1,
},
{
.ops = &os08a10_ctrl_ops,
.id = V4L2_CID_FRAME_LENGTH,
.name = "Frame Length",
.type = V4L2_CTRL_TYPE_INTEGER,
.flags = V4L2_CTRL_FLAG_SLIDER,
.min = OV9281_MIN_FRAME_LENGTH,
.max = OV9281_MAX_FRAME_LENGTH,
.def = OV9281_DEFAULT_FRAME_LENGTH,
.step = 1,
},
{
.ops = &os08a10_ctrl_ops,
.id = V4L2_CID_COARSE_TIME,
.name = "Coarse Time",
.type = V4L2_CTRL_TYPE_INTEGER,
.flags = V4L2_CTRL_FLAG_SLIDER,
.min = OV9281_MIN_EXPOSURE_COARSE,
.max = OV9281_MAX_EXPOSURE_COARSE,
.def = OV9281_DEFAULT_EXPOSURE_COARSE,
.step = 1,
},
{
.ops = &os08a10_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 = &os08a10_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 = &os08a10_ctrl_ops,
.id = V4L2_CID_OTP_DATA,
.name = "OTP Data",
.type = V4L2_CTRL_TYPE_STRING,
.flags = V4L2_CTRL_FLAG_READ_ONLY,
.min = 0,
.max = OS08A10_OTP_STR_SIZE,
.step = 2,
},
{
.ops = &os08a10_ctrl_ops,
.id = V4L2_CID_FUSE_ID,
.name = "Fuse ID",
.type = V4L2_CTRL_TYPE_STRING,
.flags = V4L2_CTRL_FLAG_READ_ONLY,
.min = 0,
.max = OS08A10_FUSE_ID_OTP_STR_SIZE,
.step = 2,
},
};
static int os08a10_ctrls_init(struct os08a10 *priv)
{
struct i2c_client *client = priv->i2c_client;
struct v4l2_ctrl *ctrl;
int num_ctrls;
int i;
int err;
dev_dbg(&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);
}
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;
}
static const struct media_entity_operations os08a10_media_ops = {
.link_validate = v4l2_subdev_link_validate,
};
/* Driver probe helper stuff */
static int os08a10_parse_dt(struct i2c_client *client, struct os08a10 *priv)
{
struct device_node *np = client->dev.of_node;
const struct of_device_id *match;
int err;
match = of_match_device(os08a10_of_match, &client->dev);
if (!match) {
dev_err(&client->dev, "Failed to find matching dt id\n");
return -EINVAL;
}
err = of_property_read_string(np, "mclk", &priv->pdata->mclk_name);
if (err) {
dev_err(&client->dev, "mclk not in DT\n");
return -EINVAL;
}
return 0;
}
static int os08a10_verify_chip_id(struct os08a10 *priv)
{
struct i2c_client *client = priv->i2c_client;
struct camera_common_data *s_data = priv->s_data;
u8 chip_id_hi, chip_id_mi, chip_id_lo;
u32 chip_id;
int err;
err = camera_common_s_power(priv->subdev, true);
if (err)
return -ENODEV;
err = os08a10_read_reg(s_data, OS08A10_CHIP_ID_HIGH_ADDR, &chip_id_hi);
if (err) {
dev_err(&client->dev, "Failed to read chip ID\n");
return err;
}
err = os08a10_read_reg(s_data, OS08A10_CHIP_ID_MID_ADDR, &chip_id_mi);
if (err) {
dev_err(&client->dev, "Failed to read chip ID\n");
return err;
}
err = os08a10_read_reg(s_data, OS08A10_CHIP_ID_LOW_ADDR, &chip_id_lo);
if (err) {
dev_err(&client->dev, "Failed to read chip ID\n");
return err;
}
chip_id = (chip_id_hi << 16) | (chip_id_mi << 8) | chip_id_lo;
dev_info(&client->dev, "Read chip ID 0x%06x\n", chip_id);
if (chip_id != 0x530841) {
dev_err(&client->dev, "Read unknown chip ID 0x%06x\n", chip_id);
return -EINVAL;
}
err = camera_common_s_power(priv->subdev, false);
if (err)
return -ENODEV;
return 0;
}
MODULE_DEVICE_TABLE(of, os08a10_of_match);
static int os08a10_probe(struct i2c_client *client,
const struct i2c_device_id *id)
{
struct camera_common_data *common_data;
struct os08a10 *priv;
char dev_name[10];
int err;
dev_info(&client->dev, "Probing v4l2 sensor.\n");
common_data = devm_kzalloc(&client->dev,
sizeof(struct camera_common_data),
GFP_KERNEL);
priv = devm_kzalloc(&client->dev,
sizeof(struct os08a10) +
(sizeof(struct v4l2_ctrl *) *
ARRAY_SIZE(ctrl_config_list)),
GFP_KERNEL);
if (!priv) {
dev_err(&client->dev,
"unable to allocate camera_common_data\n");
return -ENOMEM;
}
priv->regmap = devm_regmap_init_i2c(client, &os08a10_regmap_config);
if (IS_ERR(priv->regmap)) {
dev_err(&client->dev,
"regmap init failed: %ld\n", PTR_ERR(priv->regmap));
return -ENODEV;
}
priv->pdata = devm_kzalloc(&client->dev,
sizeof(struct camera_common_pdata),
GFP_KERNEL);
if (!priv->pdata) {
dev_err(&client->dev,
"unable to allocate camera_common_pdata\n");
return -ENOMEM;
}
err = os08a10_parse_dt(client, priv);
if (err)
return err;
common_data->ops = &os08a10_common_ops;
common_data->ctrl_handler = &priv->ctrl_handler;
common_data->i2c_client = client;
common_data->frmfmt = os08a10_frmfmt;
common_data->colorfmt =
camera_common_find_datafmt(OS08A10_DEFAULT_DATAFMT);
common_data->power = &priv->power;
common_data->ctrls = priv->ctrls;
common_data->priv = (void *)priv;
common_data->numctrls = ARRAY_SIZE(ctrl_config_list);
common_data->numfmts = ARRAY_SIZE(os08a10_frmfmt);
common_data->def_mode = OS08A10_DEFAULT_MODE;
common_data->def_width = OS08A10_DEFAULT_WIDTH;
common_data->def_height = OS08A10_DEFAULT_HEIGHT;
common_data->def_clk_freq = OS08A10_DEFAULT_CLK_FREQ;
common_data->fmt_width = common_data->def_width;
common_data->fmt_height = common_data->def_height;
priv->i2c_client = client;
priv->s_data = common_data;
priv->subdev = &common_data->subdev;
priv->subdev->dev = &client->dev;
priv->group_hold_prev = 0;
err = os08a10_power_get(priv);
if (err)
return err;
err = camera_common_parse_ports(client, common_data);
if (err) {
dev_err(&client->dev, "Failed to find port info\n");
return err;
}
sprintf(dev_name, "os08a10%c", common_data->csi_port + 'a');
dev_dbg(&client->dev, "%s: name %s\n", __func__, dev_name);
camera_common_create_debugfs(common_data, dev_name);
v4l2_i2c_subdev_init(&common_data->subdev, client,
&os08a10_subdev_ops);
err = os08a10_ctrls_init(priv);
if (err)
return err;
err = os08a10_verify_chip_id(priv);
if (err)
return err;
/* err = os08a10_otp_setup(priv);
if (err) {
dev_err(&client->dev, "Error %d reading otp data\n", err);
return err;
}
err = os08a10_fuse_id_setup(priv);
if (err) {
dev_err(&client->dev, "Error %d reading fuse id data\n", err);
return err;
}
*/
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 = &os08a10_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;
dev_info(&client->dev, "Probed v4l2 sensor.\n");
return 0;
}
static int
os08a10_remove(struct i2c_client *client)
{
struct camera_common_data *s_data = to_camera_common_data(client);
struct os08a10 *priv = (struct os08a10 *)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);
os08a10_power_put(priv);
camera_common_remove_debugfs(s_data);
return 0;
}
static const struct i2c_device_id os08a10_id[] = {
{ "os08a10", 0 },
{ }
};
MODULE_DEVICE_TABLE(i2c, os08a10_id);
static struct i2c_driver os08a10_i2c_driver = {
.driver = {
.name = "os08a10",
.owner = THIS_MODULE,
.of_match_table = of_match_ptr(os08a10_of_match),
},
.probe = os08a10_probe,
.remove = os08a10_remove,
.id_table = os08a10_id,
};
module_i2c_driver(os08a10_i2c_driver);