add: airlink,补充实现wakeupPin唤醒wifi休眠的功能

components/airlink/binding/luat_lib_airlink.c

@@ -34,6 +34,7 @@ extern airlink_statistic_t g_airlink_statistic;
 extern uint32_t g_airlink_spi_task_mode;
 extern uint32_t g_airlink_pause;
 extern luat_airlink_dev_info_t g_airlink_ext_dev_info;
+extern luat_airlink_irq_ctx_t g_airlink_wakeup_irq_ctx;
 
 /*
 初始化AirLink
@@ -422,6 +423,10 @@ airlink.pause(1)
 */
 static int l_airlink_pause(lua_State *L) {
     g_airlink_pause = luaL_checkinteger(L, 1);
+    // 配置过wakeup pin，并且airlink恢复运行时，就触发一次中断唤醒
+    if (g_airlink_wakeup_irq_ctx.master_pin != 0 && !g_airlink_pause) {
+        g_airlink_wakeup_irq_ctx.enable = 1;
+    }
     return 0;
 }
 

components/airlink/include/luat_airlink.h

@@ -293,9 +293,11 @@ typedef struct luat_airlink_irq_ctx
     int master_pin;
     int slave_pin;
     int slave_ready;
+    int irq_mode;
 }luat_airlink_irq_ctx_t;
 
 int luat_airlink_irqmode(luat_airlink_irq_ctx_t *ctx);
+int luat_airlink_wakeup_irqmode(luat_airlink_irq_ctx_t *ctx);
 
 int luat_airlink_has_wifi(void);
 

components/airlink/include/luat_airlink_drv_pm.h

@@ -7,5 +7,6 @@
 
 int luat_airlink_drv_pm_request(int mode);
 int luat_airlink_drv_pm_power_ctrl(int id, uint8_t val);
+int luat_airlink_drv_pm_wakeup_pin(int pin, int val);
 
 #endif

components/airlink/src/driver/luat_airlink_drv_pm.c

@@ -50,3 +50,21 @@ int luat_airlink_drv_pm_power_ctrl(int id, uint8_t val) {
     luat_airlink_queue_send(LUAT_AIRLINK_QUEUE_CMD, &item);
     return 0;
 }
+
+int luat_airlink_drv_pm_wakeup_pin(int pin, int val) {
+    uint64_t luat_airlink_next_cmd_id = luat_airlink_get_next_cmd_id();
+    airlink_queue_item_t item = {
+        .len = 5 + sizeof(luat_airlink_cmd_t) + 8
+    };
+    luat_airlink_cmd_t* cmd = luat_airlink_cmd_new(0x602, 5 + 8) ;
+    if (cmd == NULL) {
+        return -101;
+    }
+
+    memcpy(cmd->data, &luat_airlink_next_cmd_id, 8);
+    memcpy(cmd->data + 8, &pin, 4);
+    memcpy(cmd->data + 8 + 4, &val, 1);
+    item.cmd = cmd;
+    luat_airlink_queue_send(LUAT_AIRLINK_QUEUE_CMD, &item);
+    return 0;
+}

components/airlink/src/exec/luat_airlink_cmd_exec_pm.c

@@ -31,3 +31,12 @@ int luat_airlink_cmd_exec_pm_power_ctrl(luat_airlink_cmd_t* cmd, void* userdata)
     luat_pm_power_ctrl(id, onoff);
     return 0;
 }
+
+int luat_airlink_cmd_exec_pm_wakeup_pin(luat_airlink_cmd_t* cmd, void* userdata) {
+    uint32_t pin = 0;
+    memcpy(&pin, cmd->data + 8, 4);
+    uint8_t val = cmd->data[8 + 4];
+    LLOGD("收到pm_wakeup_pin指令!!! pin %d val %d", pin, val);
+    luat_pm_wakeup_pin(pin, val);
+    return 0;
+}

components/airlink/src/luat_airlink_cmds.c

@@ -76,6 +76,7 @@ CMD_DEFINE(bt_resp_cb);
 // PM指令, 0x600开始
 CMD_DEFINE(pm_request);
 CMD_DEFINE(pm_power_ctrl);
