mawei/onepilot
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

oneplus cleanup (#20200)

Browse Source 
* start cleanup

* cleanup camerad

* remove unused

* little more

Co-authored-by: Comma Device <device@comma.ai>
old-commit-hash: 07ab081a42e4c383bd0fbd3e7e5723a126c8da12
This commit is contained in:
Adeeb Shihadeh
2021-03-01 17:14:03 -08:00
committed by GitHub
parent 939d4f8dd2
commit 6dbc7c6d92
6 changed files with 153 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
launch_chffrplus.sh
View File

@@ -54,8 +54,7 @@ function two_init {
echo 1 > /proc/irq/6/smp_affinity_list # MDSS
# USB traffic needs realtime handling on cpu 3
[ -d "/proc/irq/733" ] && echo 3 > /proc/irq/733/smp_affinity_list # USB for LeEco
[ -d "/proc/irq/736" ] && echo 3 > /proc/irq/736/smp_affinity_list # USB for OP3T
[ -d "/proc/irq/733" ] && echo 3 > /proc/irq/733/smp_affinity_list
# GPU and camera get cpu 2
CAM_IRQS="177 178 179 180 181 182 183 184 185 186 192"
@@ -91,18 +90,6 @@ function two_init {
"$DIR/installer/updater/updater" "file://$DIR/installer/updater/update.json"
fi
# One-time fix for a subset of OP3T with gyro orientation offsets.
# Remove and regenerate qcom sensor registry. Only done on OP3T mainboards.
# Performed exactly once. The old registry is preserved just-in-case, and
# doubles as a flag denoting we've already done the reset.
if ! $(grep -q "letv" /proc/cmdline) && [ ! -f "/persist/comma/op3t-sns-reg-backup" ]; then
echo "Performing OP3T sensor registry reset"
mv /persist/sensors/sns.reg /persist/comma/op3t-sns-reg-backup &&
rm -f /persist/sensors/sensors_settings /persist/sensors/error_log /persist/sensors/gyro_sensitity_cal &&
echo "restart" > /sys/kernel/debug/msm_subsys/slpi &&
sleep 5 # Give Android sensor subsystem a moment to recover
fi
}
function tici_init {

650
selfdrive/camerad/cameras/camera_qcom.cc
View File

@@ -203,27 +203,6 @@ static int ov8865_apply_exposure(CameraState *s, int gain, int integ_lines, int
return err;
}
static int imx179_s5k3p8sp_apply_exposure(CameraState *s, int gain, int integ_lines, int frame_length) {
//printf("driver camera: %d %d %d\n", gain, integ_lines, frame_length);
struct msm_camera_i2c_reg_array reg_array[] = {
{0x104,0x1,0},
// FRM_LENGTH
{0x340, (uint16_t)(frame_length >> 8), 0}, {0x341, (uint16_t)(frame_length & 0xff), 0},
// coarse_int_time
{0x202, (uint16_t)(integ_lines >> 8), 0}, {0x203, (uint16_t)(integ_lines & 0xff),0},
// global_gain
{0x204, (uint16_t)(gain >> 8), 0}, {0x205, (uint16_t)(gain & 0xff),0},
{0x104,0x0,0},
};
int err = sensor_write_regs(s, reg_array, ARRAYSIZE(reg_array), MSM_CAMERA_I2C_BYTE_DATA);
if (err != 0) {
LOGE("apply_exposure err %d", err);
}
return err;
}
cl_program build_conv_program(cl_device_id device_id, cl_context context, int image_w, int image_h, int filter_size) {
char args[4096];
snprintf(args, sizeof(args),
@@ -238,28 +217,12 @@ cl_program build_conv_program(cl_device_id device_id, cl_context context, int im
void cameras_init(VisionIpcServer *v, MultiCameraState *s, cl_device_id device_id, cl_context ctx) {
char project_name[1024] = {0};
property_get("ro.boot.project_name", project_name, "");
assert(strlen(project_name) == 0);
char product_name[1024] = {0};
property_get("ro.product.name", product_name, "");
if (strlen(project_name) == 0) {
LOGD("LePro 3 op system detected");
s->device = DEVICE_LP3;
// sensor is flipped in LP3
// IMAGE_ORIENT = 3
init_array_imx298[0].reg_data = 3;
cameras_supported[CAMERA_ID_IMX298].bayer_flip = 3;
} else if (strcmp(product_name, "OnePlus3") == 0 && strcmp(project_name, "15811") != 0) {
// no more OP3 support
s->device = DEVICE_OP3;
assert(false);
} else if (strcmp(product_name, "OnePlus3") == 0 && strcmp(project_name, "15811") == 0) {
// only OP3T support
s->device = DEVICE_OP3T;
} else {
assert(false);
}
// sensor is flipped in LP3
// IMAGE_ORIENT = 3
init_array_imx298[0].reg_data = 3;
cameras_supported[CAMERA_ID_IMX298].bayer_flip = 3;
// 0 = ISO 100
// 256 = ISO 200
@@ -283,28 +246,11 @@ void cameras_init(VisionIpcServer *v, MultiCameraState *s, cl_device_id device_i
VISION_STREAM_RGB_BACK, VISION_STREAM_YUV_BACK);
s->road_cam.apply_exposure = imx298_apply_exposure;
if (s->device == DEVICE_OP3T) {
camera_init(v, &s->driver_cam, CAMERA_ID_S5K3P8SP, 1,
/*pixel_clock=*/560000000, /*line_length_pclk=*/5120,
/*max_gain=*/510, 10, device_id, ctx,
VISION_STREAM_RGB_FRONT, VISION_STREAM_YUV_FRONT);
s->driver_cam.apply_exposure = imx179_s5k3p8sp_apply_exposure;
} else if (s->device == DEVICE_LP3) {
camera_init(v, &s->driver_cam, CAMERA_ID_OV8865, 1,
/*pixel_clock=*/72000000, /*line_length_pclk=*/1602,
/*max_gain=*/510, 10, device_id, ctx,
VISION_STREAM_RGB_FRONT, VISION_STREAM_YUV_FRONT);
s->driver_cam.apply_exposure = ov8865_apply_exposure;
} else {
camera_init(v, &s->driver_cam, CAMERA_ID_IMX179, 1,
/*pixel_clock=*/251200000, /*line_length_pclk=*/3440,
/*max_gain=*/224, 20, device_id, ctx,
VISION_STREAM_RGB_FRONT, VISION_STREAM_YUV_FRONT);
s->driver_cam.apply_exposure = imx179_s5k3p8sp_apply_exposure;
}
s->road_cam.device = s->device;
s->driver_cam.device = s->device;
camera_init(v, &s->driver_cam, CAMERA_ID_OV8865, 1,
/*pixel_clock=*/72000000, /*line_length_pclk=*/1602,
/*max_gain=*/510, 10, device_id, ctx,
VISION_STREAM_RGB_FRONT, VISION_STREAM_YUV_FRONT);
s->driver_cam.apply_exposure = ov8865_apply_exposure;
s->sm = new SubMaster({"driverState"});
s->pm = new PubMaster({"roadCameraState", "driverCameraState", "thumbnail"});
@@ -452,158 +398,52 @@ static uint8_t* get_eeprom(int eeprom_fd, size_t *out_len) {
return buffer;
}
static void imx298_ois_calibration(int ois_fd, uint8_t* eeprom) {
const int ois_registers[][2] = {
// == SET_FADJ_PARAM() == (factory adjustment)
// Set Hall Current DAC
{0x8230, *(uint16_t*)(eeprom+0x102)}, //_P_30_ADC_CH0 (CURDAT)
// Set Hall PreAmp Offset
{0x8231, *(uint16_t*)(eeprom+0x104)}, //_P_31_ADC_CH1 (HALOFS_X)
{0x8232, *(uint16_t*)(eeprom+0x106)}, //_P_32_ADC_CH2 (HALOFS_Y)
// Set Hall-X/Y PostAmp Offset
{0x841e, *(uint16_t*)(eeprom+0x108)}, //_M_X_H_ofs
{0x849e, *(uint16_t*)(eeprom+0x10a)}, //_M_Y_H_ofs
// Set Residual Offset
{0x8239, *(uint16_t*)(eeprom+0x10c)}, //_P_39_Ch3_VAL_1 (PSTXOF)
{0x823b, *(uint16_t*)(eeprom+0x10e)}, //_P_3B_Ch3_VAL_3 (PSTYOF)
// DIGITAL GYRO OFFSET
{0x8406, *(uint16_t*)(eeprom+0x110)}, //_M_Kgx00
{0x8486, *(uint16_t*)(eeprom+0x112)}, //_M_Kgy00
{0x846a, *(uint16_t*)(eeprom+0x120)}, //_M_TMP_X_
{0x846b, *(uint16_t*)(eeprom+0x122)}, //_M_TMP_Y_
// HALLSENSE
// Set Hall Gain
{0x8446, *(uint16_t*)(eeprom+0x114)}, //_M_KgxHG
{0x84c6, *(uint16_t*)(eeprom+0x116)}, //_M_KgyHG
// Set Cross Talk Canceller
{0x8470, *(uint16_t*)(eeprom+0x124)}, //_M_KgxH0
{0x8472, *(uint16_t*)(eeprom+0x126)}, //_M_KgyH0
// LOOPGAIN
{0x840f, *(uint16_t*)(eeprom+0x118)}, //_M_KgxG
{0x848f, *(uint16_t*)(eeprom+0x11a)}, //_M_KgyG
// Position Servo ON ( OIS OFF )
{0x847f, 0x0c0c}, //_M_EQCTL
};
struct msm_camera_i2c_seq_reg_array ois_reg_settings[ARRAYSIZE(ois_registers)] = {{0}};
for (int i=0; i<ARRAYSIZE(ois_registers); i++) {
ois_reg_settings[i].reg_addr = ois_registers[i][0];
ois_reg_settings[i].reg_data[0] = ois_registers[i][1] & 0xff;
ois_reg_settings[i].reg_data[1] = (ois_registers[i][1] >> 8) & 0xff;
ois_reg_settings[i].reg_data_size = 2;
}
struct msm_camera_i2c_seq_reg_setting ois_reg_setting = {
.reg_setting = &ois_reg_settings[0],
.size = ARRAYSIZE(ois_reg_settings),
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.delay = 0,
};
msm_ois_cfg_data cfg = {.cfgtype = CFG_OIS_I2C_WRITE_SEQ_TABLE, .cfg.settings = &ois_reg_setting};
int err = ioctl(ois_fd, VIDIOC_MSM_OIS_CFG, &cfg);
LOG("ois reg calibration: %d", err);
}
static void sensors_init(MultiCameraState *s) {
int err;
unique_fd sensorinit_fd;
if (s->device == DEVICE_LP3) {
sensorinit_fd = open("/dev/v4l-subdev11", O_RDWR | O_NONBLOCK);
} else {
sensorinit_fd = open("/dev/v4l-subdev12", O_RDWR | O_NONBLOCK);
}
sensorinit_fd = open("/dev/v4l-subdev11", O_RDWR | O_NONBLOCK);
assert(sensorinit_fd >= 0);
// init road camera sensor
struct msm_camera_sensor_slave_info slave_info = {0};
if (s->device == DEVICE_LP3) {
slave_info = (struct msm_camera_sensor_slave_info){
.sensor_name = "imx298",
.eeprom_name = "sony_imx298",
.actuator_name = "dw9800w",
.ois_name = "",
.flash_name = "pmic",
.camera_id = CAMERA_0,
.slave_addr = 32,
.i2c_freq_mode = I2C_FAST_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id_reg_addr = 22, .sensor_id = 664, .module_id = 9, .vcm_id = 6},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_GPIO, .seq_val = 5, .config_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 10},
},
.size = 7,
.power_down_setting_a = {
{.seq_type = SENSOR_CLK, .delay = 1},
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_GPIO, .seq_val = 5},
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
},
.size_down = 6,
slave_info = (struct msm_camera_sensor_slave_info){
.sensor_name = "imx298",
.eeprom_name = "sony_imx298",
.actuator_name = "dw9800w",
.ois_name = "",
.flash_name = "pmic",
.camera_id = CAMERA_0,
.slave_addr = 32,
.i2c_freq_mode = I2C_FAST_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id_reg_addr = 22, .sensor_id = 664, .module_id = 9, .vcm_id = 6},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_GPIO, .seq_val = 5, .config_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 10},
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = BACK_CAMERA_B, .sensor_mount_angle = 90},
.output_format = MSM_SENSOR_BAYER,
};
} else {
slave_info = (struct msm_camera_sensor_slave_info){
.sensor_name = "imx298",
.eeprom_name = "sony_imx298",
.actuator_name = "rohm_bu63165gwl",
.ois_name = "rohm_bu63165gwl",
.camera_id = CAMERA_0,
.slave_addr = 52,
.i2c_freq_mode = I2C_CUSTOM_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id_reg_addr = 22, .sensor_id = 664},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 2},
{.seq_type = SENSOR_VREG, .seq_val = 2, .delay = 2},
{.seq_type = SENSOR_VREG, .delay = 2},
{.seq_type = SENSOR_VREG, .seq_val = 1, .delay = 2},
{.seq_type = SENSOR_GPIO, .seq_val = 6, .config_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 5},
{.seq_type = SENSOR_VREG, .seq_val = 4, .delay = 5},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 2},
{.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 2},
},
.size = 9,
.power_down_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 10},
{.seq_type = SENSOR_CLK, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 4},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
{.seq_type = SENSOR_GPIO, .seq_val = 6},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_VREG, .seq_val = 2},
},
.size_down = 8,
.size = 7,
.power_down_setting_a = {
{.seq_type = SENSOR_CLK, .delay = 1},
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_GPIO, .seq_val = 5},
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = BACK_CAMERA_B, .sensor_mount_angle = 360},
.output_format = MSM_SENSOR_BAYER,
};
}
.size_down = 6,
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = BACK_CAMERA_B, .sensor_mount_angle = 90},
.output_format = MSM_SENSOR_BAYER,
};
slave_info.power_setting_array.power_setting = &slave_info.power_setting_array.power_setting_a[0];
slave_info.power_setting_array.power_down_setting = &slave_info.power_setting_array.power_down_setting_a[0];
sensor_init_cfg_data sensor_init_cfg = {.cfgtype = CFG_SINIT_PROBE, .cfg.setting = &slave_info};
@@ -612,111 +452,40 @@ static void sensors_init(MultiCameraState *s) {
assert(err >= 0);
struct msm_camera_sensor_slave_info slave_info2 = {0};
if (s->device == DEVICE_LP3) {
slave_info2 = (struct msm_camera_sensor_slave_info){
.sensor_name = "ov8865_sunny",
.eeprom_name = "ov8865_plus",
.actuator_name = "",
.ois_name = "",
.flash_name = "",
.camera_id = CAMERA_2,
.slave_addr = 108,
.i2c_freq_mode = I2C_FAST_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id_reg_addr = 12299, .sensor_id = 34917, .module_id = 2},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 5},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 1},
},
.size = 6,
.power_down_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 5},
{.seq_type = SENSOR_CLK, .delay = 1},
{.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2, .delay = 1},
},
.size_down = 5,
slave_info2 = (struct msm_camera_sensor_slave_info){
.sensor_name = "ov8865_sunny",
.eeprom_name = "ov8865_plus",
.actuator_name = "",
.ois_name = "",
.flash_name = "",
.camera_id = CAMERA_2,
.slave_addr = 108,
.i2c_freq_mode = I2C_FAST_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id_reg_addr = 12299, .sensor_id = 34917, .module_id = 2},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 5},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 1},
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = FRONT_CAMERA_B, .sensor_mount_angle = 270},
.output_format = MSM_SENSOR_BAYER,
};
} else if (s->driver_cam.camera_id == CAMERA_ID_S5K3P8SP) {
// init driver camera
slave_info2 = (struct msm_camera_sensor_slave_info){
.sensor_name = "s5k3p8sp",
.eeprom_name = "s5k3p8sp_m24c64s",
.actuator_name = "",
.ois_name = "",
.camera_id = CAMERA_1,
.slave_addr = 32,
.i2c_freq_mode = I2C_FAST_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id = 12552},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 1, .delay = 1},
{.seq_type = SENSOR_VREG, .delay = 1},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 1},
},
.size = 6,
.power_down_setting_a = {
{.seq_type = SENSOR_CLK, .delay = 1},
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 1, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2, .delay = 1},
},
.size_down = 5,
.size = 6,
.power_down_setting_a = {
{.seq_type = SENSOR_GPIO, .delay = 5},
{.seq_type = SENSOR_CLK, .delay = 1},
{.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2, .delay = 1},
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = FRONT_CAMERA_B, .sensor_mount_angle = 270},
.output_format = MSM_SENSOR_BAYER,
};
} else {
// init driver camera
slave_info2 = (struct msm_camera_sensor_slave_info){
.sensor_name = "imx179",
.eeprom_name = "sony_imx179",
.actuator_name = "",
.ois_name = "",
.camera_id = CAMERA_1,
.slave_addr = 32,
.i2c_freq_mode = I2C_FAST_MODE,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.sensor_id_info = {.sensor_id_reg_addr = 2, .sensor_id = 377, .sensor_id_mask = 4095},
.power_setting_array = {
.power_setting_a = {
{.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_GPIO, .config_val = 2},
{.seq_type = SENSOR_CLK, .config_val = 24000000},
},
.size = 5,
.power_down_setting_a = {
{.seq_type = SENSOR_CLK},
{.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_VREG, .delay = 2},
{.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 2},
},
.size_down = 5,
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = FRONT_CAMERA_B, .sensor_mount_angle = 270},
.output_format = MSM_SENSOR_BAYER,
};
}
.size_down = 5,
},
.is_init_params_valid = 0,
.sensor_init_params = {.modes_supported = 1, .position = FRONT_CAMERA_B, .sensor_mount_angle = 270},
.output_format = MSM_SENSOR_BAYER,
};
slave_info2.power_setting_array.power_setting = &slave_info2.power_setting_array.power_setting_a[0];
slave_info2.power_setting_array.power_down_setting = &slave_info2.power_setting_array.power_down_setting_a[0];
sensor_init_cfg.cfgtype = CFG_SINIT_PROBE;
@@ -733,7 +502,6 @@ static void camera_open(CameraState *s, bool is_road_cam) {
struct v4l2_event_subscription sub = {};
struct msm_actuator_cfg_data actuator_cfg_data = {};
struct msm_ois_cfg_data ois_cfg_data = {};
// open devices
const char *sensor_dev;
@@ -742,42 +510,21 @@ static void camera_open(CameraState *s, bool is_road_cam) {
assert(s->csid_fd >= 0);
s->csiphy_fd = open("/dev/v4l-subdev0", O_RDWR | O_NONBLOCK);
assert(s->csiphy_fd >= 0);
if (s->device == DEVICE_LP3) {
sensor_dev = "/dev/v4l-subdev17";
} else {
sensor_dev = "/dev/v4l-subdev18";
}
if (s->device == DEVICE_LP3) {
s->isp_fd = open("/dev/v4l-subdev13", O_RDWR | O_NONBLOCK);
} else {
s->isp_fd = open("/dev/v4l-subdev14", O_RDWR | O_NONBLOCK);
}
sensor_dev = "/dev/v4l-subdev17";
s->isp_fd = open("/dev/v4l-subdev13", O_RDWR | O_NONBLOCK);
assert(s->isp_fd >= 0);
s->eeprom_fd = open("/dev/v4l-subdev8", O_RDWR | O_NONBLOCK);
assert(s->eeprom_fd >= 0);
s->actuator_fd = open("/dev/v4l-subdev7", O_RDWR | O_NONBLOCK);
assert(s->actuator_fd >= 0);
if (s->device != DEVICE_LP3) {
s->ois_fd = open("/dev/v4l-subdev10", O_RDWR | O_NONBLOCK);
assert(s->ois_fd >= 0);
}
} else {
s->csid_fd = open("/dev/v4l-subdev5", O_RDWR | O_NONBLOCK);
assert(s->csid_fd >= 0);
s->csiphy_fd = open("/dev/v4l-subdev2", O_RDWR | O_NONBLOCK);
assert(s->csiphy_fd >= 0);
if (s->device == DEVICE_LP3) {
sensor_dev = "/dev/v4l-subdev18";
} else {
sensor_dev = "/dev/v4l-subdev19";
}
if (s->device == DEVICE_LP3) {
s->isp_fd = open("/dev/v4l-subdev14", O_RDWR | O_NONBLOCK);
} else {
s->isp_fd = open("/dev/v4l-subdev15", O_RDWR | O_NONBLOCK);
}
sensor_dev = "/dev/v4l-subdev18";
s->isp_fd = open("/dev/v4l-subdev14", O_RDWR | O_NONBLOCK);
assert(s->isp_fd >= 0);
s->eeprom_fd = open("/dev/v4l-subdev9", O_RDWR | O_NONBLOCK);
assert(s->eeprom_fd >= 0);
@@ -812,13 +559,6 @@ static void camera_open(CameraState *s, bool is_road_cam) {
err = ioctl(s->sensor_fd, VIDIOC_MSM_SENSOR_CFG, &sensorb_cfg_data);
LOG("sensor power down: %d", err);
if (is_road_cam && s->device != DEVICE_LP3) {
// ois powerdown
ois_cfg_data.cfgtype = CFG_OIS_POWERDOWN;
err = ioctl(s->ois_fd, VIDIOC_MSM_OIS_CFG, &ois_cfg_data);
LOG("ois powerdown: %d", err);
}
// actuator powerdown
actuator_cfg_data.cfgtype = CFG_ACTUATOR_POWERDOWN;
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
@@ -911,143 +651,61 @@ static void camera_open(CameraState *s, bool is_road_cam) {
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
LOG("actuator init: %d", err);
// leeco actuator (DW9800W H-Bridge Driver IC)
// from sniff
s->infinity_dac = 364;
// no OIS in LP3
if (s->device != DEVICE_LP3) {
// see sony_imx298_eeprom_format_afdata in libmmcamera_sony_imx298_eeprom.so
const float far_margin = -0.28;
uint16_t macro_dac = *(uint16_t*)(s->eeprom + 0x24);
s->infinity_dac = *(uint16_t*)(s->eeprom + 0x26);
LOG("macro_dac: %d infinity_dac: %d", macro_dac, s->infinity_dac);
struct msm_actuator_reg_params_t actuator_reg_params[] = {
{
.reg_write_type = MSM_ACTUATOR_WRITE_DAC,
// MSB here at address 3
.reg_addr = 3,
.data_type = 9,
.addr_type = 4,
},
};
int dac_range = macro_dac - s->infinity_dac;
s->infinity_dac += far_margin * dac_range;
struct reg_settings_t actuator_init_settings[] = {
{ .reg_addr=2, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=1, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 0 }, // PD = power down
{ .reg_addr=2, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=0, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 2 }, // 0 = power up
{ .reg_addr=2, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=2, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 2 }, // RING = SAC mode
{ .reg_addr=6, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=64, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 0 }, // 0x40 = SAC3 mode
{ .reg_addr=7, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=113, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 0 },
// 0x71 = DIV1 | DIV0 | SACT0 -- Tvib x 1/4 (quarter)
// SAC Tvib = 6.3 ms + 0.1 ms = 6.4 ms / 4 = 1.6 ms
// LSC 1-step = 252 + 1*4 = 256 ms / 4 = 64 ms
};
LOG(" -> macro_dac: %d infinity_dac: %d", macro_dac, s->infinity_dac);
struct region_params_t region_params[] = {
{.step_bound = {238, 0,}, .code_per_step = 235, .qvalue = 128}
};
struct msm_actuator_reg_params_t actuator_reg_params[] = {
{.reg_write_type = MSM_ACTUATOR_WRITE_DAC, .reg_addr = 240, .data_type = 10, .addr_type = 4},
{.reg_write_type = MSM_ACTUATOR_WRITE_DAC, .reg_addr = 241, .data_type = 10, .addr_type = 4},
{.reg_write_type = MSM_ACTUATOR_WRITE_DAC, .reg_addr = 242, .data_type = 10, .addr_type = 4},
{.reg_write_type = MSM_ACTUATOR_WRITE_DAC, .reg_addr = 243, .data_type = 10, .addr_type = 4},
};
actuator_cfg_data.cfgtype = CFG_SET_ACTUATOR_INFO;
actuator_cfg_data.cfg.set_info = (struct msm_actuator_set_info_t){
.actuator_params = {
.act_type = ACTUATOR_BIVCM,
.reg_tbl_size = 1,
.data_size = 10,
.init_setting_size = 5,
.i2c_freq_mode = I2C_STANDARD_MODE,
.i2c_addr = 24,
.i2c_addr_type = MSM_ACTUATOR_BYTE_ADDR,
.i2c_data_type = MSM_ACTUATOR_WORD_DATA,
.reg_tbl_params = &actuator_reg_params[0],
.init_settings = &actuator_init_settings[0],
.park_lens = {.damping_step = 1023, .damping_delay = 14000, .hw_params = 11, .max_step = 20},
},
.af_tuning_params = {
.initial_code = (int16_t)s->infinity_dac,
.pwd_step = 0,
.region_size = 1,
.total_steps = 238,
.region_params = &region_params[0],
},
};
//...
struct reg_settings_t actuator_init_settings[1] = {0};
struct region_params_t region_params[] = {
{.step_bound = {512, 0,}, .code_per_step = 118, .qvalue = 128}
};
actuator_cfg_data.cfgtype = CFG_SET_ACTUATOR_INFO;
actuator_cfg_data.cfg.set_info = (struct msm_actuator_set_info_t){
.actuator_params = {
.act_type = ACTUATOR_VCM,
.reg_tbl_size = 4,
.data_size = 10,
.init_setting_size = 0,
.i2c_freq_mode = I2C_CUSTOM_MODE,
.i2c_addr = 28,
.i2c_addr_type = MSM_ACTUATOR_BYTE_ADDR,
.i2c_data_type = MSM_ACTUATOR_BYTE_DATA,
.reg_tbl_params = &actuator_reg_params[0],
.init_settings = &actuator_init_settings[0],
.park_lens = {
.damping_step = 1023,
.damping_delay = 15000,
.hw_params = 58404,
.max_step = 20,
}
},
.af_tuning_params = {
.initial_code = (int16_t)s->infinity_dac,
.pwd_step = 0,
.region_size = 1,
.total_steps = 512,
.region_params = &region_params[0],
},
};
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
LOG("actuator set info: %d", err);
// power up ois
ois_cfg_data.cfgtype = CFG_OIS_POWERUP;
err = ioctl(s->ois_fd, VIDIOC_MSM_OIS_CFG, &ois_cfg_data);
LOG("ois powerup: %d", err);
ois_cfg_data.cfgtype = CFG_OIS_INIT;
err = ioctl(s->ois_fd, VIDIOC_MSM_OIS_CFG, &ois_cfg_data);
LOG("ois init: %d", err);
ois_cfg_data.cfgtype = CFG_OIS_CONTROL;
ois_cfg_data.cfg.set_info.ois_params = (struct msm_ois_params_t){
// .data_size = 26312,
.setting_size = 120,
.i2c_addr = 28,
.i2c_freq_mode = I2C_CUSTOM_MODE,
// .i2c_addr_type = wtf
// .i2c_data_type = wtf
.settings = &ois_init_settings[0],
};
err = ioctl(s->ois_fd, VIDIOC_MSM_OIS_CFG, &ois_cfg_data);
LOG("ois init settings: %d", err);
} else {
// leeco actuator (DW9800W H-Bridge Driver IC)
// from sniff
s->infinity_dac = 364;
struct msm_actuator_reg_params_t actuator_reg_params[] = {
{
.reg_write_type = MSM_ACTUATOR_WRITE_DAC,
// MSB here at address 3
.reg_addr = 3,
.data_type = 9,
.addr_type = 4,
},
};
struct reg_settings_t actuator_init_settings[] = {
{ .reg_addr=2, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=1, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 0 }, // PD = power down
{ .reg_addr=2, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=0, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 2 }, // 0 = power up
{ .reg_addr=2, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=2, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 2 }, // RING = SAC mode
{ .reg_addr=6, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=64, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 0 }, // 0x40 = SAC3 mode
{ .reg_addr=7, .addr_type=MSM_ACTUATOR_BYTE_ADDR, .reg_data=113, .data_type = MSM_ACTUATOR_BYTE_DATA, .i2c_operation = MSM_ACT_WRITE, .delay = 0 },
// 0x71 = DIV1 | DIV0 | SACT0 -- Tvib x 1/4 (quarter)
// SAC Tvib = 6.3 ms + 0.1 ms = 6.4 ms / 4 = 1.6 ms
// LSC 1-step = 252 + 1*4 = 256 ms / 4 = 64 ms
};
struct region_params_t region_params[] = {
{.step_bound = {238, 0,}, .code_per_step = 235, .qvalue = 128}
};
actuator_cfg_data.cfgtype = CFG_SET_ACTUATOR_INFO;
actuator_cfg_data.cfg.set_info = (struct msm_actuator_set_info_t){
.actuator_params = {
.act_type = ACTUATOR_BIVCM,
.reg_tbl_size = 1,
.data_size = 10,
.init_setting_size = 5,
.i2c_freq_mode = I2C_STANDARD_MODE,
.i2c_addr = 24,
.i2c_addr_type = MSM_ACTUATOR_BYTE_ADDR,
.i2c_data_type = MSM_ACTUATOR_WORD_DATA,
.reg_tbl_params = &actuator_reg_params[0],
.init_settings = &actuator_init_settings[0],
.park_lens = {.damping_step = 1023, .damping_delay = 14000, .hw_params = 11, .max_step = 20},
},
.af_tuning_params = {
.initial_code = (int16_t)s->infinity_dac,
.pwd_step = 0,
.region_size = 1,
.total_steps = 238,
.region_params = &region_params[0],
},
};
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
LOG("actuator set info: %d", err);
}
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
LOG("actuator set info: %d", err);
}
if (s->camera_id == CAMERA_ID_IMX298) {
@@ -1218,30 +876,21 @@ static void road_camera_start(CameraState *s) {
// focus on infinity assuming phone is perpendicular
int inf_step;
if (s->device != DEVICE_LP3) {
imx298_ois_calibration(s->ois_fd, s->eeprom);
inf_step = 332 - s->infinity_dac;
actuator_ringing_params.damping_step = 1023;
actuator_ringing_params.damping_delay = 20000;
actuator_ringing_params.hw_params = 13;
// initial guess
s->lens_true_pos = 300;
} else {
// default is OP3, this is for LeEco
actuator_ringing_params.damping_step = 1023;
actuator_ringing_params.damping_delay = 20000;
actuator_ringing_params.hw_params = 13;
inf_step = 512 - s->infinity_dac;
inf_step = 512 - s->infinity_dac;
// initial guess
s->lens_true_pos = 400;
}
// initial guess
s->lens_true_pos = 400;
// reset lens position
memset(&actuator_cfg_data, 0, sizeof(actuator_cfg_data));
actuator_cfg_data.cfgtype = CFG_SET_POSITION;
actuator_cfg_data.cfg.setpos = (struct msm_actuator_set_position_t){
.number_of_steps = 1,
.hw_params = (uint32_t)((s->device != DEVICE_LP3) ? 0x0000e424 : 7),
.hw_params = (uint32_t)7,
.pos = {s->infinity_dac, 0},
.delay = {0,}
};
@@ -1272,11 +921,8 @@ static void road_camera_start(CameraState *s) {
}
void actuator_move(CameraState *s, uint16_t target) {
int step = target - s->cur_lens_pos;
// LP3 moves only on even positions. TODO: use proper sensor params
if (s->device == DEVICE_LP3) {
step /= 2;
}
int step = (target - s->cur_lens_pos) / 2;
int dest_step_pos = s->cur_step_pos + step;
dest_step_pos = std::clamp(dest_step_pos, 0, 255);
@@ -1363,8 +1009,8 @@ static std::optional<float> get_accel_z(SubMaster *sm) {
static void do_autofocus(CameraState *s, SubMaster *sm) {
// params for focus PI controller
const int dac_up = s->device == DEVICE_LP3? LP3_AF_DAC_UP:OP3T_AF_DAC_UP;
const int dac_down = s->device == DEVICE_LP3? LP3_AF_DAC_DOWN:OP3T_AF_DAC_DOWN;
const int dac_up = LP3_AF_DAC_UP;
const int dac_down = LP3_AF_DAC_DOWN;
float lens_true_pos = s->lens_true_pos.load();
if (!isnan(s->focus_err)) {
@@ -1434,11 +1080,7 @@ void cameras_open(MultiCameraState *s) {
s->v4l_fd = open("/dev/video0", O_RDWR | O_NONBLOCK);
assert(s->v4l_fd >= 0);
if (s->device == DEVICE_LP3) {
s->ispif_fd = open("/dev/v4l-subdev15", O_RDWR | O_NONBLOCK);
} else {
s->ispif_fd = open("/dev/v4l-subdev16", O_RDWR | O_NONBLOCK);
}
s->ispif_fd = open("/dev/v4l-subdev15", O_RDWR | O_NONBLOCK);
assert(s->ispif_fd >= 0);
// ISPIF: stop
@@ -1615,10 +1257,10 @@ static void update_lapmap(MultiCameraState *s, const CameraBuf *b, const int cnt
}
static void setup_self_recover(CameraState *c, const uint16_t *lapres, size_t lapres_size) {
const int dac_down = c->device == DEVICE_LP3 ? LP3_AF_DAC_DOWN : OP3T_AF_DAC_DOWN;
const int dac_up = c->device == DEVICE_LP3 ? LP3_AF_DAC_UP : OP3T_AF_DAC_UP;
const int dac_m = c->device == DEVICE_LP3 ? LP3_AF_DAC_M : OP3T_AF_DAC_M;
const int dac_3sig = c->device == DEVICE_LP3 ? LP3_AF_DAC_3SIG : OP3T_AF_DAC_3SIG;
const int dac_down = LP3_AF_DAC_DOWN;
const int dac_up = LP3_AF_DAC_UP;
const int dac_m = LP3_AF_DAC_M;
const int dac_3sig = LP3_AF_DAC_3SIG;
const float lens_true_pos = c->lens_true_pos.load();
int self_recover = c->self_recover.load();

14
selfdrive/camerad/cameras/camera_qcom.h
View File

@@ -22,20 +22,12 @@
#define FRAME_BUF_COUNT 4
#define METADATA_BUF_COUNT 4
#define DEVICE_OP3 0
#define DEVICE_OP3T 1
#define DEVICE_LP3 2
#define NUM_FOCUS 8
#define LP3_AF_DAC_DOWN 366
#define LP3_AF_DAC_UP 634
#define LP3_AF_DAC_M 440
#define LP3_AF_DAC_3SIG 52
#define OP3T_AF_DAC_DOWN 224
#define OP3T_AF_DAC_UP 456
#define OP3T_AF_DAC_M 300
#define OP3T_AF_DAC_3SIG 96
#define FOCUS_RECOVER_PATIENCE 50 // 2.5 seconds of complete blur
#define FOCUS_RECOVER_STEPS 240 // 6 seconds
@@ -54,7 +46,7 @@ typedef struct StreamState {
typedef struct CameraState {
int camera_num;
int camera_id;
int device;
int fps;
CameraInfo ci;
@@ -71,7 +63,7 @@ typedef struct CameraState {
pthread_mutex_t frame_info_lock;
FrameMetadata frame_metadata[METADATA_BUF_COUNT];
int frame_metadata_idx;
// exposure
uint32_t pixel_clock, line_length_pclk;
unsigned int max_gain;
@@ -98,8 +90,6 @@ typedef struct CameraState {
typedef struct MultiCameraState {
int device;
unique_fd ispif_fd;
unique_fd msmcfg_fd;
unique_fd v4l_fd;

3
selfdrive/car/car_helpers.py
View File

@@ -5,7 +5,6 @@ from selfdrive.version import comma_remote, tested_branch
from selfdrive.car.fingerprints import eliminate_incompatible_cars, all_known_cars
from selfdrive.car.vin import get_vin, VIN_UNKNOWN
from selfdrive.car.fw_versions import get_fw_versions, match_fw_to_car
from selfdrive.hardware import EON
from selfdrive.swaglog import cloudlog
import cereal.messaging as messaging
from selfdrive.car import gen_empty_fingerprint
@@ -24,8 +23,6 @@ def get_startup_event(car_recognized, controller_available):
event = EventName.startupNoCar
elif car_recognized and not controller_available:
event = EventName.startupNoControl
elif EON and "letv" not in open("/proc/cmdline").read():
event = EventName.startupOneplus
return event

10
selfdrive/ui/android/ui.cc
View File

@@ -123,21 +123,19 @@ int main(int argc, char* argv[]) {
PubMaster *pm = new PubMaster({"offroadLayout"});
// light sensor scaling and volume params
const bool LEON = util::read_file("/proc/cmdline").find("letv") != std::string::npos;
float brightness_b = 0, brightness_m = 0;
int result = read_param(&brightness_b, "BRIGHTNESS_B", true);
result += read_param(&brightness_m, "BRIGHTNESS_M", true);
if (result != 0) {
brightness_b = LEON ? 10.0 : 5.0;
brightness_m = LEON ? 2.6 : 1.3;
brightness_b = 10.0;
brightness_m = 2.6;
write_param_float(brightness_b, "BRIGHTNESS_B", true);
write_param_float(brightness_m, "BRIGHTNESS_M", true);
}
float smooth_brightness = brightness_b;
const int MIN_VOLUME = LEON ? 12 : 9;
const int MAX_VOLUME = LEON ? 15 : 12;
const int MIN_VOLUME = 12;
const int MAX_VOLUME = 15;
s->sound->setVolume(MIN_VOLUME);
while (!do_exit) {

4
selfdrive/updated.py
View File

@@ -328,10 +328,6 @@ def main():
if params.get("DisableUpdates") == b"1":
raise RuntimeError("updates are disabled by the DisableUpdates param")
# TODO: remove this after next release
if EON and "letv" not in open("/proc/cmdline").read():
raise RuntimeError("updates are disabled due to device deprecation")
if EON and os.geteuid() != 0:
raise RuntimeError("updated must be launched as root!")