逆向WiFi驱动板 RISC-V BL602

//  启动时调用以初始化驱动程序并运行事件循环
static void aos_loop_proc(void *pvParameters) {
  //  省略部分: 初始化驱动程序
  ...
  //  为WiFi事件注册回调函数
  aos_register_event_filter(
    EV_WIFI,              //  Event Type
    event_cb_wifi_event,  //  Event Callback Function
    NULL);                //  Event Callback Argument

  //  启动WiFi网络堆栈
  cmd_stack_wifi(NULL, 0, 0, NULL);

  //  运行事件循环
  aos_loop_run();
}

//  启动WiFi网络堆栈
static void cmd_stack_wifi(char *buf, int len, int argc, char **argv) {
  //  Check whether WiFi Networking is already started
  static uint8_t stack_wifi_init  = 0;
  if (1 == stack_wifi_init) { return; }  //  Already started
  stack_wifi_init = 1;

  //  启动WiFi固件任务 (FreeRTOS)
  hal_wifi_start_firmware_task();

  //  发布WiFi事件以启动WiFi管理器任务
  aos_post_event(
    EV_WIFI,                 //  Event Type
    CODE_WIFI_ON_INIT_DONE,  //  Event Code
    0);                      //  Event Argument
}

//  WiFi事件的回调功能
static void event_cb_wifi_event(input_event_t *event, void *private_data) {

  //  处理WiFi事件
  switch (event->code) {

  //  由cmd_stack_wifi发布以启动Wi-Fi管理器任务
    case CODE_WIFI_ON_INIT_DONE:

    //  启动WiFi管理器任务 (FreeRTOS)
      wifi_mgmr_start_background(&conf);
      break;

    //  省略部分: 处理其他WiFi事件

wifi_sta_connect YOUR_WIFI_SSID YOUR_WIFI_PASSWORD

//  连接到WiFi接入点
static void wifi_sta_connect(char *ssid, char *password) {

  //  启用WiFi客户端
  wifi_interface_t wifi_interface
    = wifi_mgmr_sta_enable();

  //  连接到WiFi接入点
  wifi_mgmr_sta_connect(
    wifi_interface,  //  WiFi Interface
    ssid,            //  SSID
    password,        //  Password
    NULL,            //  PMK
    NULL,            //  MAC Address
    0,               //  Band
    0);              //  Frequency
}

httpc

//  使用LWIP发送HTTP GET请求
static void cmd_httpc_test(char *buf, int len, int argc, char **argv) {
  //  检查HTTP请求是否已在运行
  static httpc_connection_t settings;
  static httpc_state_t *req;
  if (req) { return; }  //  请求已在运行

  //  初始化LWIP HTTP设置
  memset(&settings, 0, sizeof(settings));
  settings.use_proxy = 0;
  settings.result_fn = cb_httpc_result;
  settings.headers_done_fn = cb_httpc_headers_done_fn;

  //  使用LWIP发送HTTP GET请求
  httpc_get_file_dns(
    "nf.cr.dandanman.com",  //  Host
    80,                     //  Port
    "/ddm/ContentResource/music/204.mp3",  //  URI
    &settings,              //  Settings
    cb_altcp_recv_fn,       //  Callback Function
    &req,                   //  Callback Argument
    &req);                  //  Request
}

//  连接到WiFi接入点
int wifi_mgmr_sta_connect(wifi_interface_t *wifi_interface, char *ssid, char *psk, char *pmk, uint8_t *mac, uint8_t band, uint16_t freq) {
  //  设置WiFi SSID和PSK
  wifi_mgmr_sta_ssid_set(ssid);
  wifi_mgmr_sta_psk_set(psk);

  //  连接到WiFi接入点
  return wifi_mgmr_api_connect(ssid, psk, pmk, mac, band, freq);
}

//  连接到WiFi接入点
int wifi_mgmr_api_connect(char *ssid, char *psk, char *pmk, uint8_t *mac, uint8_t band, uint16_t freq) {
  //  省略部分: 复制PSK、PMK、MAC地址、频带和频率
  ...
  //  向WiFi管理器任务发送连接请求
  wifi_mgmr_event_notify(msg);
  return 0;
}

//  向WiFi管理器任务发送请求
int wifi_mgmr_event_notify(wifi_mgmr_msg_t *msg) {
  //  省略部分: 等待WiFi管理器启动
  ...
  //  通过消息队列向WiFi管理器发送请求
  if (os_mq_send(
    &(wifiMgmr.mq),  //  Message Queue
    msg,             //  Request Message
    msg->len)) {     //  Message Length
    //  发送请求失败
    return -1;
  }
  return 0;
}

#define os_mq_send(mq, msg, len) \
    (xMessageBufferSend(mq, msg, len, portMAX_DELAY) > 0 ? 0 : 1)

//  当WiFi管理器接收到连接请求时调用
static void stateIdleAction_connect( void *oldStateData, struct event *event, void *newStateData) {
  //  为连接请求设置WiFi配置文件
  wifi_mgmr_msg_t *msg = event->data;
  wifi_mgmr_profile_msg_t *profile_msg = (wifi_mgmr_profile_msg_t*) msg->data;
  profile_msg->ssid_tail[0] = '\0';
  profile_msg->psk_tail[0]  = '\0';

  //  记住WiFi管理器中的WiFi配置文件
  wifi_mgmr_profile_add(&wifiMgmr, profile_msg, -1);

  //  连接到WiFi配置文件。TODO:其他安全支持
  bl_main_connect(
    (const uint8_t *) profile_msg->ssid, profile_msg->ssid_len,
    (const uint8_t *) profile_msg->psk, profile_msg->psk_len,
    (const uint8_t *) profile_msg->pmk, profile_msg->pmk_len,
    (const uint8_t *) profile_msg->mac, (const uint8_t) profile_msg->band, (const uint16_t) profile_msg->freq);
}

//  连接到WiFi配置文件
int bl_main_connect(const uint8_t* ssid, int ssid_len, const uint8_t *psk, int psk_len, const uint8_t *pmk, int pmk_len, const uint8_t *mac, const uint8_t band, const uint16_t freq) {

  //  802.11 WiFi协议的连接参数
  struct cfg80211_connect_params sme;    

  //  省略部分: 设置802.11连接参数
  ...
  //  使用802.11连接参数连接到WiFi网络
  bl_cfg80211_connect(&wifi_hw, &sme);
  return 0;
}

//  使用802.11连接参数连接到WiFi网络
int bl_cfg80211_connect(struct bl_hw *bl_hw, struct cfg80211_connect_params *sme) {

  //  将填充连接结果
  struct sm_connect_cfm sm_connect_cfm;

  //  将连接参数转发到LMAC
  int error = bl_send_sm_connect_req(bl_hw, sme, &sm_connect_cfm);

  //  省略部分: 检查连接结果

//  将连接参数转发到LMAC
int bl_send_sm_connect_req(struct bl_hw *bl_hw, struct cfg80211_connect_params *sme, struct sm_connect_cfm *cfm) {

  //  生成SM_CONNECT_REQ消息
  struct sm_connect_req *req = bl_msg_zalloc(SM_CONNECT_REQ, TASK_SM, DRV_TASK_ID, sizeof(struct sm_connect_req));

  //  省略部分: 设置SM_CONNECT_REQ消息的参数
  ...
  //  向LMAC固件发送SM_CONNECT_REQ消息
  return bl_send_msg(bl_hw, req, 1, SM_CONNECT_CFM, cfm);
}

//  向LMAC固件发送消息的函数，静态定义
static int bl_send_msg(struct bl_hw *bl_hw, const void *msg_params, int reqcfm, lmac_msg_id_t reqid, void *cfm) {
  //  省略：为消息分配缓冲区
  ...
  //  省略：将消息复制到缓冲区 
  ...
  //  将消息添加到LMAC消息队列
  int ret = bl_hw->cmd_mgr.queue(&bl_hw->cmd_mgr, cmd);

//  将消息添加到LMAC消息队列。
//  IPC = Interprocess Communication 进程间通信
int ipc_host_msg_push(struct ipc_host_env_tag *env, void *msg_buf, uint16_t len) {
    //  Get the address of the IPC message buffer in Shared RAM
    uint32_t *src = (uint32_t*) ((struct bl_cmd *) msg_buf)->a2e_msg;
    uint32_t *dst = (uint32_t*) &(env->shared->msg_a2e_buf.msg);

    //  将消息复制到仪表板消息缓冲区
    for (int i = 0; i < len; i += 4) { *dst++ = *src++; }
    env->msga2e_hostid = msg_buf;

    //  触发LMAC中断以将消息发送到EMB
    //  IPC_IRQ_A2E_MSG is 2
    ipc_app2emb_trigger_set(IPC_IRQ_A2E_MSG);

//  触发LMAC中断以将消息发送到EMB
//  IPC_IRQ_A2E_MSG is 2
ipc_app2emb_trigger_set(IPC_IRQ_A2E_MSG);

//  WiFi硬件寄存器基本地址
#define REG_WIFI_REG_BASE          0x44000000

//  IPC硬件寄存器基址
#define IPC_REG_BASE_ADDR          0x00800000

//  APP2EMB_TRIGGER 寄存器定义
//  Bits    Field Name           Reset Value
//  -----   ------------------   -----------
//  31:00   APP2EMB_TRIGGER      0x0
#define IPC_APP2EMB_TRIGGER_ADDR   0x12000000
#define IPC_APP2EMB_TRIGGER_OFFSET 0x00000000
#define IPC_APP2EMB_TRIGGER_INDEX  0x00000000
#define IPC_APP2EMB_TRIGGER_RESET  0x00000000

//  Write to IPC 寄存器
#define REG_IPC_APP_WR(env, INDEX, value) \
  (*(volatile u32 *) ((u8 *) env + IPC_REG_BASE_ADDR + 4*(INDEX)) \
    = value)

//  触发LMAC中断
static inline void ipc_app2emb_trigger_set(u32 value) {
  //  写入地址为0x4480 0000的WiFi IPC寄存器
  REG_IPC_APP_WR(
    REG_WIFI_REG_BASE, 
    IPC_APP2EMB_TRIGGER_INDEX, 
    value);
}

REG_WIFI_REG_BASE + IPC_REG_BASE_ADDR + 4 * IPC_APP2EMB_TRIGGER_INDEX

https://github.com/lupyuen/bl602nutcracker1/blob/main/bl602_demo_wifi.c#L38512-L38609

bl602_demo_wifi.c#L38512-L38609

//  启动WiFi固件任务 (FreeRTOS)
int hal_wifi_start_firmware_task(void) {
  //  WiFi固件任务的堆栈空间
  static StackType_t wifi_fw_stack[WIFI_STACK_SIZE];

  //  WiFi固件任务的任务句柄
  static StaticTask_t wifi_fw_task;

  //  创建FreeRTOS后台任务
  xTaskCreateStatic(
    wifi_main,         //  即将运行的任务函数
    (char *) "fw",     //  任务名 
    WIFI_STACK_SIZE,   //  任务堆栈大小
    NULL,              //  任务参数
    TASK_PRIORITY_FW,  //  任务优先级
    wifi_fw_stack,     //  任务堆栈
    &wifi_fw_task);    //  任务句柄
  return 0;
}

//  WiFi固件任务将永远运行
void wifi_main(void *param) {
  ...
  //  初始化LMAC和UMAC
  rfc_init(40000000);
  mpif_clk_init();
  sysctrl_init();
  intc_init();
  ipc_emb_init();
  bl_init();
  ...
  //  循环永远处理WiFi内核事件
  do {
    ...
    //  等等 
    if (ke_env.evt_field == 0) { ipc_emb_wait(); }
    ...
    //  安排WiFi内核事件并进行处理
    ke_evt_schedule();

    //  休息一下
    iVar1 = bl_sleep();

    coex_wifi_pta_forece_enable((uint) (iVar1 == 0));
  } while( true );
}

//  安排WiFi内核事件并进行处理
void ke_evt_schedule(void) {
  int iVar1;
  evt_ptr_t *peVar2;

  while (ke_env.evt_field != 0) {
    iVar1 = __clzsi2(ke_env.evt_field);
    peVar2 = ke_evt_hdlr[iVar1].func;
    if ((0x1a < iVar1) || (peVar2 == (evt_ptr_t *)0x0)) {
      assert_err("(event < KE_EVT_MAX) && ke_evt_hdlr[event].func","module",0xdd);
    }
    (*peVar2)(ke_evt_hdlr[iVar1].param);
  }
  //  这一行可能被错误地反编译了
  gp = (code *)((int)SFlash_Cache_Hit_Count_Get + 6);
  return;
}

//  事件调度程序入口点。必须在后台循环中调用此原语，才能执行所设置事件的事件处理程序。
void ke_evt_schedule(void) {
  uint32_t field, event;
  field = ke_env.evt_field;
  while (field) { // 假定编译器使用循环反转进行优化

    // 查找优先级最高的事件集
    event = co_clz(field);

    // 过滤检查
    ASSERT_ERR((event < KE_EVT_MAX) && ke_evt_hdlr[event].func);

    // 执行相应的处理程序
    (ke_evt_hdlr[event].func)(ke_evt_hdlr[event].param);

    // 更新volatile值
    field = ke_env.evt_field;
  }
}

(event < KE_EVT_MAX) && ke_evt_hdlr[event].func

//  ke_evt_schedule调用的事件处理程序
static const struct ke_evt_tag ke_evt_hdlr[32] = {
  {&rwnxl_reset_evt,    0},      // [KE_EVT_RESET]        
  {&ke_timer_schedule,  0},      // [KE_EVT_KE_TIMER]   
  {&txl_payload_handle, AC_VO},  // [KE_EVT_IPC_EMB_TXDESC_AC3]

  //  此事件处理程序看起来很有意思                                                   
  {&txl_payload_handle, AC_VI},  // [KE_EVT_IPC_EMB_TXDESC_AC2]
  {&txl_payload_handle, AC_BE},  // [KE_EVT_IPC_EMB_TXDESC_AC1]
  {&txl_payload_handle, AC_BK},  // [KE_EVT_IPC_EMB_TXDESC_AC0]        

  {&ke_task_schedule,   0},      // [KE_EVT_KE_MESSAGE]
  {&mm_hw_idle_evt,     0},      // [KE_EVT_HW_IDLE]
  ...

//  对已从主机内存传输的有效负载执行操作。该原语由中断控制器ISR调用。如果需要，它执行LLC翻译和MIC计算。
//  LLC = 逻辑链路控制, MIC = Message Integrity Code消息完整性代码
void txl_payload_handle(int access_category);

//  处理传输有效载荷
void txl_payload_handle(void) {
  while ((_DAT_44a00024 & 0x1f) != 0) {
    int iVar1 = __clzsi2(_DAT_44a00024 & 0x1f);

    //  写入0x44A0 0020的WiFi寄存器
    _DAT_44a00020 = 1 << (0x1fU - iVar1 & 0x1f);
  }
}

//  另一个传输有效负载处理程序。
//可能与txl_payload_handle的工作方式相同
//在BL602而不是LMAC固件上运行。
void txl_payload_handle_backup(void) {
  ...
  //  Iterate through a list of packet buffers (?)
  while (ptVar4 = ptVar10->list[0].first, ptVar4 == (txl_buffer_tag *)0x0) {
LAB_230059f6:
    uVar3 = uVar3 + 1;
    ptVar10 = (txl_buffer_env_tag *)&ptVar10->buf_idx[0].free_size;
    ptVar11 = (txl_cntrl_env_tag *)(ptVar11->txlist + 1);
  }

//  循环 (until when?)
  do {
    //  调用一些RXU、TXL和TXU函数
    rxu_cntrl_monitor_pm((mac_addr *)&ptVar4[1].lenheader);
    ...
    txl_machdr_format((uint32_t)(ptVar4 + 1));
    ...
    txu_cntrl_tkip_mic_append(txdesc,(uint8_t)uVar2);

//  写入WiFi寄存器
    _DAT_44b08180 = 0x800;
    _DAT_44b081a4 = ptVar9;
    ...
    _DAT_44b08180 = 0x1000;
    _DAT_44b081a8 = ptVar9;
    ...
    _DAT_44b08180 = 0x100;
    _DAT_44b08198 = ptVar9;

//  断言检查
    line = 0x23c;
    condition = "blmac_tx_ac_2_state_getf() != 2";
    ...
    line = 0x236;
    condition = "blmac_tx_ac_3_state_getf() != 2";
    ...
    line = 0x22f;
    condition = "blmac_tx_bcn_state_getf() != 2";
    ...
    line = 0x242;
    condition = "blmac_tx_ac_1_state_getf() != 2";
    ...
    line = 0x248;
    condition = "blmac_tx_ac_0_state_getf() != 2";
    ...
    assert_rec(condition, "module", line);

//  设置计时器
    blmac_abs_timer_set(uVar6, (uint32_t)(puVar8 + _DAT_44b00120));

    //  继续循环
  } while( true );
}

Copyright (C) RivieraWaves 2011-2016

//  来自BL602反编译代码：初始化物理层
void phy_init(phy_cfg_tag *config) {
  mdm_reset();
  ...
  mdm_txcbwmax_setf((byte)(_DAT_44c00000 >> 0x18) & 3);
  _Var2 = phy_vht_supported();
  agc_config();
  ...
  // 初始发射机速率功率控制
  trpc_init();

  // 初始物理自适应功能
  pa_init();

  phy_tcal_reset();
  phy_tcal_start();
}

//  从GitHub搜索： Init Physical Layer //初始化物理层:
void phy_init(const struct phy_cfg_tag *config) {
  const struct phy_bl602_cfg_tag *cfg = (const struct phy_bl602_cfg_tag *)&config->parameters;
  phy_hw_init(cfg);
  phy_env->cfg               = *cfg;
  phy_env->band              = PHY_BAND_2G4;
  phy_env->chnl_type         = PHY_CHNL_BW_OTHER;
  phy_env->chnl_prim20_freq  = PHY_UNUSED;
  phy_env->chnl_center1_freq = PHY_UNUSED;
  phy_env->chnl_center2_freq = PHY_UNUSED;

  // 初始化传输速率控制
  trpc_init();

  // 初始物理自适应功能
  pa_init();
}

# Extract the function names (and line numbers)
# from the decompiled firmware. The line must
# begin with an underscore or a letter,
# without indentation.
grep --line-number \
    "^[_a-zA-Z]" \
    bl602_demo_wifi.c \
    | grep -v LAB_ \
    >bl602_demo_wifi.txt