sadmen
/
openpilot_comma
mirror of https://github.com/commaai/openpilot.git
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>
pull/20215/head
Adeeb Shihadeh 4 years ago committed by GitHub
parent dd2bba0b42
commit 07ab081a42
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 154 additions and 544 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 15
      launch_chffrplus.sh
  2. 652
      selfdrive/camerad/cameras/camera_qcom.cc
  3. 14
      selfdrive/camerad/cameras/camera_qcom.h
  4. 3
      selfdrive/car/car_helpers.py
  5. 10
      selfdrive/ui/android/ui.cc
  6. 4
      selfdrive/updated.py

15
launch_chffrplus.sh
Unescape View File

@ -54,8 +54,7 @@ function two_init {
echo 1 > /proc/irq/6/smp_affinity_list # MDSS echo 1 > /proc/irq/6/smp_affinity_list # MDSS
# USB traffic needs realtime handling on cpu 3 # 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/733" ] && echo 3 > /proc/irq/733/smp_affinity_list
[ -d "/proc/irq/736" ] && echo 3 > /proc/irq/736/smp_affinity_list # USB for OP3T
# GPU and camera get cpu 2 # GPU and camera get cpu 2
CAM_IRQS="177 178 179 180 181 182 183 184 185 186 192" 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" "$DIR/installer/updater/updater" "file://$DIR/installer/updater/update.json"
fi 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 { function tici_init {

652
selfdrive/camerad/cameras/camera_qcom.cc
Unescape View File

@ -203,27 +203,6 @@ static int ov8865_apply_exposure(CameraState *s, int gain, int integ_lines, int
return err; 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) { 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]; char args[4096];
snprintf(args, sizeof(args), 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) { void cameras_init(VisionIpcServer *v, MultiCameraState *s, cl_device_id device_id, cl_context ctx) {
char project_name[1024] = {0}; char project_name[1024] = {0};
property_get("ro.boot.project_name", project_name, ""); property_get("ro.boot.project_name", project_name, "");
assert(strlen(project_name) == 0);
char product_name[1024] = {0}; // sensor is flipped in LP3
property_get("ro.product.name", product_name, ""); // IMAGE_ORIENT = 3
init_array_imx298[0].reg_data = 3;
if (strlen(project_name) == 0) { cameras_supported[CAMERA_ID_IMX298].bayer_flip = 3;
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);
}
// 0 = ISO 100 // 0 = ISO 100
// 256 = ISO 200 // 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); VISION_STREAM_RGB_BACK, VISION_STREAM_YUV_BACK);
s->road_cam.apply_exposure = imx298_apply_exposure; s->road_cam.apply_exposure = imx298_apply_exposure;
if (s->device == DEVICE_OP3T) { camera_init(v, &s->driver_cam, CAMERA_ID_OV8865, 1,
camera_init(v, &s->driver_cam, CAMERA_ID_S5K3P8SP, 1, /*pixel_clock=*/72000000, /*line_length_pclk=*/1602,
/*pixel_clock=*/560000000, /*line_length_pclk=*/5120, /*max_gain=*/510, 10, device_id, ctx,
/*max_gain=*/510, 10, device_id, ctx, VISION_STREAM_RGB_FRONT, VISION_STREAM_YUV_FRONT);
VISION_STREAM_RGB_FRONT, VISION_STREAM_YUV_FRONT); s->driver_cam.apply_exposure = ov8865_apply_exposure;
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;
s->sm = new SubMaster({"driverState"}); s->sm = new SubMaster({"driverState"});
s->pm = new PubMaster({"roadCameraState", "driverCameraState", "thumbnail"}); 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; 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) { static void sensors_init(MultiCameraState *s) {
int err; int err;
unique_fd sensorinit_fd; unique_fd sensorinit_fd;
if (s->device == DEVICE_LP3) { sensorinit_fd = open("/dev/v4l-subdev11", O_RDWR | O_NONBLOCK);
sensorinit_fd = open("/dev/v4l-subdev11", O_RDWR | O_NONBLOCK);
} else {
sensorinit_fd = open("/dev/v4l-subdev12", O_RDWR | O_NONBLOCK);
}
assert(sensorinit_fd >= 0); assert(sensorinit_fd >= 0);
// init road camera sensor // init road camera sensor
struct msm_camera_sensor_slave_info slave_info = {0}; struct msm_camera_sensor_slave_info slave_info = {0};
if (s->device == DEVICE_LP3) { slave_info = (struct msm_camera_sensor_slave_info){
slave_info = (struct msm_camera_sensor_slave_info){ .sensor_name = "imx298",
.sensor_name = "imx298", .eeprom_name = "sony_imx298",
.eeprom_name = "sony_imx298", .actuator_name = "dw9800w",
.actuator_name = "dw9800w", .ois_name = "",
.ois_name = "", .flash_name = "pmic",
.flash_name = "pmic", .camera_id = CAMERA_0,
.camera_id = CAMERA_0, .slave_addr = 32,
.slave_addr = 32, .i2c_freq_mode = I2C_FAST_MODE,
.i2c_freq_mode = I2C_FAST_MODE, .addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR, .sensor_id_info = {.sensor_id_reg_addr = 22, .sensor_id = 664, .module_id = 9, .vcm_id = 6},
.sensor_id_info = {.sensor_id_reg_addr = 22, .sensor_id = 664, .module_id = 9, .vcm_id = 6}, .power_setting_array = {
.power_setting_array = { .power_setting_a = {
.power_setting_a = { {.seq_type = SENSOR_GPIO, .delay = 1},
{.seq_type = SENSOR_GPIO, .delay = 1}, {.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 2}, {.seq_type = SENSOR_GPIO, .seq_val = 5, .config_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 = 1}, {.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
{.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1}, {.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1}, {.seq_type = SENSOR_GPIO, .config_val = 2, .delay = 10},
{.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,
}, },
.is_init_params_valid = 0, .size = 7,
.sensor_init_params = {.modes_supported = 1, .position = BACK_CAMERA_B, .sensor_mount_angle = 90}, .power_down_setting_a = {
.output_format = MSM_SENSOR_BAYER, {.seq_type = SENSOR_CLK, .delay = 1},
}; {.seq_type = SENSOR_GPIO, .delay = 1},
} else { {.seq_type = SENSOR_VREG, .seq_val = 1},
slave_info = (struct msm_camera_sensor_slave_info){ {.seq_type = SENSOR_GPIO, .seq_val = 5},
.sensor_name = "imx298", {.seq_type = SENSOR_VREG, .seq_val = 2},
.eeprom_name = "sony_imx298", {.seq_type = SENSOR_VREG, .seq_val = 3, .delay = 1},
.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,
}, },
.is_init_params_valid = 0, .size_down = 6,
.sensor_init_params = {.modes_supported = 1, .position = BACK_CAMERA_B, .sensor_mount_angle = 360}, },
.output_format = MSM_SENSOR_BAYER, .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_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]; 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}; 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); assert(err >= 0);
struct msm_camera_sensor_slave_info slave_info2 = {0}; struct msm_camera_sensor_slave_info slave_info2 = {0};
if (s->device == DEVICE_LP3) { slave_info2 = (struct msm_camera_sensor_slave_info){
slave_info2 = (struct msm_camera_sensor_slave_info){ .sensor_name = "ov8865_sunny",
.sensor_name = "ov8865_sunny", .eeprom_name = "ov8865_plus",
.eeprom_name = "ov8865_plus", .actuator_name = "",
.actuator_name = "", .ois_name = "",
.ois_name = "", .flash_name = "",
.flash_name = "", .camera_id = CAMERA_2,
.camera_id = CAMERA_2, .slave_addr = 108,
.slave_addr = 108, .i2c_freq_mode = I2C_FAST_MODE,
.i2c_freq_mode = I2C_FAST_MODE, .addr_type = MSM_CAMERA_I2C_WORD_ADDR,
.addr_type = MSM_CAMERA_I2C_WORD_ADDR, .sensor_id_info = {.sensor_id_reg_addr = 12299, .sensor_id = 34917, .module_id = 2},
.sensor_id_info = {.sensor_id_reg_addr = 12299, .sensor_id = 34917, .module_id = 2}, .power_setting_array = {
.power_setting_array = { .power_setting_a = {
.power_setting_a = { {.seq_type = SENSOR_GPIO, .delay = 5},
{.seq_type = SENSOR_GPIO, .delay = 5}, {.seq_type = SENSOR_VREG, .seq_val = 1},
{.seq_type = SENSOR_VREG, .seq_val = 1}, {.seq_type = SENSOR_VREG, .seq_val = 2},
{.seq_type = SENSOR_VREG, .seq_val = 2}, {.seq_type = SENSOR_VREG},
{.seq_type = SENSOR_VREG}, {.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1},
{.seq_type = SENSOR_CLK, .config_val = 24000000, .delay = 1}, {.seq_type = SENSOR_GPIO, .config_val = 2, .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,
},
.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,
}, },
.is_init_params_valid = 0, .size = 6,
.sensor_init_params = {.modes_supported = 1, .position = FRONT_CAMERA_B, .sensor_mount_angle = 270}, .power_down_setting_a = {
.output_format = MSM_SENSOR_BAYER, {.seq_type = SENSOR_GPIO, .delay = 5},
}; {.seq_type = SENSOR_CLK, .delay = 1},
} else { {.seq_type = SENSOR_VREG},
// init driver camera {.seq_type = SENSOR_VREG, .seq_val = 1},
slave_info2 = (struct msm_camera_sensor_slave_info){ {.seq_type = SENSOR_VREG, .seq_val = 2, .delay = 1},
.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, .size_down = 5,
.sensor_init_params = {.modes_supported = 1, .position = FRONT_CAMERA_B, .sensor_mount_angle = 270}, },
.output_format = MSM_SENSOR_BAYER, .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_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]; 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; 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 v4l2_event_subscription sub = {};
struct msm_actuator_cfg_data actuator_cfg_data = {}; struct msm_actuator_cfg_data actuator_cfg_data = {};
struct msm_ois_cfg_data ois_cfg_data = {};
// open devices // open devices
const char *sensor_dev; const char *sensor_dev;
@ -742,42 +510,21 @@ static void camera_open(CameraState *s, bool is_road_cam) {
assert(s->csid_fd >= 0); assert(s->csid_fd >= 0);
s->csiphy_fd = open("/dev/v4l-subdev0", O_RDWR | O_NONBLOCK); s->csiphy_fd = open("/dev/v4l-subdev0", O_RDWR | O_NONBLOCK);
assert(s->csiphy_fd >= 0); assert(s->csiphy_fd >= 0);
if (s->device == DEVICE_LP3) { sensor_dev = "/dev/v4l-subdev17";
sensor_dev = "/dev/v4l-subdev17"; s->isp_fd = open("/dev/v4l-subdev13", O_RDWR | O_NONBLOCK);
} 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);
}
assert(s->isp_fd >= 0); assert(s->isp_fd >= 0);
s->eeprom_fd = open("/dev/v4l-subdev8", O_RDWR | O_NONBLOCK); s->eeprom_fd = open("/dev/v4l-subdev8", O_RDWR | O_NONBLOCK);
assert(s->eeprom_fd >= 0); assert(s->eeprom_fd >= 0);
s->actuator_fd = open("/dev/v4l-subdev7", O_RDWR | O_NONBLOCK); s->actuator_fd = open("/dev/v4l-subdev7", O_RDWR | O_NONBLOCK);
assert(s->actuator_fd >= 0); 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 { } else {
s->csid_fd = open("/dev/v4l-subdev5", O_RDWR | O_NONBLOCK); s->csid_fd = open("/dev/v4l-subdev5", O_RDWR | O_NONBLOCK);
assert(s->csid_fd >= 0); assert(s->csid_fd >= 0);
s->csiphy_fd = open("/dev/v4l-subdev2", O_RDWR | O_NONBLOCK); s->csiphy_fd = open("/dev/v4l-subdev2", O_RDWR | O_NONBLOCK);
assert(s->csiphy_fd >= 0); assert(s->csiphy_fd >= 0);
if (s->device == DEVICE_LP3) { sensor_dev = "/dev/v4l-subdev18";
sensor_dev = "/dev/v4l-subdev18"; s->isp_fd = open("/dev/v4l-subdev14", O_RDWR | O_NONBLOCK);
} 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);
}
assert(s->isp_fd >= 0); assert(s->isp_fd >= 0);
s->eeprom_fd = open("/dev/v4l-subdev9", O_RDWR | O_NONBLOCK); s->eeprom_fd = open("/dev/v4l-subdev9", O_RDWR | O_NONBLOCK);
assert(s->eeprom_fd >= 0); 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); err = ioctl(s->sensor_fd, VIDIOC_MSM_SENSOR_CFG, &sensorb_cfg_data);
LOG("sensor power down: %d", err); 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 powerdown
actuator_cfg_data.cfgtype = CFG_ACTUATOR_POWERDOWN; actuator_cfg_data.cfgtype = CFG_ACTUATOR_POWERDOWN;
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data); 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); err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
LOG("actuator init: %d", err); LOG("actuator init: %d", err);
// 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,
},
};
// no OIS in LP3 struct reg_settings_t actuator_init_settings[] = {
if (s->device != DEVICE_LP3) { { .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
// see sony_imx298_eeprom_format_afdata in libmmcamera_sony_imx298_eeprom.so { .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
const float far_margin = -0.28; { .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
uint16_t macro_dac = *(uint16_t*)(s->eeprom + 0x24); { .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
s->infinity_dac = *(uint16_t*)(s->eeprom + 0x26); { .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 },
LOG("macro_dac: %d infinity_dac: %d", macro_dac, s->infinity_dac); // 0x71 = DIV1 | DIV0 | SACT0 -- Tvib x 1/4 (quarter)
// SAC Tvib = 6.3 ms + 0.1 ms = 6.4 ms / 4 = 1.6 ms
int dac_range = macro_dac - s->infinity_dac; // LSC 1-step = 252 + 1*4 = 256 ms / 4 = 64 ms
s->infinity_dac += far_margin * dac_range; };
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, .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},
};
//...
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[] = { struct region_params_t region_params[] = {
{.step_bound = {238, 0,}, .code_per_step = 235, .qvalue = 128} {.step_bound = {238, 0,}, .code_per_step = 235, .qvalue = 128}
}; };
actuator_cfg_data.cfgtype = CFG_SET_ACTUATOR_INFO; actuator_cfg_data.cfgtype = CFG_SET_ACTUATOR_INFO;
actuator_cfg_data.cfg.set_info = (struct msm_actuator_set_info_t){ actuator_cfg_data.cfg.set_info = (struct msm_actuator_set_info_t){
.actuator_params = { .actuator_params = {
.act_type = ACTUATOR_BIVCM, .act_type = ACTUATOR_BIVCM,
.reg_tbl_size = 1, .reg_tbl_size = 1,
.data_size = 10, .data_size = 10,
.init_setting_size = 5, .init_setting_size = 5,
.i2c_freq_mode = I2C_STANDARD_MODE, .i2c_freq_mode = I2C_STANDARD_MODE,
.i2c_addr = 24, .i2c_addr = 24,
.i2c_addr_type = MSM_ACTUATOR_BYTE_ADDR, .i2c_addr_type = MSM_ACTUATOR_BYTE_ADDR,
.i2c_data_type = MSM_ACTUATOR_WORD_DATA, .i2c_data_type = MSM_ACTUATOR_WORD_DATA,
.reg_tbl_params = &actuator_reg_params[0], .reg_tbl_params = &actuator_reg_params[0],
.init_settings = &actuator_init_settings[0], .init_settings = &actuator_init_settings[0],
.park_lens = {.damping_step = 1023, .damping_delay = 14000, .hw_params = 11, .max_step = 20}, .park_lens = {.damping_step = 1023, .damping_delay = 14000, .hw_params = 11, .max_step = 20},
}, },
.af_tuning_params = { .af_tuning_params = {
.initial_code = (int16_t)s->infinity_dac, .initial_code = (int16_t)s->infinity_dac,
.pwd_step = 0, .pwd_step = 0,
.region_size = 1, .region_size = 1,
.total_steps = 238, .total_steps = 238,
.region_params = &region_params[0], .region_params = &region_params[0],
}, },
}; };
err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data); err = ioctl(s->actuator_fd, VIDIOC_MSM_ACTUATOR_CFG, &actuator_cfg_data);
LOG("actuator set info: %d", err); LOG("actuator set info: %d", err);
}
} }
if (s->camera_id == CAMERA_ID_IMX298) { 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 // focus on infinity assuming phone is perpendicular
int inf_step; int inf_step;
if (s->device != DEVICE_LP3) { actuator_ringing_params.damping_step = 1023;
imx298_ois_calibration(s->ois_fd, s->eeprom); actuator_ringing_params.damping_delay = 20000;
inf_step = 332 - s->infinity_dac; actuator_ringing_params.hw_params = 13;
// initial guess inf_step = 512 - s->infinity_dac;
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;
// initial guess // initial guess
s->lens_true_pos = 400; s->lens_true_pos = 400;
}
// reset lens position // reset lens position
memset(&actuator_cfg_data, 0, sizeof(actuator_cfg_data)); memset(&actuator_cfg_data, 0, sizeof(actuator_cfg_data));
actuator_cfg_data.cfgtype = CFG_SET_POSITION; actuator_cfg_data.cfgtype = CFG_SET_POSITION;
actuator_cfg_data.cfg.setpos = (struct msm_actuator_set_position_t){ actuator_cfg_data.cfg.setpos = (struct msm_actuator_set_position_t){
.number_of_steps = 1, .number_of_steps = 1,
.hw_params = (uint32_t)((s->device != DEVICE_LP3) ? 0x0000e424 : 7), .hw_params = (uint32_t)7,
.pos = {s->infinity_dac, 0}, .pos = {s->infinity_dac, 0},
.delay = {0,} .delay = {0,}
}; };
@ -1272,11 +921,8 @@ static void road_camera_start(CameraState *s) {
} }
void actuator_move(CameraState *s, uint16_t target) { 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 // LP3 moves only on even positions. TODO: use proper sensor params
if (s->device == DEVICE_LP3) { int step = (target - s->cur_lens_pos) / 2;
step /= 2;
}
int dest_step_pos = s->cur_step_pos + step; int dest_step_pos = s->cur_step_pos + step;
dest_step_pos = std::clamp(dest_step_pos, 0, 255); 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) { static void do_autofocus(CameraState *s, SubMaster *sm) {
// params for focus PI controller // params for focus PI controller
const int dac_up = s->device == DEVICE_LP3? LP3_AF_DAC_UP:OP3T_AF_DAC_UP; const int dac_up = LP3_AF_DAC_UP;
const int dac_down = s->device == DEVICE_LP3? LP3_AF_DAC_DOWN:OP3T_AF_DAC_DOWN; const int dac_down = LP3_AF_DAC_DOWN;
float lens_true_pos = s->lens_true_pos.load(); float lens_true_pos = s->lens_true_pos.load();
if (!isnan(s->focus_err)) { if (!isnan(s->focus_err)) {
@ -1434,11 +1080,7 @@ void cameras_open(MultiCameraState *s) {
s->v4l_fd = open("/dev/video0", O_RDWR | O_NONBLOCK); s->v4l_fd = open("/dev/video0", O_RDWR | O_NONBLOCK);
assert(s->v4l_fd >= 0); assert(s->v4l_fd >= 0);
if (s->device == DEVICE_LP3) { s->ispif_fd = open("/dev/v4l-subdev15", O_RDWR | O_NONBLOCK);
s->ispif_fd = open("/dev/v4l-subdev15", O_RDWR | O_NONBLOCK);
} else {
s->ispif_fd = open("/dev/v4l-subdev16", O_RDWR | O_NONBLOCK);
}
assert(s->ispif_fd >= 0); assert(s->ispif_fd >= 0);
// ISPIF: stop // 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) { 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_down = LP3_AF_DAC_DOWN;
const int dac_up = c->device == DEVICE_LP3 ? LP3_AF_DAC_UP : OP3T_AF_DAC_UP; const int dac_up = LP3_AF_DAC_UP;
const int dac_m = c->device == DEVICE_LP3 ? LP3_AF_DAC_M : OP3T_AF_DAC_M; const int dac_m = LP3_AF_DAC_M;
const int dac_3sig = c->device == DEVICE_LP3 ? LP3_AF_DAC_3SIG : OP3T_AF_DAC_3SIG; const int dac_3sig = LP3_AF_DAC_3SIG;
const float lens_true_pos = c->lens_true_pos.load(); const float lens_true_pos = c->lens_true_pos.load();
int self_recover = c->self_recover.load(); int self_recover = c->self_recover.load();

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

@ -22,20 +22,12 @@
#define FRAME_BUF_COUNT 4 #define FRAME_BUF_COUNT 4
#define METADATA_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 NUM_FOCUS 8
#define LP3_AF_DAC_DOWN 366 #define LP3_AF_DAC_DOWN 366
#define LP3_AF_DAC_UP 634 #define LP3_AF_DAC_UP 634
#define LP3_AF_DAC_M 440 #define LP3_AF_DAC_M 440
#define LP3_AF_DAC_3SIG 52 #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_PATIENCE 50 // 2.5 seconds of complete blur
#define FOCUS_RECOVER_STEPS 240 // 6 seconds #define FOCUS_RECOVER_STEPS 240 // 6 seconds
@ -54,7 +46,7 @@ typedef struct StreamState {
typedef struct CameraState { typedef struct CameraState {
int camera_num; int camera_num;
int camera_id; int camera_id;
int device;
int fps; int fps;
CameraInfo ci; CameraInfo ci;
@ -71,7 +63,7 @@ typedef struct CameraState {
pthread_mutex_t frame_info_lock; pthread_mutex_t frame_info_lock;
FrameMetadata frame_metadata[METADATA_BUF_COUNT]; FrameMetadata frame_metadata[METADATA_BUF_COUNT];
int frame_metadata_idx; int frame_metadata_idx;
// exposure // exposure
uint32_t pixel_clock, line_length_pclk; uint32_t pixel_clock, line_length_pclk;
unsigned int max_gain; unsigned int max_gain;
@ -98,8 +90,6 @@ typedef struct CameraState {
typedef struct MultiCameraState { typedef struct MultiCameraState {
int device;
unique_fd ispif_fd; unique_fd ispif_fd;
unique_fd msmcfg_fd; unique_fd msmcfg_fd;
unique_fd v4l_fd; unique_fd v4l_fd;

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

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

@ -123,21 +123,19 @@ int main(int argc, char* argv[]) {
PubMaster *pm = new PubMaster({"offroadLayout"}); PubMaster *pm = new PubMaster({"offroadLayout"});
// light sensor scaling and volume params // 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; float brightness_b = 0, brightness_m = 0;
int result = read_param(&brightness_b, "BRIGHTNESS_B", true); int result = read_param(&brightness_b, "BRIGHTNESS_B", true);
result += read_param(&brightness_m, "BRIGHTNESS_M", true); result += read_param(&brightness_m, "BRIGHTNESS_M", true);
if (result != 0) { if (result != 0) {
brightness_b = LEON ? 10.0 : 5.0; brightness_b = 10.0;
brightness_m = LEON ? 2.6 : 1.3; brightness_m = 2.6;
write_param_float(brightness_b, "BRIGHTNESS_B", true); write_param_float(brightness_b, "BRIGHTNESS_B", true);
write_param_float(brightness_m, "BRIGHTNESS_M", true); write_param_float(brightness_m, "BRIGHTNESS_M", true);
} }
float smooth_brightness = brightness_b; float smooth_brightness = brightness_b;
const int MIN_VOLUME = LEON ? 12 : 9; const int MIN_VOLUME = 12;
const int MAX_VOLUME = LEON ? 15 : 12; const int MAX_VOLUME = 15;
s->sound->setVolume(MIN_VOLUME); s->sound->setVolume(MIN_VOLUME);
while (!do_exit) { while (!do_exit) {

4
selfdrive/updated.py
Unescape View File

@ -328,10 +328,6 @@ def main():
if params.get("DisableUpdates") == b"1": if params.get("DisableUpdates") == b"1":
raise RuntimeError("updates are disabled by the DisableUpdates param") 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: if EON and os.geteuid() != 0:
raise RuntimeError("updated must be launched as root!") raise RuntimeError("updated must be launched as root!")

Write Preview
Loading…
Cancel
Save