【SPRD CAMERA】1 HAL层初始化流程

一、前言       

        根据我的理解以前android在启动camera service 会直接去操作hal层，这样hal层和framework就耦合在一起了。现在 Android O 中，加入了Camera Provider这一抽象层，该层作为一个独立进程存在于整个系统中，并且通过HIDL这一自定义语言成功地将Camera Hal Module从Camera Service中解耦出来。启动一个 CameraProvider 服务，作为一个独立进程 android.hardware.camera.provider@2.4-service 用来控制 camera HAL。

二、代码分析

      我们从android.hardware.camera.provider@2.4-service 这个服务来分析整个初始化流程。

      系统启动过程中，init进程通过解析init.rc 文件来启动服务。

idh.code\hardware\interfaces\camera\provider\2.4\default\android.hardware.camera.provider@2.4-service.rc

service vendor.camera-provider-2-4 /vendor/bin/hw/android.hardware.camera.provider@2.4-service
    interface android.hardware.camera.provider@2.4::ICameraProvider legacy/0
    class hal
    user cameraserver
    group audio camera input drmrpc inet system
    ioprio rt 4
    capabilities SYS_NICE
    writepid /dev/cpuset/camera-daemon/tasks /dev/stune/top-app/tasks

服务的入口时在service.cpp中。

idh.code\hardware\interfaces\camera\provider\2.4\default\service.cpp

int main()
{
    ALOGI("CameraProvider@2.4 legacy service is starting.");
    // The camera HAL may communicate to other vendor components via
    // /dev/vndbinder
    android::ProcessState::initWithDriver("/dev/vndbinder");
    status_t status;

    status = defaultLazyPassthroughServiceImplementation<ICameraProvider>("legacy/0",
                                                                              /*maxThreads*/ 6);
    return status;
}

这里采用的时直通模式，通过这个函数会去获取CameraProvider 服务并注册到hardwareservicemanage中，cameraservice启动时回去获取CameraProvider服务的远程代理。通过这个代理来调用CameraProvider中提供的接口。

        我们不详细介绍如何注册服务，我们只关系CameraProvider 的启动过程。经过一系列的调用最终调用到，HIDL_FETCH_ICameraProvider 这里会生成一个ICameraProvider 的对象，注册到

hardwareservicemanage。

idh.code\vendor\sprd\interfaces\camera\provider\2.4\default\CameraProvider_2_4.cpp

ICameraProvider* HIDL_FETCH_ICameraProvider(const char* name) {
    using namespace android::hardware::camera::provider::V2_4::implementation;
    ICameraProvider* provider = nullptr;
   
    provider = getProviderImpl<LegacyCameraProviderImpl_2_4>();

    return provider;
}

template<typename IMPL>
CameraProvider<IMPL>* getProviderImpl() {
    CameraProvider<IMPL> *provider = new CameraProvider<IMPL>();

    return provider;
}

这里时生成一个CameraProvider 的对象。我们继续看CameraProvider 的类。

idh.code\vendor\sprd\interfaces\camera\provider\2.4\default\CameraProvider_2_4.h

template<typename IMPL>
struct CameraProvider : public ICameraProvider {
    CameraProvider() : impl() {}
    ~CameraProvider() {}

    // Caller must use this method to check if CameraProvider ctor failed
    bool isInitFailed() { return impl.isInitFailed(); }

    // Methods from ::android::hardware::camera::provider::V2_4::ICameraProvider follow.
    Return<Status> setCallback(const sp<ICameraProviderCallback>& callback) override {
        return impl.setCallback(callback);
    }

    Return<void> getVendorTags(getVendorTags_cb _hidl_cb) override {
        return impl.getVendorTags(_hidl_cb);
    }

    Return<void> getCameraIdList(getCameraIdList_cb _hidl_cb) override {
        return impl.getCameraIdList(_hidl_cb);
    }

    Return<void> isSetTorchModeSupported(isSetTorchModeSupported_cb _hidl_cb) override {
        return impl.isSetTorchModeSupported(_hidl_cb);
    }

