OS04C10 support (#30658)

* getting frames

* ok

* support both output

* cleanup

* fix unused

* undo

* fix release files

---------

Co-authored-by: Comma Device <device@comma.ai>
old-commit-hash: cd1d7eb4d2

release/files_common

@@ -291,11 +291,8 @@ system/camerad/main.cc
 system/camerad/snapshot/*
 system/camerad/cameras/camera_common.h
 system/camerad/cameras/camera_common.cc
-system/camerad/sensors/ar0231.cc
+system/camerad/sensors/*.h
-system/camerad/sensors/ar0231_registers.h
+system/camerad/sensors/*.cc
-system/camerad/sensors/ox03c10.cc
-system/camerad/sensors/ox03c10_registers.h
-system/camerad/sensors/sensor.h
 
 selfdrive/manager/__init__.py
 selfdrive/manager/build.py

system/camerad/SConscript

@@ -3,7 +3,7 @@ Import('env', 'arch', 'cereal', 'messaging', 'common', 'gpucommon', 'visionipc')
 libs = ['m', 'pthread', common, 'jpeg', 'OpenCL', 'yuv', cereal, messaging, 'zmq', 'capnp', 'kj', visionipc, gpucommon, 'atomic']
 
 camera_obj = env.Object(['cameras/camera_qcom2.cc', 'cameras/camera_common.cc', 'cameras/camera_util.cc',
-                         'sensors/ar0231.cc', 'sensors/ox03c10.cc'])
+                         'sensors/ar0231.cc', 'sensors/ox03c10.cc', 'sensors/os04c10.cc'])
 env.Program('camerad', ['main.cc', camera_obj], LIBS=libs)
 
 if GetOption("extras") and arch == "x86_64":

system/camerad/cameras/camera_qcom2.cc

@@ -150,7 +150,7 @@ int CameraState::sensors_init() {
   power->count = 1;
   power->cmd_type = CAMERA_SENSOR_CMD_TYPE_PWR_UP;
   power->power_settings[0].power_seq_type = 0;
-  power->power_settings[0].config_val_low = ci->power_config_val_low;
+  power->power_settings[0].config_val_low = ci->mclk_frequency;
   power = power_set_wait(power, 1);
 
   // reset high
@@ -316,10 +316,10 @@ void CameraState::config_isp(int io_mem_handle, int fence, int request_id, int b
       .h_init = 0x0,
       .v_init = 0x0,
     };
-    io_cfg[0].format = CAM_FORMAT_MIPI_RAW_12;             // CAM_FORMAT_UBWC_TP10 for YUV
+    io_cfg[0].format = ci->mipi_format;                    // CAM_FORMAT_UBWC_TP10 for YUV
     io_cfg[0].color_space = CAM_COLOR_SPACE_BASE;          // CAM_COLOR_SPACE_BT601_FULL for YUV
     io_cfg[0].color_pattern = 0x5;                         // 0x0 for YUV
-    io_cfg[0].bpp = 0xc;
+    io_cfg[0].bpp = (ci->mipi_format == CAM_FORMAT_MIPI_RAW_10 ? 0xa : 0xc);  // bits per pixel
     io_cfg[0].resource_type = CAM_ISP_IFE_OUT_RES_RDI_0;   // CAM_ISP_IFE_OUT_RES_FULL for YUV
     io_cfg[0].fence = fence;
     io_cfg[0].direction = CAM_BUF_OUTPUT;
@@ -459,7 +459,8 @@ void CameraState::camera_open(MultiCameraState *multi_cam_state_, int camera_num
 
   // Try different sensors one by one until it success.
   if (!init_sensor_lambda(new AR0231) &&
-      !init_sensor_lambda(new OX03C10)) {
+      !init_sensor_lambda(new OX03C10) &&
+      !init_sensor_lambda(new OS04C10)) {
     LOGE("** sensor %d FAILED bringup, disabling", camera_num);
     enabled = false;
     return;
@@ -481,7 +482,6 @@ void CameraState::camera_open(MultiCameraState *multi_cam_state_, int camera_num
 
   LOG("-- Configuring sensor");
   sensors_i2c(ci->init_reg_array.data(), ci->init_reg_array.size(), CAM_SENSOR_PACKET_OPCODE_SENSOR_CONFIG, ci->data_word);
-  printf("dt is %x\n", ci->in_port_info_dt);
 
   // NOTE: to be able to disable road and wide road, we still have to configure the sensor over i2c
   // If you don't do this, the strobe GPIO is an output (even in reset it seems!)
@@ -495,8 +495,8 @@ void CameraState::camera_open(MultiCameraState *multi_cam_state_, int camera_num
     .lane_cfg = 0x3210,
 
     .vc = 0x0,
-    .dt = ci->in_port_info_dt,
+    .dt = ci->frame_data_type,
-    .format = CAM_FORMAT_MIPI_RAW_12,
+    .format = ci->mipi_format,
 
     .test_pattern = 0x2,  // 0x3?
     .usage_type = 0x0,
@@ -522,7 +522,7 @@ void CameraState::camera_open(MultiCameraState *multi_cam_state_, int camera_num
     .num_out_res = 0x1,
     .data[0] = (struct cam_isp_out_port_info){
       .res_type = CAM_ISP_IFE_OUT_RES_RDI_0,
-      .format = CAM_FORMAT_MIPI_RAW_12,
+      .format = ci->mipi_format,
       .width = ci->frame_width,
       .height = ci->frame_height + ci->extra_height,
       .comp_grp_id = 0x0, .split_point = 0x0, .secure_mode = 0x0,
@@ -971,6 +971,9 @@ void cameras_run(MultiCameraState *s) {
                  event_data->u.frame_msg.frame_id, event_data->u.frame_msg.request_id, event_data->u.frame_msg.timestamp/1e6, event_data->u.frame_msg.sof_status);
         }
 
+        // for debugging
+        //do_exit = do_exit || event_data->u.frame_msg.frame_id > (30*20);
+
         if (event_data->session_hdl == s->road_cam.session_handle) {
           s->road_cam.handle_camera_event(event_data);
         } else if (event_data->session_hdl == s->wide_road_cam.session_handle) {
@@ -981,6 +984,8 @@ void cameras_run(MultiCameraState *s) {
           LOGE("Unknown vidioc event source");
           assert(false);
         }
+      } else {
+        LOGE("unhandled event %d\n", ev.type);
       }
     } else {
       LOGE("VIDIOC_DQEVENT failed, errno=%d", errno);

system/camerad/sensors/ar0231.cc

@@ -93,8 +93,9 @@ AR0231::AR0231() {
   init_reg_array.assign(std::begin(init_array_ar0231), std::end(init_array_ar0231));
   probe_reg_addr = 0x3000;
   probe_expected_data = 0x354;
-  in_port_info_dt = 0x12;  // Changing stats to 0x2C doesn't work, so change pixels to 0x12 instead
+  mipi_format = CAM_FORMAT_MIPI_RAW_12;
-  power_config_val_low = 19200000; //Hz
+  frame_data_type = 0x12;  // Changing stats to 0x2C doesn't work, so change pixels to 0x12 instead
+  mclk_frequency = 19200000; //Hz
 
   dc_gain_factor = 2.5;
   dc_gain_min_weight = 0;

system/camerad/sensors/os04c10.cc

@@ -0,0 +1,105 @@
+#include "system/camerad/sensors/sensor.h"
+
+namespace {
+
+const float sensor_analog_gains_OS04C10[] = {
+    1.0, 1.0625, 1.125, 1.1875, 1.25, 1.3125, 1.375, 1.4375, 1.5, 1.5625, 1.6875,
+    1.8125, 1.9375, 2.0, 2.125, 2.25, 2.375, 2.5, 2.625, 2.75, 2.875, 3.0,
+    3.125, 3.375, 3.625, 3.875, 4.0, 4.25, 4.5, 4.75, 5.0, 5.25, 5.5,
+    5.75, 6.0, 6.25, 6.5, 7.0, 7.5, 8.0, 8.5, 9.0, 9.5, 10.0,
+    10.5, 11.0, 11.5, 12.0, 12.5, 13.0, 13.5, 14.0, 14.5, 15.0, 15.5};
+
+const uint32_t os04c10_analog_gains_reg[] = {
+    0x100, 0x110, 0x120, 0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x1B0,
+    0x1D0, 0x1F0, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0, 0x300,
+    0x320, 0x360, 0x3A0, 0x3E0, 0x400, 0x440, 0x480, 0x4C0, 0x500, 0x540, 0x580,
+    0x5C0, 0x600, 0x640, 0x680, 0x700, 0x780, 0x800, 0x880, 0x900, 0x980, 0xA00,
+    0xA80, 0xB00, 0xB80, 0xC00, 0xC80, 0xD00, 0xD80, 0xE00, 0xE80, 0xF00, 0xF80};
+
+const uint32_t VS_TIME_MIN_OS04C10 = 1;
+//const uint32_t VS_TIME_MAX_OS04C10 = 34;  // vs < 35
+
+}  // namespace
+
+OS04C10::OS04C10() {
+  image_sensor = cereal::FrameData::ImageSensor::OS04C10;
+  data_word = false;
+
+  frame_width = 1920;
+  frame_height = 1080;
+  frame_stride = (1920*10/8);
+
+  /*
+  frame_width = 0xa80;
+  frame_height = 0x5f0;
+  frame_stride = 0xd20;
+  */
+
+  extra_height = 0;
+  frame_offset = 0;
+
+  start_reg_array.assign(std::begin(start_reg_array_os04c10), std::end(start_reg_array_os04c10));
+  init_reg_array.assign(std::begin(init_array_os04c10), std::end(init_array_os04c10));
+  probe_reg_addr = 0x300a;
+  probe_expected_data = 0x5304;
+  mipi_format = CAM_FORMAT_MIPI_RAW_10;
+  frame_data_type = 0x2b;
+  mclk_frequency = 24000000; // Hz
+
+  dc_gain_factor = 7.32;
+  dc_gain_min_weight = 1;  // always on is fine
+  dc_gain_max_weight = 1;
+  dc_gain_on_grey = 0.9;
+  dc_gain_off_grey = 1.0;
+  exposure_time_min = 2;  // 1x
+  exposure_time_max = 2016;
+  analog_gain_min_idx = 0x0;
+  analog_gain_rec_idx = 0x0;  // 1x
+  analog_gain_max_idx = 0x36;
+  analog_gain_cost_delta = -1;
+  analog_gain_cost_low = 0.4;
+  analog_gain_cost_high = 6.4;
+  for (int i = 0; i <= analog_gain_max_idx; i++) {
+    sensor_analog_gains[i] = sensor_analog_gains_OS04C10[i];
+  }
+  min_ev = (exposure_time_min + VS_TIME_MIN_OS04C10) * sensor_analog_gains[analog_gain_min_idx];
+  max_ev = exposure_time_max * dc_gain_factor * sensor_analog_gains[analog_gain_max_idx];
+  target_grey_factor = 0.01;
+}
+
+std::vector<i2c_random_wr_payload> OS04C10::getExposureRegisters(int exposure_time, int new_exp_g, bool dc_gain_enabled) const {
+  // t_HCG&t_LCG + t_VS on LPD, t_SPD on SPD
+  uint32_t hcg_time = exposure_time;
+  //uint32_t lcg_time = hcg_time;
+  //uint32_t spd_time = std::min(std::max((uint32_t)exposure_time, (exposure_time_max + VS_TIME_MAX_OS04C10) / 3), exposure_time_max + VS_TIME_MAX_OS04C10);
+  //uint32_t vs_time = std::min(std::max((uint32_t)exposure_time / 40, VS_TIME_MIN_OS04C10), VS_TIME_MAX_OS04C10);
+
+  uint32_t real_gain = os04c10_analog_gains_reg[new_exp_g];
+
+  hcg_time = 100;
+  real_gain = 0x320;
+
+  return {
+    {0x3501, hcg_time>>8}, {0x3502, hcg_time&0xFF},
+    //{0x3581, lcg_time>>8}, {0x3582, lcg_time&0xFF},
+    //{0x3541, spd_time>>8}, {0x3542, spd_time&0xFF},
+    //{0x35c2, vs_time&0xFF},
+
+    {0x3508, real_gain>>8}, {0x3509, real_gain&0xFF},
+  };
+}
+
+int OS04C10::getSlaveAddress(int port) const {
+  assert(port >= 0 && port <= 2);
+  return (int[]){0x6C, 0x20, 0x6C}[port];
+}
+
+float OS04C10::getExposureScore(float desired_ev, int exp_t, int exp_g_idx, float exp_gain, int gain_idx) const {
+  float score = std::abs(desired_ev - (exp_t * exp_gain));
+  float m = exp_g_idx > analog_gain_rec_idx ? analog_gain_cost_high : analog_gain_cost_low;
+  score += std::abs(exp_g_idx - (int)analog_gain_rec_idx) * m;
+  score += ((1 - analog_gain_cost_delta) +
+            analog_gain_cost_delta * (exp_g_idx - analog_gain_min_idx) / (analog_gain_max_idx - analog_gain_min_idx)) *
+           std::abs(exp_g_idx - gain_idx) * 5.0;
+  return score;
+}

