1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31#include <linux/module.h>
32#include <linux/acpi.h>
33#include <linux/dmi.h>
34#include <linux/sched.h>
35#include <linux/clockchips.h>
36#include <linux/cpuidle.h>
37#include <linux/syscore_ops.h>
38
39
40
41
42
43
44
45#ifdef CONFIG_X86
46#include <asm/apic.h>
47#endif
48
49#include <acpi/acpi_bus.h>
50#include <acpi/processor.h>
51
52#define PREFIX "ACPI: "
53
54#define ACPI_PROCESSOR_CLASS "processor"
55#define _COMPONENT ACPI_PROCESSOR_COMPONENT
56ACPI_MODULE_NAME("processor_idle");
57
58static unsigned int max_cstate __read_mostly = ACPI_PROCESSOR_MAX_POWER;
59module_param(max_cstate, uint, 0000);
60static unsigned int nocst __read_mostly;
61module_param(nocst, uint, 0000);
62static int bm_check_disable __read_mostly;
63module_param(bm_check_disable, uint, 0000);
64
65static unsigned int latency_factor __read_mostly = 2;
66module_param(latency_factor, uint, 0644);
67
68static DEFINE_PER_CPU(struct cpuidle_device *, acpi_cpuidle_device);
69
70static DEFINE_PER_CPU(struct acpi_processor_cx * [CPUIDLE_STATE_MAX],
71 acpi_cstate);
72
73static int disabled_by_idle_boot_param(void)
74{
75 return boot_option_idle_override == IDLE_POLL ||
76 boot_option_idle_override == IDLE_HALT;
77}
78
79
80
81
82
83
84
85static int set_max_cstate(const struct dmi_system_id *id)
86{
87 if (max_cstate > ACPI_PROCESSOR_MAX_POWER)
88 return 0;
89
90 printk(KERN_NOTICE PREFIX "%s detected - limiting to C%ld max_cstate."
91 " Override with \"processor.max_cstate=%d\"\n", id->ident,
92 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1);
93
94 max_cstate = (long)id->driver_data;
95
96 return 0;
97}
98
99
100
101static struct dmi_system_id __cpuinitdata processor_power_dmi_table[] = {
102 { set_max_cstate, "Clevo 5600D", {
103 DMI_MATCH(DMI_BIOS_VENDOR,"Phoenix Technologies LTD"),
104 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
105 (void *)2},
106 { set_max_cstate, "Pavilion zv5000", {
107 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
108 DMI_MATCH(DMI_PRODUCT_NAME,"Pavilion zv5000 (DS502A#ABA)")},
109 (void *)1},
110 { set_max_cstate, "Asus L8400B", {
111 DMI_MATCH(DMI_SYS_VENDOR, "ASUSTeK Computer Inc."),
112 DMI_MATCH(DMI_PRODUCT_NAME,"L8400B series Notebook PC")},
113 (void *)1},
114 {},
115};
116
117
118
119
120
121
122static void acpi_safe_halt(void)
123{
124 current_thread_info()->status &= ~TS_POLLING;
125
126
127
128
129 smp_mb();
130 if (!need_resched()) {
131 safe_halt();
132 local_irq_disable();
133 }
134 current_thread_info()->status |= TS_POLLING;
135}
136
137#ifdef ARCH_APICTIMER_STOPS_ON_C3
138
139
140
141
142
143
144
145static void lapic_timer_check_state(int state, struct acpi_processor *pr,
146 struct acpi_processor_cx *cx)
147{
148 struct acpi_processor_power *pwr = &pr->power;
149 u8 type = local_apic_timer_c2_ok ? ACPI_STATE_C3 : ACPI_STATE_C2;
150
151 if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT))
152 return;
153
154 if (amd_e400_c1e_detected)
155 type = ACPI_STATE_C1;
156
157
158
159
160
161 if (pwr->timer_broadcast_on_state < state)
162 return;
163
164 if (cx->type >= type)
165 pr->power.timer_broadcast_on_state = state;
166}
167
168static void __lapic_timer_propagate_broadcast(void *arg)
169{
170 struct acpi_processor *pr = (struct acpi_processor *) arg;
171 unsigned long reason;
172
173 reason = pr->power.timer_broadcast_on_state < INT_MAX ?
174 CLOCK_EVT_NOTIFY_BROADCAST_ON : CLOCK_EVT_NOTIFY_BROADCAST_OFF;
175
176 clockevents_notify(reason, &pr->id);
177}
178
179static void lapic_timer_propagate_broadcast(struct acpi_processor *pr)
180{
181 smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast,
182 (void *)pr, 1);
183}
184
185
186static void lapic_timer_state_broadcast(struct acpi_processor *pr,
187 struct acpi_processor_cx *cx,
188 int broadcast)
189{
190 int state = cx - pr->power.states;
191
192 if (state >= pr->power.timer_broadcast_on_state) {
193 unsigned long reason;
194
195 reason = broadcast ? CLOCK_EVT_NOTIFY_BROADCAST_ENTER :
196 CLOCK_EVT_NOTIFY_BROADCAST_EXIT;
197 clockevents_notify(reason, &pr->id);
198 }
199}
200
201#else
202
203static void lapic_timer_check_state(int state, struct acpi_processor *pr,
204 struct acpi_processor_cx *cstate) { }
205static void lapic_timer_propagate_broadcast(struct acpi_processor *pr) { }
206static void lapic_timer_state_broadcast(struct acpi_processor *pr,
207 struct acpi_processor_cx *cx,
208 int broadcast)
209{
210}
211
212#endif
213
214#ifdef CONFIG_PM_SLEEP
215static u32 saved_bm_rld;
216
217int acpi_processor_suspend(void)
218{
219 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &saved_bm_rld);
220 return 0;
221}
222
223void acpi_processor_resume(void)
224{
225 u32 resumed_bm_rld;
226
227 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_RLD, &resumed_bm_rld);
228 if (resumed_bm_rld == saved_bm_rld)
229 return;
230
231 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, saved_bm_rld);
232}
233
234static struct syscore_ops acpi_processor_syscore_ops = {
235 .suspend = acpi_processor_suspend,
236 .resume = acpi_processor_resume,
237};
238
239void acpi_processor_syscore_init(void)
240{
241 register_syscore_ops(&acpi_processor_syscore_ops);
242}
243
244void acpi_processor_syscore_exit(void)
245{
246 unregister_syscore_ops(&acpi_processor_syscore_ops);
247}
248#endif
249
250#if defined(CONFIG_X86)
251static void tsc_check_state(int state)
252{
253 switch (boot_cpu_data.x86_vendor) {
254 case X86_VENDOR_AMD:
255 case X86_VENDOR_INTEL:
256
257
258
259
260 if (boot_cpu_has(X86_FEATURE_NONSTOP_TSC))
261 return;
262
263
264 default:
265
266 if (state > ACPI_STATE_C1)
267 mark_tsc_unstable("TSC halts in idle");
268 }
269}
270#else
271static void tsc_check_state(int state) { return; }
272#endif
273
274static int acpi_processor_get_power_info_fadt(struct acpi_processor *pr)
275{
276
277 if (!pr)
278 return -EINVAL;
279
280 if (!pr->pblk)
281 return -ENODEV;
282
283
284 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2;
285 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3;
286
287#ifndef CONFIG_HOTPLUG_CPU
288
289
290
291
292 if ((num_online_cpus() > 1) &&
293 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
294 return -ENODEV;
295#endif
296
297
298 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4;
299 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5;
300
301
302 pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency;
303 pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency;
304
305
306
307
308
309 if (acpi_gbl_FADT.c2_latency > ACPI_PROCESSOR_MAX_C2_LATENCY) {
310 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
311 "C2 latency too large [%d]\n", acpi_gbl_FADT.c2_latency));
312
313 pr->power.states[ACPI_STATE_C2].address = 0;
314 }
315
316
317
318
319
320 if (acpi_gbl_FADT.c3_latency > ACPI_PROCESSOR_MAX_C3_LATENCY) {
321 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
322 "C3 latency too large [%d]\n", acpi_gbl_FADT.c3_latency));
323
324 pr->power.states[ACPI_STATE_C3].address = 0;
325 }
326
327 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
328 "lvl2[0x%08x] lvl3[0x%08x]\n",
329 pr->power.states[ACPI_STATE_C2].address,
330 pr->power.states[ACPI_STATE_C3].address));
331
332 return 0;
333}
334
335static int acpi_processor_get_power_info_default(struct acpi_processor *pr)
336{
337 if (!pr->power.states[ACPI_STATE_C1].valid) {
338
339
340 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1;
341 pr->power.states[ACPI_STATE_C1].valid = 1;
342 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT;
343 }
344
345 pr->power.states[ACPI_STATE_C0].valid = 1;
346 return 0;
347}
348
349static int acpi_processor_get_power_info_cst(struct acpi_processor *pr)
350{
351 acpi_status status = 0;
352 u64 count;
353 int current_count;
354 int i;
355 struct acpi_buffer buffer = { ACPI_ALLOCATE_BUFFER, NULL };
356 union acpi_object *cst;
357
358
359 if (nocst)
360 return -ENODEV;
361
362 current_count = 0;
363
364 status = acpi_evaluate_object(pr->handle, "_CST", NULL, &buffer);
365 if (ACPI_FAILURE(status)) {
366 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "No _CST, giving up\n"));
367 return -ENODEV;
368 }
369
370 cst = buffer.pointer;
371
372
373 if (!cst || (cst->type != ACPI_TYPE_PACKAGE) || cst->package.count < 2) {
374 printk(KERN_ERR PREFIX "not enough elements in _CST\n");
375 status = -EFAULT;
376 goto end;
377 }
378
379 count = cst->package.elements[0].integer.value;
380
381
382 if (count < 1 || count != cst->package.count - 1) {
383 printk(KERN_ERR PREFIX "count given by _CST is not valid\n");
384 status = -EFAULT;
385 goto end;
386 }
387
388
389 pr->flags.has_cst = 1;
390
391 for (i = 1; i <= count; i++) {
392 union acpi_object *element;
393 union acpi_object *obj;
394 struct acpi_power_register *reg;
395 struct acpi_processor_cx cx;
396
397 memset(&cx, 0, sizeof(cx));
398
399 element = &(cst->package.elements[i]);
400 if (element->type != ACPI_TYPE_PACKAGE)
401 continue;
402
403 if (element->package.count != 4)
404 continue;
405
406 obj = &(element->package.elements[0]);
407
408 if (obj->type != ACPI_TYPE_BUFFER)
409 continue;
410
411 reg = (struct acpi_power_register *)obj->buffer.pointer;
412
413 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO &&
414 (reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE))
415 continue;
416
417
418 obj = &(element->package.elements[1]);
419 if (obj->type != ACPI_TYPE_INTEGER)
420 continue;
421
422 cx.type = obj->integer.value;
423
424
425
426
427 if (i == 1 && cx.type != ACPI_STATE_C1)
428 current_count++;
429
430 cx.address = reg->address;
431 cx.index = current_count + 1;
432
433 cx.entry_method = ACPI_CSTATE_SYSTEMIO;
434 if (reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) {
435 if (acpi_processor_ffh_cstate_probe
436 (pr->id, &cx, reg) == 0) {
437 cx.entry_method = ACPI_CSTATE_FFH;
438 } else if (cx.type == ACPI_STATE_C1) {
439
440
441
442
443
444
445 cx.entry_method = ACPI_CSTATE_HALT;
446 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
447 } else {
448 continue;
449 }
450 if (cx.type == ACPI_STATE_C1 &&
451 (boot_option_idle_override == IDLE_NOMWAIT)) {
452
453
454
455
456
457
458
459
460
461
462 cx.entry_method = ACPI_CSTATE_HALT;
463 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI HLT");
464 }
465 } else {
466 snprintf(cx.desc, ACPI_CX_DESC_LEN, "ACPI IOPORT 0x%x",
467 cx.address);
468 }
469
470 if (cx.type == ACPI_STATE_C1) {
471 cx.valid = 1;
472 }
473
474 obj = &(element->package.elements[2]);
475 if (obj->type != ACPI_TYPE_INTEGER)
476 continue;
477
478 cx.latency = obj->integer.value;
479
480 obj = &(element->package.elements[3]);
481 if (obj->type != ACPI_TYPE_INTEGER)
482 continue;
483
484 current_count++;
485 memcpy(&(pr->power.states[current_count]), &cx, sizeof(cx));
486
487
488
489
490
491 if (current_count >= (ACPI_PROCESSOR_MAX_POWER - 1)) {
492 printk(KERN_WARNING
493 "Limiting number of power states to max (%d)\n",
494 ACPI_PROCESSOR_MAX_POWER);
495 printk(KERN_WARNING
496 "Please increase ACPI_PROCESSOR_MAX_POWER if needed.\n");
497 break;
498 }
499 }
500
501 ACPI_DEBUG_PRINT((ACPI_DB_INFO, "Found %d power states\n",
502 current_count));
503
504
505 if (current_count < 2)
506 status = -EFAULT;
507
508 end:
509 kfree(buffer.pointer);
510
511 return status;
512}
513
514static void acpi_processor_power_verify_c3(struct acpi_processor *pr,
515 struct acpi_processor_cx *cx)
516{
517 static int bm_check_flag = -1;
518 static int bm_control_flag = -1;
519
520
521 if (!cx->address)
522 return;
523
524
525
526
527
528
529
530
531 else if (errata.piix4.fdma) {
532 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
533 "C3 not supported on PIIX4 with Type-F DMA\n"));
534 return;
535 }
536
537
538 if (bm_check_flag == -1) {
539
540 acpi_processor_power_init_bm_check(&(pr->flags), pr->id);
541 bm_check_flag = pr->flags.bm_check;
542 bm_control_flag = pr->flags.bm_control;
543 } else {
544 pr->flags.bm_check = bm_check_flag;
545 pr->flags.bm_control = bm_control_flag;
546 }
547
548 if (pr->flags.bm_check) {
549 if (!pr->flags.bm_control) {
550 if (pr->flags.has_cst != 1) {
551
552 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
553 "C3 support requires BM control\n"));
554 return;
555 } else {
556
557 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
558 "C3 support without BM control\n"));
559 }
560 }
561 } else {
562
563
564
565
566 if (!(acpi_gbl_FADT.flags & ACPI_FADT_WBINVD)) {
567 ACPI_DEBUG_PRINT((ACPI_DB_INFO,
568 "Cache invalidation should work properly"
569 " for C3 to be enabled on SMP systems\n"));
570 return;
571 }
572 }
573
574
575
576
577
578
579
580 cx->valid = 1;
581
582
583
584
585
586
587
588
589
590 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_RLD, 1);
591
592 return;
593}
594
595static int acpi_processor_power_verify(struct acpi_processor *pr)
596{
597 unsigned int i;
598 unsigned int working = 0;
599
600 pr->power.timer_broadcast_on_state = INT_MAX;
601
602 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
603 struct acpi_processor_cx *cx = &pr->power.states[i];
604
605 switch (cx->type) {
606 case ACPI_STATE_C1:
607 cx->valid = 1;
608 break;
609
610 case ACPI_STATE_C2:
611 if (!cx->address)
612 break;
613 cx->valid = 1;
614 break;
615
616 case ACPI_STATE_C3:
617 acpi_processor_power_verify_c3(pr, cx);
618 break;
619 }
620 if (!cx->valid)
621 continue;
622
623 lapic_timer_check_state(i, pr, cx);
624 tsc_check_state(cx->type);
625 working++;
626 }
627
628 lapic_timer_propagate_broadcast(pr);
629
630 return (working);
631}
632
633static int acpi_processor_get_power_info(struct acpi_processor *pr)
634{
635 unsigned int i;
636 int result;
637
638
639
640
641
642
643 memset(pr->power.states, 0, sizeof(pr->power.states));
644
645 result = acpi_processor_get_power_info_cst(pr);
646 if (result == -ENODEV)
647 result = acpi_processor_get_power_info_fadt(pr);
648
649 if (result)
650 return result;
651
652 acpi_processor_get_power_info_default(pr);
653
654 pr->power.count = acpi_processor_power_verify(pr);
655
656
657
658
659
660 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER; i++) {
661 if (pr->power.states[i].valid) {
662 pr->power.count = i;
663 if (pr->power.states[i].type >= ACPI_STATE_C2)
664 pr->flags.power = 1;
665 }
666 }
667
668 return 0;
669}
670
671
672
673
674static int acpi_idle_bm_check(void)
675{
676 u32 bm_status = 0;
677
678 if (bm_check_disable)
679 return 0;
680
681 acpi_read_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, &bm_status);
682 if (bm_status)
683 acpi_write_bit_register(ACPI_BITREG_BUS_MASTER_STATUS, 1);
684
685
686
687
688
689 else if (errata.piix4.bmisx) {
690 if ((inb_p(errata.piix4.bmisx + 0x02) & 0x01)
691 || (inb_p(errata.piix4.bmisx + 0x0A) & 0x01))
692 bm_status = 1;
693 }
694 return bm_status;
695}
696
697
698
699
700
701
702
703static inline void acpi_idle_do_entry(struct acpi_processor_cx *cx)
704{
705
706 stop_critical_timings();
707 if (cx->entry_method == ACPI_CSTATE_FFH) {
708
709 acpi_processor_ffh_cstate_enter(cx);
710 } else if (cx->entry_method == ACPI_CSTATE_HALT) {
711 acpi_safe_halt();
712 } else {
713
714 inb(cx->address);
715
716
717
718 inl(acpi_gbl_FADT.xpm_timer_block.address);
719 }
720 start_critical_timings();
721}
722
723
724
725
726
727
728
729
730
731static int acpi_idle_enter_c1(struct cpuidle_device *dev,
732 struct cpuidle_driver *drv, int index)
733{
734 struct acpi_processor *pr;
735 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
736
737 pr = __this_cpu_read(processors);
738
739 if (unlikely(!pr))
740 return -EINVAL;
741
742 lapic_timer_state_broadcast(pr, cx, 1);
743 acpi_idle_do_entry(cx);
744
745 lapic_timer_state_broadcast(pr, cx, 0);
746
747 return index;
748}
749
750
751
752
753
754
755
756static int acpi_idle_play_dead(struct cpuidle_device *dev, int index)
757{
758 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
759
760 ACPI_FLUSH_CPU_CACHE();
761
762 while (1) {
763
764 if (cx->entry_method == ACPI_CSTATE_HALT)
765 safe_halt();
766 else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) {
767 inb(cx->address);
768
769 inl(acpi_gbl_FADT.xpm_timer_block.address);
770 } else
771 return -ENODEV;
772 }
773
774
775 return 0;
776}
777
778
779
780
781
782
783
784static int acpi_idle_enter_simple(struct cpuidle_device *dev,
785 struct cpuidle_driver *drv, int index)
786{
787 struct acpi_processor *pr;
788 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
789
790 pr = __this_cpu_read(processors);
791
792 if (unlikely(!pr))
793 return -EINVAL;
794
795 if (cx->entry_method != ACPI_CSTATE_FFH) {
796 current_thread_info()->status &= ~TS_POLLING;
797
798
799
800
801 smp_mb();
802
803 if (unlikely(need_resched())) {
804 current_thread_info()->status |= TS_POLLING;
805 return -EINVAL;
806 }
807 }
808
809
810
811
812
813 lapic_timer_state_broadcast(pr, cx, 1);
814
815 if (cx->type == ACPI_STATE_C3)
816 ACPI_FLUSH_CPU_CACHE();
817
818
819 sched_clock_idle_sleep_event();
820 acpi_idle_do_entry(cx);
821
822 sched_clock_idle_wakeup_event(0);
823
824 if (cx->entry_method != ACPI_CSTATE_FFH)
825 current_thread_info()->status |= TS_POLLING;
826
827 lapic_timer_state_broadcast(pr, cx, 0);
828 return index;
829}
830
831static int c3_cpu_count;
832static DEFINE_RAW_SPINLOCK(c3_lock);
833
834
835
836
837
838
839
840
841
842static int acpi_idle_enter_bm(struct cpuidle_device *dev,
843 struct cpuidle_driver *drv, int index)
844{
845 struct acpi_processor *pr;
846 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu);
847
848 pr = __this_cpu_read(processors);
849
850 if (unlikely(!pr))
851 return -EINVAL;
852
853 if (!cx->bm_sts_skip && acpi_idle_bm_check()) {
854 if (drv->safe_state_index >= 0) {
855 return drv->states[drv->safe_state_index].enter(dev,
856 drv, drv->safe_state_index);
857 } else {
858 acpi_safe_halt();
859 return -EBUSY;
860 }
861 }
862
863 if (cx->entry_method != ACPI_CSTATE_FFH) {
864 current_thread_info()->status &= ~TS_POLLING;
865
866
867
868
869 smp_mb();
870
871 if (unlikely(need_resched())) {
872 current_thread_info()->status |= TS_POLLING;
873 return -EINVAL;
874 }
875 }
876
877 acpi_unlazy_tlb(smp_processor_id());
878
879
880 sched_clock_idle_sleep_event();
881
882
883
884
885 lapic_timer_state_broadcast(pr, cx, 1);
886
887
888
889
890
891
892
893
894
895
896
897 if (pr->flags.bm_check && pr->flags.bm_control) {
898 raw_spin_lock(&c3_lock);
899 c3_cpu_count++;
900
901 if (c3_cpu_count == num_online_cpus())
902 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 1);
903 raw_spin_unlock(&c3_lock);
904 } else if (!pr->flags.bm_check) {
905 ACPI_FLUSH_CPU_CACHE();
906 }
907
908 acpi_idle_do_entry(cx);
909
910
911 if (pr->flags.bm_check && pr->flags.bm_control) {
912 raw_spin_lock(&c3_lock);
913 acpi_write_bit_register(ACPI_BITREG_ARB_DISABLE, 0);
914 c3_cpu_count--;
915 raw_spin_unlock(&c3_lock);
916 }
917
918 sched_clock_idle_wakeup_event(0);
919
920 if (cx->entry_method != ACPI_CSTATE_FFH)
921 current_thread_info()->status |= TS_POLLING;
922
923 lapic_timer_state_broadcast(pr, cx, 0);
924 return index;
925}
926
927struct cpuidle_driver acpi_idle_driver = {
928 .name = "acpi_idle",
929 .owner = THIS_MODULE,
930};
931
932
933
934
935
936
937
938
939static int acpi_processor_setup_cpuidle_cx(struct acpi_processor *pr,
940 struct cpuidle_device *dev)
941{
942 int i, count = CPUIDLE_DRIVER_STATE_START;
943 struct acpi_processor_cx *cx;
944
945 if (!pr->flags.power_setup_done)
946 return -EINVAL;
947
948 if (pr->flags.power == 0) {
949 return -EINVAL;
950 }
951
952 if (!dev)
953 return -EINVAL;
954
955 dev->cpu = pr->id;
956
957 if (max_cstate == 0)
958 max_cstate = 1;
959
960 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
961 cx = &pr->power.states[i];
962
963 if (!cx->valid)
964 continue;
965
966#ifdef CONFIG_HOTPLUG_CPU
967 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
968 !pr->flags.has_cst &&
969 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
970 continue;
971#endif
972 per_cpu(acpi_cstate[count], dev->cpu) = cx;
973
974 count++;
975 if (count == CPUIDLE_STATE_MAX)
976 break;
977 }
978
979 dev->state_count = count;
980
981 if (!count)
982 return -EINVAL;
983
984 return 0;
985}
986
987
988
989
990
991
992
993static int acpi_processor_setup_cpuidle_states(struct acpi_processor *pr)
994{
995 int i, count = CPUIDLE_DRIVER_STATE_START;
996 struct acpi_processor_cx *cx;
997 struct cpuidle_state *state;
998 struct cpuidle_driver *drv = &acpi_idle_driver;
999
1000 if (!pr->flags.power_setup_done)
1001 return -EINVAL;
1002
1003 if (pr->flags.power == 0)
1004 return -EINVAL;
1005
1006 drv->safe_state_index = -1;
1007 for (i = 0; i < CPUIDLE_STATE_MAX; i++) {
1008 drv->states[i].name[0] = '\0';
1009 drv->states[i].desc[0] = '\0';
1010 }
1011
1012 if (max_cstate == 0)
1013 max_cstate = 1;
1014
1015 for (i = 1; i < ACPI_PROCESSOR_MAX_POWER && i <= max_cstate; i++) {
1016 cx = &pr->power.states[i];
1017
1018 if (!cx->valid)
1019 continue;
1020
1021#ifdef CONFIG_HOTPLUG_CPU
1022 if ((cx->type != ACPI_STATE_C1) && (num_online_cpus() > 1) &&
1023 !pr->flags.has_cst &&
1024 !(acpi_gbl_FADT.flags & ACPI_FADT_C2_MP_SUPPORTED))
1025 continue;
1026#endif
1027
1028 state = &drv->states[count];
1029 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i);
1030 strncpy(state->desc, cx->desc, CPUIDLE_DESC_LEN);
1031 state->exit_latency = cx->latency;
1032 state->target_residency = cx->latency * latency_factor;
1033
1034 state->flags = 0;
1035 switch (cx->type) {
1036 case ACPI_STATE_C1:
1037 if (cx->entry_method == ACPI_CSTATE_FFH)
1038 state->flags |= CPUIDLE_FLAG_TIME_VALID;
1039
1040 state->enter = acpi_idle_enter_c1;
1041 state->enter_dead = acpi_idle_play_dead;
1042 drv->safe_state_index = count;
1043 break;
1044
1045 case ACPI_STATE_C2:
1046 state->flags |= CPUIDLE_FLAG_TIME_VALID;
1047 state->enter = acpi_idle_enter_simple;
1048 state->enter_dead = acpi_idle_play_dead;
1049 drv->safe_state_index = count;
1050 break;
1051
1052 case ACPI_STATE_C3:
1053 state->flags |= CPUIDLE_FLAG_TIME_VALID;
1054 state->enter = pr->flags.bm_check ?
1055 acpi_idle_enter_bm :
1056 acpi_idle_enter_simple;
1057 break;
1058 }
1059
1060 count++;
1061 if (count == CPUIDLE_STATE_MAX)
1062 break;
1063 }
1064
1065 drv->state_count = count;
1066
1067 if (!count)
1068 return -EINVAL;
1069
1070 return 0;
1071}
1072
1073int acpi_processor_hotplug(struct acpi_processor *pr)
1074{
1075 int ret = 0;
1076 struct cpuidle_device *dev;
1077
1078 if (disabled_by_idle_boot_param())
1079 return 0;
1080
1081 if (!pr)
1082 return -EINVAL;
1083
1084 if (nocst) {
1085 return -ENODEV;
1086 }
1087
1088 if (!pr->flags.power_setup_done)
1089 return -ENODEV;
1090
1091 dev = per_cpu(acpi_cpuidle_device, pr->id);
1092 cpuidle_pause_and_lock();
1093 cpuidle_disable_device(dev);
1094 acpi_processor_get_power_info(pr);
1095 if (pr->flags.power) {
1096 acpi_processor_setup_cpuidle_cx(pr, dev);
1097 ret = cpuidle_enable_device(dev);
1098 }
1099 cpuidle_resume_and_unlock();
1100
1101 return ret;
1102}
1103
1104int acpi_processor_cst_has_changed(struct acpi_processor *pr)
1105{
1106 int cpu;
1107 struct acpi_processor *_pr;
1108 struct cpuidle_device *dev;
1109
1110 if (disabled_by_idle_boot_param())
1111 return 0;
1112
1113 if (!pr)
1114 return -EINVAL;
1115
1116 if (nocst)
1117 return -ENODEV;
1118
1119 if (!pr->flags.power_setup_done)
1120 return -ENODEV;
1121
1122
1123
1124
1125
1126
1127
1128 if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) {
1129
1130 cpuidle_pause_and_lock();
1131
1132 get_online_cpus();
1133
1134
1135 for_each_online_cpu(cpu) {
1136 _pr = per_cpu(processors, cpu);
1137 if (!_pr || !_pr->flags.power_setup_done)
1138 continue;
1139 dev = per_cpu(acpi_cpuidle_device, cpu);
1140 cpuidle_disable_device(dev);
1141 }
1142
1143
1144 acpi_processor_get_power_info(pr);
1145 acpi_processor_setup_cpuidle_states(pr);
1146
1147
1148 for_each_online_cpu(cpu) {
1149 _pr = per_cpu(processors, cpu);
1150 if (!_pr || !_pr->flags.power_setup_done)
1151 continue;
1152 acpi_processor_get_power_info(_pr);
1153 if (_pr->flags.power) {
1154 dev = per_cpu(acpi_cpuidle_device, cpu);
1155 acpi_processor_setup_cpuidle_cx(_pr, dev);
1156 cpuidle_enable_device(dev);
1157 }
1158 }
1159 put_online_cpus();
1160 cpuidle_resume_and_unlock();
1161 }
1162
1163 return 0;
1164}
1165
1166static int acpi_processor_registered;
1167
1168int __cpuinit acpi_processor_power_init(struct acpi_processor *pr)
1169{
1170 acpi_status status = 0;
1171 int retval;
1172 struct cpuidle_device *dev;
1173 static int first_run;
1174
1175 if (disabled_by_idle_boot_param())
1176 return 0;
1177
1178 if (!first_run) {
1179 dmi_check_system(processor_power_dmi_table);
1180 max_cstate = acpi_processor_cstate_check(max_cstate);
1181 if (max_cstate < ACPI_C_STATES_MAX)
1182 printk(KERN_NOTICE
1183 "ACPI: processor limited to max C-state %d\n",
1184 max_cstate);
1185 first_run++;
1186 }
1187
1188 if (!pr)
1189 return -EINVAL;
1190
1191 if (acpi_gbl_FADT.cst_control && !nocst) {
1192 status =
1193 acpi_os_write_port(acpi_gbl_FADT.smi_command, acpi_gbl_FADT.cst_control, 8);
1194 if (ACPI_FAILURE(status)) {
1195 ACPI_EXCEPTION((AE_INFO, status,
1196 "Notifying BIOS of _CST ability failed"));
1197 }
1198 }
1199
1200 acpi_processor_get_power_info(pr);
1201 pr->flags.power_setup_done = 1;
1202
1203
1204
1205
1206
1207
1208 if (pr->flags.power) {
1209
1210 if (!acpi_processor_registered) {
1211 acpi_processor_setup_cpuidle_states(pr);
1212 retval = cpuidle_register_driver(&acpi_idle_driver);
1213 if (retval)
1214 return retval;
1215 printk(KERN_DEBUG "ACPI: %s registered with cpuidle\n",
1216 acpi_idle_driver.name);
1217 }
1218
1219 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
1220 if (!dev)
1221 return -ENOMEM;
1222 per_cpu(acpi_cpuidle_device, pr->id) = dev;
1223
1224 acpi_processor_setup_cpuidle_cx(pr, dev);
1225
1226
1227
1228
1229 retval = cpuidle_register_device(dev);
1230 if (retval) {
1231 if (acpi_processor_registered == 0)
1232 cpuidle_unregister_driver(&acpi_idle_driver);
1233 return retval;
1234 }
1235 acpi_processor_registered++;
1236 }
1237 return 0;
1238}
1239
1240int acpi_processor_power_exit(struct acpi_processor *pr)
1241{
1242 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id);
1243
1244 if (disabled_by_idle_boot_param())
1245 return 0;
1246
1247 if (pr->flags.power) {
1248 cpuidle_unregister_device(dev);
1249 acpi_processor_registered--;
1250 if (acpi_processor_registered == 0)
1251 cpuidle_unregister_driver(&acpi_idle_driver);
1252 }
1253
1254 pr->flags.power_setup_done = 0;
1255 return 0;
1256}
1257