    Return<void> getCameraDeviceInterface_V1_x(
            const hidl_string& cameraDeviceName,
            getCameraDeviceInterface_V1_x_cb _hidl_cb) override {
        return impl.getCameraDeviceInterface_V1_x(cameraDeviceName, _hidl_cb);
    }

    Return<void> getCameraDeviceInterface_V3_x(
            const hidl_string& cameraDeviceName,
            getCameraDeviceInterface_V3_x_cb _hidl_cb) override {
        return impl.getCameraDeviceInterface_V3_x(cameraDeviceName, _hidl_cb);
    }

private:
    IMPL impl;
};

结合上一片的代码看，我们可以发现 new CameraProvider 相当于 就是实例化了 IMPL(LegacyCameraProviderImpl_2_4)，远程调用的接口也是调用 LegacyCameraProviderImpl_2_4对应的接口，相当于只是一层封装。

继续跟踪这个LegacyCameraProviderImpl_2_4的构造函数

idh.code\vendor\sprd\interfaces\camera\provider\2.4\default\LegacyCameraProviderImpl_2_4.cpp

LegacyCameraProviderImpl_2_4::LegacyCameraProviderImpl_2_4() :
    camera_module_callbacks_t({sCameraDeviceStatusChange,
                               sTorchModeStatusChange}) {
    mInitFailed = initialize();
}

1、camera_module_callbacks 

idh.code\hardware\libhardware\include\hardware\camera_common.h

typedef struct camera_module_callbacks {

    void (*camera_device_status_change)(const struct camera_module_callbacks*,
            int camera_id,
            int new_status);

    void (*torch_mode_status_change)(const struct camera_module_callbacks*,
            const char* camera_id,
            int new_status);

} camera_module_callbacks_t;
camera_module_callbacks_t({sCameraDeviceStatusChange, sTorchModeStatusChange}) 

这里知识初始化父类，赋值两个回调函数。

2、LegacyCameraProviderImpl_2_4::initialize

这个initialize时这个流程中最重要的函数下面会拆成几部分分析

bool LegacyCameraProviderImpl_2_4::initialize() {
    camera_module_t *rawModule;
    int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
            (const hw_module_t **)&rawModule);

    mModule = new CameraModule(rawModule);
    err = mModule->init();

    ALOGE("Loaded \"%s\" camera module", mModule->getModuleName());

    // Setup vendor tags here so HAL can setup vendor keys in camera characteristics
    VendorTagDescriptor::clearGlobalVendorTagDescriptor();
    if (!setUpVendorTags()) {
        ALOGE("%s: Vendor tag setup failed, will not be available.", __FUNCTION__);
    }

    // Setup callback now because we are going to try openLegacy next
    err = mModule->setCallbacks(this);

    mPreferredHal3MinorVersion =
        property_get_int32("ro.vendor.camera.wrapper.hal3TrebleMinorVersion", 3);
    ALOGV("Preferred HAL 3 minor version is %d", mPreferredHal3MinorVersion);

    mNumberOfLegacyCameras = mModule->getNumberOfCameras();
	    
    for (int i = 0; i < mNumberOfLegacyCameras; i++) {
	#define SEARCH_SINGLE_CAMERAS 2
        struct camera_info info;
        auto rc = mModule->getCameraInfo(i, &info);

        if (checkCameraVersion(i, info) != OK) {
            ALOGE("%s: Camera version check failed!", __func__);
            mModule.clear();
            return true;
        }

        char cameraId[kMaxCameraIdLen];
        snprintf(cameraId, sizeof(cameraId), "%d", i);
        std::string cameraIdStr(cameraId);
        mCameraStatusMap[cameraIdStr] = CAMERA_DEVICE_STATUS_PRESENT;

        addDeviceNames(i);
    }

    return false; // mInitFailed
}

这里将这个初始化函数拆成几个部分单独分析。

2.1、hw_get_module

int err = hw_get_module(CAMERA_HARDWARE_MODULE_ID,
            (const hw_module_t **)&rawModule);

这个函数是链接 camera hal 的库 camera.sp9863a.so，获得他的 hw_module_t 结构体。