+CMD_DEFINE(pm_wakeup_pin);
 
 // PWM指令, 0x700开始
 CMD_DEFINE(pwm_setup);
@@ -149,6 +150,7 @@ __USER_FUNC_IN_RAM__ const luat_airlink_cmd_reg_t airlink_cmds[] = {
 #ifdef LUAT_USE_AIRLINK_EXEC_PM
     CMD_REG(0x600, pm_request),
     CMD_REG(0x601, pm_power_ctrl),
+    CMD_REG(0x602, pm_wakeup_pin),
 #endif
 
 #ifdef LUAT_USE_AIRLINK_EXEC_PWM

components/airlink/src/task/luat_airlink_spi_master_task.c

@@ -47,8 +47,10 @@ static uint32_t is_waiting_queue = 0;
 static luat_rtos_queue_t evt_queue;
 
 extern luat_airlink_irq_ctx_t g_airlink_irq_ctx;
+extern luat_airlink_irq_ctx_t g_airlink_wakeup_irq_ctx;
 
 luat_airlink_irq_ctx_t g_airlink_irq_ctx;
+luat_airlink_irq_ctx_t g_airlink_wakeup_irq_ctx;
 
 __USER_FUNC_IN_RAM__ static int slave_irq_cb(void *data, void *args)
 {
@@ -67,6 +69,14 @@ __USER_FUNC_IN_RAM__ static int slave_irq_cb(void *data, void *args)
     return 0;
 }
 
+__USER_FUNC_IN_RAM__ static int wakeup_irq_cb(void *data, void *args)
+{
+    // g_airlink_wakeup_irq_ctx.enable = 0;
+    LLOGI("触发唤醒wifi wakeup_irq_cb");
+    return 0;
+}
+
+
 __USER_FUNC_IN_RAM__ static void on_newdata_notify(void)
 {
     luat_event_t evt = {.id = 3};
@@ -234,6 +244,25 @@ __USER_FUNC_IN_RAM__ void airlink_wait_and_prepare_data(uint8_t *txbuff)
             luat_rtos_task_sleep(1000);
         }
     }
+    if (g_airlink_wakeup_irq_ctx.enable)
+    {
+        luat_gpio_cfg_t gpio_cfg = {0};
+        luat_gpio_set_default_cfg(&gpio_cfg);
+        int pin = g_airlink_wakeup_irq_ctx.master_pin;
+        int val = g_airlink_wakeup_irq_ctx.irq_mode == Luat_GPIO_FALLING ? 1 : 0;
+        gpio_cfg.pin = pin;
+        gpio_cfg.mode = LUAT_GPIO_OUTPUT;
+        gpio_cfg.pull = g_airlink_wakeup_irq_ctx.irq_mode == Luat_GPIO_FALLING ? LUAT_GPIO_PULLUP : LUAT_GPIO_PULLDOWN;
+        gpio_cfg.output_level = val;
+        luat_gpio_open(&gpio_cfg);
+        LLOGI("g_airlink_wakeup_irq_ctx %p, state %d, slave_pin %d", g_airlink_wakeup_irq_ctx, g_airlink_wakeup_irq_ctx.enable, g_airlink_wakeup_irq_ctx.slave_pin);
+        luat_gpio_set(pin, val);
+        luat_rtos_task_sleep(120);
+        luat_gpio_set(pin, !val);
+        luat_rtos_task_sleep(120);
+        luat_gpio_set(pin, val);
+        g_airlink_wakeup_irq_ctx.enable = 0;
+    }
     // 等到消息
     // LLOGD("link irq %d cmd %d ip %d", s_link.flags.irq_ready, s_link.flags.queue_cmd, s_link.flags.queue_ip);
     if (s_link.flags.irq_ready) {
@@ -354,3 +383,23 @@ int luat_airlink_irqmode(luat_airlink_irq_ctx_t *ctx) {
     }
     return 0;
 }
