Android WiFi 源码分析(三):驱动加载 — QCOM 与 MTK 怎么把芯片叫醒?

// qcacld-3.0/core/hdd/src/wlan_hdd_main.cstatic int hdd_module_init(void){    if (hdd_driver_load())        return -EINVAL;    return 0;}

// qcacld-3.0/core/hdd/src/wlan_hdd_main.c:18333// 精简重组版：按逻辑步骤编号，实际调用顺序和错误处理更复杂，完整版见源码inthdd_driver_load(void){    // 1. 初始化 QDF（QCOM Driver Framework）基础设施    //    QDF 提供内存分配、链表、定时器、work queue、spinlock 等封装    //    这是 qcacld-3.0 自己的「标准库」，所有其他模块都依赖它    status = hdd_qdf_init();    if (status)        goto exit;    // 2. 初始化 OS 接口同步机制    //    osif_sync 是 QCOM 驱动的并发控制核心——它保证关键操作    //    （如 probe/remove/SSR）不会被并发执行    osif_sync_init();  // void 函数，无错误检查    status = osif_driver_sync_create_and_trans(&driver_sync);  // 创建驱动同步对象    if (status)        goto sync_deinit;    // 3. 分配 CDS 上下文，注册调试回调，初始化 trace 系统    //    CDS（Converged Data Services）是所有子系统的调度中枢    status = hdd_init();    if (status)        goto trans_stop;    // 4. 初始化组件回调机制    //    每个 UMAC 组件（scan、regulatory、MLME、crypto 等）在此时注册回调    status = hdd_component_cb_init();    if (status)        goto hdd_deinit;    status = hdd_component_init();    if (status)        goto comp_cb_deinit;    // 5. 创建 wakelock，防止系统在初始化过程中进入深度睡眠    qdf_wake_lock_create(&wlan_wake_lock, "wlan");    // 6. 连接参数初始化    hdd_set_conparam(con_mode);    // 7. 初始化平台驱动层（PLD）    //    分配 pld_context，建立与 cnss2/icnss2 的通信桥梁    status = pld_init();    if (status)        goto wakelock_destroy;    // 8. 向平台层传递驱动模式    pld_set_mode(con_mode);    // 9. 向平台层注册 WLAN 驱动（含重试逻辑）    status = hdd_register_driver_retry();    if (status)        goto pld_deinit;    // 10. 创建 /sys/kernel/wlan state_control 节点    wlan_hdd_state_ctrl_param_create();    // ...省略...    return 0;    // 错误回滚（反向顺序）unregister_driver:    wlan_hdd_unregister_driver();pld_deinit:    pld_deinit();wakelock_destroy:    qdf_wake_lock_destroy(&wlan_wake_lock);comp_deinit:    hdd_component_deinit();comp_cb_deinit:    hdd_component_cb_deinit();    // ...省略...}

// qcacld-3.0/core/pld/src/pld_common.cintpld_register_driver(struct pld_driver_ops *ops){    // 保存驱动操作回调（probe / remove / suspend / resume / idle_shutdown / reinit）    pld_ctx->ops = ops;    // 向所有支持的总线类型注册    // 实际走哪条总线由设备树和硬件决定，但驱动一次性全部注册    status = pld_pcie_register_driver();           // PCIe（独立 WiFi 芯片）    if (status) goto pcie_fail;    status = pld_snoc_register_driver();           // SNOC（集成 WiFi，如 WCN6750）    if (status) goto snoc_fail;    status = pld_sdio_register_driver();           // SDIO    if (status) goto sdio_fail;    status = pld_snoc_fw_sim_register_driver();    // SNOC FW 仿真    if (status) goto snoc_fw_sim_fail;    status = pld_pcie_fw_sim_register_driver();    // PCIe FW 仿真    if (status) goto pcie_fw_sim_fail;    status = pld_usb_register_driver();            // USB    if (status) goto usb_fail;    status = pld_ipci_register_driver();           // IPCI（模拟/测试）    if (status) goto ipci_fail;    return 0;    // 级联回滚：哪个注册失败了，就把之前成功注册的逐个注销    // ...省略...}

// platform/cnss2/pci.c:8819-8976// 精简说明：仅展示阶段 B 的核心步骤，阶段 A/C 和错误回滚见上方流程图staticintcnss_pci_probe(struct pci_dev *pci_dev,                          const struct pci_device_id *id){    // ... 阶段 A：上电、SMMU、SSR 注册（见流程图）...    // ===== 阶段 B：总线和通道建立 =====    // 使能 PCI 总线（BAR 空间、DMA mask、bus mastering）    ret = cnss_pci_enable_bus(pci_priv);    if (ret) goto dereg_pci_event;    // 使能 MSI 中断（比传统 INTx 更多向量、更低延迟）    ret = cnss_pci_enable_msi(pci_priv);    if (ret) goto disable_bus;    // 注册 MHI —— Host-Firmware 的双向通信协议    // MHI 定义了 channel 概念：channel 0 = WMI 命令，channel 1 = WMI 事件    ret = cnss_pci_register_mhi(pci_priv);    if (ret) goto disable_msi;    // ===== 阶段 C：设备特定配置 =====    switch (pci_dev->device) {    case QCA6174_DEVICE_ID:        pci_read_config_word(pci_dev, QCA6174_REV_ID_OFFSET,                             &pci_priv->revision_id);        break;    case QCA6290_DEVICE_ID ... FIG_DEVICE_ID:        // WLAON/timer/wake_gpio 初始化（QCA6490/KIWI/MANGO 等共享）        cnss_pci_set_wlaon_pwr_ctrl(pci_priv, false, false, false);        timer_setup(&pci_priv->dev_rddm_timer, cnss_dev_rddm_timeout_hdlr, 0);        cnss_pci_wake_gpio_init(pci_priv);        break;    default:        ret = -ENODEV;        goto unreg_mhi;    }    cnss_pci_config_regs(pci_priv);    set_bit(CNSS_PCI_PROBE_DONE, &plat_priv->driver_state);    return 0;    // 错误回滚（反向顺序）unreg_mhi:     cnss_pci_unregister_mhi(pci_priv);disable_msi:   cnss_pci_disable_msi(pci_priv);disable_bus:   cnss_pci_disable_bus(pci_priv);dereg_pci_event: cnss_dereg_pci_event(pci_priv);    // ... 更多回滚标签 ...}

