add via modify part source code for wm8880 4.4 kitkat

5 files changed, 189 insertions, 17 deletions

diff --git a/ANDROID_3.4.5/drivers/base/platform.c b/ANDROID_3.4.5/drivers/base/platform.c
index a1a72250..42069c46 100644
--- a/ANDROID_3.4.5/drivers/base/platform.c
+++ b/ANDROID_3.4.5/drivers/base/platform.c
@@ -682,8 +682,10 @@ static int platform_legacy_suspend(struct device *dev, pm_message_t mesg)
 	struct platform_device *pdev = to_platform_device(dev);
 	int ret = 0;
 
-	if (dev->driver && pdrv->suspend)
+	if (dev->driver && pdrv->suspend){
+		printk(KERN_ERR"platform_legacy_suspend %s\n",pdrv->driver.name);
 		ret = pdrv->suspend(pdev, mesg);
+	}
 
 	return ret;
 }
@@ -694,8 +696,10 @@ static int platform_legacy_resume(struct device *dev)
 	struct platform_device *pdev = to_platform_device(dev);
 	int ret = 0;
 
-	if (dev->driver && pdrv->resume)
+	if (dev->driver && pdrv->resume){
+		printk(KERN_ERR"platform_legacy_resume %s\n",pdrv->driver.name);
 		ret = pdrv->resume(pdev);
+	}
 
 	return ret;
 }
@@ -713,8 +717,11 @@ int platform_pm_suspend(struct device *dev)
 		return 0;
 
 	if (drv->pm) {
-		if (drv->pm->suspend)
+		if (drv->pm->suspend){
+			printk("platform_pm_suspend %s start\n",drv->name);
 			ret = drv->pm->suspend(dev);
+			printk("platform_pm_suspend %s end\n",drv->name);
+		}
 	} else {
 		ret = platform_legacy_suspend(dev, PMSG_SUSPEND);
 	}
@@ -731,8 +738,11 @@ int platform_pm_resume(struct device *dev)
 		return 0;
 
 	if (drv->pm) {
-		if (drv->pm->resume)
+		if (drv->pm->resume){
+			printk("platform_pm_resume %s start\n",drv->name);
 			ret = drv->pm->resume(dev);
+			printk("platform_pm_resume %s end\n",drv->name);
+		}
 	} else {
 		ret = platform_legacy_resume(dev);
 	}
diff --git a/ANDROID_3.4.5/drivers/base/power/main.c b/ANDROID_3.4.5/drivers/base/power/main.c
index ab7f180b..e153e03b 100644
--- a/ANDROID_3.4.5/drivers/base/power/main.c
+++ b/ANDROID_3.4.5/drivers/base/power/main.c
@@ -32,6 +32,7 @@
 
 #include "../base.h"
 #include "power.h"
+#include <mach/wmt_secure.h>
 
 typedef int (*pm_callback_t)(struct device *);
 
@@ -62,6 +63,9 @@ struct dpm_watchdog {
 };
 
 static int async_error;
+extern unsigned int cpu_trustzone_enabled;
+extern int console_printk[];
+#define console_loglevel (console_printk[0])
 
 /**
  * device_pm_init - Initialize the PM-related part of a device object.
@@ -729,7 +733,8 @@ void dpm_resume(pm_message_t state)
 {
 	struct device *dev;
 	ktime_t starttime = ktime_get();
-
+	int tmp;
+	
 	might_sleep();
 
 	mutex_lock(&dpm_list_mtx);
@@ -743,7 +748,9 @@ void dpm_resume(pm_message_t state)
 			async_schedule(async_resume, dev);
 		}
 	}
-
+	
+	tmp = console_loglevel;
+	console_loglevel = 7;
 	while (!list_empty(&dpm_suspended_list)) {
 		dev = to_device(dpm_suspended_list.next);
 		get_device(dev);
@@ -766,6 +773,7 @@ void dpm_resume(pm_message_t state)
 			list_move_tail(&dev->power.entry, &dpm_prepared_list);
 		put_device(dev);
 	}
+	console_loglevel = tmp;	
 	mutex_unlock(&dpm_list_mtx);
 	async_synchronize_full();
 	dpm_show_time(starttime, state, NULL);
@@ -851,6 +859,10 @@ void dpm_complete(pm_message_t state)
  */
 void dpm_resume_end(pm_message_t state)
 {
+	if (cpu_trustzone_enabled == 1) {
+		wmt_smc(WMT_SMC_CMD_DEVICE_RESUME, 0x1001);
+	}
+	
 	dpm_resume(state);
 	dpm_complete(state);
 }
