diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/LICENSE b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/LICENSE
new file mode 100755
index 0000000..1b15bd2
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/LICENSE
@@ -0,0 +1,31 @@
+opyright Statement:
+
+This software/firmware and related documentation ("MobileTek Software") are
+protected under relevant copyright laws. The information contained herein is
+confidential and proprietary to MobileTek Inc. and/or its licensors. Without
+the prior written permission of MobileTek inc. and/or its licensors, any
+reproduction, modification, use or disclosure of MobileTek Software, and
+information contained herein, in whole or in part, shall be strictly
+prohibited.
+
+MobileTek Inc. (C) 2015. All rights reserved.
+
+BY OPENING THIS FILE, RECEIVER HEREBY UNEQUIVOCALLY ACKNOWLEDGES AND AGREES
+THAT THE SOFTWARE/FIRMWARE AND ITS DOCUMENTATIONS ("MobileTek SOFTWARE")
+RECEIVED FROM MobileTek AND/OR ITS REPRESENTATIVES ARE PROVIDED TO RECEIVER
+ON AN "AS-IS" BASIS ONLY. MobileTek EXPRESSLY DISCLAIMS ANY AND ALL
+WARRANTIES, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE IMPLIED
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE OR
+NONINFRINGEMENT. NEITHER DOES MobileTek PROVIDE ANY WARRANTY WHATSOEVER WITH
+RESPECT TO THE SOFTWARE OF ANY THIRD PARTY WHICH MAY BE USED BY,
+INCORPORATED IN, OR SUPPLIED WITH THE MobileTek SOFTWARE, AND RECEIVER AGREES
+TO LOOK ONLY TO SUCH THIRD PARTY FOR ANY WARRANTY CLAIM RELATING THERETO.
+RECEIVER EXPRESSLY ACKNOWLEDGES THAT IT IS RECEIVER'S SOLE RESPONSIBILITY TO
+OBTAIN FROM ANY THIRD PARTY ALL PROPER LICENSES CONTAINED IN MobileTek
+SOFTWARE. MobileTek SHALL ALSO NOT BE RESPONSIBLE FOR ANY MobileTek SOFTWARE
+RELEASES MADE TO RECEIVER'S SPECIFICATION OR TO CONFORM TO A PARTICULAR
+STANDARD OR OPEN FORUM. RECEIVER'S SOLE AND EXCLUSIVE REMEDY AND MobileTek'S
+ENTIRE AND CUMULATIVE LIABILITY WITH RESPECT TO THE MobileTek SOFTWARE
+RELEASED HEREUNDER WILL BE, AT MobileTek'S OPTION, TO REVISE OR REPLACE THE
+MobileTek SOFTWARE AT ISSUE, OR REFUND ANY SOFTWARE LICENSE FEES OR SERVICE
+CHARGE PAID BY RECEIVER TO MobileTek FOR SUCH MobileTek SOFTWARE AT ISSUE.
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.c b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.c
new file mode 100755
index 0000000..ff653f6
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.c
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "AUTOSUSPEND"
+
+#include <stdbool.h>
+
+#include <log/log.h>
+#include <liblog/lynq_deflog.h>
+
+#include "autosuspend.h"
+
+#include "autosuspend_ops.h"
+
+static struct autosuspend_ops *autosuspend_ops;
+static bool autosuspend_enabled;
+static bool autosuspend_inited;
+
+static int autosuspend_init(void)
+{
+    if (autosuspend_inited) {
+        return 0;
+    }
+
+    autosuspend_ops = autosuspend_wakeup_count_init();
+    if (autosuspend_ops) {
+        goto out;
+    }
+
+    if (!autosuspend_ops) {
+        ALOGI("failed to initialize autosuspend\n");
+        return -1;
+    }
+
+out:
+    autosuspend_inited = true;
+
+    ALOGI("autosuspend initialized\n");
+    return 0;
+}
+
+int autosuspend_enable(void)
+{
+    int ret;
+
+    ret = autosuspend_init();
+    if (ret) {
+        return ret;
+    }
+
+    ALOGI("autosuspend_enable\n");
+
+    if (autosuspend_enabled) {
+        return 0;
+    }
+
+    ret = autosuspend_ops->enable();
+    if (ret) {
+        return ret;
+    }
+
+    autosuspend_enabled = true;
+    return 0;
+}
+
+int autosuspend_disable(void)
+{
+    int ret;
+
+    ret = autosuspend_init();
+    if (ret) {
+        return ret;
+    }
+
+    ALOGI("autosuspend_disable\n");
+
+    if (!autosuspend_enabled) {
+        return 0;
+    }
+
+    ret = autosuspend_ops->disable();
+    if (ret) {
+        return ret;
+    }
+
+    autosuspend_enabled = false;
+    return 0;
+}
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.h b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.h
new file mode 100755
index 0000000..59188a8
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.h
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _LIBSUSPEND_AUTOSUSPEND_H_
+#define _LIBSUSPEND_AUTOSUSPEND_H_
+
+#include <sys/cdefs.h>
+#include <stdbool.h>
+
+__BEGIN_DECLS
+
+/*
+ * autosuspend_enable
+ *
+ * Turn on autosuspend in the kernel, allowing it to enter suspend if no
+ * wakelocks/wakeup_sources are held.
+ *
+ *
+ *
+ * Returns 0 on success, -1 if autosuspend was not enabled.
+ */
+int autosuspend_enable(void);
+
+/*
+ * autosuspend_disable
+ *
+ * Turn off autosuspend in the kernel, preventing suspend and synchronizing
+ * with any in-progress resume.
+ *
+ * Returns 0 on success, -1 if autosuspend was not disabled.
+ */
+int autosuspend_disable(void);
+
+/*
+ * set_wakeup_callback
+ *
+ * Set a function to be called each time the device returns from suspend.
+ * success is true if the suspend was sucessful and false if the suspend
+ * aborted due to some reason.
+ */
+void set_wakeup_callback(void (*func)(bool success));
+
+__END_DECLS
+
+#endif
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.service b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.service
new file mode 100755
index 0000000..3cbb46c
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend.service
@@ -0,0 +1,10 @@
+[Unit]
+Description=lynq-autosuspend-service
+
+[Service]
+ExecStart=/usr/bin/autosuspend
+Type=simple
+
+[Install]
+WantedBy=multi-user.target
+
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend_ops.h b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend_ops.h
new file mode 100755
index 0000000..698e25b
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend_ops.h
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef _LIBSUSPEND_AUTOSUSPEND_OPS_H_
+#define _LIBSUSPEND_AUTOSUSPEND_OPS_H_
+
+struct autosuspend_ops {
+    int (*enable)(void);
+    int (*disable)(void);
+};
+
+struct autosuspend_ops *autosuspend_autosleep_init(void);
+struct autosuspend_ops *autosuspend_earlysuspend_init(void);
+struct autosuspend_ops *autosuspend_wakeup_count_init(void);
+
+#endif
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend_wakeup_count.c b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend_wakeup_count.c
new file mode 100755
index 0000000..85fbc84
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/autosuspend_wakeup_count.c
@@ -0,0 +1,560 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "AUTOSUSPEND"
+//#define LOG_NDEBUG 0
+
+#include <errno.h>
+#include <fcntl.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <stddef.h>
+#include <stdbool.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <sys/time.h>
+
+#include <unistd.h>
+#include <dlfcn.h>
+//#include <cutils/properties.h>
+#define USER_LOG_TAG "PMS"
+#include <liblog/lynq_deflog.h>
+#include <log/log.h>
+#include <stdlib.h>
+#include "autosuspend_ops.h"
+
+#ifdef MOBILETEK_SUSPEND_CFG
+#define SYS_POWER_STATE "/sys/power/state"
+#endif
+
+#ifdef MOBILETEK_TARGET_PLATFORM_T106
+#define SYS_POWER_STATE "/sys/power/autosleep"
+#endif
+#define SYS_POWER_WAKEUP_COUNT "/sys/power/wakeup_count"
+#define SYS_POWER_SPM_SUSPEND_CRTL "/sys/power/spm/suspend_ctrl"
+
+#define BASE_SLEEP_TIME 100000
+#define POSSIBLE_MAX_SLEEP_TIME 60000000
+
+static int state_fd;
+static int wakeup_count_fd;
+static int suspend_ctrl_fd;
+static pthread_t suspend_thread;
+static sem_t suspend_lockout;
+extern pthread_cond_t feedback_cond;
+extern pthread_mutex_t feedback_mutex;
+extern pthread_mutex_t time_info_mutex;
+static const char *sleep_state = "mem";
+#ifdef MOBILETEK_SUSPEND_CFG
+static const char *reg_netsys[5] = {"reg_netsys_srcclkena_mask_b 0",
+                                    "reg_netsys_infra_req_mask_b 0",
+                                    "reg_netsys_apsrc_req_mask_b 0",
+                                    "reg_netsys_vrf18_req_mask_b 0",
+                                    "reg_netsys_ddr_en_mask_b 0"};
+#endif
+static void (*wakeup_func)(bool success) = NULL;
+static int sleep_time = BASE_SLEEP_TIME;
+static int possible_max_sleep_time = POSSIBLE_MAX_SLEEP_TIME;
+
+extern int adb_debug_mode;
+
+static long start_time;  // 出错点：time_info_t 结构体两个成员都是long，因此这两个变量必须是long型，不能定义成int
+static long end_time; 
+
+
+
+# define TEMP_FAILURE_RETRY(expression) \
+  (__extension__							      \
+    ({ long int __result;						      \
+       do __result = (long int) (expression);				      \
+       while (__result == -1L && errno == EINTR);			      \
+       __result; }))
+
+
+pid_t pid = 0;
+
+enum {
+    PARTIAL_WAKE_LOCK = 1,  // the cpu stays on, but the screen is off
+    FULL_WAKE_LOCK = 2      // the screen is also on
+};
+
+// while you have a lock held, the device will stay on at least at the
+// level you request.
+
+struct time_info_t
+{
+    long sleep_start_time;
+    long wakeup_time;
+};
+
+extern struct time_info_t time_info;
+
+struct timeval tv;
+
+#ifdef MOBILETEK_SUSPEND_CFG
+void *dlHandle_wakelock;
+void *dlHandle_log;
+void *dlHandle_network;
+static void* dlHandle_sim;
+
+int (*lynq_screen)(int num);
+int (*lynq_sim_init)(int utoken);
+int (*acquire_wake_lock)(int lock, const char* id);
+int (*release_wake_lock)(const char* id);
+int (*lynq_query_registration_state)(const char *type,int* regState,int* imsRegState,char * LAC,char * CID,int *
+netType,int *radioTechFam,int *errorCode);
+int (*lynq_network_init)(int utoken);
+
+void init_wakelock_func(void)
+{
+    const char *lynqLibPath_WakeLock = "/usr/lib64/libpower.so";
+    const char *lynqLibPath_Log = "/lib64/liblynq-log.so";
+
+    dlHandle_wakelock = dlopen(lynqLibPath_WakeLock, RTLD_NOW);
+    if (dlHandle_wakelock == NULL) 
+    {
+        ALOGI("dlopen lynqLibPath_WakeLock failed: %s", dlerror());
+        exit(EXIT_FAILURE);
+    }
+    dlHandle_log = dlopen(lynqLibPath_Log, RTLD_NOW);
+    if (dlHandle_log == NULL) 
+    {
+        ALOGI("dlopen dlHandle_log failed: %s", dlerror());
+        exit(EXIT_FAILURE);
+    }
+    acquire_wake_lock = (int(*)(int,const char*))dlsym(dlHandle_wakelock, "acquire_wake_lock");
+    if (acquire_wake_lock == NULL) {
+        ALOGI("acquire_wake_lock not defined or exported in %s", lynqLibPath_WakeLock);
+        exit(EXIT_FAILURE);
+    }
+    release_wake_lock = (int(*)( const char*))dlsym(dlHandle_wakelock, "release_wake_lock");
+    if (release_wake_lock == NULL) {
+        ALOGI("release_wake_lock not defined or exported in %s", lynqLibPath_WakeLock);
+        exit(EXIT_FAILURE);
+    }
+    dlerror(); // Clear any previous dlerror
+
+  return;
+}
+
+
+ void init_sim_func()
+{
+    int res;
+    const char *lynqLibPath_Sim = "/lib64/liblynq-sim.so";
+
+    pid = getpid();
+    dlHandle_sim = dlopen(lynqLibPath_Sim, RTLD_NOW);
+    if (dlHandle_sim == NULL) 
+    {
+        ALOGI("dlopen lynqLibPath_Sim failed: %s", dlerror());
+        exit(EXIT_FAILURE);
+    }
+
+    lynq_screen = (int(*)(int))dlsym(dlHandle_sim, "lynq_screen");
+    if (lynq_screen == NULL) {
+        ALOGI("lynq_screen not defined or exported in %s", lynqLibPath_Sim);
+        exit(EXIT_FAILURE);
+    }
+
+    lynq_sim_init = (int(*)(int utoken))dlsym(dlHandle_sim,"lynq_sim_init");
+    if (lynq_sim_init == NULL) {
+        ALOGI("lynq_sim_init not defined or exported in %s", lynqLibPath_Sim);
+        exit(EXIT_FAILURE);
+    }
+    dlerror(); // Clear any previous dlerror
+
+    res = lynq_sim_init((int)pid);
+    if(res == 0)
+    {
+        ALOGI("Run lynq_sim_init\n");
+    }else{
+        ALOGI("lynq sim init error\n");
+    }
+    sleep(1);    
+
+    return;
+}
+
+
+void init_network_func()
+{
+    int res;
+    const char *lynqLibPath_Network = "/lib64/liblynq-network.so";
+    dlHandle_network = dlopen(lynqLibPath_Network, RTLD_NOW);
+    if (dlHandle_network == NULL) 
+    {
+        ALOGI("dlopen lynqLibPath_Network failed: %s", dlerror());
+        exit(EXIT_FAILURE);
+    }
+
+    lynq_query_registration_state = (int(*)(const char*,int*,int*,char *,char *,int *,int *,int*))dlsym(
+dlHandle_network, "lynq_query_registration_state");
+    if (lynq_query_registration_state == NULL) {
+        ALOGI("lynq_query_registration_state not defined or exported in %s", lynqLibPath_Network);
+        exit(EXIT_FAILURE);
+    }
+
+    lynq_network_init = (int(*)(int))dlsym(dlHandle_network, "lynq_network_init");
+    if (lynq_network_init == NULL) {
+        ALOGI("lynq_network_init not defined or exported in %s", lynqLibPath_Network);
+        exit(EXIT_FAILURE);
+    }
+
+    ALOGI("start lynq_network_init\n");
+    printf("start lynq_network_init\n");
+    res = lynq_network_init(2);
+    sleep(10);
+
+    if(res == 0)
+    {
+        ALOGI("Run lynq_network_init\n");
+        printf("Run lynq_network_init\n");
+    }else{
+        ALOGI("lynq_network_init error\n");
+        printf("lynq_network_init error\n");
+    }       
+
+    dlerror(); // Clear any previous dlerror
+    return;            
+}
+#endif
+
+static int suspend_ctrl(char *wakeup_count,int wakeup_count_len)
+{
+
+
+    char buf[80];
+    int ret = 0;
+#ifdef MOBILETEK_SUSPEND_CFG
+    system("echo \"Sys standby mode\" >/dev/console");
+    // sleep(1);
+    system("echo 7 | emdlogger_ctrl");
+    // sleep(1);
+
+    if (lynq_screen(0) != 0)  //notify ril for screen off
+    {
+        ALOGI("lynq_screen off fail\n");
+        return -1;
+    }
+    system("echo mode 4 0 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
+    system("echo out 4 1 >/sys/devices/platform/10005000.pinctrl/mt_gpio");
+    RLOGD("ring GPIO PASS\n");
+    system("hwclock -w");
+    RLOGD("TIME: sys to rtc\n");
+    lseek(wakeup_count_fd, 0, SEEK_SET);
+    system("echo \"autosuspend:Sys seek\" >/dev/console");
+    wakeup_count_len = TEMP_FAILURE_RETRY(read(wakeup_count_fd, wakeup_count,
+               200));
+    ALOGE("%s: %d, write %s to wakeup_count\n", __func__, wakeup_count_len, wakeup_count);
+    if (wakeup_count_len < 0) {
+            strerror_r(errno, buf, sizeof(buf));
+            ALOGE("Error reading from %s: %s\n", SYS_POWER_WAKEUP_COUNT, buf);
+            wakeup_count_len = 0;
+            return -1;
+     }
+
+    for(int i = 0;i < 5;i++)  //notify spm (other core) to handle pre-sleep configuration
+    {
+        if(TEMP_FAILURE_RETRY(write(suspend_ctrl_fd,reg_netsys[i],strlen(reg_netsys[i]))) < 0)
+        {
+            strerror_r(errno, buf, sizeof(buf));
+            ALOGI("Error writing to %s: %s\n", SYS_POWER_SPM_SUSPEND_CRTL, buf);
+            return -1;
+        }    
+    }
+#endif
+
+    system("echo \"autosuspend:Sys suspend\" >/dev/console");
+    if(TEMP_FAILURE_RETRY(write(state_fd, sleep_state, strlen(sleep_state))) < 0) //enter suspend procedures in kernel
+    {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error writing to %s: %s\n", SYS_POWER_STATE, buf);
+        return -1;
+    }
+
+    return 0;
+}
+
+
+void wakeup_feedback(bool success)
+{
+
+    char buf[80];
+    long sleeptime = 0;
+#ifdef MOBILETEK_SUSPEND_CFG
+    system("hwclock -s");
+    RLOGD("TIME: rtc to sys\n");
+    if (!success)
+    {
+
+       system("mdlogctl start");
+
+       system("echo 8 | emdlogger_ctrl");
+    
+       usleep(200000); 
+       ALOGI("Log on with failure\n");
+       return ;
+    }
+
+    
+    if (lynq_screen(1) != 0)  // notify ril for screen on
+    {
+    ALOGI("lynq_screen on fail\n");
+
+    }
+
+    system("mdlogctl start");
+
+//  sleep(1);
+
+    system("echo 8 | emdlogger_ctrl");
+
+    usleep(300000); //delay 2s for ril handling screen on,at least 70ms
+#endif
+
+    pthread_mutex_lock(&time_info_mutex);
+    memset(&tv,0,sizeof(struct timeval));
+    gettimeofday(&tv,NULL);
+    // time_info.wakeup_time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    end_time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+    ALOGI("%s: wake up time: %ld ms\n", __func__,end_time);
+
+    memset(&time_info,0,sizeof(struct time_info_t));
+
+    time_info.sleep_start_time = start_time;
+    time_info.wakeup_time = end_time;
+    sleeptime = end_time -start_time;
+    RLOGD("sleep time is %ld ms\n", sleeptime);
+    pthread_mutex_unlock(&time_info_mutex);
+
+    if (pthread_cond_broadcast(&feedback_cond) != 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error broadcast cond: %s\n", buf);
+    }
+
+    return ;
+
+}
+
+static void update_sleep_time(bool success) {
+    if (success) {
+        sleep_time = BASE_SLEEP_TIME;
+        return;
+    }
+    // double sleep time after each failure up to one minute
+    sleep_time = MIN(sleep_time * 2, possible_max_sleep_time);
+}
+
+static void *suspend_thread_func(void *arg __attribute__((unused)))
+{
+    char buf[80];
+    char wakeup_count[20];
+    int wakeup_count_len;
+    int ret;
+    bool success = true;
+
+    while (1) {
+        update_sleep_time(success);
+        usleep(sleep_time);
+        success = false;
+
+        ALOGI("%s: wait\n", __func__);
+        ret = sem_wait(&suspend_lockout);
+        if (ret < 0) {
+            strerror_r(errno, buf, sizeof(buf));
+            ALOGI("Error waiting on semaphore: %s\n", buf);
+            continue;
+        }
+
+        ALOGV("%s: read wakeup_count\n", __func__);
+        lseek(wakeup_count_fd, 0, SEEK_SET);
+        wakeup_count_len = TEMP_FAILURE_RETRY(read(wakeup_count_fd, wakeup_count,
+                sizeof(wakeup_count)));
+        if (wakeup_count_len < 0) {
+            strerror_r(errno, buf, sizeof(buf));
+            ALOGE("Error reading from %s: %s\n", SYS_POWER_WAKEUP_COUNT, buf);
+            wakeup_count_len = 0;
+            continue;
+        }
+        if (!wakeup_count_len) {
+            ALOGE("Empty wakeup count\n");
+            continue;
+        }
+
+        ALOGI("%s: start suspend_ctrl\n", __func__);
+        memset(&tv,0,sizeof(struct timeval));
+        // memset(&time_info,0 ,sizeof(struct time_info_t));
+        gettimeofday(&tv,NULL);
+
+        start_time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+        ALOGI("%s: suspend start time: %ld ms\n", __func__,start_time);
+        // time_info.sleep_start_time = tv.tv_sec * 1000 + tv.tv_usec / 1000;
+
+        ret = suspend_ctrl(wakeup_count,wakeup_count_len);
+
+        if (ret >= 0) {
+                ALOGI("suspend_ctrl success.\n");
+                success = true;
+         }
+         else
+         {
+                ALOGI("suspend_ctrl false.\n");
+                success = false;
+         }
+
+         void (*func)(bool success) = wakeup_func;
+         if (func != NULL) {
+                (*func)(success); //handling resume event for other libs /apps
+            }
+
+         ALOGI("%s: release sem\n", __func__);
+         ret = sem_post(&suspend_lockout);
+         if (ret < 0) {
+            strerror_r(errno, buf, sizeof(buf));
+            ALOGI("Error releasing semaphore: %s\n", buf);
+         } 
+
+         if(adb_debug_mode == 1) // it's neccessary to wait for autosuspend_disable function calling in debug mode when finish resume procedure.
+         {
+           sleep(40);
+         }
+         else
+         {
+            ALOGI("%s: adb_debug unsupported\n", __func__);
+         }
+
+         ALOGI("%s: END SLEEP\n", __func__);
+    }
+    return NULL;
+}
+
+static int autosuspend_wakeup_count_enable(void)
+{
+    char buf[80];
+    int ret;
+
+    ALOGI("autosuspend_wakeup_count_enable\n");
+
+    ret = sem_post(&suspend_lockout);
+
+    if (ret < 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error changing semaphore: %s\n", buf);
+    }
+
+    ALOGI("autosuspend_wakeup_count_enable done\n");
+
+    return ret;
+}
+
+static int autosuspend_wakeup_count_disable(void)
+{
+    char buf[80];
+    int ret;
+
+    ALOGI("autosuspend_wakeup_count_disable\n");
+
+    ret = sem_wait(&suspend_lockout);
+
+    if (ret < 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error changing semaphore: %s\n", buf);
+    }
+
+    ALOGI("autosuspend_wakeup_count_disable done\n");
+
+    return ret;
+}
+
+void set_wakeup_callback(void (*func)(bool success))
+{
+    if (wakeup_func != NULL) {
+        ALOGI("Duplicate wakeup callback applied, keeping original");
+        return;
+    }
+    wakeup_func = func;
+}
+
+struct autosuspend_ops autosuspend_wakeup_count_ops = {
+        .enable = autosuspend_wakeup_count_enable,
+        .disable = autosuspend_wakeup_count_disable,
+};
+
+struct autosuspend_ops *autosuspend_wakeup_count_init(void)
+{
+    int ret;
+    char buf[80];
+    char timeout_str[100]="100000";
+
+    //if (property_get("sys.autosuspend.timeout", timeout_str, NULL))
+    {
+        possible_max_sleep_time = atoi(timeout_str);
+        ALOGI("autosuspend timeout is %d\n", possible_max_sleep_time);
+    }
+
+    state_fd = TEMP_FAILURE_RETRY(open(SYS_POWER_STATE, O_RDWR));
+    if (state_fd < 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error opening %s: %s\n", SYS_POWER_STATE, buf);
+        goto err_open_state;
+    }
+
+    wakeup_count_fd = TEMP_FAILURE_RETRY(open(SYS_POWER_WAKEUP_COUNT, O_RDWR));
+    if (wakeup_count_fd < 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error opening %s: %s\n", SYS_POWER_WAKEUP_COUNT, buf);
+        goto err_open_wakeup_count;
+    }
+#ifdef MOBILETEK_SUSPEND_CFG
+    suspend_ctrl_fd = TEMP_FAILURE_RETRY(open(SYS_POWER_SPM_SUSPEND_CRTL, O_RDWR));
+    if (suspend_ctrl_fd < 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error opening %s: %s\n", SYS_POWER_SPM_SUSPEND_CRTL, buf);
+        goto err_open_suspend_ctrl;
+    }
+#endif
+    ret = sem_init(&suspend_lockout, 0, 0);
+    if (ret < 0) {
+        strerror_r(errno, buf, sizeof(buf));
+        ALOGI("Error creating semaphore: %s\n", buf);
+        goto err_sem_init;
+    }
+    ret = pthread_create(&suspend_thread, NULL, suspend_thread_func, NULL);
+    if (ret) {
+        strerror_r(ret, buf, sizeof(buf));
+        ALOGI("Error creating thread: %s\n", buf);
+        goto err_pthread_create;
+    }
+
+    ALOGI("Selected wakeup count\n");
+    return &autosuspend_wakeup_count_ops;
+
+err_pthread_create:
+    sem_destroy(&suspend_lockout);
+err_sem_init:
+    close(wakeup_count_fd);
+err_open_wakeup_count:
+    close(state_fd);
+#ifdef MOBILETEK_SUSPEND_CFG
+err_open_suspend_ctrl:
+    close(suspend_ctrl_fd);
+#endif
+err_open_state:
+    return NULL;
+}
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/lynq-autosuspend.sh b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/lynq-autosuspend.sh
new file mode 100644
index 0000000..8e96831
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/lynq-autosuspend.sh
@@ -0,0 +1,39 @@
+#!/bin/sh
+#
+# Run the daemon
+#
+
+DAEMON="lynq-autosuspend-service"
+PIDFILE="/var/run/$DAEMON.pid"
+EXEC="/usr/bin/autosuspend"
+EXEC_ARGS=""
+
+
+start() {
+        echo -n "Starting $DAEMON... "
+        start-stop-daemon --no-close -S -b -m -p $PIDFILE -x $EXEC -- $EXEC_ARGS
+        [ $? -eq 0 ] && echo "OK" || echo "ERROR"
+}
+
+stop() {
+        echo -n "Stopping $DAEMON... "
+        start-stop-daemon -K -p $PIDFILE
+        [ $? -eq 0 ] && echo "OK" || echo "ERROR"
+}
+
+restart() {
+        stop
+        start
+}
+
+case "$1" in
+  start|stop|restart)
+        "$1"
+        ;;
+  *)
+        echo "Usage: $0 {start|stop|restart}"
+        exit 1
+esac
+
+exit $?
+
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/main.c b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/main.c
new file mode 100755
index 0000000..d4e6960
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/main.c
@@ -0,0 +1,491 @@
+/* //device/system/rild/rild.c
+**
+** Copyright 2006 The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+**     http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <dlfcn.h>
+#include <string.h>
+#include <pthread.h>
+#include <stdint.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <log/log.h>
+#include <liblog/lynq_deflog.h>
+#include <include/lynq_uci.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <signal.h>
+
+
+#define LOG_UCI_MODULE "lynq_autosuspend"
+#define LOG_UCI_FILE "lynq_uci"
+
+#define LOG_TAG "AUTOSUSPEND"
+
+#define USER_LOG_TAG "PMS"
+
+#define SOCK_PATH  "/tmp/autosuspend.cmd.server"  //不能在当前这个目录创建socket文件，否则报错找不到文件(可能是因为这是在共享文件夹下，不支持创建socket文件)
+
+#define SOCK_DATA_PATH  "/tmp/autosuspend.data.server"
+
+// #define LYINFLOG(X...)  lynq_log_global_output(LOG_INFO,X)
+
+#define TIME_OUT_TIME 30
+
+
+#define MAX_LIB_ARGS        16
+
+int adb_debug_mode = 0;
+
+
+pthread_cond_t feedback_cond = PTHREAD_COND_INITIALIZER;
+pthread_mutex_t feedback_mutex = PTHREAD_MUTEX_INITIALIZER;
+pthread_mutex_t time_info_mutex = PTHREAD_MUTEX_INITIALIZER;
+
+extern int autosuspend_enable(void);
+extern int autosuspend_disable(void);
+extern void init_wakelock_func(void);
+extern void init_sim_func();
+extern void init_network_func();
+extern void set_wakeup_callback(void (*func)(bool success));
+extern void wakeup_feedback(bool success);
+extern int (*lynq_screen)(int num);
+
+struct time_info_t
+{
+    long sleep_start_time;
+    long wakeup_time;
+};
+
+struct time_info_t time_info; 
+
+static void usage(const char *argv0) {
+    fprintf(stderr, "Usage: %s -l <possible_max_sleep_time> [-- <args for Autosuspend Service>]\n", argv0);
+    exit(EXIT_FAILURE);
+}
+
+
+
+static int make_argv(char * args, char ** argv) {
+    // Note: reserve argv[0]
+    int count = 1;
+    char * tok;
+    char * s = args;
+
+    while ((tok = strtok(s, " \0"))) {
+        argv[count] = tok;
+        s = NULL;
+        count++;
+    }
+    return count;
+}
+
+static int Accept(int fd, struct sockaddr *sa, socklen_t *salenptr)
+{
+    int n;
+
+    while((n = accept(fd, sa, salenptr)) < 0)
+    {
+        if((errno == ECONNABORTED) || (errno == EINTR))
+            continue;
+        else
+        {
+            ALOGI("accept error\n");
+            return -1;
+        }
+    }
+    return n;
+}
+
+static int Bind(int fd, const struct sockaddr *sa, socklen_t salen)
+{
+    if(bind(fd, sa, salen) < 0)
+    {
+        // ALOGI("bind error\n");
+        perror("bind error");
+        return -1;
+    }
+	return 0;
+}
+
+
+static int Socket(int family, int type, int protocol)
+{
+    int n;
+
+    if ( (n = socket(family, type, protocol)) < 0)
+    {
+        ALOGI("socket error\n");
+        return -1;
+    }
+    return n;
+}
+
+static int Listen(int fd, int backlog)
+{
+    if(listen(fd, backlog) < 0)
+    {
+        ALOGI("listen error\n");
+        return -1;
+    }
+	return 0;
+}
+
+
+static int listen_port(struct sockaddr_un *addr, char *sockpath)
+{
+    int listenfd;
+    listenfd = Socket(AF_UNIX,SOCK_STREAM,0);
+    if(listenfd == -1)
+        return -1;
+    memset(addr, 0, sizeof(struct sockaddr_un));
+    addr->sun_family = AF_UNIX;
+    strcpy(addr->sun_path,sockpath);
+    // int opt = 1;
+	// if(setsockopt(listenfd, SOL_SOCKET,SO_REUSEADDR, (const void *)&opt, sizeof(opt)) == -1)
+    // {
+    //     perror("setsockopt error");
+    //     return -1;
+    // }
+
+// 以上方法对非网络的本地socket无效，应该用unlink函数避免Address already in use的错误
+
+
+    unlink(sockpath);
+    if(Bind(listenfd,(struct sockaddr *)addr,sizeof(*addr)) == -1)
+        return -1;
+
+    if(Listen(listenfd,20) == -1)
+        return -1;
+
+    return listenfd; 
+}
+
+static ssize_t Read(int fd, void *ptr, size_t nbytes)
+{
+    ssize_t n;
+    
+    while((n = read(fd, ptr, nbytes)) == -1)
+    {
+       //printf("READ,%d\n",fd);
+        if (errno == EINTR)
+		{	
+			ALOGI("read error eintr\n");
+            continue;
+		}
+        else if(errno == EAGAIN || errno == EWOULDBLOCK)
+        {
+            ALOGI("read time out\n");
+            return -1;
+        }
+        else
+        {
+            ALOGI("read error\n");
+            return -1;
+        }
+    }
+    //sleep(2);
+    //printf("READ1,%d\n", fd);
+    return n;
+}
+
+static ssize_t Write(int fd, const void *ptr, size_t nbytes)
+{
+    ssize_t n;
+
+    while((n = write(fd, ptr, nbytes)) == -1)
+    {
+        if (errno == EINTR)
+            continue;
+        else if(errno == EPIPE)
+		{
+			ALOGI("write error epipe\n");
+			return -1;
+		}  
+		else
+			return -1;
+    }
+    return n;
+}
+
+static int Close(int fd)
+{
+    if (close(fd) == -1)
+    {
+        ALOGI("close error\n");
+        return -1;
+    }
+	return 0;
+}
+
+
+void *deal_autosuspend(void *sockfd)
+{
+    int commfd = *((int *)sockfd);
+    char buf[20];
+    char res[15];
+
+    while(1)
+    {
+        memset(buf,0,sizeof(buf));
+        ALOGI("deal_autosuspend start to read.\n");
+        // 错误点：read函数在对端关闭后，也会直接返回0,不会阻塞，因此要判断是否返回0,返回0表示对端已经关闭，此时要跳出while循环不再监听
+        // 为什么对端会关闭？因为在客户端没有用nohup方式打开的情况下，系统睡眠后客户端进行会直接被杀死，对端会关闭，所以会导致read不阻塞，且总是返回0的现象
+        if(Read(commfd,buf,sizeof(buf)) <= 0) 
+        {
+            ALOGI("service receive suspend_cmd fail or client is closed.\n");
+            Close(commfd);
+            break;
+        }
+        if(strcmp(buf,"enable") == 0)
+        {
+            if(autosuspend_enable() < 0)
+            {
+                ALOGI("autosuspend_enable fail.\n");
+            }
+            else
+            {
+                ALOGI("autosuspend_enable success.\n");
+            }        
+        }
+        else if(strcmp(buf,"disable") == 0)
+        {
+            if(autosuspend_disable() < 0)
+            {
+                ALOGI("autosuspend_disable fail.\n");
+            }
+            else
+            {
+                ALOGI("autosuspend_disable success.\n");
+
+            }        
+        }
+
+        else
+        {
+            ALOGI("Unknown cmd : %s\n",buf);
+        }
+
+    }
+
+
+
+}
+
+#ifdef GSW_SUSPEND_CFG
+/*jb.qi add for service send when DTR is low on 20221111 start */
+void *dtr_wakeup()
+{
+    FILE *fp;
+    int ret;
+    bool success = true;
+    char buf[30];
+    char dtr_buffer[25];
+    RLOGD("dtr_wakeup start\n");
+    while(1)
+    {
+        fp = popen("cat /sys/devices/platform/10005000.pinctrl/mt_gpio |grep 006:","r");
+        fgets(dtr_buffer, sizeof(dtr_buffer), fp);
+        if(dtr_buffer[7] == '0')
+        {
+            time_info.sleep_start_time = 123;
+            time_info.wakeup_time = 123;
+            if (pthread_cond_broadcast(&feedback_cond) != 0) 
+            {
+                strerror_r(errno, buf, sizeof(buf));
+                ALOGI("Error broadcast cond: %s\n", buf);
+            }   
+            RLOGD("dtr_wakeup success!\n");
+            sleep(3);
+        }
+        usleep(500);
+        pclose(fp);
+    }
+}
+/*jb.qi add for service send when DTR is low on 20221111 end */
+#endif
+
+void *send_feedback(void *sockfd)
+{
+    int commfd = *((int *)sockfd);
+    char buf[80];
+
+    while (1)
+    {
+        memset(buf,0,sizeof(buf));
+        ALOGI("send_feedback thread wait to send.\n");
+        pthread_mutex_lock(&feedback_mutex);
+        pthread_cond_wait(&feedback_cond,&feedback_mutex);
+
+        ALOGI("send_feedback thread is now sending the feedback to client.\n");
+        pthread_mutex_lock(&time_info_mutex);
+        if(Write(commfd,&time_info,sizeof(struct time_info_t)) <= 0) 
+        {
+            ALOGI("service send wakeup_feedback struct fail.\n");
+            Close(commfd);
+            pthread_mutex_unlock(&time_info_mutex);
+            pthread_mutex_unlock(&feedback_mutex);
+#ifdef GSW_SUSPEND_CFG
+            continue ;//jb.qi add for service send when DTR is low on 20221111 
+#endif
+
+#ifdef MOBILETEK_SUSPEND_CFG
+            break ;
+#endif
+        }        
+        pthread_mutex_unlock(&time_info_mutex);
+
+        pthread_mutex_unlock(&feedback_mutex);
+
+
+
+    }
+
+}
+
+
+int main(int argc, char **argv) {
+
+
+    // int i = 0;
+    // RLOGD("**Autosuspend Service Daemon Started**");
+    // RLOGD("**Autosuspend Service param count=%d**", argc);
+    char tmp[20];
+
+    int commfd, commfd_data, server_sock, server_data_sock,len, len_data;
+
+    struct sockaddr_un server_sockaddr;
+    struct sockaddr_un server_data_sockaddr;
+    struct sockaddr_un client_sockaddr;
+
+    len = sizeof(server_sockaddr);
+
+
+    pthread_t tid;
+#ifdef GSW_SUSPEND_CFG
+	pthread_t tid_1;//jb.qi add for service send when DTR is low on 20221111 
+#endif
+    
+    LYLOGEINIT(USER_LOG_TAG);
+    LYLOGSET(LOG_DEBUG);    
+    // LYLOGSET(LOG_ERROR);
+
+    int auto_enable = 0;
+
+    lynq_get_value(LOG_UCI_FILE, LOG_UCI_MODULE, "debug", tmp); // 即获取系统层面的环境变量
+    ALOGI("Autosuspend Service Daemon. debug %s\n",tmp);
+    adb_debug_mode=atoi(tmp);
+    lynq_get_value(LOG_UCI_FILE, LOG_UCI_MODULE, "auto_enable", tmp);
+    auto_enable=atoi(tmp);
+    ALOGI("Autosuspend Service Daemon. auto_enable %s\n",tmp);
+#ifdef MOBILETEK_SUSPEND_CFG
+    init_wakelock_func();
+    init_sim_func();
+#endif
+    signal(SIGPIPE,SIG_IGN); // 忽略SIGPIPE信号，防止由于客户端关闭，继续往客户端write，会导致服务端收到SIGPIPE信号而Broken pipe
+
+    
+    // init_network_func();
+
+    // if(pthread_cond_init(&feedback_cond,NULL) != 0)
+    // {
+    //     strerror_r(errno, buf, sizeof(buf));
+    //     ALOGI("Error creating cond: %s\n", buf);
+    //     return -1;
+    // }
+
+    set_wakeup_callback(wakeup_feedback);
+    // 注册回调函数
+
+   if(auto_enable==0)
+   {
+      if(autosuspend_disable() < 0)
+     {
+       ALOGI("autosuspend_disable fail.\n");
+     }
+     else
+     {
+       ALOGI("autosuspend_disable success.\n");
+     }
+   }
+   if(auto_enable==1)
+   {
+      if(autosuspend_enable() < 0)
+     {
+       ALOGI("autosuspend_enable fail.\n");
+     }
+     else
+     {
+       ALOGI("autosuspend_enable success.\n");
+     }
+   }
+
+
+    server_sock = listen_port(&server_sockaddr,SOCK_PATH);
+    if(server_sock == -1)
+        return -1;
+
+    server_data_sock = listen_port(&server_data_sockaddr,SOCK_DATA_PATH);
+    if(server_data_sock == -1)
+        return -1;
+#ifdef GSW_SUSPEND_CFG
+    /*jb.qi add for service send when DTR is low on 20221111 start*/
+    pthread_create(&tid_1,NULL,dtr_wakeup,NULL);
+    pthread_detach(tid_1);
+    /*jb.qi add for service send when DTR is low on 20221111 end*/
+#endif
+
+    while (1)
+    {
+        ALOGI("service socket listening...\n");
+        commfd = Accept(server_sock,(struct sockaddr *)&client_sockaddr,&len);
+        if(commfd == -1)
+        {
+            return -1;
+        }
+        if(getpeername(commfd, (struct sockaddr *)&client_sockaddr, &len) == -1)
+        {
+            ALOGI("GETPEERNAME ERROR.\n");
+            // Close(server_sock);
+            Close(commfd);
+            continue;
+        }
+        else
+        {
+            ALOGI("Client socket filepath: %s\n", client_sockaddr.sun_path);
+        }
+
+        commfd_data = Accept(server_data_sock,NULL,NULL);
+        if(commfd_data == -1)
+        {
+            return -1;
+        }
+        ALOGI("data channel connected.\n");
+        
+        pthread_create(&tid,NULL,deal_autosuspend,(void*)&commfd);//这里很容易错，最后一个参数要取地址，这是一个指针
+        pthread_detach(tid);   
+
+        pthread_create(&tid,NULL,send_feedback,(void*)&commfd_data);
+        pthread_detach(tid); 
+
+
+    }
+    
+ 
+}
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/makefile b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/makefile
new file mode 100755
index 0000000..0441d43
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/files/makefile
@@ -0,0 +1,67 @@
+SHELL = /bin/sh
+RM = rm -f
+
+LOCAL_CFLAGS := -Wall \
+                -g -Os \
+                -flto \
+                -DRIL_SHLIB \
+                -DATCI_PARSE \
+                -DKEEP_ALIVE \
+                -D__LINUX_OS__ \
+                -DECALL_SUPPORT
+
+
+
+ifeq ($(strip $(TARGET_PLATFORM)), T106)
+LOCAL_CFLAGS += -DHAVE_SYS_UIO_H -DRIL_TIME_CB
+endif
+
+ifeq ($(strip $(TARGET_PLATFORM)), T106)
+    LOCAL_CFLAGS += -DMOBILETEK_TARGET_PLATFORM_T106
+endif
+
+ifeq ($(strip $(MOBILETEK_SUSPEND_CFG)), GSW)
+    LOCAL_CFLAGS += -DGSW_SUSPEND_CFG
+
+endif
+
+ifeq ($(strip $(MOBILETEK_SUSPEND_CFG)), PLATFORM)
+    LOCAL_CFLAGS += -DMOBILETEK_SUSPEND_CFG
+
+endif
+
+
+LOCAL_PATH   = .
+
+LOCAL_C_INCLUDES = \
+  -I.   -I$(ROOT)$(includedir)/liblog -I$(ROOT)$(includedir) \
+
+
+
+
+LOCAL_LIBS := \
+    -L. \
+    -ldl \
+    -lpthread \
+    -llynq-log \
+    -llynq-uci \
+    -llog \
+    -lbsp \
+
+
+SOURCES = $(wildcard *.c )
+
+EXECUTABLE = autosuspend
+
+OBJECTS=$(SOURCES:.c=.o)
+all: $(EXECUTABLE)
+
+$(EXECUTABLE): $(OBJECTS)
+	$(CXX) $(OBJECTS) $(LOCAL_LIBS) $(LOCAL_CFLAGS) $(LOCAL_C_INCLUDES) -o $@
+
+%.o : %.c
+	$(CC) $(LOCAL_C_INCLUDES) $(LOCAL_CFLAGS) $(LOCAL_LIBS) -o $@ -c $<
+
+.PHONY: clean
+clean:
+	$(RM) $(OBJECTS) $(EXECUTABLE)
diff --git a/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/lynq-autosuspend.bb b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/lynq-autosuspend.bb
new file mode 100755
index 0000000..c646163
--- /dev/null
+++ b/cap/zx297520v3/sources/meta-zxic-custom/recipes-lynq/lynq-autosuspend/lynq-autosuspend.bb
@@ -0,0 +1,79 @@
+inherit externalsrc package systemd
+
+DESCRIPTION = "autosuspend.service"
+
+LICENSE = "MobileTekProprietary"
+LIC_FILES_CHKSUM = "file://${WORKDIR}/LICENSE;md5=44d8d2b6296ca24bcd4894bb7155bf27"
+
+SRC_URI = "file://autosuspend.c file://LICENSE \
+           file://autosuspend.h \
+           file://autosuspend_ops.h \
+           file://autosuspend_wakeup_count.c \
+           file://main.c \
+           file://autosuspend.service \
+           file://lynq-autosuspend.sh \
+           file://makefile \
+"
+
+EXTRA_OEMAKE = "'RAT_CONFIG_C2K_SUPPORT = ${RAT_CONFIG_C2K_SUPPORT}'\
+                'MTK_MULTI_SIM_SUPPORT = ${MTK_MULTI_SIM_SUPPORT}'\
+                'TARGET_PLATFORM = ${TARGET_PLATFORM}'"
+
+TARGET_CC_ARCH += "${LDFLAGS}"
+
+LOCAL_C_INCLUDES = "-I. "
+
+DEPENDS = "liblynq-log liblynq-uci"
+DEPENDS += "${@bb.utils.contains('TARGET_PLATFORM', 'mt2735', 'audio-mixer-ctrl streamer1.0', '', d)} liblynq-log liblynq-uci libbsp"
+LOCAL_LIBS = "-L. -ldl -lstdc++ -lpthread -llog"
+SOURCES = "$(wildcard *.c )"
+
+OBJECTS = "$(SOURCES:.c=.o)"
+
+EXTRA_OEMAKE += "'MOBILETEK_SUSPEND_CFG = ${MOBILETEK_SUSPEND_CFG}'\
+                 'TARGET_PLATFORM = ${TARGET_PLATFORM}'\
+                 'MTK_LED_SUPPORT = ${MTK_LED_SUPPORT}'\
+                 'TARGET_PLATFORM = ${TARGET_PLATFORM}'"
+
+EXECUTABLE = "autosuspend"
+S = "${WORKDIR}"
+TARGET_CC_ARCH += "${LDFLAGS}"
+SYSTEMD_PACKAGES = "${PN}"
+SYSTEMD_SERVICE_${PN} = "autosuspend.service"
+FILES_${PN} += "${systemd_unitdir}/system/autosuspend.service"
+#INHIBIT_PACKAGE_STRIP = "1"
+do_compile () {
+
+	#${CXX} -Wall ${LOCAL_C_INCLUDES} autosuspend.c autosuspend_wakeup_count.c main.c ${LOCAL_LIBS} -o ${EXECUTABLE}
+	if test "${PACKAGE_ARCH}" = "cortexa7hf-vfp-vfpv4-neon" || test "${PACKAGE_ARCH}" = "cortexa7hf-neon-vfpv4"; then
+		oe_runmake all ROOT=${STAGING_DIR_HOST} OFLAGS="--sysroot=${STAGING_DIR_HOST} -mhard-float"
+	else
+		oe_runmake all ROOT=${STAGING_DIR_HOST} OFLAGS="--sysroot=${STAGING_DIR_HOST}"
+	fi
+}
+
+do_install() {
+	install -d ${D}${bindir}/
+	echo "Installing image PN ${PN}"
+	echo "Installing image systemd_unitdir ${systemd_unitdir}"
+	echo "Installing image D ${D}"
+	echo "Installing image B ${B}"
+	if ${@bb.utils.contains('DISTRO_FEATURES','systemd','true','false',d)}; then
+		install -d ${D}${systemd_unitdir}/system/
+		install -m 0644 ${B}/autosuspend.service ${D}${systemd_unitdir}/system
+    else
+		install -d ${D}${sysconfdir}/init.d
+        install -m 0755  ${S}/lynq-autosuspend.sh ${D}${sysconfdir}/init.d/
+        install -d ${D}${sysconfdir}/rcS.d
+        ln -s ../init.d/lynq-autosuspend.sh ${D}${sysconfdir}/rcS.d/S82lynq-autosuspend-service
+	fi
+
+	install -m 0755 ${S}/autosuspend ${D}${bindir}/
+	install -d ${D}${includedir}
+}
+
+
+
+
+
+