// platform/cnss2/pci.c:9060-9101staticintcnss_pci_enumerate(struct cnss_plat_data *plat_priv,                              u32 rc_num){    int ret, retry = 0;    // 1. QCA6490：设置最大链路速度为 Gen2 (5.0 GT/s)    //    原因：QCA6490 在 Gen3 速度下可能出现链路不稳定（:9069-9074）    if (plat_priv->device_id == QCA6490_DEVICE_ID) {        ret = cnss_pci_set_max_link_speed(plat_priv->bus_priv, rc_num,                                          PCI_EXP_LNKSTA_CLS_5_0GB);        if (ret && ret != -EPROBE_DEFER)            cnss_pr_err("Failed to set max PCIe RC%x link speed to Gen2, err = %d\n",                        rc_num, ret);    } else {        // 2. 其他设备：降级 RC 速度（:9076）        cnss_pci_downgrade_rc_speed(plat_priv, rc_num);    }    // 3. 使能 PCIe RC 并触发链路训练（:9080-9094）    //    使用 goto retry 模式而非 for 循环retry:    ret = _cnss_pci_enumerate(plat_priv, rc_num);    if (ret) {        if (ret == -EPROBE_DEFER) {            // RC 驱动未就绪，向上返回让 probe 延迟            cnss_pr_dbg("PCIe RC driver is not ready, defer probe\n");            goto out;        }        cnss_pr_err("Failed to enable PCIe RC%x, err = %d\n", rc_num, ret);        if (retry++ < LINK_TRAINING_RETRY_MAX_TIMES) {            cnss_pr_dbg("Retry PCI link training #%d\n", retry);            goto retry;        }    }    plat_priv->rc_num = rc_num;out:    return ret;}

// qcacld-3.0/core/hdd/src/wlan_hdd_driver_ops.cstatic int __hdd_soc_probe(struct device *dev, void *bdev,                           const struct hif_bus_id *bid,                           enum qdf_bus_type bus_type){    // 1. 获取加载锁，防止并发 probe    hdd_soc_load_lock();    // 2. 标记 load 进行中，重置不良状态标志    cds_set_load_in_progress(true);    cds_set_driver_in_bad_state(false);    cds_set_recovery_in_progress(false);    // 3. 初始化 QDF 上下文（设备、总线、驱动句柄）    status = hdd_init_qdf_ctx(dev, bdev, bid, bus_type);    // 4. 初始化 DMA mask（32位或64位取决于芯片能力）    status = hdd_init_dma_mask(dev);    // 5. 创建 HDD 上下文（分配 wiphy、解析 INI、创建 psoc 对象）    hdd_ctx = hdd_context_create(dev);    // 6. 数据通路预分配初始化    ucfg_dp_prealloc_init(hdd_ctx);    // 7. 【核心】启动 WLAN 子系统    status = hdd_wlan_startup(hdd_ctx);    // 8. 创建虚拟设备（vdev）    status = hdd_psoc_create_vdevs(hdd_ctx);    // 9. 标记驱动已加载，通知等待者（必须在 thermal 注册之前）    probe_fail_cnt = 0;                            // 重置连续失败计数    cds_set_driver_loaded(true);    cds_set_load_in_progress(false);               // 清除加载中标志    // 10. 注册 thermal mitigation 回调    hdd_thermal_mitigation_register(hdd_ctx, dev);    hdd_soc_load_unlock();    return 0;    // 错误回滚wlan_exit:    wlan_exit(hdd_ctx);hdd_context_destroy:    hdd_context_destroy(hdd_ctx);    // ...省略...}

// qcacld-3.0/core/hdd/src/wlan_hdd_main.cstruct hdd_context *hdd_context_create(struct device *dev){    struct hdd_context *hdd_ctx;    struct wiphy *wiphy;    // 1. 向 cfg80211 注册，分配 wiphy    //    wiphy 是 cfg80211 框架的核心数据结构，内核用它表示一个无线物理设备    //    它的能力字段（支持的频段、带宽、加密方式、接口类型）来自 INI 文件    wiphy = hdd_cfg80211_wiphy_alloc(&hdd_wiphy_ops,                                      sizeof(struct hdd_context));    if (!wiphy)        goto err;    hdd_ctx = wiphy_priv(wiphy);    hdd_ctx->wiphy = wiphy;    // 2. 创建 psoc 空闲超时 work（用于自动关闭不活动的芯片）    qdf_create_work(0, &hdd_ctx->psoc_idle_timeout_work,                    hdd_psoc_idle_timeout_handler, hdd_ctx);    // 3. 初始化 PM notifier（电源管理通知链）    hdd_pm_qos_notify_init(hdd_ctx);    // 4. 从 WLAN_INI_FILE 解析配置文件    //    这是数百个参数的 INI 文件，控制整个驱动的运行时行为    //    例如：gEnableFwSelfRecovery、gMaxVdevCount、gCountryCodePriority 等    hdd_ctx->config = cfg_parse(WLAN_INI_FILE);    if (!hdd_ctx->config)        goto wiphy_free;    // 5. 创建 psoc 对象（wlan_objmgr 层次化对象模型的根节点）    status = hdd_objmgr_create_and_store_psoc(hdd_ctx, &psoc_id);    if (status)        goto config_free;    // 6. 初始化配置参数    hdd_cfg_params_init(hdd_ctx);    // 7. 应用 INI 覆盖（通过 /sys/kernel/wlan 接口覆盖的参数）    hdd_override_ini_config(hdd_ctx);    // 8. 初始化上下文（workqueue、netlink 服务、trace levels 等）    status = hdd_context_init(hdd_ctx);    if (status)        goto psoc_destroy;    // 9. 初始化 netlink 服务（用于用户空间与驱动通信）    //    在 EPPING 模式下跳过    hdd_init_netlink_services(hdd_ctx);    // 10. 初始化 SAR（Specific Absorption Rate）timer    hdd_init_sar_timers(hdd_ctx);    return hdd_ctx;psoc_destroy:    hdd_objmgr_release_and_destroy_psoc(hdd_ctx);config_free:    cfg_free(hdd_ctx->config);wiphy_free:    wiphy_free(wiphy);    // ...省略...}

