2 * acpi_pad.c ACPI Processor Aggregator Driver
4 * Copyright (c) 2009, Intel Corporation.
6 * This program is free software; you can redistribute it and/or modify it
7 * under the terms and conditions of the GNU General Public License,
8 * version 2, as published by the Free Software Foundation.
10 * This program is distributed in the hope it will be useful, but WITHOUT
11 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
12 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
15 * You should have received a copy of the GNU General Public License along with
16 * this program; if not, write to the Free Software Foundation, Inc.,
17 * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
21 #include <linux/kernel.h>
22 #include <linux/cpumask.h>
23 #include <linux/module.h>
24 #include <linux/init.h>
25 #include <linux/types.h>
26 #include <linux/kthread.h>
27 #include <linux/freezer.h>
28 #include <linux/cpu.h>
29 #include <linux/clockchips.h>
30 #include <linux/slab.h>
31 #include <acpi/acpi_bus.h>
32 #include <acpi/acpi_drivers.h>
34 #define ACPI_PROCESSOR_AGGREGATOR_CLASS "acpi_pad"
35 #define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"
36 #define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80
37 static DEFINE_MUTEX(isolated_cpus_lock
);
39 #define MWAIT_SUBSTATE_MASK (0xf)
40 #define MWAIT_CSTATE_MASK (0xf)
41 #define MWAIT_SUBSTATE_SIZE (4)
42 #define CPUID_MWAIT_LEAF (5)
43 #define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1)
44 #define CPUID5_ECX_INTERRUPT_BREAK (0x2)
45 static unsigned long power_saving_mwait_eax
;
47 static unsigned char tsc_detected_unstable
;
48 static unsigned char tsc_marked_unstable
;
49 static unsigned char lapic_detected_unstable
;
50 static unsigned char lapic_marked_unstable
;
52 static void power_saving_mwait_init(void)
54 unsigned int eax
, ebx
, ecx
, edx
;
55 unsigned int highest_cstate
= 0;
56 unsigned int highest_subcstate
= 0;
59 if (!boot_cpu_has(X86_FEATURE_MWAIT
))
61 if (boot_cpu_data
.cpuid_level
< CPUID_MWAIT_LEAF
)
64 cpuid(CPUID_MWAIT_LEAF
, &eax
, &ebx
, &ecx
, &edx
);
66 if (!(ecx
& CPUID5_ECX_EXTENSIONS_SUPPORTED
) ||
67 !(ecx
& CPUID5_ECX_INTERRUPT_BREAK
))
70 edx
>>= MWAIT_SUBSTATE_SIZE
;
71 for (i
= 0; i
< 7 && edx
; i
++, edx
>>= MWAIT_SUBSTATE_SIZE
) {
72 if (edx
& MWAIT_SUBSTATE_MASK
) {
74 highest_subcstate
= edx
& MWAIT_SUBSTATE_MASK
;
77 power_saving_mwait_eax
= (highest_cstate
<< MWAIT_SUBSTATE_SIZE
) |
78 (highest_subcstate
- 1);
80 #if defined(CONFIG_X86)
81 switch (boot_cpu_data
.x86_vendor
) {
83 case X86_VENDOR_INTEL
:
85 * AMD Fam10h TSC will tick in all
86 * C/P/S0/S1 states when this bit is set.
88 if (!boot_cpu_has(X86_FEATURE_NONSTOP_TSC
))
89 tsc_detected_unstable
= 1;
90 if (!boot_cpu_has(X86_FEATURE_ARAT
))
91 lapic_detected_unstable
= 1;
94 /* TSC & LAPIC could halt in idle */
95 tsc_detected_unstable
= 1;
96 lapic_detected_unstable
= 1;
101 static unsigned long cpu_weight
[NR_CPUS
];
102 static int tsk_in_cpu
[NR_CPUS
] = {[0 ... NR_CPUS
-1] = -1};
103 static DECLARE_BITMAP(pad_busy_cpus_bits
, NR_CPUS
);
104 static void round_robin_cpu(unsigned int tsk_index
)
106 struct cpumask
*pad_busy_cpus
= to_cpumask(pad_busy_cpus_bits
);
109 unsigned long min_weight
= -1;
110 unsigned long uninitialized_var(preferred_cpu
);
112 if (!alloc_cpumask_var(&tmp
, GFP_KERNEL
))
115 mutex_lock(&isolated_cpus_lock
);
117 for_each_cpu(cpu
, pad_busy_cpus
)
118 cpumask_or(tmp
, tmp
, topology_thread_cpumask(cpu
));
119 cpumask_andnot(tmp
, cpu_online_mask
, tmp
);
120 /* avoid HT sibilings if possible */
121 if (cpumask_empty(tmp
))
122 cpumask_andnot(tmp
, cpu_online_mask
, pad_busy_cpus
);
123 if (cpumask_empty(tmp
)) {
124 mutex_unlock(&isolated_cpus_lock
);
127 for_each_cpu(cpu
, tmp
) {
128 if (cpu_weight
[cpu
] < min_weight
) {
129 min_weight
= cpu_weight
[cpu
];
134 if (tsk_in_cpu
[tsk_index
] != -1)
135 cpumask_clear_cpu(tsk_in_cpu
[tsk_index
], pad_busy_cpus
);
136 tsk_in_cpu
[tsk_index
] = preferred_cpu
;
137 cpumask_set_cpu(preferred_cpu
, pad_busy_cpus
);
138 cpu_weight
[preferred_cpu
]++;
139 mutex_unlock(&isolated_cpus_lock
);
141 set_cpus_allowed_ptr(current
, cpumask_of(preferred_cpu
));
144 static void exit_round_robin(unsigned int tsk_index
)
146 struct cpumask
*pad_busy_cpus
= to_cpumask(pad_busy_cpus_bits
);
147 cpumask_clear_cpu(tsk_in_cpu
[tsk_index
], pad_busy_cpus
);
148 tsk_in_cpu
[tsk_index
] = -1;
151 static unsigned int idle_pct
= 5; /* percentage */
152 static unsigned int round_robin_time
= 10; /* second */
153 static int power_saving_thread(void *data
)
155 struct sched_param param
= {.sched_priority
= 1};
157 unsigned int tsk_index
= (unsigned long)data
;
158 u64 last_jiffies
= 0;
160 sched_setscheduler(current
, SCHED_RR
, ¶m
);
162 while (!kthread_should_stop()) {
168 /* round robin to cpus */
169 if (last_jiffies
+ round_robin_time
* HZ
< jiffies
) {
170 last_jiffies
= jiffies
;
171 round_robin_cpu(tsk_index
);
176 expire_time
= jiffies
+ HZ
* (100 - idle_pct
) / 100;
178 while (!need_resched()) {
179 if (tsc_detected_unstable
&& !tsc_marked_unstable
) {
180 /* TSC could halt in idle, so notify users */
181 mark_tsc_unstable("TSC halts in idle");
182 tsc_marked_unstable
= 1;
184 if (lapic_detected_unstable
&& !lapic_marked_unstable
) {
186 /* LAPIC could halt in idle, so notify users */
187 for_each_online_cpu(i
)
189 CLOCK_EVT_NOTIFY_BROADCAST_ON
,
191 lapic_marked_unstable
= 1;
194 cpu
= smp_processor_id();
195 if (lapic_marked_unstable
)
197 CLOCK_EVT_NOTIFY_BROADCAST_ENTER
, &cpu
);
198 stop_critical_timings();
200 __monitor((void *)¤t_thread_info()->flags
, 0, 0);
203 __mwait(power_saving_mwait_eax
, 1);
205 start_critical_timings();
206 if (lapic_marked_unstable
)
208 CLOCK_EVT_NOTIFY_BROADCAST_EXIT
, &cpu
);
211 if (jiffies
> expire_time
) {
218 * current sched_rt has threshold for rt task running time.
219 * When a rt task uses 95% CPU time, the rt thread will be
220 * scheduled out for 5% CPU time to not starve other tasks. But
221 * the mechanism only works when all CPUs have RT task running,
222 * as if one CPU hasn't RT task, RT task from other CPUs will
223 * borrow CPU time from this CPU and cause RT task use > 95%
224 * CPU time. To make 'avoid starvation' work, takes a nap here.
227 schedule_timeout_killable(HZ
* idle_pct
/ 100);
230 exit_round_robin(tsk_index
);
234 static struct task_struct
*ps_tsks
[NR_CPUS
];
235 static unsigned int ps_tsk_num
;
236 static int create_power_saving_task(void)
240 ps_tsks
[ps_tsk_num
] = kthread_run(power_saving_thread
,
241 (void *)(unsigned long)ps_tsk_num
,
242 "power_saving/%d", ps_tsk_num
);
243 rc
= IS_ERR(ps_tsks
[ps_tsk_num
]) ? PTR_ERR(ps_tsks
[ps_tsk_num
]) : 0;
247 ps_tsks
[ps_tsk_num
] = NULL
;
252 static void destroy_power_saving_task(void)
254 if (ps_tsk_num
> 0) {
256 kthread_stop(ps_tsks
[ps_tsk_num
]);
257 ps_tsks
[ps_tsk_num
] = NULL
;
261 static void set_power_saving_task_num(unsigned int num
)
263 if (num
> ps_tsk_num
) {
264 while (ps_tsk_num
< num
) {
265 if (create_power_saving_task())
268 } else if (num
< ps_tsk_num
) {
269 while (ps_tsk_num
> num
)
270 destroy_power_saving_task();
274 static void acpi_pad_idle_cpus(unsigned int num_cpus
)
278 num_cpus
= min_t(unsigned int, num_cpus
, num_online_cpus());
279 set_power_saving_task_num(num_cpus
);
284 static uint32_t acpi_pad_idle_cpus_num(void)
289 static ssize_t
acpi_pad_rrtime_store(struct device
*dev
,
290 struct device_attribute
*attr
, const char *buf
, size_t count
)
293 if (strict_strtoul(buf
, 0, &num
))
295 if (num
< 1 || num
>= 100)
297 mutex_lock(&isolated_cpus_lock
);
298 round_robin_time
= num
;
299 mutex_unlock(&isolated_cpus_lock
);
303 static ssize_t
acpi_pad_rrtime_show(struct device
*dev
,
304 struct device_attribute
*attr
, char *buf
)
306 return scnprintf(buf
, PAGE_SIZE
, "%d", round_robin_time
);
308 static DEVICE_ATTR(rrtime
, S_IRUGO
|S_IWUSR
,
309 acpi_pad_rrtime_show
,
310 acpi_pad_rrtime_store
);
312 static ssize_t
acpi_pad_idlepct_store(struct device
*dev
,
313 struct device_attribute
*attr
, const char *buf
, size_t count
)
316 if (strict_strtoul(buf
, 0, &num
))
318 if (num
< 1 || num
>= 100)
320 mutex_lock(&isolated_cpus_lock
);
322 mutex_unlock(&isolated_cpus_lock
);
326 static ssize_t
acpi_pad_idlepct_show(struct device
*dev
,
327 struct device_attribute
*attr
, char *buf
)
329 return scnprintf(buf
, PAGE_SIZE
, "%d", idle_pct
);
331 static DEVICE_ATTR(idlepct
, S_IRUGO
|S_IWUSR
,
332 acpi_pad_idlepct_show
,
333 acpi_pad_idlepct_store
);
335 static ssize_t
acpi_pad_idlecpus_store(struct device
*dev
,
336 struct device_attribute
*attr
, const char *buf
, size_t count
)
339 if (strict_strtoul(buf
, 0, &num
))
341 mutex_lock(&isolated_cpus_lock
);
342 acpi_pad_idle_cpus(num
);
343 mutex_unlock(&isolated_cpus_lock
);
347 static ssize_t
acpi_pad_idlecpus_show(struct device
*dev
,
348 struct device_attribute
*attr
, char *buf
)
350 return cpumask_scnprintf(buf
, PAGE_SIZE
,
351 to_cpumask(pad_busy_cpus_bits
));
353 static DEVICE_ATTR(idlecpus
, S_IRUGO
|S_IWUSR
,
354 acpi_pad_idlecpus_show
,
355 acpi_pad_idlecpus_store
);
357 static int acpi_pad_add_sysfs(struct acpi_device
*device
)
361 result
= device_create_file(&device
->dev
, &dev_attr_idlecpus
);
364 result
= device_create_file(&device
->dev
, &dev_attr_idlepct
);
366 device_remove_file(&device
->dev
, &dev_attr_idlecpus
);
369 result
= device_create_file(&device
->dev
, &dev_attr_rrtime
);
371 device_remove_file(&device
->dev
, &dev_attr_idlecpus
);
372 device_remove_file(&device
->dev
, &dev_attr_idlepct
);
378 static void acpi_pad_remove_sysfs(struct acpi_device
*device
)
380 device_remove_file(&device
->dev
, &dev_attr_idlecpus
);
381 device_remove_file(&device
->dev
, &dev_attr_idlepct
);
382 device_remove_file(&device
->dev
, &dev_attr_rrtime
);
386 * Query firmware how many CPUs should be idle
387 * return -1 on failure
389 static int acpi_pad_pur(acpi_handle handle
)
391 struct acpi_buffer buffer
= {ACPI_ALLOCATE_BUFFER
, NULL
};
392 union acpi_object
*package
;
395 if (ACPI_FAILURE(acpi_evaluate_object(handle
, "_PUR", NULL
, &buffer
)))
398 if (!buffer
.length
|| !buffer
.pointer
)
401 package
= buffer
.pointer
;
403 if (package
->type
== ACPI_TYPE_PACKAGE
&&
404 package
->package
.count
== 2 &&
405 package
->package
.elements
[0].integer
.value
== 1) /* rev 1 */
407 num
= package
->package
.elements
[1].integer
.value
;
409 kfree(buffer
.pointer
);
413 /* Notify firmware how many CPUs are idle */
414 static void acpi_pad_ost(acpi_handle handle
, int stat
,
417 union acpi_object params
[3] = {
418 {.type
= ACPI_TYPE_INTEGER
,},
419 {.type
= ACPI_TYPE_INTEGER
,},
420 {.type
= ACPI_TYPE_BUFFER
,},
422 struct acpi_object_list arg_list
= {3, params
};
424 params
[0].integer
.value
= ACPI_PROCESSOR_AGGREGATOR_NOTIFY
;
425 params
[1].integer
.value
= stat
;
426 params
[2].buffer
.length
= 4;
427 params
[2].buffer
.pointer
= (void *)&idle_cpus
;
428 acpi_evaluate_object(handle
, "_OST", &arg_list
, NULL
);
431 static void acpi_pad_handle_notify(acpi_handle handle
)
436 mutex_lock(&isolated_cpus_lock
);
437 num_cpus
= acpi_pad_pur(handle
);
439 mutex_unlock(&isolated_cpus_lock
);
442 acpi_pad_idle_cpus(num_cpus
);
443 idle_cpus
= acpi_pad_idle_cpus_num();
444 acpi_pad_ost(handle
, 0, idle_cpus
);
445 mutex_unlock(&isolated_cpus_lock
);
448 static void acpi_pad_notify(acpi_handle handle
, u32 event
,
451 struct acpi_device
*device
= data
;
454 case ACPI_PROCESSOR_AGGREGATOR_NOTIFY
:
455 acpi_pad_handle_notify(handle
);
456 acpi_bus_generate_proc_event(device
, event
, 0);
457 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
458 dev_name(&device
->dev
), event
, 0);
461 printk(KERN_WARNING
"Unsupported event [0x%x]\n", event
);
466 static int acpi_pad_add(struct acpi_device
*device
)
470 strcpy(acpi_device_name(device
), ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME
);
471 strcpy(acpi_device_class(device
), ACPI_PROCESSOR_AGGREGATOR_CLASS
);
473 if (acpi_pad_add_sysfs(device
))
476 status
= acpi_install_notify_handler(device
->handle
,
477 ACPI_DEVICE_NOTIFY
, acpi_pad_notify
, device
);
478 if (ACPI_FAILURE(status
)) {
479 acpi_pad_remove_sysfs(device
);
486 static int acpi_pad_remove(struct acpi_device
*device
,
489 mutex_lock(&isolated_cpus_lock
);
490 acpi_pad_idle_cpus(0);
491 mutex_unlock(&isolated_cpus_lock
);
493 acpi_remove_notify_handler(device
->handle
,
494 ACPI_DEVICE_NOTIFY
, acpi_pad_notify
);
495 acpi_pad_remove_sysfs(device
);
499 static const struct acpi_device_id pad_device_ids
[] = {
503 MODULE_DEVICE_TABLE(acpi
, pad_device_ids
);
505 static struct acpi_driver acpi_pad_driver
= {
506 .name
= "processor_aggregator",
507 .class = ACPI_PROCESSOR_AGGREGATOR_CLASS
,
508 .ids
= pad_device_ids
,
511 .remove
= acpi_pad_remove
,
515 static int __init
acpi_pad_init(void)
517 power_saving_mwait_init();
518 if (power_saving_mwait_eax
== 0)
521 return acpi_bus_register_driver(&acpi_pad_driver
);
524 static void __exit
acpi_pad_exit(void)
526 acpi_bus_unregister_driver(&acpi_pad_driver
);
529 module_init(acpi_pad_init
);
530 module_exit(acpi_pad_exit
);
531 MODULE_AUTHOR("Shaohua Li<shaohua.li@intel.com>");
532 MODULE_DESCRIPTION("ACPI Processor Aggregator Driver");
533 MODULE_LICENSE("GPL");