system/camerad/sensors/os04c10_registers.h

@@ -0,0 +1,298 @@
+#pragma once
+
+const struct i2c_random_wr_payload start_reg_array_os04c10[] = {{0x100, 1}};
+const struct i2c_random_wr_payload stop_reg_array_os04c10[] = {{0x100, 0}};
+
+const struct i2c_random_wr_payload init_array_os04c10[] = {
+  // OS04C10_AA_00_02_17_wAO_1920x1080_MIPI728Mbps_Linear12bit_20FPS_4Lane_MCLK24MHz
+  {0x0103, 0x01},
+  {0x0301, 0x84},
+  {0x0303, 0x01},
+  {0x0305, 0x5b},
+  {0x0306, 0x01},
+  {0x0307, 0x17},
+  {0x0323, 0x04},
+  {0x0324, 0x01},
+  {0x0325, 0x62},
+  {0x3012, 0x06},
+  {0x3013, 0x02},
+  {0x3016, 0x72},
+  {0x3021, 0x03},
+  {0x3106, 0x21},
+  {0x3107, 0xa1},
+  {0x3500, 0x00},
+  {0x3501, 0x00},
+  {0x3502, 0x40},
+  {0x3503, 0x88},
+  {0x3508, 0x07},
+  {0x3509, 0xc0},
+  {0x350a, 0x04},
+  {0x350b, 0x00},
+  {0x350c, 0x07},
+  {0x350d, 0xc0},
+  {0x350e, 0x04},
+  {0x350f, 0x00},
+  {0x3510, 0x00},
+  {0x3511, 0x00},
+  {0x3512, 0x20},
+  {0x3624, 0x00},
+  {0x3625, 0x4c},
+  {0x3660, 0x00},
+  {0x3666, 0xa5},
+  {0x3667, 0xa5},
+  {0x366a, 0x64},
+  {0x3673, 0x0d},
+  {0x3672, 0x0d},
+  {0x3671, 0x0d},
+  {0x3670, 0x0d},
+  {0x3685, 0x00},
+  {0x3694, 0x0d},
+  {0x3693, 0x0d},
+  {0x3692, 0x0d},
+  {0x3691, 0x0d},
+  {0x3696, 0x4c},
+  {0x3697, 0x4c},
+  {0x3698, 0x40},
+  {0x3699, 0x80},
+  {0x369a, 0x18},
+  {0x369b, 0x1f},
+  {0x369c, 0x14},
+  {0x369d, 0x80},
+  {0x369e, 0x40},
+  {0x369f, 0x21},
+  {0x36a0, 0x12},
+  {0x36a1, 0x5d},
+  {0x36a2, 0x66},
+  {0x370a, 0x00},
+  {0x370e, 0x0c},
+  {0x3710, 0x00},
+  {0x3713, 0x00},
+  {0x3725, 0x02},
+  {0x372a, 0x03},
+  {0x3738, 0xce},
+  {0x3748, 0x00},
+  {0x374a, 0x00},
+  {0x374c, 0x00},
+  {0x374e, 0x00},
+  {0x3756, 0x00},
+  {0x3757, 0x0e},
+  {0x3767, 0x00},
+  {0x3771, 0x00},
+  {0x377b, 0x20},
+  {0x377c, 0x00},
+  {0x377d, 0x0c},
+  {0x3781, 0x03},
+  {0x3782, 0x00},
+  {0x3789, 0x14},
+  {0x3795, 0x02},
+  {0x379c, 0x00},
+  {0x379d, 0x00},
+  {0x37b8, 0x04},
+  {0x37ba, 0x03},
+  {0x37bb, 0x00},
+  {0x37bc, 0x04},
+  {0x37be, 0x08},
+  {0x37c4, 0x11},
+  {0x37c5, 0x80},
+  {0x37c6, 0x14},
+  {0x37c7, 0x08},
+  {0x37da, 0x11},
+  {0x381f, 0x08},
+  {0x3829, 0x03},
+  {0x3881, 0x00},
+  {0x3888, 0x04},
+  {0x388b, 0x00},
+  {0x3c80, 0x10},
+  {0x3c86, 0x00},
+  {0x3c8c, 0x20},
+  {0x3c9f, 0x01},
+  {0x3d85, 0x1b},
+  {0x3d8c, 0x71},
+  {0x3d8d, 0xe2},
+  {0x3f00, 0x0b},
+  {0x3f06, 0x04},
+  {0x400a, 0x01},
+  {0x400b, 0x50},
+  {0x400e, 0x08},
+  {0x4043, 0x7e},
+  {0x4045, 0x7e},
+  {0x4047, 0x7e},
+  {0x4049, 0x7e},
+  {0x4090, 0x14},
+  {0x40b0, 0x00},
+  {0x40b1, 0x00},
+  {0x40b2, 0x00},
+  {0x40b3, 0x00},
+  {0x40b4, 0x00},
+  {0x40b5, 0x00},
+  {0x40b7, 0x00},
+  {0x40b8, 0x00},
+  {0x40b9, 0x00},
+  {0x40ba, 0x00},
+  {0x4301, 0x00},
+  {0x4303, 0x00},
+  {0x4502, 0x04},
+  {0x4503, 0x00},
+  {0x4504, 0x06},
+  {0x4506, 0x00},
+  {0x4507, 0x64},
+  {0x4803, 0x00},
+  {0x480c, 0x32},
+  {0x480e, 0x00},
+  {0x4813, 0x00},
+  {0x4819, 0x70},
+  {0x481f, 0x30},
+  {0x4823, 0x3f},
+  {0x4825, 0x30},
+  {0x4833, 0x10},
+  {0x484b, 0x07},
+  {0x488b, 0x00},
+  {0x4d00, 0x04},
+  {0x4d01, 0xad},
+  {0x4d02, 0xbc},
+  {0x4d03, 0xa1},
+  {0x4d04, 0x1f},
+  {0x4d05, 0x4c},
+  {0x4d0b, 0x01},
+  {0x4e00, 0x2a},
+  {0x4e0d, 0x00},
+  {0x5001, 0x09},
+  {0x5004, 0x00},
+  {0x5080, 0x04},
+  {0x5036, 0x00},
+  {0x5180, 0x70},
+  {0x5181, 0x10},
+  {0x520a, 0x03},
+  {0x520b, 0x06},
+  {0x520c, 0x0c},
+  {0x580b, 0x0f},
+  {0x580d, 0x00},
+  {0x580f, 0x00},
+  {0x5820, 0x00},
+  {0x5821, 0x00},
+  {0x301c, 0xf8},
+  {0x301e, 0xb4},
+  {0x301f, 0xd0},
+  {0x3022, 0x01},
+  {0x3109, 0xe7},
+  {0x3600, 0x00},
+  {0x3610, 0x65},
+  {0x3611, 0x85},
+  {0x3613, 0x3a},
+  {0x3615, 0x60},
+  {0x3621, 0x90},
+  {0x3620, 0x0c},
+  {0x3629, 0x00},
+  {0x3661, 0x04},
+  {0x3664, 0x70},
+  {0x3665, 0x00},
+  {0x3681, 0xa6},
+  {0x3682, 0x53},
+  {0x3683, 0x2a},
+  {0x3684, 0x15},
+  {0x3700, 0x2a},
+  {0x3701, 0x12},
+  {0x3703, 0x28},
+  {0x3704, 0x0e},
+  {0x3706, 0x4a},
+  {0x3709, 0x4a},
+  {0x370b, 0xa2},
+  {0x370c, 0x01},
+  {0x370f, 0x04},
+  {0x3714, 0x24},
+  {0x3716, 0x24},
+  {0x3719, 0x11},
+  {0x371a, 0x1e},
+  {0x3720, 0x00},
+  {0x3724, 0x13},
+  {0x373f, 0xb0},
+  {0x3741, 0x4a},
+  {0x3743, 0x4a},
+  {0x3745, 0x4a},
+  {0x3747, 0x4a},
+  {0x3749, 0xa2},
+  {0x374b, 0xa2},
+  {0x374d, 0xa2},
+  {0x374f, 0xa2},
+  {0x3755, 0x10},
+  {0x376c, 0x00},
+  {0x378d, 0x30},
+  {0x3790, 0x4a},
+  {0x3791, 0xa2},
+  {0x3798, 0x40},
+  {0x379e, 0x00},
+  {0x379f, 0x04},
+  {0x37a1, 0x10},
+  {0x37a2, 0x1e},
+  {0x37a8, 0x10},
+  {0x37a9, 0x1e},
+  {0x37ac, 0xa0},
+  {0x37b9, 0x01},
+  {0x37bd, 0x01},
+  {0x37bf, 0x26},
+  {0x37c0, 0x11},
+  {0x37c2, 0x04},
+  {0x37cd, 0x19},
+  {0x37e0, 0x08},
+  {0x37e6, 0x04},
+  {0x37e5, 0x02},
+  {0x37e1, 0x0c},
+  {0x3737, 0x04},
+  {0x37d8, 0x02},
+  {0x37e2, 0x10},
+  {0x3739, 0x10},
+  {0x3662, 0x10},
+  {0x37e4, 0x20},
+  {0x37e3, 0x08},
+  {0x37d9, 0x08},
+  {0x4040, 0x00},
+  {0x4041, 0x07},
+  {0x4008, 0x02},
+  {0x4009, 0x0d},
+  {0x3800, 0x01},
+  {0x3801, 0x80},
+  {0x3802, 0x00},
+  {0x3803, 0xdc},
+  {0x3804, 0x09},
+  {0x3805, 0x0f},
+  {0x3806, 0x05},
+  {0x3807, 0x23},
+  {0x3808, 0x07},
+  {0x3809, 0x80},
+  {0x380a, 0x04},
+  {0x380b, 0x38},
+  {0x380c, 0x04},
+  {0x380d, 0x2e},
+  {0x380e, 0x12},
+  {0x380f, 0x70},
+  {0x3811, 0x08},
+  {0x3813, 0x08},
+  {0x3814, 0x01},
+  {0x3815, 0x01},
+  {0x3816, 0x01},
+  {0x3817, 0x01},
+  {0x3820, 0x88},
+  {0x3821, 0x00},
+  {0x3880, 0x25},
+  {0x3882, 0x20},
+  {0x3c91, 0x0b},
+  {0x3c94, 0x45},
+  {0x3cad, 0x00},
+  {0x3cae, 0x00},
+  {0x4000, 0xf3},
+  {0x4001, 0x60},
+  {0x4003, 0x40},
+  {0x4300, 0xff},
+  {0x4302, 0x0f},
+  {0x4305, 0x83},
+  {0x4505, 0x84},
+  {0x4809, 0x1e},
+  {0x480a, 0x04},
+  {0x4837, 0x15},
+  {0x4c00, 0x08},
+  {0x4c01, 0x08},
+  {0x4c04, 0x00},
+  {0x4c05, 0x00},
+  {0x5000, 0xf9},
+  {0x3c8c, 0x10},
+};