// qcacld-3.0/core/hdd/src/wlan_hdd_main.c// 精简说明：省略了 IPA 配置、NAN/SR 回调注册等非核心步骤inthdd_wlan_start_modules(struct hdd_context *hdd_ctx, bool reinit){    int status;    switch (hdd_ctx->driver_status) {    case DRIVER_MODULES_UNINITIALIZED: // fall through    case DRIVER_MODULES_CLOSED: break;    default: QDF_DEBUG_PANIC("Unknown driver state:%d", hdd_ctx->driver_status);             return -EINVAL;    }    // ===== 阶段 A：电源和硬件通道 =====    if (!reinit) {        status = pld_power_on(hdd_ctx->pld_context);        if (status) goto release_lock;    }    status = hdd_hif_open(hdd_ctx->parent_dev, HIF_ENABLE_TYPE_PROBE);    ol_cds_init(hdd_ctx->qdf_dev, hdd_ctx, NULL);  // BMI 初始化    // ===== 阶段 B：子系统打开 =====    // CDS 内部按依赖顺序：WMA open → SME open → PE open    // 每个子系统的 open 回调中注册 WMI 事件处理器    status = cds_open(hdd_ctx->cds_context, hdd_ctx->psoc);    status = cds_dp_open(hdd_ctx->cds_context);    // ===== 阶段 C：注册和使能 =====    status = hdd_register_cb(hdd_ctx);    hdd_register_notifiers(hdd_ctx);    status = cds_pre_enable(hdd_ctx->cds_context);    status = hdd_configure_cds(hdd_ctx);    // 完成 WMI 握手 + 配置运行时参数    hdd_enable_power_management(hdd_ctx);    hdd_ctx->driver_status = DRIVER_MODULES_ENABLED;    return 0;    // 错误回滚（反向顺序）deconfigure_cds: /* ... */ ;release_lock:    return status;}

// qca-wifi-host-cmn/target_if/init_deinit/src/init_event_handler.cQDF_STATUS init_deinit_register_tgt_psoc_ev_handlers(    struct wlan_objmgr_psoc *psoc){    // 实际源码为两步调用，此处简化为宏：    // tgt_hdl = wlan_psoc_get_tgt_if_handle(psoc);    // wmi_handle = (wmi_unified_t)target_psoc_get_wmi_hdl(tgt_hdl);    wmi_handle = GET_WMI_HDL_FROM_PSOC(psoc);    // 注册 5 个核心 WMI 事件处理器，每个对应一种握手阶段    wmi_unified_register_event_handler(        wmi_handle, wmi_service_ready_event_id,        init_deinit_service_ready_event_handler,        WMI_RX_WORK_CTX);    wmi_unified_register_event_handler(        wmi_handle, wmi_service_ready_ext_event_id,        init_deinit_service_ext_ready_event_handler,        WMI_RX_WORK_CTX);    wmi_unified_register_event_handler(        wmi_handle, wmi_service_available_event_id,        init_deinit_service_available_handler,        WMI_RX_UMAC_CTX);  // 注意：此 handler 使用 UMAC 上下文，非 WORK 上下文    wmi_unified_register_event_handler(        wmi_handle, wmi_ready_event_id,        init_deinit_ready_event_handler,        WMI_RX_WORK_CTX);    wmi_unified_register_event_handler(        wmi_handle, wmi_service_ready_ext2_event_id,        init_deinit_service_ext2_ready_event_handler,        WMI_RX_WORK_CTX);    return QDF_STATUS_SUCCESS;}

