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 <acpi/acpi_bus.h>
31 #include <acpi/acpi_drivers.h>
33 #define ACPI_PROCESSOR_AGGREGATOR_CLASS "processor_aggregator"
34 #define ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME "Processor Aggregator"
35 #define ACPI_PROCESSOR_AGGREGATOR_NOTIFY 0x80
36 static DEFINE_MUTEX(isolated_cpus_lock
);
38 #define MWAIT_SUBSTATE_MASK (0xf)
39 #define MWAIT_CSTATE_MASK (0xf)
40 #define MWAIT_SUBSTATE_SIZE (4)
41 #define CPUID_MWAIT_LEAF (5)
42 #define CPUID5_ECX_EXTENSIONS_SUPPORTED (0x1)
43 #define CPUID5_ECX_INTERRUPT_BREAK (0x2)
44 static unsigned long power_saving_mwait_eax
;
45 static void power_saving_mwait_init(void)
47 unsigned int eax
, ebx
, ecx
, edx
;
48 unsigned int highest_cstate
= 0;
49 unsigned int highest_subcstate
= 0;
52 if (!boot_cpu_has(X86_FEATURE_MWAIT
))
54 if (boot_cpu_data
.cpuid_level
< CPUID_MWAIT_LEAF
)
57 cpuid(CPUID_MWAIT_LEAF
, &eax
, &ebx
, &ecx
, &edx
);
59 if (!(ecx
& CPUID5_ECX_EXTENSIONS_SUPPORTED
) ||
60 !(ecx
& CPUID5_ECX_INTERRUPT_BREAK
))
63 edx
>>= MWAIT_SUBSTATE_SIZE
;
64 for (i
= 0; i
< 7 && edx
; i
++, edx
>>= MWAIT_SUBSTATE_SIZE
) {
65 if (edx
& MWAIT_SUBSTATE_MASK
) {
67 highest_subcstate
= edx
& MWAIT_SUBSTATE_MASK
;
70 power_saving_mwait_eax
= (highest_cstate
<< MWAIT_SUBSTATE_SIZE
) |
71 (highest_subcstate
- 1);
73 for_each_online_cpu(i
)
74 clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ON
, &i
);
76 #if defined(CONFIG_GENERIC_TIME) && defined(CONFIG_X86)
77 switch (boot_cpu_data
.x86_vendor
) {
79 case X86_VENDOR_INTEL
:
81 * AMD Fam10h TSC will tick in all
82 * C/P/S0/S1 states when this bit is set.
84 if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC
))
89 /* TSC could halt in idle, so notify users */
90 mark_tsc_unstable("TSC halts in idle");
95 static unsigned long cpu_weight
[NR_CPUS
];
96 static int tsk_in_cpu
[NR_CPUS
] = {[0 ... NR_CPUS
-1] = -1};
97 static DECLARE_BITMAP(pad_busy_cpus_bits
, NR_CPUS
);
98 static void round_robin_cpu(unsigned int tsk_index
)
100 struct cpumask
*pad_busy_cpus
= to_cpumask(pad_busy_cpus_bits
);
103 unsigned long min_weight
= -1;
104 unsigned long uninitialized_var(preferred_cpu
);
106 if (!alloc_cpumask_var(&tmp
, GFP_KERNEL
))
109 mutex_lock(&isolated_cpus_lock
);
111 for_each_cpu(cpu
, pad_busy_cpus
)
112 cpumask_or(tmp
, tmp
, topology_thread_cpumask(cpu
));
113 cpumask_andnot(tmp
, cpu_online_mask
, tmp
);
114 /* avoid HT sibilings if possible */
115 if (cpumask_empty(tmp
))
116 cpumask_andnot(tmp
, cpu_online_mask
, pad_busy_cpus
);
117 if (cpumask_empty(tmp
)) {
118 mutex_unlock(&isolated_cpus_lock
);
121 for_each_cpu(cpu
, tmp
) {
122 if (cpu_weight
[cpu
] < min_weight
) {
123 min_weight
= cpu_weight
[cpu
];
128 if (tsk_in_cpu
[tsk_index
] != -1)
129 cpumask_clear_cpu(tsk_in_cpu
[tsk_index
], pad_busy_cpus
);
130 tsk_in_cpu
[tsk_index
] = preferred_cpu
;
131 cpumask_set_cpu(preferred_cpu
, pad_busy_cpus
);
132 cpu_weight
[preferred_cpu
]++;
133 mutex_unlock(&isolated_cpus_lock
);
135 set_cpus_allowed_ptr(current
, cpumask_of(preferred_cpu
));
138 static void exit_round_robin(unsigned int tsk_index
)
140 struct cpumask
*pad_busy_cpus
= to_cpumask(pad_busy_cpus_bits
);
141 cpumask_clear_cpu(tsk_in_cpu
[tsk_index
], pad_busy_cpus
);
142 tsk_in_cpu
[tsk_index
] = -1;
145 static unsigned int idle_pct
= 5; /* percentage */
146 static unsigned int round_robin_time
= 10; /* second */
147 static int power_saving_thread(void *data
)
149 struct sched_param param
= {.sched_priority
= 1};
151 unsigned int tsk_index
= (unsigned long)data
;
152 u64 last_jiffies
= 0;
154 sched_setscheduler(current
, SCHED_RR
, ¶m
);
156 while (!kthread_should_stop()) {
162 /* round robin to cpus */
163 if (last_jiffies
+ round_robin_time
* HZ
< jiffies
) {
164 last_jiffies
= jiffies
;
165 round_robin_cpu(tsk_index
);
170 current_thread_info()->status
&= ~TS_POLLING
;
172 * TS_POLLING-cleared state must be visible before we test
177 expire_time
= jiffies
+ HZ
* (100 - idle_pct
) / 100;
179 while (!need_resched()) {
181 cpu
= smp_processor_id();
182 clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_ENTER
,
184 stop_critical_timings();
186 __monitor((void *)¤t_thread_info()->flags
, 0, 0);
189 __mwait(power_saving_mwait_eax
, 1);
191 start_critical_timings();
192 clockevents_notify(CLOCK_EVT_NOTIFY_BROADCAST_EXIT
,
196 if (jiffies
> expire_time
) {
202 current_thread_info()->status
|= TS_POLLING
;
205 * current sched_rt has threshold for rt task running time.
206 * When a rt task uses 95% CPU time, the rt thread will be
207 * scheduled out for 5% CPU time to not starve other tasks. But
208 * the mechanism only works when all CPUs have RT task running,
209 * as if one CPU hasn't RT task, RT task from other CPUs will
210 * borrow CPU time from this CPU and cause RT task use > 95%
211 * CPU time. To make 'avoid staration' work, takes a nap here.
214 schedule_timeout_killable(HZ
* idle_pct
/ 100);
217 exit_round_robin(tsk_index
);
221 static struct task_struct
*ps_tsks
[NR_CPUS
];
222 static unsigned int ps_tsk_num
;
223 static int create_power_saving_task(void)
225 ps_tsks
[ps_tsk_num
] = kthread_run(power_saving_thread
,
226 (void *)(unsigned long)ps_tsk_num
,
227 "power_saving/%d", ps_tsk_num
);
228 if (ps_tsks
[ps_tsk_num
]) {
235 static void destroy_power_saving_task(void)
237 if (ps_tsk_num
> 0) {
239 kthread_stop(ps_tsks
[ps_tsk_num
]);
243 static void set_power_saving_task_num(unsigned int num
)
245 if (num
> ps_tsk_num
) {
246 while (ps_tsk_num
< num
) {
247 if (create_power_saving_task())
250 } else if (num
< ps_tsk_num
) {
251 while (ps_tsk_num
> num
)
252 destroy_power_saving_task();
256 static int acpi_pad_idle_cpus(unsigned int num_cpus
)
260 num_cpus
= min_t(unsigned int, num_cpus
, num_online_cpus());
261 set_power_saving_task_num(num_cpus
);
267 static uint32_t acpi_pad_idle_cpus_num(void)
272 static ssize_t
acpi_pad_rrtime_store(struct device
*dev
,
273 struct device_attribute
*attr
, const char *buf
, size_t count
)
276 if (strict_strtoul(buf
, 0, &num
))
278 if (num
< 1 || num
>= 100)
280 mutex_lock(&isolated_cpus_lock
);
281 round_robin_time
= num
;
282 mutex_unlock(&isolated_cpus_lock
);
286 static ssize_t
acpi_pad_rrtime_show(struct device
*dev
,
287 struct device_attribute
*attr
, char *buf
)
289 return scnprintf(buf
, PAGE_SIZE
, "%d", round_robin_time
);
291 static DEVICE_ATTR(rrtime
, S_IRUGO
|S_IWUSR
,
292 acpi_pad_rrtime_show
,
293 acpi_pad_rrtime_store
);
295 static ssize_t
acpi_pad_idlepct_store(struct device
*dev
,
296 struct device_attribute
*attr
, const char *buf
, size_t count
)
299 if (strict_strtoul(buf
, 0, &num
))
301 if (num
< 1 || num
>= 100)
303 mutex_lock(&isolated_cpus_lock
);
305 mutex_unlock(&isolated_cpus_lock
);
309 static ssize_t
acpi_pad_idlepct_show(struct device
*dev
,
310 struct device_attribute
*attr
, char *buf
)
312 return scnprintf(buf
, PAGE_SIZE
, "%d", idle_pct
);
314 static DEVICE_ATTR(idlepct
, S_IRUGO
|S_IWUSR
,
315 acpi_pad_idlepct_show
,
316 acpi_pad_idlepct_store
);
318 static ssize_t
acpi_pad_idlecpus_store(struct device
*dev
,
319 struct device_attribute
*attr
, const char *buf
, size_t count
)
322 if (strict_strtoul(buf
, 0, &num
))
324 mutex_lock(&isolated_cpus_lock
);
325 acpi_pad_idle_cpus(num
);
326 mutex_unlock(&isolated_cpus_lock
);
330 static ssize_t
acpi_pad_idlecpus_show(struct device
*dev
,
331 struct device_attribute
*attr
, char *buf
)
333 return cpumask_scnprintf(buf
, PAGE_SIZE
,
334 to_cpumask(pad_busy_cpus_bits
));
336 static DEVICE_ATTR(idlecpus
, S_IRUGO
|S_IWUSR
,
337 acpi_pad_idlecpus_show
,
338 acpi_pad_idlecpus_store
);
340 static int acpi_pad_add_sysfs(struct acpi_device
*device
)
344 result
= device_create_file(&device
->dev
, &dev_attr_idlecpus
);
347 result
= device_create_file(&device
->dev
, &dev_attr_idlepct
);
349 device_remove_file(&device
->dev
, &dev_attr_idlecpus
);
352 result
= device_create_file(&device
->dev
, &dev_attr_rrtime
);
354 device_remove_file(&device
->dev
, &dev_attr_idlecpus
);
355 device_remove_file(&device
->dev
, &dev_attr_idlepct
);
361 static void acpi_pad_remove_sysfs(struct acpi_device
*device
)
363 device_remove_file(&device
->dev
, &dev_attr_idlecpus
);
364 device_remove_file(&device
->dev
, &dev_attr_idlepct
);
365 device_remove_file(&device
->dev
, &dev_attr_rrtime
);
368 /* Query firmware how many CPUs should be idle */
369 static int acpi_pad_pur(acpi_handle handle
, int *num_cpus
)
371 struct acpi_buffer buffer
= {ACPI_ALLOCATE_BUFFER
, NULL
};
373 union acpi_object
*package
;
374 int rev
, num
, ret
= -EINVAL
;
376 status
= acpi_evaluate_object(handle
, "_PUR", NULL
, &buffer
);
377 if (ACPI_FAILURE(status
))
379 package
= buffer
.pointer
;
380 if (package
->type
!= ACPI_TYPE_PACKAGE
|| package
->package
.count
!= 2)
382 rev
= package
->package
.elements
[0].integer
.value
;
383 num
= package
->package
.elements
[1].integer
.value
;
389 kfree(buffer
.pointer
);
393 /* Notify firmware how many CPUs are idle */
394 static void acpi_pad_ost(acpi_handle handle
, int stat
,
397 union acpi_object params
[3] = {
398 {.type
= ACPI_TYPE_INTEGER
,},
399 {.type
= ACPI_TYPE_INTEGER
,},
400 {.type
= ACPI_TYPE_BUFFER
,},
402 struct acpi_object_list arg_list
= {3, params
};
404 params
[0].integer
.value
= ACPI_PROCESSOR_AGGREGATOR_NOTIFY
;
405 params
[1].integer
.value
= stat
;
406 params
[2].buffer
.length
= 4;
407 params
[2].buffer
.pointer
= (void *)&idle_cpus
;
408 acpi_evaluate_object(handle
, "_OST", &arg_list
, NULL
);
411 static void acpi_pad_handle_notify(acpi_handle handle
)
416 mutex_lock(&isolated_cpus_lock
);
417 if (acpi_pad_pur(handle
, &num_cpus
)) {
418 mutex_unlock(&isolated_cpus_lock
);
421 ret
= acpi_pad_idle_cpus(num_cpus
);
422 idle_cpus
= acpi_pad_idle_cpus_num();
424 acpi_pad_ost(handle
, 0, idle_cpus
);
426 acpi_pad_ost(handle
, 1, 0);
427 mutex_unlock(&isolated_cpus_lock
);
430 static void acpi_pad_notify(acpi_handle handle
, u32 event
,
433 struct acpi_device
*device
= data
;
436 case ACPI_PROCESSOR_AGGREGATOR_NOTIFY
:
437 acpi_pad_handle_notify(handle
);
438 acpi_bus_generate_proc_event(device
, event
, 0);
439 acpi_bus_generate_netlink_event(device
->pnp
.device_class
,
440 dev_name(&device
->dev
), event
, 0);
443 printk(KERN_WARNING
"Unsupported event [0x%x]\n", event
);
448 static int acpi_pad_add(struct acpi_device
*device
)
452 strcpy(acpi_device_name(device
), ACPI_PROCESSOR_AGGREGATOR_DEVICE_NAME
);
453 strcpy(acpi_device_class(device
), ACPI_PROCESSOR_AGGREGATOR_CLASS
);
455 if (acpi_pad_add_sysfs(device
))
458 status
= acpi_install_notify_handler(device
->handle
,
459 ACPI_DEVICE_NOTIFY
, acpi_pad_notify
, device
);
460 if (ACPI_FAILURE(status
)) {
461 acpi_pad_remove_sysfs(device
);
468 static int acpi_pad_remove(struct acpi_device
*device
,
471 mutex_lock(&isolated_cpus_lock
);
472 acpi_pad_idle_cpus(0);
473 mutex_unlock(&isolated_cpus_lock
);
475 acpi_remove_notify_handler(device
->handle
,
476 ACPI_DEVICE_NOTIFY
, acpi_pad_notify
);
477 acpi_pad_remove_sysfs(device
);
481 static const struct acpi_device_id pad_device_ids
[] = {
485 MODULE_DEVICE_TABLE(acpi
, pad_device_ids
);
487 static struct acpi_driver acpi_pad_driver
= {
488 .name
= "processor_aggregator",
489 .class = ACPI_PROCESSOR_AGGREGATOR_CLASS
,
490 .ids
= pad_device_ids
,
493 .remove
= acpi_pad_remove
,
497 static int __init
acpi_pad_init(void)
499 power_saving_mwait_init();
500 if (power_saving_mwait_eax
== 0)
503 return acpi_bus_register_driver(&acpi_pad_driver
);
506 static void __exit
acpi_pad_exit(void)
508 acpi_bus_unregister_driver(&acpi_pad_driver
);
511 module_init(acpi_pad_init
);
512 module_exit(acpi_pad_exit
);
513 MODULE_AUTHOR("Shaohua Li<shaohua.li@intel.com>");
514 MODULE_DESCRIPTION("ACPI Processor Aggregator Driver");
515 MODULE_LICENSE("GPL");