这里虽然获取到的 hw_module_t 的地址，但是 hw_module_t 是 camera_module_t 的第一个成员变量，只要强转一下指针的类型就可以得到 camera_module_t 。

hw_get_module 的代码路径为

idh.code\hardware\libhardware\hardware.c

这里就不具体分析他是怎么找到 camera.sp9863a.so ，我们只看和camera有关的东西。

idh.code\vendor\sprd\modules\libcamera\hal3_2v6\SprdCamera3Hal.cpp

static hw_module_t camera_common = {
    .tag = HARDWARE_MODULE_TAG,
    .module_api_version =
        CAMERA_MODULE_API_VERSION_2_4, // CAMERA_MODULE_API_VERSION_2_0,
    .hal_api_version = HARDWARE_HAL_API_VERSION,
    .id = CAMERA_HARDWARE_MODULE_ID,
    .name = "Sprd Camera HAL3",
    .author = "Spreadtrum Corporation",
    .methods = &sprdcamera::SprdCamera3Factory::mModuleMethods,
    .dso = NULL,
    .reserved = {0},
};

camera_module_t HAL_MODULE_INFO_SYM = {
    .common = camera_common,
    .get_number_of_cameras =
        sprdcamera::SprdCamera3Factory::get_number_of_cameras,
    .get_camera_info = sprdcamera::SprdCamera3Factory::get_camera_info,
    .set_callbacks = sprdcamera::SprdCamera3Factory::set_callbacks, /*HAL 3.2*/
    .get_vendor_tag_ops =
        sprdcamera::SprdCamera3Factory::get_vendor_tag_ops, /*HAL 3.2*/
    .open_legacy = HAL_open_legacy,
    .set_torch_mode = sprdcamera::SprdCamera3Factory::setTorchMode,
};

2.2、CameraModule

mModule = new CameraModule(rawModule);

idh.code\hardware\interfaces\camera\common\1.0\default\CameraModule.cpp

CameraModule::CameraModule(camera_module_t *module) : mNumberOfCameras(0) {
    if (module == NULL) {
        ALOGE("%s: camera hardware module must not be null", __FUNCTION__);
        assert(0);
    }
    mModule = module;
}

这里只有一个赋值，创造了一个 CameraModule 对象。

2.3、mModule->init()

idh.code\hardware\interfaces\camera\common\1.0\default\CameraModule.cpp

int CameraModule::init() {
    int res = OK;
    //获取xml中配置的总尽头个数
    mNumberOfCameras = getNumberOfCameras();
    //设置容器的大小
    mCameraInfoMap.setCapacity(mNumberOfCameras);
    return res;
}
int CameraModule::getNumberOfCameras() {
    int numCameras;
    numCameras = mModule->get_number_of_cameras();
    return numCameras;
}

这里调用到 camera_module_t 中的函数，上面有列出来。

int SprdCamera3Factory::get_number_of_cameras() {
    return gSprdCamera3Factory.getNumberOfCameras();
}
int SprdCamera3Factory::getNumberOfCameras() {
    if(mNumOfCameras == 0) {
        mNumOfCameras = SprdCamera3Setting::getNumberOfCameras();
    }
    return mNumOfCameras;
}

这里插一句，通过日志来看在调用 SprdCamera3Factory::get_number_of_cameras()之前会调用SprdCamera3Factory 的构造函数。

应该是和这里有一个在 SprdCamera3Factory.c 中定义了一个 对象 gSprdCamera3Factory 有关系。构造函数里面会调用get_number_of_cameras 并赋值 mNumOfCameras，所以

这里会因为 mNumOfCameras不等于0，直接退出。我们开始关注构造函数里面的代码。

SprdCamera3Factory::SprdCamera3Factory() {

    mNumOfCameras = SprdCamera3Setting::getNumberOfCameras();
    SprdCamera3Wrapper::getCameraWrapper(&gSprdCamera3Wrapper);

    mStaticMetadata = NULL;
}

idh.code\vendor\sprd\modules\libcamera\hal3_2v6\SprdCamera3Setting.cpp