// platform/cnss2/qmi.cintcnss_wlfw_bdf_dnld_send_sync(struct cnss_plat_data *plat_priv){    struct qmi_txn txn;    void *bdf_data;    u32 bdf_size;    int ret;    // 1. 获取 BDF 文件名    //    根据芯片型号和板级信息确定文件名    //    例如：bdwlan.bin → bdwlan.e05 → bdwlan.b090    //    支持文件名回退机制（fallback chain）    cnss_get_bdf_file_name(plat_priv, &bdf_name);    // 2. 读取 BDF 文件内容    //    对于 REGDB 类型的 BDF：使用 cnss_request_firmware_direct()    //    对于其他类型：使用 cnss_request_firmware_update_timer()    //       └── firmware_request_nowarm() → 标准 Linux firmware API    //       └── 同时启动 fw_boot_timer（CNSS_TIMEOUT_FW_LOAD ms）    ret = cnss_request_firmware_update_timer(fw_entry, ...);    bdf_data = fw_entry->data;    bdf_size = fw_entry->size;    // 3. 【核心】通过 QMI 分段传输 BDF 数据    //    每个 segment 不超过 QMI_WLFW_MAX_DATA_SIZE_V01 字节    offset = 0;    while (offset < bdf_size) {        seg_size = min(bdf_size - offset,                       QMI_WLFW_MAX_DATA_SIZE_V01);        // 构造 QMI 请求消息        req.bdf_total_size = bdf_size;        req.bdf_seg_offset = offset;        req.bdf_seg_size = seg_size;        memcpy(req.bdf_seg_data, bdf_data + offset, seg_size);        // 发送 QMI_WLFW_BDF_DOWNLOAD_REQ_V01 消息（三步 QMI 调用）        ret = qmi_txn_init(&qmi_hdl, &txn,            QMI_WLFW_BDF_DOWNLOAD_RESP_V01, NULL);        ret = qmi_send_request(&qmi_hdl, &txn,            QMI_WLFW_BDF_DOWNLOAD_REQ_V01,            &req, sizeof(req));        ret = qmi_txn_wait(&txn, QMI_WLFW_TIMEOUT_JF);  // JF = Jiffies timeout        if (resp.resp.result != QMI_RESULT_SUCCESS)            return -EIO;        offset += seg_size;    }    // 4. BDF 下载完成后处理    //    HW_XPA 配置、CalDB 配置、Radio OFF 配置    if (resp.host_bdf_data_valid)        cnss_process_host_bdf_data(plat_priv, resp.host_bdf_data);    return 0;}

// qca-wifi-host-cmn/umac/cmn_services/obj_mgr/src/wlan_objmgr_psoc_obj.cstruct wlan_objmgr_psoc *wlan_objmgr_psoc_obj_create(    uint32_t phy_version, WLAN_DEV_TYPE dev_type){    uint8_t id;    struct wlan_objmgr_psoc *psoc = NULL;    wlan_objmgr_psoc_create_handler handler;    wlan_objmgr_psoc_status_handler stat_handler;    QDF_STATUS obj_status;    void *arg;    // 分配并初始化 psoc 对象    psoc = qdf_mem_malloc(sizeof(*psoc));    if (!psoc)        return NULL;    psoc->obj_state = WLAN_OBJ_STATE_ALLOCATED;    qdf_spinlock_create(&psoc->psoc_lock);    // 初始化默认参数：pdev_count = 0, vdev_count = 0, peer_count = 0    // max_vdev_count, max_peer_count 从 INI 配置读取    // 【核心】两阶段创建模型：    //   阶段 1：遍历所有 UMAC 组件，将每个 handler 的返回值存入 psoc->obj_status[id]    //   阶段 2：通过 wlan_objmgr_psoc_object_status() 遍历 obj_status[] 做聚合判断    for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) {        handler = g_umac_glb_obj->psoc_create_handler[id];        arg = g_umac_glb_obj->psoc_create_handler_arg[id];        if (handler)            psoc->obj_status[id] = handler(psoc, arg);        else            psoc->obj_status[id] = QDF_STATUS_COMP_DISABLED;    }    // 阶段 2：聚合所有组件的 obj_status[]，推导最终对象状态    //   - 任一组件 QDF_STATUS_E_NOMEM/E_FAILURE → 整体失败    //   - 任一组件 QDF_STATUS_COMP_ASYNC 且私有对象尚未 attach → PARTIALLY_CREATED    //   - 全部 QDF_STATUS_SUCCESS 或 COMP_DISABLED → 创建成功    obj_status = wlan_objmgr_psoc_object_status(psoc);    if (obj_status == QDF_STATUS_SUCCESS) {        // 所有组件同步创建成功        psoc->obj_state = WLAN_OBJ_STATE_CREATED;        for (id = 0; id < WLAN_UMAC_MAX_COMPONENTS; id++) {            stat_handler = g_umac_glb_obj->psoc_status_handler[id];            arg = g_umac_glb_obj->psoc_status_handler_arg[id];            if (stat_handler)                stat_handler(psoc, arg, QDF_STATUS_SUCCESS);        }    } else if (obj_status == QDF_STATUS_COMP_ASYNC) {        // 部分组件需要异步完成（如等待固件响应）        psoc->obj_state = WLAN_OBJ_STATE_PARTIALLY_CREATED;    } else if (obj_status == QDF_STATUS_E_FAILURE) {        // 任一组件失败 → 整个 psoc 创建失败，触发清理        obj_mgr_err("PSOC component objects allocation failed");        wlan_objmgr_psoc_obj_delete(psoc);        return NULL;    }    // 将 psoc 挂入全局对象列表    if (wlan_objmgr_psoc_object_attach(psoc) != QDF_STATUS_SUCCESS) {        wlan_objmgr_psoc_obj_delete(psoc);        return NULL;    }    return psoc;}

