diff options
author | venkatesh.pallipadi@intel.com <venkatesh.pallipadi@intel.com> | 2009-07-02 20:08:32 -0400 |
---|---|---|
committer | Dave Jones <davej@redhat.com> | 2009-07-06 21:38:28 -0400 |
commit | 5a75c82828e7c088ca6e7b4827911dc29cc8e774 (patch) | |
tree | 65d155c6f277de757778eb8d91d1556f7198362c | |
parent | 37c90e8887efd218dc4af949b7f498ca2da4af9f (diff) |
[CPUFREQ] Cleanup locking in ondemand governor
Redesign the locking inside ondemand driver. Make dbs_mutex handle all the
global state changes inside the driver and invent a new percpu mutex
to serialize percpu timer and frequency limit change.
Signed-off-by: Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
Signed-off-by: Dave Jones <davej@redhat.com>
-rw-r--r-- | drivers/cpufreq/cpufreq_ondemand.c | 62 |
1 files changed, 27 insertions, 35 deletions
diff --git a/drivers/cpufreq/cpufreq_ondemand.c b/drivers/cpufreq/cpufreq_ondemand.c index 246ae147df74..d6ba14276bb1 100644 --- a/drivers/cpufreq/cpufreq_ondemand.c +++ b/drivers/cpufreq/cpufreq_ondemand.c | |||
@@ -70,8 +70,13 @@ struct cpu_dbs_info_s { | |||
70 | unsigned int freq_lo_jiffies; | 70 | unsigned int freq_lo_jiffies; |
71 | unsigned int freq_hi_jiffies; | 71 | unsigned int freq_hi_jiffies; |
72 | int cpu; | 72 | int cpu; |
73 | unsigned int enable:1, | 73 | unsigned int sample_type:1; |
74 | sample_type:1; | 74 | /* |
75 | * percpu mutex that serializes governor limit change with | ||
76 | * do_dbs_timer invocation. We do not want do_dbs_timer to run | ||
77 | * when user is changing the governor or limits. | ||
78 | */ | ||
79 | struct mutex timer_mutex; | ||
75 | }; | 80 | }; |
76 | static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info); | 81 | static DEFINE_PER_CPU(struct cpu_dbs_info_s, cpu_dbs_info); |
77 | 82 | ||
@@ -79,9 +84,7 @@ static unsigned int dbs_enable; /* number of CPUs using this policy */ | |||
79 | 84 | ||
80 | /* | 85 | /* |
81 | * dbs_mutex protects data in dbs_tuners_ins from concurrent changes on | 86 | * dbs_mutex protects data in dbs_tuners_ins from concurrent changes on |
82 | * different CPUs. It protects dbs_enable in governor start/stop. It also | 87 | * different CPUs. It protects dbs_enable in governor start/stop. |
83 | * serializes governor limit_change with do_dbs_timer. We do not want | ||
84 | * do_dbs_timer to run when user is changing the governor or limits. | ||
85 | */ | 88 | */ |
86 | static DEFINE_MUTEX(dbs_mutex); | 89 | static DEFINE_MUTEX(dbs_mutex); |
87 | 90 | ||
@@ -187,13 +190,18 @@ static unsigned int powersave_bias_target(struct cpufreq_policy *policy, | |||
187 | return freq_hi; | 190 | return freq_hi; |
188 | } | 191 | } |
189 | 192 | ||
193 | static void ondemand_powersave_bias_init_cpu(int cpu) | ||
194 | { | ||
195 | struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, cpu); | ||
196 | dbs_info->freq_table = cpufreq_frequency_get_table(cpu); | ||
197 | dbs_info->freq_lo = 0; | ||
198 | } | ||
199 | |||
190 | static void ondemand_powersave_bias_init(void) | 200 | static void ondemand_powersave_bias_init(void) |
191 | { | 201 | { |
192 | int i; | 202 | int i; |
193 | for_each_online_cpu(i) { | 203 | for_each_online_cpu(i) { |
194 | struct cpu_dbs_info_s *dbs_info = &per_cpu(cpu_dbs_info, i); | 204 | ondemand_powersave_bias_init_cpu(i); |
195 | dbs_info->freq_table = cpufreq_frequency_get_table(i); | ||
196 | dbs_info->freq_lo = 0; | ||
197 | } | 205 | } |
198 | } | 206 | } |
199 | 207 | ||
@@ -235,12 +243,10 @@ static ssize_t store_sampling_rate(struct cpufreq_policy *unused, | |||
235 | unsigned int input; | 243 | unsigned int input; |
236 | int ret; | 244 | int ret; |
237 | ret = sscanf(buf, "%u", &input); | 245 | ret = sscanf(buf, "%u", &input); |
246 | if (ret != 1) | ||
247 | return -EINVAL; | ||
238 | 248 | ||
239 | mutex_lock(&dbs_mutex); | 249 | mutex_lock(&dbs_mutex); |
240 | if (ret != 1) { | ||
241 | mutex_unlock(&dbs_mutex); | ||
242 | return -EINVAL; | ||
243 | } | ||
244 | dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate); | 250 | dbs_tuners_ins.sampling_rate = max(input, min_sampling_rate); |
245 | mutex_unlock(&dbs_mutex); | 251 | mutex_unlock(&dbs_mutex); |
246 | 252 | ||
@@ -254,13 +260,12 @@ static ssize_t store_up_threshold(struct cpufreq_policy *unused, | |||
254 | int ret; | 260 | int ret; |
255 | ret = sscanf(buf, "%u", &input); | 261 | ret = sscanf(buf, "%u", &input); |
256 | 262 | ||
257 | mutex_lock(&dbs_mutex); | ||
258 | if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || | 263 | if (ret != 1 || input > MAX_FREQUENCY_UP_THRESHOLD || |
259 | input < MIN_FREQUENCY_UP_THRESHOLD) { | 264 | input < MIN_FREQUENCY_UP_THRESHOLD) { |
260 | mutex_unlock(&dbs_mutex); | ||
261 | return -EINVAL; | 265 | return -EINVAL; |
262 | } | 266 | } |
263 | 267 | ||
268 | mutex_lock(&dbs_mutex); | ||
264 | dbs_tuners_ins.up_threshold = input; | 269 | dbs_tuners_ins.up_threshold = input; |
265 | mutex_unlock(&dbs_mutex); | 270 | mutex_unlock(&dbs_mutex); |
266 | 271 | ||
@@ -358,9 +363,6 @@ static void dbs_check_cpu(struct cpu_dbs_info_s *this_dbs_info) | |||
358 | struct cpufreq_policy *policy; | 363 | struct cpufreq_policy *policy; |
359 | unsigned int j; | 364 | unsigned int j; |
360 | 365 | ||
361 | if (!this_dbs_info->enable) | ||
362 | return; | ||
363 | |||
364 | this_dbs_info->freq_lo = 0; | 366 | this_dbs_info->freq_lo = 0; |
365 | policy = this_dbs_info->cur_policy; | 367 | policy = this_dbs_info->cur_policy; |
366 | 368 | ||
@@ -488,13 +490,7 @@ static void do_dbs_timer(struct work_struct *work) | |||
488 | int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); | 490 | int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); |
489 | 491 | ||
490 | delay -= jiffies % delay; | 492 | delay -= jiffies % delay; |
491 | 493 | mutex_lock(&dbs_info->timer_mutex); | |
492 | mutex_lock(&dbs_mutex); | ||
493 | |||
494 | if (!dbs_info->enable) { | ||
495 | mutex_unlock(&dbs_mutex); | ||
496 | return; | ||
497 | } | ||
498 | 494 | ||
499 | /* Common NORMAL_SAMPLE setup */ | 495 | /* Common NORMAL_SAMPLE setup */ |
500 | dbs_info->sample_type = DBS_NORMAL_SAMPLE; | 496 | dbs_info->sample_type = DBS_NORMAL_SAMPLE; |
@@ -511,7 +507,7 @@ static void do_dbs_timer(struct work_struct *work) | |||
511 | dbs_info->freq_lo, CPUFREQ_RELATION_H); | 507 | dbs_info->freq_lo, CPUFREQ_RELATION_H); |
512 | } | 508 | } |
513 | queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay); | 509 | queue_delayed_work_on(cpu, kondemand_wq, &dbs_info->work, delay); |
514 | mutex_unlock(&dbs_mutex); | 510 | mutex_unlock(&dbs_info->timer_mutex); |
515 | } | 511 | } |
516 | 512 | ||
517 | static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) | 513 | static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) |
@@ -520,8 +516,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) | |||
520 | int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); | 516 | int delay = usecs_to_jiffies(dbs_tuners_ins.sampling_rate); |
521 | delay -= jiffies % delay; | 517 | delay -= jiffies % delay; |
522 | 518 | ||
523 | dbs_info->enable = 1; | ||
524 | ondemand_powersave_bias_init(); | ||
525 | dbs_info->sample_type = DBS_NORMAL_SAMPLE; | 519 | dbs_info->sample_type = DBS_NORMAL_SAMPLE; |
526 | INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer); | 520 | INIT_DELAYED_WORK_DEFERRABLE(&dbs_info->work, do_dbs_timer); |
527 | queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work, | 521 | queue_delayed_work_on(dbs_info->cpu, kondemand_wq, &dbs_info->work, |
@@ -530,7 +524,6 @@ static inline void dbs_timer_init(struct cpu_dbs_info_s *dbs_info) | |||
530 | 524 | ||
531 | static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info) | 525 | static inline void dbs_timer_exit(struct cpu_dbs_info_s *dbs_info) |
532 | { | 526 | { |
533 | dbs_info->enable = 0; | ||
534 | cancel_delayed_work_sync(&dbs_info->work); | 527 | cancel_delayed_work_sync(&dbs_info->work); |
535 | } | 528 | } |
536 | 529 | ||
@@ -549,19 +542,15 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, | |||
549 | if ((!cpu_online(cpu)) || (!policy->cur)) | 542 | if ((!cpu_online(cpu)) || (!policy->cur)) |
550 | return -EINVAL; | 543 | return -EINVAL; |
551 | 544 | ||
552 | if (this_dbs_info->enable) /* Already enabled */ | ||
553 | break; | ||
554 | |||
555 | mutex_lock(&dbs_mutex); | 545 | mutex_lock(&dbs_mutex); |
556 | dbs_enable++; | ||
557 | 546 | ||
558 | rc = sysfs_create_group(&policy->kobj, &dbs_attr_group); | 547 | rc = sysfs_create_group(&policy->kobj, &dbs_attr_group); |
559 | if (rc) { | 548 | if (rc) { |
560 | dbs_enable--; | ||
561 | mutex_unlock(&dbs_mutex); | 549 | mutex_unlock(&dbs_mutex); |
562 | return rc; | 550 | return rc; |
563 | } | 551 | } |
564 | 552 | ||
553 | dbs_enable++; | ||
565 | for_each_cpu(j, policy->cpus) { | 554 | for_each_cpu(j, policy->cpus) { |
566 | struct cpu_dbs_info_s *j_dbs_info; | 555 | struct cpu_dbs_info_s *j_dbs_info; |
567 | j_dbs_info = &per_cpu(cpu_dbs_info, j); | 556 | j_dbs_info = &per_cpu(cpu_dbs_info, j); |
@@ -575,6 +564,8 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, | |||
575 | } | 564 | } |
576 | } | 565 | } |
577 | this_dbs_info->cpu = cpu; | 566 | this_dbs_info->cpu = cpu; |
567 | ondemand_powersave_bias_init_cpu(cpu); | ||
568 | mutex_init(&this_dbs_info->timer_mutex); | ||
578 | /* | 569 | /* |
579 | * Start the timerschedule work, when this governor | 570 | * Start the timerschedule work, when this governor |
580 | * is used for first time | 571 | * is used for first time |
@@ -602,20 +593,21 @@ static int cpufreq_governor_dbs(struct cpufreq_policy *policy, | |||
602 | 593 | ||
603 | mutex_lock(&dbs_mutex); | 594 | mutex_lock(&dbs_mutex); |
604 | sysfs_remove_group(&policy->kobj, &dbs_attr_group); | 595 | sysfs_remove_group(&policy->kobj, &dbs_attr_group); |
596 | mutex_destroy(&this_dbs_info->timer_mutex); | ||
605 | dbs_enable--; | 597 | dbs_enable--; |
606 | mutex_unlock(&dbs_mutex); | 598 | mutex_unlock(&dbs_mutex); |
607 | 599 | ||
608 | break; | 600 | break; |
609 | 601 | ||
610 | case CPUFREQ_GOV_LIMITS: | 602 | case CPUFREQ_GOV_LIMITS: |
611 | mutex_lock(&dbs_mutex); | 603 | mutex_lock(&this_dbs_info->timer_mutex); |
612 | if (policy->max < this_dbs_info->cur_policy->cur) | 604 | if (policy->max < this_dbs_info->cur_policy->cur) |
613 | __cpufreq_driver_target(this_dbs_info->cur_policy, | 605 | __cpufreq_driver_target(this_dbs_info->cur_policy, |
614 | policy->max, CPUFREQ_RELATION_H); | 606 | policy->max, CPUFREQ_RELATION_H); |
615 | else if (policy->min > this_dbs_info->cur_policy->cur) | 607 | else if (policy->min > this_dbs_info->cur_policy->cur) |
616 | __cpufreq_driver_target(this_dbs_info->cur_policy, | 608 | __cpufreq_driver_target(this_dbs_info->cur_policy, |
617 | policy->min, CPUFREQ_RELATION_L); | 609 | policy->min, CPUFREQ_RELATION_L); |
618 | mutex_unlock(&dbs_mutex); | 610 | mutex_unlock(&this_dbs_info->timer_mutex); |
619 | break; | 611 | break; |
620 | } | 612 | } |
621 | return 0; | 613 | return 0; |