+
+int luat_airlink_wakeup_irqmode(luat_airlink_irq_ctx_t *ctx) {
+    if (!ctx) {
+        return -1;
+    }
+    luat_gpio_cfg_t gpio_cfg = {0};
+    ctx->slave_ready = 0;
+    memcpy(&g_airlink_wakeup_irq_ctx, ctx, sizeof(luat_airlink_irq_ctx_t));
+    if (ctx->enable) {
+        luat_gpio_set_default_cfg(&gpio_cfg);
+        gpio_cfg.pin = ctx->master_pin;
+        gpio_cfg.mode = LUAT_GPIO_IRQ;
+        gpio_cfg.irq_type = ctx->irq_mode;
+        gpio_cfg.pull = ctx->irq_mode == Luat_GPIO_FALLING ? LUAT_GPIO_PULLUP : LUAT_GPIO_PULLDOWN;
+        gpio_cfg.irq_cb = wakeup_irq_cb;
+        luat_gpio_open(&gpio_cfg);
+        LLOGD("WAKEUP中断模式(GPIO%d)开启,等待slave就绪", ctx->master_pin);
+    }
+    return 0;
+}

components/drv/include/luat/drv_pm.h

@@ -6,5 +6,6 @@
 
 int luat_drv_pm_request(int chip, int mode);
 int luat_drv_pm_power_ctrl(int chip, int id, uint8_t val);
+int luat_drv_pm_wakeup_pin(int chip, int pin, int val);
 
 #endif

components/drv/src/luat_drv_pm.c

@@ -29,3 +29,13 @@ int luat_drv_pm_power_ctrl(int chip, int id, uint8_t val) {
         return luat_airlink_drv_pm_power_ctrl(id, val);
     }
 }
+
+int luat_drv_pm_wakeup_pin(int chip, int pin, int val) {
+    if (chip == 0) {
+        return luat_pm_wakeup_pin(pin, val);
+    }
+    else {
+        pin -= 128;
+        return luat_airlink_drv_pm_wakeup_pin(pin, val);
+    }
+}

luat/modules/luat_lib_pm.c

@@ -58,7 +58,11 @@ pm.request(pm.IDLE) -- 通过切换不同的值请求进入不同的休眠模式
 #include "luat_log.h"
 
 #ifdef LUAT_USE_DRV_PM
+#include "luat_airlink.h"
 #include "luat/drv_pm.h"
+
+luat_airlink_irq_ctx_t ctx = {0};
+extern uint32_t g_airlink_pause;
 #endif
 
 // static int lua_event_cb = 0;
@@ -106,6 +110,9 @@ static int l_pm_request(lua_State *L) {
     int chip = 0;
     if (lua_isinteger(L, 2)) {
         chip = luaL_checkinteger(L, 2);
+        if (chip > 0) {
+            g_airlink_pause = 1;    // wifi进入休眠自动暂停airlink工作
+        }
     }
     ret = luat_drv_pm_request(chip, mode);
     #else
@@ -419,7 +426,31 @@ static int l_pm_wakeup_pin(lua_State *L) {
 			lua_pop(L, 1);
 		}
     }else if(lua_isnumber(L, 1)){
+        #ifdef LUAT_USE_DRV_PM
+        int chip = 0;
+        if (lua_isinteger(L, 3)) {
+            chip = luaL_checkinteger(L, 3);
+        }
+        int pin = luaL_checkinteger(L, 1);
+        if (lua_isinteger(L, 4) && lua_isinteger(L, 5)) {
+            ctx.enable = luaL_checkinteger(L, 5);
+            if (ctx.enable) {
+                ctx.master_pin = luaL_checkinteger(L, 4);
+                ctx.slave_pin = pin;
+                ctx.irq_mode = level;
+            }
+            else {
+                ctx.master_pin = 0;
+                ctx.slave_pin = 0;
+                ctx.irq_mode = 0;
+            }
+            luat_airlink_wakeup_irqmode(&ctx);
+        }
+
+        luat_drv_pm_wakeup_pin(chip, pin, level);
+        #else
         luat_pm_wakeup_pin(luaL_checkinteger(L, 1), level);
+        #endif
     }
     lua_pushboolean(L, 1);
     return 1;