// platform/icnss2/main.cstaticinticnss_probe(struct platform_device *pdev){    struct icnss_priv *priv;    const struct of_device_id *match;    // 1. 通过设备树匹配设备    match = of_match_device(icnss_dt_match, &pdev->dev);    // 2. 分配 icnss_priv    priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);    // 3. 初始化 regulators、clocks、GPIO 列表    INIT_LIST_HEAD(&priv->vreg_list);    INIT_LIST_HEAD(&priv->clk_list);    // 4. 预分配内存池（集成 WiFi 需要从系统内存中 carve out 一块给固件）    icnss_initialize_mem_pool(priv->device_id);    // 5. 解析设备树资源：regulators、clocks、interrupts、memory regions    icnss_resource_parse(priv);    // 6. 解析 MSA（Memory System Architecture）配置    icnss_msa_dt_parse(priv);    // 7. 解析 SMMU 配置    icnss_smmu_dt_parse(priv);    // 8. 注册 bus scaling（动态调整总线带宽）    icnss_register_bus_scale(priv);    // 9. 创建 event workqueue    priv->event_wq = alloc_workqueue("icnss_driver_event", WQ_UNBOUND, 1);    // 10. 【关键】注册 QMI firmware service    //     集成 WiFi 通过 QMI 协议与 FW 通信（不用 MHI）    icnss_register_fw_service(priv);    // 11. 设备特定初始化（使用 if 条件链，非 switch）    if (priv->device_id == WCN6750_DEVICE_ID ||        priv->device_id == WCN7750_DEVICE_ID ||        priv->device_id == WCN6450_DEVICE_ID) {        // SoC wake workqueue、genl 初始化、runtime PM、AOP 接口        // 设置 ICNSS_COLD_BOOT_CAL、bdf_download_support = true    }    if (priv->device_id == WCN7750_DEVICE_ID) {        // WPSS 支持（Wireless Processor SubSystem）        // DMS init、WPSS load work init    }    return 0;    // 级联回滚out_unregister_fw_service:    icnss_unregister_fw_service(priv);    // ...省略...}

&wifi {    firmware-name = "wcn6750/WCNSS_qcom_wlan_nv.bin";};