int SprdCamera3Setting::getNumberOfCameras() {
    int num = 0;

    mPhysicalSensorNum = sensorGetPhysicalSnsNum();

    if (mPhysicalSensorNum) {
        mLogicalSensorNum = sensorGetLogicalSnsNum();
    }

    num = mPhysicalSensorNum;

    return num;
}

idh.code\vendor\sprd\modules\libcamera\sensor\sensor_drv_u.c

int sensorGetPhysicalSnsNum(void) {
    struct camera_device_manager *devPtr = &camera_dev_manger;
    //static struct camera_device_manager camera_dev_manger = {0};

    sensor_drv_scan_hw();

    return devPtr->physical_num;
};
static cmr_int sensor_drv_scan_hw(void) {
    struct camera_device_manager *devPtr = &camera_dev_manger;
    struct sensor_drv_context sns_cxt;
    struct sensor_drv_context *sensor_cxt = &sns_cxt;
    cmr_u32 physical_num = 0;
    cmr_int i = 0;
    cmr_int ret = SENSOR_FAIL;
    char sensor_version_info[SENSOR_ID_MAX * 32] = {0};
    int32_t bytes = 0;
    char config_xml_name[CONFIG_XML_NAME_LEN];
    char pax_config_xml_name[CONFIG_XML_NAME_LEN]={0};
    xmlDocPtr docPtr = NULL;
    xmlNodePtr rootPtr = NULL;
    xmlNodePtr nodePtr = NULL;
    cmr_int module_cfg_num = 0;
    xml_camera_module_cfg_t module_cfg;
    struct xml_camera_cfg_info camera_cfg_info;
    cmr_int slot_id = 0;
    cmr_u8 sensor_count[SENSOR_ID_MAX] = {0xff};
    cmr_u8 probe_identify[SENSOR_ID_MAX] = {0};
    cmr_u32 project_num = 0;

    sensor_drv_sensor_info_list_init();
        //struct slotSensorInfo *slotPtr = slot_sensor_info_list;
        //struct phySensorInfo *phyPtr = phy_sensor_info_list;
        //struct logicalSensorInfo *logicalPtr = logical_sensor_info_list;
        //对这些资源全局变量初始化

    select_sensor_config_xml(pax_config_xml_name);
    bytes = snprintf(config_xml_name, sizeof(config_xml_name), "%s%s",
                     CONFIG_XML_PATH, pax_config_xml_name);
    //上面两行是找到我们设备的资源配置文件，就是vendor/etc/xxx.xml

    ret = sensor_drv_xml_load_file(config_xml_name, &docPtr, &rootPtr, "root");
    //导入文件，找到根节点

    module_cfg_num = sensor_drv_xml_get_node_num(rootPtr, "CameraModuleCfg");
    //适配了多少个镜头

    camera_cfg_info.docPtr = docPtr;
    camera_cfg_info.cfgPtr = &module_cfg;

    //对每个镜头资源进行解析
    for (i = 0; i < module_cfg_num; i++) {
        nodePtr = sensor_drv_xml_get_node(rootPtr, "CameraModuleCfg", i);
        //找到第i个镜头的节点

        memset(&module_cfg, 0, sizeof(xml_camera_module_cfg_t));
        camera_cfg_info.nodePtr = nodePtr;
        ret = sensor_drv_xml_parse_camera_module_info(&camera_cfg_info);
        //解析xml的文件,初始化module_cfg。

        slot_id = module_cfg.slot_id;

        sensor_count[slot_id] = slot_id;

        ret = sensor_context_init(sensor_cxt, slot_id, 0, 0);
        //open节点/dev/sprd_sensor
        //创建hw_drv_handle 的句柄

        memcpy(sensor_cxt->xml_info, &camera_cfg_info,
               sizeof(struct xml_camera_cfg_info));

        //这里会导入libsensor_gc5035.so，就是具体的sensor库 ,设置ic地址，上电，验证sensor id，一些变量的初始化
        if (SENSOR_SUCCESS == sensor_drv_identify(sensor_cxt, slot_id)) {
            sensor_drv_store_version_info(sensor_cxt, sensor_version_info);
            sensor_drv_create_slot_sensor_info(sensor_cxt, slot_id);
            sensor_drv_create_phy_sensor_info(sensor_cxt, slot_id,
                                              physical_num);
            physical_num++;
            probe_identify[slot_id] = 1;
        }

        sensor_context_deinit(sensor_cxt, 0);
        //sensor验证完后，删除sensor_cxt 临时变量的初始化信息，这里知识验证sensor id 。但是全局的变量保存了很多重要的信息。
    }

    sensor_rid_save_sensor_info(sensor_version_info);

    for (i = 0; i < SENSOR_ID_MAX; i++) {
        if (sensor_count[i] != 0xff)
            project_num++;
    }
    devPtr->physical_num = project_num;

    devPtr->logical_num =
        sensor_drv_create_logical_sensor_info(devPtr->physical_num);
        //物理信息转化成逻辑信息，这里我没太看懂，是不是和多摄有关

    if (docPtr) {
        sensor_drv_xml_unload_file(docPtr);
    }

    return devPtr->physical_num;
};