@@ -1219,12 +1231,16 @@ int dpm_suspend(pm_message_t state)
 {
 	ktime_t starttime = ktime_get();
 	int error = 0;
-
+	int tmp;
+	
 	might_sleep();
 
 	mutex_lock(&dpm_list_mtx);
 	pm_transition = state;
 	async_error = 0;
+
+	tmp = console_loglevel;
+	console_loglevel = 7;
 	while (!list_empty(&dpm_prepared_list)) {
 		struct device *dev = to_device(dpm_prepared_list.prev);
 
@@ -1246,6 +1262,7 @@ int dpm_suspend(pm_message_t state)
 		if (async_error)
 			break;
 	}
+	console_loglevel = tmp;
 	mutex_unlock(&dpm_list_mtx);
 	async_synchronize_full();
 	if (!error)
@@ -1365,6 +1382,9 @@ int dpm_suspend_start(pm_message_t state)
 		dpm_save_failed_step(SUSPEND_PREPARE);
 	} else
 		error = dpm_suspend(state);
+	if (cpu_trustzone_enabled == 1) {
+		wmt_smc(WMT_SMC_CMD_DEVICE_SUSPEND, 0x1001);
+	}
 	return error;
 }
 EXPORT_SYMBOL_GPL(dpm_suspend_start);
diff --git a/ANDROID_3.4.5/drivers/base/power/wakeup.c b/ANDROID_3.4.5/drivers/base/power/wakeup.c
index e6ee5e80..ba06da42 100644
--- a/ANDROID_3.4.5/drivers/base/power/wakeup.c
+++ b/ANDROID_3.4.5/drivers/base/power/wakeup.c
@@ -415,6 +415,70 @@ static void wakeup_source_report_event(struct wakeup_source *ws)
  *
  * It is safe to call this function from interrupt context.
  */