reserved-memory {    wlan_msa_mem: wlan_msa_region {        compatible = "removed-dma-pool";        no-map;        reg = <0x0 0x8e400000 0x0 0x400000>;  // 4MB carve-out    };};

// kernel_modules-connectivity-conninfra/conn_drv/connv2/src/connv2_drv.cintconnv2_drv_init(void){    int ret;    // 1. 探测 conninfra 平台设备（解析设备树）    ret = platform_driver_probe(&mtk_conninfra_dev_drv,                                mtk_conninfra_probe);    // 2. 轮询等待硬件初始化完成    //    conninfra probe 可能是异步的（设备树节点依赖 clock 初始化完成）    //    这里用轮询等待而不是同步阻塞，避免死锁    //    g_connv2_hw_init_done 是 atomic_t 类型    while (!atomic_read(&g_connv2_hw_init_done)) {        osal_sleep_ms(50);    }    // 3. 初始化 conninfra 核心    //    support_drv 是一个位掩码，表示哪些子驱动（WiFi/BT/FM/GPS）被当前硬件支持    conninfra_core_init(consys_hw_get_support_drv());    // 4. 向 adaptor 层注册    //    adaptor 层是 conninfra 对上层子系统暴露的统一接口    conn_adaptor_register_drv_gen(        CONN_ADAPTOR_DRV_GEN_CONNAC_2, &g_connv2_drv_gen);    return 0;}

// kernel_modules-connectivity-wlan-core-gen4m/os/linux/gl_init.cstaticintinitWlan(void){    // 1. 检查启动模式（KPOC = 关机充电模式，跳过 WiFi 初始化）    //    仅在 CFG_MTK_ANDROID_WMT 模式下生效    #if CFG_MTK_ANDROID_WMT    if (wlanGetBootMode() == KERNEL_POWER_OFF_CHARGING_BOOT)        return -1;    #endif    // 2. 注册 reset-KO 模块（如果支持芯片复位）    resetko_register_module(RESET_MODULE_TYPE_WIFI, "wifi", ...);    // 3. 初始化调试基础设施（log level、debug filter）    wlanDebugInit();    // 4. 预分配 IO 缓冲区（避免运行时动态分配导致的延迟）    kalInitIOBuffer();    // 5. 注册 netdev notifier（监听网络设备状态变更）    wlanRegisterNetdevNotifier();    // 6. 初始化 procfs / sysfs 节点    procInitFs();    sysInitFs();    // 7. 创建无线设备（分配 GLUE_INFO、wireless_dev）    wlanCreateWirelessDevice();    // 8. P2P 无线设备创建    glP2pCreateWirelessDevice();    // 9. 【关键】向总线层注册 probe/remove 回调    glRegisterBus(wlanProbe, wlanRemove);    // 10. 【关键】如果使用非 WMT 模式（编译期宏 CFG_MTK_ANDROID_WMT == 0），    //     立即给总线上电，触发 PCIe 设备枚举，进而触发 wlanProbe    #if (!CFG_MTK_ANDROID_WMT)        glBusFuncOn();    #endif    // 11. 初始化芯片复位基础设施    glResetInit();    // 12. 注册各种 notifier（framebuffer、battery、IDC 等）    kalFbNotifierReg(prGlueInfo);    kalBatNotifierReg(prGlueInfo);    // ...省略...    return 0;}

// kernel_modules-connectivity-wlan-core-gen4m/os/linux/hif/pcie/pcie.cstaticintmtk_pci_probe(struct pci_dev *pdev,                         const struct pci_device_id *id){    int ret, i;    // 1. 使能 PCI 设备    ret = pcim_enable_device(pdev);    // 2. 映射 PCI BAR 空间（循环尝试 BAR0-BAR5，找到第一个可用的）    for (i = 0; i <= PCI_STD_RESOURCE_END; i++) {        ret = pcim_iomap_regions(pdev, BIT(i), pci_name(pdev));        if (ret == 0)            break;    }    // 3. 使能 bus mastering（芯片才能发起 DMA）    pci_set_master(pdev);    // 4. 分配 MSI 中断向量    //    u4MaxMsiNum 通常是 4 或 8    ret = pci_alloc_irq_vectors(pdev, 1, u4MaxMsiNum,                                PCI_IRQ_MSI);    // 5. 保存 CSR 基地址（从成功的 BAR 映射得到，i 是上面循环找到的 BAR 号）    prChipInfo->CSRBaseAddress = pcim_iomap_table(pdev) ?        pcim_iomap_table(pdev)[i] : NULL;    // 6. 配置 DMA mask（从芯片信息中读取位宽）    dma_set_mask(&pdev->dev, DMA_BIT_MASK(prChipInfo->bus_info->u4DmaMask));    // 7. 【核心】调用 wlanProbe    ret = pfWlanProbe((void *)pdev, (void *)id->driver_data);    // 8. 配置 ASPM（Active State Power Management）    //    L1/L1.1/L1.2 模式在 probe 成功后才使能    //    （受 CFG_CONTROL_ASPM_BY_FW + CFG_SUPPORT_PCIE_ASPM 条件编译保护）    glBusConfigASPM(pdev, DISABLE_ASPM_L1);    glBusConfigASPML1SS(pdev, PCI_L1PM_CTR1_ASPM_L12_EN | PCI_L1PM_CTR1_ASPM_L11_EN);    glBusConfigASPM(pdev, ENABLE_ASPM_L1);    // 9. 标记驱动已 probe    g_fgDriverProbed = TRUE;    return 0;    // 错误处理out_irq_free:    pci_free_irq_vectors(pdev);    // ...省略...}

// os/linux/gl_init.c// 精简说明：省略了部分错误检查和参数传递细节static int32_t wlanProbe(void *pvData, void *pvDriverData){    enum ENUM_PROBE_FAIL_REASON eFailReason = FAIL_REASON_NUM;    #if CFG_CHIP_RESET_SUPPORT    if (fgSimplifyResetFlow) return wlanOnAtReset();  // 复位路径    #endif    do {        if (!glBusInit(pvData))                    { eFailReason = BUS_INIT_FAIL; break; }        if (!wlanNetCreate(pvData, pvDriverData))  { eFailReason = NET_CREATE_FAIL; break; }        if (prChipInfo->fw_dl_ops->mcu_init(prAdapter))                                                   { eFailReason = ROM_DL_FAIL; break; }        glTxRxInit(prGlueInfo);        if (!glBusSetIrq(prGlueInfo, pvData, ...)) { eFailReason = BUS_SET_IRQ_FAIL; break; }        wlanOnPreAdapterStart(prGlueInfo, prAdapter, &prRegInfo, prChipInfo);        // 【核心】固件下载 + FW Ready 轮询 + NIC 能力查询        if (wlanAdapterStart(prAdapter, prRegInfo, FALSE) != WLAN_STATUS_SUCCESS)            i4Status = -EIO;        wlanOnPostAdapterStart(prAdapter, prGlueInfo);  // 无论成功与否都执行（trace-only stub）        if (i4Status < 0) { eFailReason = ADAPTER_START_FAIL; break; }        if (wlanOnPreNetRegister(prGlueInfo, prAdapter, prChipInfo, prWifiVar, FALSE))                                                   { eFailReason = NET_REGISTER_FAIL; break; }        i4DevIdx = wlanNetRegister(prWdev);        if (i4DevIdx < 0)                          { eFailReason = NET_REGISTER_FAIL; break; }        wlanOnPostNetRegister();                   // early suspend/inet notifier        procCreateFsEntry(); sysCreateFsEntry();        wlanOnWhenProbeSuccess(prGlueInfo, prAdapter, FALSE);        return 0;  // 成功    } while (FALSE);    // 级联错误回滚：switch (eFailReason) 按失败类型执行不同清理    return -1;}

// common/wlan_lib.c// 精简说明：省略了部分参数检查和非核心初始化，完整版约 200 行uint32_t wlanAdapterStart(struct ADAPTER *prAdapter,                          struct REG_INFO *prRegInfo,                          const u_int8_t bAtResetFlow){    // ===== 阶段 A：内存和硬件控制 =====    if (!bAtResetFlow) {        if (nicAllocateAdapterMemory(prAdapter))            return ALLOC_ADAPTER_MEM_FAIL;    }    // 获取驱动对硬件的控制权（防止 conninfra 自动休眠）    prAdapter->fgIsWiFiOnDrvOwn = TRUE;    ACQUIRE_POWER_CONTROL_FROM_PM(prAdapter);  // void 宏，失败通过 fgIsFwOwn 检查    prAdapter->fgIsWiFiOnDrvOwn = FALSE;    if (prAdapter->fgIsFwOwn == TRUE)        return DRIVER_OWN_FAIL;    if (!bAtResetFlow && nicInitializeAdapter(prAdapter))        return INIT_ADAPTER_FAIL;    wlanWakeUpWiFi(prAdapter);    halHifSwInfoInit(prAdapter);    // ===== 阶段 B-D：固件下载 =====    HAL_ENABLE_FWDL(prAdapter, TRUE);       // 使能 HIF cut-through 模式    wlanSetChipEcoInfo(prAdapter);    nicDisableInterrupt(prAdapter);          // 下载期间用轮询    nicTxInitResetResource(prAdapter);    if (wlanDownloadFW(prAdapter)) {         // N9 → CR4 → DSP 顺序下载        nicEnableInterrupt(prAdapter);        return RAM_CODE_DOWNLOAD_FAIL;    }    // ===== 阶段 D：等待固件就绪 =====    if (wlanCheckWifiFunc(prAdapter, TRUE)) {  // 轮询 Ready 位        nicEnableInterrupt(prAdapter);        return WAIT_FIRMWARE_READY_FAIL;    }    // ===== 阶段 E-F：固件就绪后初始化 =====    prAdapter->fgIsFwDownloaded = TRUE;    wlanQueryNicCapability(prAdapter);         // 查询芯片能力    wlanQueryNicCapabilityV2(prAdapter);    wlanUpdateNicResourceInformation(prAdapter);    wlanUpdateNetworkAddress(prAdapter);        // 设置 MAC 地址    nicApplyNetworkAddress(prAdapter);    if (bAtResetFlow)        wlanLoadManufactureData(prAdapter, prRegInfo);    else        wlanOnPostFirmwareReady(prAdapter, prRegInfo);    nicEnableInterrupt(prAdapter);             // 恢复中断模式    nicSerInit(prAdapter, bAtResetFlow);       // SER 模块初始化    thrmInit(prAdapter);                       // thermal 保护    RECLAIM_POWER_CONTROL_TO_PM(prAdapter);    // 释放控制权给 conninfra    return WLAN_STATUS_SUCCESS;}

// chips/common/fw_dl.cuint32_t wlanDownloadFW(struct ADAPTER *prAdapter){    struct FWDL_OPS_T *prFwDlOps = prAdapter->chip_info->fw_dl_ops;    // 1. 使能固件下载模式    HAL_ENABLE_FWDL(prAdapter, TRUE);    // 2. 下载 ROM 补丁（Patch）    //    ROM code 可能在出厂后有 bug 被发现，ROM patch 用于    //    在引导阶段修复这些 bug（等效于 ROM code 的热修复）    if (prFwDlOps->downloadPatch) {        ret = prFwDlOps->downloadPatch(prAdapter);        if (ret) goto error;    }    // 3. 下载 ZB 补丁（Zero-Backoff，WiFi Direct 相关）    if (prFwDlOps->downloadZbPatch) {        ret = prFwDlOps->downloadZbPatch(prAdapter);    }    // 4. 下载 BT 补丁（如果芯片支持蓝牙共存）    if (prFwDlOps->downloadBtPatch) {        ret = prFwDlOps->downloadBtPatch(prAdapter);    }    // 5. 同步时间到固件（第二个参数 TRUE 表示初始化命令）    kalSyncTimeToFW(prAdapter, TRUE);    // 6. 查询 PMIC 信息    prChipInfo->queryPmicInfo(prAdapter);    // 7. PHY 动作（射频校准前准备）    if (prFwDlOps->phyAction) {        ret = prFwDlOps->phyAction(prAdapter);    }    // 8. 下载 N9 主固件（WiFi MCU firmware）    ret = prFwDlOps->downloadFirmware(prAdapter, IMG_DL_IDX_N9_FW);    if (ret) goto error;    // 9. 下载 CR4 协处理器固件（如果芯片支持 CR4 或 WACPU）    if (prChipInfo->is_support_cr4 || prChipInfo->is_support_wacpu) {        if (prFwDlOps->downloadFirmware) {            ret = prFwDlOps->downloadFirmware(                prAdapter, IMG_DL_IDX_CR4_FW);            if (ret) goto error;        }    }    // 10. 下载 DSP 固件（如果是 WiFi 音频相关的芯片）    if (prFwDlOps->downloadDspFw) {        ret = prFwDlOps->downloadDspFw(prAdapter);    }    // 11. 关闭固件下载模式    HAL_ENABLE_FWDL(prAdapter, FALSE);    return WLAN_STATUS_SUCCESS;error:    HAL_ENABLE_FWDL(prAdapter, FALSE);    return WLAN_STATUS_FAILURE;}

// common/wlan_lib.cuint32_t wlanCheckWifiFunc(struct ADAPTER *prAdapter,                           u_int8_t fgRdyChk){    uint32_t u4LoopCount = 0;    OS_TIME_T rStartTime;    uint32_t u4ReadyFlag = 0;    // 记录开始时间    rStartTime = kalGetTimeTick();  // 宏，展开为 jiffies_to_msecs(jiffies)，无参数    while (TRUE) {        // 通过芯片特定的宏读取硬件 Ready 寄存器        // 例如：读取 WF_TOP_CFG_ON 寄存器中对应的 Ready 位        HAL_WIFI_FUNC_READY_CHECK(prAdapter,                                  prAdapter->chip_info->sw_ready_bits,                                  &u4ReadyFlag);        // Ready 位集合检查通过        if (u4ReadyFlag) {            DBGLOG(INIT, INFO,                   "Ready bit asserted, loop=%u\n", u4LoopCount);            return WLAN_STATUS_SUCCESS;        }        // 检查中断状态变化中的卡移除/总线访问错误        if (kalIsCardRemoved(prAdapter->prGlueInfo) == TRUE ||            fgIsBusAccessFailed == TRUE) {            return WLAN_STATUS_FAILURE;        }        // 超时检查        if (CHECK_FOR_TIMEOUT(rStartTime,                              CFG_RESPONSE_POLLING_TIMEOUT,                              CFG_RESPONSE_POLLING_DELAY)) {            // 读取当前状态，帮助 debug            HAL_WIFI_FUNC_GET_STATUS(prAdapter);            DBGLOG(INIT, ERROR, "Ready bit timeout\n");            // 触发复位            GL_DEFAULT_RESET_TRIGGER(prAdapter, RST_CHECK_READY_BIT_TIMEOUT);            return WLAN_STATUS_FAILURE;        }        // 如果循环次数超过 5 次，发送 AEE 警告        // AEE = Android Exception Engine，MTK 的错误报告系统        if (u4LoopCount > 5) {            kalSendAeeWarning("WFSYS",                             "wlanCheckWifiFunc fail\n");        }        u4LoopCount++;        kalMsleep(CFG_RESPONSE_POLLING_DELAY);  // 通常是 10ms    }}

// os/linux/hif/sdio/sdio.cuint32_t glBusInit(void *pvData){    struct sdio_func *func = (struct sdio_func *)pvData;    // 1. Claim SDIO host（获取 SDIO 控制器的独占使用权）    sdio_claim_host(func);    // 2. 设置块大小为 512 字节    sdio_set_block_size(func, 512);    // 4. 配置 I/O 超时（防止芯片不响应导致 Host 挂起）    //    SDIO 是同步总线，如果芯片不响应，Host 会永远等待    //    超时保护是必需的    // 5. 释放 SDIO host    sdio_release_host(func);    return TRUE;}

cnss: Failed to enable PCIe RC%x, err = %dcnss: PCIe RC driver is not ready, defer probe

cnss: Failed to get BDF fileDirect firmware load for <fw_name> failed with error -2

RAM_CODE_DOWNLOAD_FAIL

target_if_err: Version mismatch with FWtarget_if_err: Failed to extract ready eventwlan_init_status != 0```text**日志关键字**（MTK）：```textReady bit timeoutkalSendAeeWarning: wlanCheckWifiFunc failWAIT_FIRMWARE_READY_FAIL

cds_open() 返回错误hdd_configure_cds() 返回错误```text**日志关键字**（MTK）：```textADAPTER_START_FAILNET_REGISTER_FAILBUS_SET_IRQ_FAIL

cds_set_recovery_in_progress(true)SSR_MAX_FAIL_CNT exceededQDF_BUG()

// qcacld-3.0/core/hdd/src/wlan_hdd_driver_ops.c// ===== 阶段一：关闭 =====static void __hdd_soc_recovery_shutdown(void){    // 1. 通知所有子系统进入 recovery 状态    //    注意：hdd_psoc_shutdown_notify() 在 hdd_soc_recovery_cleanup() 内部调用    //    （清理 scan queue、IPA pipe shutdown、shutdown notifier call/purge）    hdd_soc_recovery_cleanup();    // 2. 等待 debugfs 线程退出（避免访问被释放的内存）    hdd_wait_for_debugfs_threads_completion();    // 3. 屏蔽 HIF 中断——防止旧数据触发 ISR    hif_mask_interrupt_call(hif_ctx);    // 4. 禁用 ISR（中断服务例程）    hif_disable_isr(hif_ctx);    // 5. HDD 全量关闭（释放所有子系统资源）    //    逆向执行 cds_open 的反操作：cds_disable → cds_close → hif_close    hdd_wlan_shutdown();}// ===== 阶段二：重新初始化 =====// 由 cnss2 在硬件复位完成后回调// 重新走一遍类似 __hdd_soc_probe 的流程，但跳过部分步骤：//  - 不重新分配内存（复用之前分配的结构体）//  - 不重新注册 wiphy（cfg80211 不知道芯片重启了）//  - 不重新创建 sysfs/procfs 节点//  - 恢复 saved state：dual STA 配置、SAR 限制、scan IE 等

// qcacld-3.0/core/hdd/src/wlan_hdd_power.c// SSR 恢复后的状态重建hdd_restore_dual_sta_config();    // 恢复双 STA 策略hdd_restore_sar_config();         // 恢复 SAR（比吸收率）限制hdd_restore_dbam_config();        // 恢复 DBAM（动态带宽分配）hdd_send_default_scan_ies();      // 重新下发默认扫描 IEhdd_ssr_restart_sap();            // 如果之前有 SAP 接口，重启之hdd_handle_cached_commands();     // 处理恢复期间被缓存的命令

// chips/common/cmm_asic_connac3x.c// 精简说明：去除了与 SSR 无关的 SW_INT_FW_LOG（固件日志）和// SW_INT_SW_WFDMA（WFDMA 软件事件）分支，仅保留复位相关逻辑。// 调用链：内核 IRQ → pcie_sw_int_top_handler（上半部）//       → pcie_sw_int_thread_handler（下半部，threaded IRQ）//       → asicConnac3xSwIntHandler（处理 FW log、子系统复位、整芯片复位）u_int8_t asicConnac3xSwIntHandler(struct ADAPTER *prAdapter){    uint32_t u4Status;    // 1. 读取 SW 中断状态寄存器    prChipInfo->get_sw_interrupt_status(prAdapter, &u4Status);    // 2. 根据中断类型分支（FW_LOG/WFDMA 等无关分支省略）    if (u4Status & SW_INT_SUBSYS_RESET) {        // WFSYS 子系统复位        // 仅重置 WiFi 子系统，BT 继续工作        // conninfra 确保复位时序正确（先摘 WiFi 电源，等 BT 完成当前操作，再恢复）        handle_wfsys_reset(prAdapter);    }    if (u4Status & SW_INT_WHOLE_RESET) {        // 整芯片复位（WiFi + BT）        // 只有在 WiFi 和 BT 同时出问题时才走这条路        // 先 dump bus hang control registers（帮助 debug）        dbg_ops->dumpBusHangCr(prAdapter);        // 如果配置了强制完整 coredump        if (CFG_WIFI_FORCE_FULL_COREDUMP) {            kalSetRstEvent(FALSE);  // 保留 coredump 内存        } else {            kalSetRstEvent(TRUE);        }        handle_whole_chip_reset(prAdapter);        //   └── conninfra_trigger_whole_chip_rst(CONNDRV_TYPE_WIFI, reason)        //       └── conninfra_core_lock_rst() → 获取复位锁        //       └── conninfra_core_trg_chip_rst() → 执行硬件复位        //       └── 复位顺序：WiFi 电源摘除 → BT 电源摘除 → 等待 → 反向恢复    }    return TRUE;}