sensor_drv_scan_hw 通过函数名字知道这是通过 xml 文件来扫描所有支持的 sensor，通过读取id来判断是否连接。同时在这个过程我们会将很多的硬件相关的信息保存到全局变量里面，这样方便后面操作的快速访问。

这里挑几个重要的函数分析一下。

1）sensor_context_init

cmr_int sensor_context_init(struct sensor_drv_context *sensor_cxt,
                            cmr_u32 sensor_id, cmr_uint is_autotest,
                            cmr_int open_phase) {
    cmr_int ret = SENSOR_SUCCESS;
    cmr_int fd_sensor = SENSOR_FD_INIT;
    struct hw_drv_init_para input_ptr;
    cmr_handle hw_drv_handle = NULL;
    struct camera_device_manager *devPtr = &camera_dev_manger;
    SENSOR_MATCH_T *sns_module = PNULL;

    cmr_bzero((void *)sensor_cxt, sizeof(struct sensor_drv_context));

    sensor_cxt->fd_sensor = SENSOR_FD_INIT;
    sensor_cxt->i2c_addr = 0xff;
    sensor_cxt->is_autotest = is_autotest;

    sensor_clean_info(sensor_cxt);

    input_ptr.sensor_id = sensor_id;
    input_ptr.caller_handle = sensor_cxt;
    fd_sensor = hw_sensor_drv_create(&input_ptr, &hw_drv_handle);

    sensor_cxt->fd_sensor = fd_sensor;
    sensor_cxt->hw_drv_handle = hw_drv_handle;
    sensor_cxt->sensor_hw_handler = hw_drv_handle;

    sensor_cxt->sensor_index = &devPtr->drv_idx[sensor_id];
    sensor_cxt->xml_info = &xml_cfg_tab[sensor_id];
    sensor_cxt->current_module = &sensor_cfg_tab[sensor_id];
    sns_module = (SENSOR_INFO_T *)sensor_cxt->current_module;
    sensor_cxt->sensor_info_ptr = sns_module->sensor_info;

    return ret;
}
cmr_int hw_sensor_drv_create(struct hw_drv_init_para *input_ptr,
                             cmr_handle *hw_drv_handle) {
    cmr_u8 ret = HW_SUCCESS;
    struct hw_drv_cxt *hw_drv_cxt = NULL;
    CHECK_PTR(input_ptr);

    *hw_drv_handle = (struct hw_drv_cxt *)malloc(sizeof(struct hw_drv_cxt));

    hw_drv_cxt = *hw_drv_handle;
    hw_drv_cxt->fd_sensor = SENSOR_FD_INIT;
    hw_drv_cxt->sensor_id = input_ptr->sensor_id;
    hw_drv_cxt->caller_handle = input_ptr->caller_handle;
    ret = _hw_sensor_dev_init(*hw_drv_handle, input_ptr->sensor_id);
        //struct hw_drv_cxt *hw_drv_cxt = (struct hw_drv_cxt *)hw_drv_handle;
        //hw_drv_cxt->fd_sensor = open(HW_SENSOR_DEV_NAME, O_RDWR, 0);
        //ioctl(hw_drv_cxt->fd_sensor, SENSOR_IO_SET_ID, &sensor_id); sensor_id传入到驱动中

    return hw_drv_cxt->fd_sensor;
}