+
+
+/*add by kevin ,for wakeup lock debug.default is uncompile
+usage:
+    1: #define WAKE_TRACE_ENABLE   1
+    2: add wake_trace_show(); in kernel/power/main.c/state_show()
+    3: cat /sys/power/state
+*/
+#define WAKE_TRACE_ENABLE   0
+
+#if WAKE_TRACE_ENABLE
+#define WAKE_TRACE_NUMBER   100
+typedef struct{
+    char name[64];
+    int val;    
+}WAKE_TRACE;
+WAKE_TRACE wake_trace[WAKE_TRACE_NUMBER];
+int wake_trace_init=0;
+
+void wake_trace_lock(struct wakeup_source *ws){
+    int i;
+    if(wake_trace_init==0){
+        wake_trace_init = 1;
+        memset(wake_trace,0,sizeof(wake_trace));
+    }
+    for(i=0;i<WAKE_TRACE_NUMBER;i++){
+        if((strlen(wake_trace[i].name)>0&&!strcmp(wake_trace[i].name,ws->name)))
+            break;
+        if(strlen(wake_trace[i].name)<=0)
+            break;
+    }
+    if(i>=WAKE_TRACE_NUMBER)
+        printk("%s %d %s error\n",__func__,__LINE__,ws->name);
+    else{
+        if(strlen(wake_trace[i].name)<=0){
+            printk("%s %d insert %s\n",__func__,__LINE__,ws->name);
+            strcpy(wake_trace[i].name,ws->name);
+        }
+        wake_trace[i].val++;
+    }
+}
+void wake_trace_unlock(struct wakeup_source *ws){
+    int i;
+    for(i=0;i<WAKE_TRACE_NUMBER;i++){
+        if((strlen(wake_trace[i].name)>0&&!strcmp(wake_trace[i].name,ws->name)))
+            break;
+    }
+    if(i>=WAKE_TRACE_NUMBER)
+        printk("%s %d %s error\n",__func__,__LINE__,ws->name);
+    else{
+        wake_trace[i].val--;
+    }
+}
+
+int wake_trace_show(void)
+{
+    int i;
+    for(i=0;i<WAKE_TRACE_NUMBER;i++){
+        if(strlen(wake_trace[i].name)>0)
+            printk("%d %s %d\n",i,wake_trace[i].name,wake_trace[i].val);
+    }
+}
+EXPORT_SYMBOL_GPL(wake_trace_show);
+#endif
 void __pm_stay_awake(struct wakeup_source *ws)
 {
 	unsigned long flags;
@@ -424,6 +488,10 @@ void __pm_stay_awake(struct wakeup_source *ws)
 
 	spin_lock_irqsave(&ws->lock, flags);
 
+#if WAKE_TRACE_ENABLE
+    wake_trace_lock(ws);
+#endif
+
 	wakeup_source_report_event(ws);
 	del_timer(&ws->timer);
 	ws->timer_expires = 0;
@@ -540,6 +608,9 @@ void __pm_relax(struct wakeup_source *ws)
 		return;
 
 	spin_lock_irqsave(&ws->lock, flags);
+#if WAKE_TRACE_ENABLE
+    wake_trace_unlock(ws);
+#endif
 	if (ws->active)
 		wakeup_source_deactivate(ws);
 	spin_unlock_irqrestore(&ws->lock, flags);
@@ -611,6 +682,10 @@ void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
 
 	spin_lock_irqsave(&ws->lock, flags);
 
+#if WAKE_TRACE_ENABLE
+    wake_trace_lock(ws);
+#endif
+
 	wakeup_source_report_event(ws);
 
 	if (!msec) {
@@ -653,16 +728,47 @@ void pm_wakeup_event(struct device *dev, unsigned int msec)
 }
 EXPORT_SYMBOL_GPL(pm_wakeup_event);
 
+extern int wmt_getsyspara(char *varname, unsigned char *varval, int *varlen);
+
+static int is_rda5991(void){
+	int retval;
+	unsigned char buf[80];
+	int varlen = 80;
+
+
+
+    memset(buf,0,sizeof(buf));
+   varlen = 80;
+    retval = wmt_getsyspara("wmt.init.rc", buf, &varlen);
+	if (retval == 0) {
+		if (!strcmp(buf, "init.rda5991.rc"))
+		{
+			printk("is rda5991\n");
+            return 1;
+		}     
+
+	}
+    return 0;
+
+}
+
 static void print_active_wakeup_sources(void)
 {
 	struct wakeup_source *ws;
 	int active = 0;
 	struct wakeup_source *last_activity_ws = NULL;
-
+	printk("\n...in %s\n",__FUNCTION__);
+    if(is_rda5991()){
+        printk("skip!\n");
+        return;
+    }
 	rcu_read_lock();
 	list_for_each_entry_rcu(ws, &wakeup_sources, entry) {
+        //kevin add for null pointer
+        if(!ws)
+            break;
 		if (ws->active) {
-			pr_info("active wakeup source: %s\n", ws->name);
+			printk("active wakeup source: %s\n", ws->name);
 			active = 1;
 		} else if (!active &&
 			   (!last_activity_ws ||
@@ -671,9 +777,8 @@ static void print_active_wakeup_sources(void)
 			last_activity_ws = ws;
 		}
 	}
-
 	if (!active && last_activity_ws)
-		pr_info("last active wakeup source: %s\n",
+		printk("last active wakeup source: %s\n",
 			last_activity_ws->name);
 	rcu_read_unlock();
 }
@@ -836,7 +941,7 @@ static int print_wakeup_source_stats(struct seq_file *m,
 		active_time = ktime_set(0, 0);
 	}
 
-	ret = seq_printf(m, "%-12s\t%lu\t\t%lu\t\t%lu\t\t%lu\t\t"
+	ret = seq_printf(m, "%-20s\t%lu\t\t%lu\t\t%lu\t\t%lu\t\t"
 			"%lld\t\t%lld\t\t%lld\t\t%lld\t\t%lld\n",
 			ws->name, active_count, ws->event_count,
 			ws->wakeup_count, ws->expire_count,
@@ -857,7 +962,7 @@ static int wakeup_sources_stats_show(struct seq_file *m, void *unused)
 {
 	struct wakeup_source *ws;
 
-	seq_puts(m, "name\t\tactive_count\tevent_count\twakeup_count\t"
+	seq_puts(m, "name\t\t\tactive_count\tevent_count\twakeup_count\t"
 		"expire_count\tactive_since\ttotal_time\tmax_time\t"
 		"last_change\tprevent_suspend_time\n");
 
diff --git a/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c b/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c
index 251eb70f..8ee03493 100644
--- a/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c
+++ b/ANDROID_3.4.5/drivers/base/regmap/regmap-debugfs.c
@@ -126,7 +126,7 @@ out:
 	return ret;
 }
 
-#undef REGMAP_ALLOW_WRITE_DEBUGFS
+#define REGMAP_ALLOW_WRITE_DEBUGFS
 #ifdef REGMAP_ALLOW_WRITE_DEBUGFS
 /*
  * This can be dangerous especially when we have clients such as
diff --git a/ANDROID_3.4.5/drivers/base/sync.c b/ANDROID_3.4.5/drivers/base/sync.c
index 809d02b2..ac9a1af0 100644
--- a/ANDROID_3.4.5/drivers/base/sync.c
+++ b/ANDROID_3.4.5/drivers/base/sync.c
@@ -31,6 +31,19 @@
 #define CREATE_TRACE_POINTS
 #include <trace/events/sync.h>
 
+/* Remove fence from sync_fence_list before release it. -- WonderMedia */
+#define FIX_SYNC_FENCE_LIST
+
+/* Limit number of pts per fence for speed. -- WonderMedia */
+#define SYNC_PTS_MAX 256
+
+#ifdef SYNC_PTS_MAX
+#include <linux/moduleparam.h>
+int sync_pts_max = SYNC_PTS_MAX;
+module_param(sync_pts_max, int, S_IRUSR | S_IWUSR | S_IWGRP | S_IRGRP | S_IROTH);
+MODULE_PARM_DESC(sync_pts_max, "Max pts per sync fence");
+#endif
+
 static void sync_fence_signal_pt(struct sync_pt *pt);
 static int _sync_pt_has_signaled(struct sync_pt *pt);
 static void sync_fence_free(struct kref *kref);
@@ -313,6 +326,9 @@ EXPORT_SYMBOL(sync_fence_create);
 static int sync_fence_copy_pts(struct sync_fence *dst, struct sync_fence *src)
 {
 	struct list_head *pos;
+#ifdef SYNC_PTS_MAX
+	int num_pts = 0;
+#endif
 
 	list_for_each(pos, &src->pt_list_head) {
 		struct sync_pt *orig_pt =
@@ -324,8 +340,16 @@ static int sync_fence_copy_pts(struct sync_fence *dst, struct sync_fence *src)
 
 		new_pt->fence = dst;
 		list_add(&new_pt->pt_list, &dst->pt_list_head);
-		sync_pt_activate(new_pt);
+#ifdef SYNC_PTS_MAX
+		num_pts++;
+#endif
 	}
+#ifdef SYNC_PTS_MAX
+	if (sync_pts_max && num_pts >= sync_pts_max) {
+		printk(KERN_ERR "too many pts per sync fence! %d\n", num_pts);
+		return -ENOMEM;
+	}
+#endif
 
 	return 0;
 }
@@ -356,7 +380,6 @@ static int sync_fence_merge_pts(struct sync_fence *dst, struct sync_fence *src)
 					new_pt->fence = dst;
 					list_replace(&dst_pt->pt_list,
 						     &new_pt->pt_list);
-					sync_pt_activate(new_pt);
 					sync_pt_free(dst_pt);
 				}
 				collapsed = true;
@@ -372,7 +395,6 @@ static int sync_fence_merge_pts(struct sync_fence *dst, struct sync_fence *src)
 
 			new_pt->fence = dst;
 			list_add(&new_pt->pt_list, &dst->pt_list_head);
-			sync_pt_activate(new_pt);
 		}
 	}
 
@@ -453,7 +475,11 @@ struct sync_fence *sync_fence_merge(const char *name,
 				    struct sync_fence *a, struct sync_fence *b)
 {
 	struct sync_fence *fence;
+	struct list_head *pos;
 	int err;
+#ifdef FIX_SYNC_FENCE_LIST
+	unsigned long flags;
+#endif
 
 	fence = sync_fence_alloc(name);
 	if (fence == NULL)
@@ -467,6 +493,12 @@ struct sync_fence *sync_fence_merge(const char *name,
 	if (err < 0)
 		goto err;
 
+	list_for_each(pos, &fence->pt_list_head) {
+		struct sync_pt *pt =
+			container_of(pos, struct sync_pt, pt_list);
+		sync_pt_activate(pt);
+	}
+
 	/*
 	 * signal the fence in case one of it's pts were activated before
 	 * they were activated
@@ -477,6 +509,11 @@ struct sync_fence *sync_fence_merge(const char *name,
 
 	return fence;
 err:
+#ifdef FIX_SYNC_FENCE_LIST
+	spin_lock_irqsave(&sync_fence_list_lock, flags);
+	list_del(&fence->sync_fence_list);
+	spin_unlock_irqrestore(&sync_fence_list_lock, flags);
+#endif
 	sync_fence_free_pts(fence);
 	kfree(fence);
 	return NULL;