system/camerad/sensors/ox03c10.cc

@@ -34,8 +34,9 @@ OX03C10::OX03C10() {
   init_reg_array.assign(std::begin(init_array_ox03c10), std::end(init_array_ox03c10));
   probe_reg_addr = 0x300a;
   probe_expected_data = 0x5803;
-  in_port_info_dt = 0x2c; // one is 0x2a, two are 0x2b
+  mipi_format = CAM_FORMAT_MIPI_RAW_12;
-  power_config_val_low = 24000000; //Hz
+  frame_data_type = 0x2c; // one is 0x2a, two are 0x2b
+  mclk_frequency = 24000000; //Hz
 
   dc_gain_factor = 7.32;
   dc_gain_min_weight = 1;  // always on is fine

system/camerad/sensors/sensor.h

@@ -9,12 +9,14 @@
 #include "system/camerad/cameras/camera_common.h"
 #include "system/camerad/sensors/ar0231_registers.h"
 #include "system/camerad/sensors/ox03c10_registers.h"
+#include "system/camerad/sensors/os04c10_registers.h"
 
 #define ANALOG_GAIN_MAX_CNT 55
 const size_t FRAME_WIDTH = 1928;
 const size_t FRAME_HEIGHT = 1208;
 const size_t FRAME_STRIDE = 2896;  // for 12 bit output. 1928 * 12 / 8 + 4 (alignment)
 
+
 class SensorInfo {
 public:
   SensorInfo() = default;
@@ -56,8 +58,10 @@ public:
   uint32_t probe_expected_data;
   std::vector<i2c_random_wr_payload> start_reg_array;
   std::vector<i2c_random_wr_payload> init_reg_array;
-  uint32_t in_port_info_dt;
+
-  uint32_t power_config_val_low;
+  uint32_t mipi_format;
+  uint32_t mclk_frequency;
+  uint32_t frame_data_type;
 };
 
 class AR0231 : public SensorInfo {
@@ -79,3 +83,11 @@ public:
   float getExposureScore(float desired_ev, int exp_t, int exp_g_idx, float exp_gain, int gain_idx) const override;
   int getSlaveAddress(int port) const override;
 };
+
+class OS04C10 : public SensorInfo {
+public:
+  OS04C10();
+  std::vector<i2c_random_wr_payload> getExposureRegisters(int exposure_time, int new_exp_g, bool dc_gain_enabled) const override;
+  float getExposureScore(float desired_ev, int exp_t, int exp_g_idx, float exp_gain, int gain_idx) const override;
+  int getSlaveAddress(int port) const override;
+};