这里主要就是初始化 sensor_cxt 这个变量，这里涉及两个全局变量

static struct xml_camera_cfg_info xml_cfg_tab[SENSOR_ID_MAX] = {0};是对应sensor 的xml 配置
static SENSOR_MATCH_T sensor_cfg_tab[SENSOR_ID_MAX] = {0};是对应sensor 驱动中了SENSOR_INFO_T g_gc5035_mipi_raw_info（以gc5035为例）

这里说的对应就是sensor 的soltid 。

 2）sensor_drv_identify

static cmr_int sensor_drv_identify(struct sensor_drv_context *sensor_cxt,
                                   cmr_u32 sensor_id) {
    cmr_int ret = SENSOR_SUCCESS;
    SENSOR_MATCH_T *sns_module = NULL;
    struct sensor_drv_lib *libPtr = &sensor_lib_mngr[sensor_id];
    struct sensor_module_info *mod_cfg_tab = NULL;
    struct xml_camera_cfg_info *camera_cfg = NULL;

    sensor_set_cxt_common(sensor_cxt);

    sns_module = (SENSOR_MATCH_T *)sensor_cxt->current_module;
    camera_cfg = sensor_cxt->xml_info;

    do {
        ret = sensor_drv_load_library(camera_cfg->cfgPtr->sensor_name, libPtr);
            //导入libsensor_gc5035.so，libPtr->sensor_info_ptr = g_gc5035_mipi_raw_info

        sns_module->sensor_info = libPtr->sensor_info_ptr;
        mod_cfg_tab = libPtr->sensor_info_ptr->module_info_tab;
        sns_module->module_id = mod_cfg_tab[0].module_id;
        strcpy(sns_module->sn_name, camera_cfg->cfgPtr->sensor_name);
        
        sensor_cxt->sensor_info_ptr = sns_module->sensor_info;

        ret = sensor_drv_ic_identify(sensor_cxt, sensor_id, 1);

        sensor_drv_unload_library(libPtr);
    } while (0);

    return ret;
}

这个函数主要时导入sensor 库，类似libsensor_gc5035.so，然后验证sensor 的 id 是否真确。

static cmr_int sensor_drv_ic_identify(struct sensor_drv_context *sensor_cxt,
                                      cmr_u32 sensor_id, cmr_u32 identify_off) {
    cmr_int ret = SENSOR_SUCCESS;
    struct module_cfg_info *mod_cfg_info = PNULL;
    struct hw_drv_cfg_param hw_drv_cfg;
    struct sensor_ic_ops *sns_ops = PNULL;

    sns_ops = sensor_cxt->sensor_info_ptr->sns_ops;

    ret = sensor_get_module_cfg_info(sensor_cxt, sensor_id, &mod_cfg_info);
    //选择sensor drv中的一个配置

    ret = sensor_ic_create(sensor_cxt, sensor_id);

    sensor_cxt->i2c_addr = mod_cfg_info->major_i2c_addr;

    do {
        if (sns_ops && sns_ops->identify) {
            //下面是初始化i2c，设置地址，上电，读取id等操作
            hw_drv_cfg.i2c_bus_config = mod_cfg_info->reg_addr_value_bits;
            hw_sensor_drv_cfg(sensor_cxt->hw_drv_handle, &hw_drv_cfg);
            sensor_set_id(sensor_cxt, sensor_id);
            sensor_i2c_init(sensor_cxt, sensor_id);
            SENSOR_LOGI("i2c_addr:0x%x", sensor_cxt->i2c_addr);
            hw_sensor_i2c_set_addr(sensor_cxt->hw_drv_handle,
                                   sensor_cxt->i2c_addr);
            hw_sensor_i2c_set_clk(sensor_cxt->hw_drv_handle);
            sensor_power_on(sensor_cxt, SCI_TRUE);

            ret = sns_ops->identify(sensor_cxt->sns_ic_drv_handle,
                                    SENSOR_ZERO_I2C);
            if (ret) {
                sensor_cxt->has_register = SCI_FALSE;
                if ((sensor_cxt->i2c_addr != mod_cfg_info->minor_i2c_addr) &&
                    mod_cfg_info->minor_i2c_addr != 0x00) {
                    sensor_power_on(sensor_cxt, SCI_FALSE);
                    sensor_cxt->i2c_addr = mod_cfg_info->minor_i2c_addr;
                } else
                    goto exit;
            } else {
                SENSOR_LOGI("sensor ic identify ok");
                sensor_cxt->has_register = SCI_TRUE;
                goto exit;
            }
        } else
            goto exit;
    } while (1);

exit:
    if (identify_off || ret) {
        SENSOR_LOGI("sensor drv ic identify power off");
        if (ret == 0 && identify_off)
            sensor_drv_get_dynamic_info(sensor_cxt);
        //这里是下电的流程
        sensor_power_on(sensor_cxt, SCI_FALSE);
        sensor_i2c_deinit(sensor_cxt, sensor_id);
        sensor_ic_delete(sensor_cxt);
    }
    return ret;
}

