Merge remote-tracking branch 'aosp/android-3.0' into develop-3.0

Conflicts:
	drivers/cpufreq/cpufreq_interactive.c
	drivers/net/wireless/bcmdhd/dhd_linux.c
	drivers/net/wireless/bcmdhd/wl_cfg80211.c
	scripts/Kbuild.include

diff --cc drivers/cpufreq/cpufreq_interactive.c
index ac8f31f726e5c2ac7637fdccba24d8f779460598,7d1952c5cb16da4401bfb334947e951c9babd827..07c2f3b944223a8e208b1bd58f17428b92440bfa
mode 100755,100644..100755
--- 1/drivers/cpufreq/cpufreq_interactive.c
--- 2/drivers/cpufreq/cpufreq_interactive.c
+++ b/drivers/cpufreq/cpufreq_interactive.c
@@@ -144,67 -286,25 +286,29 @@@ static void cpufreq_interactive_timer(u
        if (!pcpu->governor_enabled)
                goto exit;
  
-       /*
-        * Once pcpu->timer_run_time is updated to >= pcpu->idle_exit_time,
-        * this lets idle exit know the current idle time sample has
-        * been processed, and idle exit can generate a new sample and
-        * re-arm the timer.  This prevents a concurrent idle
-        * exit on that CPU from writing a new set of info at the same time
-        * the timer function runs (the timer function can't use that info
-        * until more time passes).
-        */
-       time_in_idle = pcpu->time_in_idle;
-       idle_exit_time = pcpu->idle_exit_time;
-       now_idle = get_cpu_idle_time_us(data, &pcpu->timer_run_time);
-       smp_wmb();
- 
-       /* If we raced with cancelling a timer, skip. */
-       if (!idle_exit_time)
-               goto exit;
- 
-       delta_idle = (unsigned int) cputime64_sub(now_idle, time_in_idle);
-       delta_time = (unsigned int) cputime64_sub(pcpu->timer_run_time,
-                                                 idle_exit_time);
+       spin_lock_irqsave(&pcpu->load_lock, flags);
+       now = update_load(data);
+       delta_time = (unsigned int)(now - pcpu->cputime_speedadj_timestamp);
+       cputime_speedadj = pcpu->cputime_speedadj;
+       spin_unlock_irqrestore(&pcpu->load_lock, flags);
  
-       /*
-        * If timer ran less than 1ms after short-term sample started, retry.
-        */
-       if (delta_time < 1000)
+       if (WARN_ON_ONCE(!delta_time))
                goto rearm;
  
-       if (delta_idle > delta_time)
-               cpu_load = 0;
-       else
-               cpu_load = 100 * (delta_time - delta_idle) / delta_time;
- 
-       delta_idle = (unsigned int) cputime64_sub(now_idle,
-                                               pcpu->target_set_time_in_idle);
-       delta_time = (unsigned int) cputime64_sub(pcpu->timer_run_time,
-                                                 pcpu->target_set_time);
- 
-       if ((delta_time == 0) || (delta_idle > delta_time))
-               load_since_change = 0;
-       else
-               load_since_change =
-                       100 * (delta_time - delta_idle) / delta_time;
- 
-       /*
-        * Choose greater of short-term load (since last idle timer
-        * started or timer function re-armed itself) or long-term load
-        * (since last frequency change).
-        */
-       if (load_since_change > cpu_load)
-               cpu_load = load_since_change;
+       do_div(cputime_speedadj, delta_time);
+       loadadjfreq = (unsigned int)cputime_speedadj * 100;
+       cpu_load = loadadjfreq / pcpu->target_freq;
+       boosted = boost_val || now < boostpulse_endtime;
  
-       if (cpu_load >= go_hispeed_load || boost_val) {
-               if (pcpu->target_freq <= pcpu->policy->min) {
 +#ifdef CONFIG_PLAT_RK
 +      pcpu->target_freq = pcpu->policy->cur;
 +#endif
 +
+       if (cpu_load >= go_hispeed_load || boosted) {
+               if (pcpu->target_freq < hispeed_freq) {
                        new_freq = hispeed_freq;
                } else {
-                       new_freq = pcpu->policy->max * cpu_load / 100;
+                       new_freq = choose_freq(pcpu, loadadjfreq);
  
                        if (new_freq < hispeed_freq)
                                new_freq = hispeed_freq;
@@@ -845,40 -914,38 +918,49 @@@ static int cpufreq_governor_interactive
                if (!cpu_online(policy->cpu))
                        return -EINVAL;
  
+               mutex_lock(&gov_lock);
+ 
                freq_table =
                        cpufreq_frequency_get_table(policy->cpu);
- 
-               for_each_cpu(j, policy->cpus) {
-                       pcpu = &per_cpu(cpuinfo, j);
-                       pcpu->policy = policy;
-                       pcpu->target_freq = policy->cur;
-                       pcpu->freq_table = freq_table;
-                       pcpu->target_set_time_in_idle =
-                               get_cpu_idle_time_us(j,
-                                            &pcpu->target_set_time);
-                       pcpu->floor_freq = pcpu->target_freq;
-                       pcpu->floor_validate_time =
-                               pcpu->target_set_time;
-                       pcpu->hispeed_validate_time =
-                               pcpu->target_set_time;
-                       pcpu->governor_enabled = 1;
-                       smp_wmb();
-               }
- 
                if (!hispeed_freq)
 +#ifdef CONFIG_PLAT_RK
 +              {
 +                      unsigned int index;
                        hispeed_freq = policy->max;
 +                      if (policy->min < 816000)
 +                              hispeed_freq = 816000;
 +                      else if (cpufreq_frequency_table_target(policy, freq_table, policy->min + 1, CPUFREQ_RELATION_L, &index) == 0)
 +                              hispeed_freq = freq_table[index].frequency;
 +              }
 +#else
 +                      hispeed_freq = policy->max;
 +#endif
  
+               for_each_cpu(j, policy->cpus) {
+                       unsigned long expires;
+ 
+                       pcpu = &per_cpu(cpuinfo, j);
+                       pcpu->policy = policy;
+                       pcpu->target_freq = policy->cur;
+                       pcpu->freq_table = freq_table;
+                       pcpu->floor_freq = pcpu->target_freq;
+                       pcpu->floor_validate_time =
+                               ktime_to_us(ktime_get());
+                       pcpu->hispeed_validate_time =
+                               pcpu->floor_validate_time;
+                       down_write(&pcpu->enable_sem);
+                       expires = jiffies + usecs_to_jiffies(timer_rate);
+                       pcpu->cpu_timer.expires = expires;
+                       add_timer_on(&pcpu->cpu_timer, j);
+                       if (timer_slack_val >= 0) {
+                               expires += usecs_to_jiffies(timer_slack_val);
+                               pcpu->cpu_slack_timer.expires = expires;
+                               add_timer_on(&pcpu->cpu_slack_timer, j);
+                       }
+                       pcpu->governor_enabled = 1;
+                       up_write(&pcpu->enable_sem);
+               }
+ 
                /*
                 * Do not register the idle hook and create sysfs
                 * entries if we have already done so.