这个函数主要是上电和读取id的流程。

static cmr_int
sensor_drv_get_dynamic_info(struct sensor_drv_context *sensor_cxt) {

    sensor_cxt->sensor_type = sensor_drv_get_sensor_type(sensor_cxt);
        //帧数据的类型是raw还是yuv

    sensor_drv_get_fov_info(sensor_cxt);

    //导入otp的库
    sensor_drv_get_module_otp_data(sensor_cxt);
    sensor_cxt->static_info =
        sensor_ic_get_data(sensor_cxt, SENSOR_CMD_GET_STATIC_INFO);
    
    //导入效果库
    sensor_drv_get_tuning_param(sensor_cxt);
    
    //保存对焦的信息
    sensor_save_pdaf_info(sensor_cxt);
    return 0;
}

导入otp、tuning的库

在真个流程里面我们涉及特别多的变量的初始化，导入很多库和资源文件，验证id 后我们又会释放这些，但是很多信息被保存到全局变量中。

2.4、setUpVendorTags()

bool LegacyCameraProviderImpl_2_4::setUpVendorTags() {

    vendor_tag_ops_t vOps = vendor_tag_ops_t();

    mModule->getVendorTagOps(&vOps);
        //void SprdCamera3Factory::get_vendor_tag_ops(vendor_tag_ops_t *ops){
        //ops->get_tag_count = SprdCamera3Setting::get_tag_count;获取个数
        //ops->get_all_tags = SprdCamera3Setting::get_all_tags; 获取tag内容
        //ops->get_section_name = SprdCamera3Setting::get_section_name;tag属于的section
        //ops->get_tag_name = SprdCamera3Setting::get_tag_name;tag的名称
        //ops->get_tag_type = SprdCamera3Setting::get_tag_type;} tag的类型

    // Read all vendor tag definitions into a descriptor
    sp<VendorTagDescriptor> desc;
    status_t res;
    res = VendorTagDescriptor::createDescriptorFromOps(&vOps, /*out*/desc);

    // Set the global descriptor to use with camera metadata
    VendorTagDescriptor::setAsGlobalVendorTagDescriptor(desc);
    const SortedVector<String8>* sectionNames = desc->getAllSectionNames();
    size_t numSections = sectionNames->size();
    std::vector<std::vector<VendorTag>> tagsBySection(numSections);
    int tagCount = desc->getTagCount();
    std::vector<uint32_t> tags(tagCount);
    desc->getTagArray(tags.data());
    for (int i = 0; i < tagCount; i++) {
        VendorTag vt;
        vt.tagId = tags[i];
        vt.tagName = desc->getTagName(tags[i]);
        vt.tagType = (CameraMetadataType) desc->getTagType(tags[i]);
        ssize_t sectionIdx = desc->getSectionIndex(tags[i]);
        tagsBySection[sectionIdx].push_back(vt);
    }
    mVendorTagSections.resize(numSections);
    for (size_t s = 0; s < numSections; s++) {
        mVendorTagSections[s].sectionName = (*sectionNames)[s].string();
        mVendorTagSections[s].tags = tagsBySection[s];
    }
    return true;
}

setUpVendorTags主要是帧的参数相关的变量进行初始化，会同帧一起回传给上层。

2.5、mModule->setCallbacks(this);

int CameraModule::setCallbacks(const camera_module_callbacks_t *callbacks) {
    int res = OK;
    res = mModule->set_callbacks(callbacks);
    return res;
}
int SprdCamera3Factory::set_callbacks(const camera_module_callbacks_t *callbacks) {
    int retval = 0;
    retval = SprdCamera3Flash::registerCallbacks(callbacks);
    return retval;
}
int32_t SprdCamera3Flash::registerCallbacks(const camera_module_callbacks_t *callbacks) {
    int32_t retVal = 0;
    if (!_instance)
        _instance = new SprdCamera3Flash();
    _instance->m_callbacks = callbacks;

    return retVal;
}

这里这个 CameraModule::setCallback 的参数是this 指针，参数类型是 camera_module_callbacks_t 。所以传入的就是上面在实例化 LegacyCameraProviderImpl_2_4 时初始化的父类代码如下。
camera_module_callbacks_t({sCameraDeviceStatusChange, sTorchModeStatusChange}) 

SprdCamera3Flash这个类只能实例化一个对象，给他的m_callbacks赋值。

2.6、mModule->getCameraInfo

idh.code\hardware\interfaces\camera\common\1.0\default\CameraModule.cpp

int CameraModule::getCameraInfo(int cameraId, struct camera_info *info) {
    ssize_t index = mCameraInfoMap.indexOfKey(cameraId);
    if (index == NAME_NOT_FOUND) {
        // Get camera info from raw module and cache it
        camera_info rawInfo, cameraInfo;
        int ret = mModule->get_camera_info(cameraId, &rawInfo);

        CameraMetadata m;
        m.append(rawInfo.static_camera_characteristics);
        deriveCameraCharacteristicsKeys(rawInfo.device_version, m);
        cameraInfo = rawInfo;
        cameraInfo.static_camera_characteristics = m.release();
        index = mCameraInfoMap.add(cameraId, cameraInfo);
    }

    // return the cached camera info
    *info = mCameraInfoMap[index];
    return OK;
}
int SprdCamera3Factory::get_camera_info(int camera_id,
                                        struct camera_info *info) {
        return gSprdCamera3Factory.getCameraInfo(
            multiCameraModeIdToPhyId(camera_id), info);
}
int SprdCamera3Factory::getCameraInfo(int camera_id, struct camera_info *info) {
    int rc;
    //sensor_drv_u中全局变量 phy_sensor_info_list 初始化seting中的成员，这些信息主要是硬件的资源信息
    SprdCamera3Setting::getSensorStaticInfo(camera_id);

    //初始化camera3_default_info.common，类型camera3_common_t，初始化的原始信息都是固化在SprdCamera3Setting结构体中默认初始化好的变量
    SprdCamera3Setting::initDefaultParameters(camera_id);

    //这里面的代码特别多，是一些初始化操作，具体作用不太了解
    rc = SprdCamera3Setting::getStaticMetadata(camera_id, &mStaticMetadata);

    SprdCamera3Setting::getCameraInfo(camera_id, info);

    info->device_version = CAMERA_DEVICE_API_VERSION_3_2;
    info->static_camera_characteristics = mStaticMetadata;
    info->conflicting_devices_length = 0;

    return rc;
}

三、总结

        这一篇主要是生成一个LegacyCameraProviderImpl_2_4 的对象带来的初始化过程，主要功能是，找到camera hal 的库，扫描所有的sensor，对的sensor、tag 相关变量进行初始化。