Lines Matching +full:p +full:- +full:states
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * processor_idle - idle state submodule to the ACPI processor driver
9 * - Added processor hotplug support
11 * - Added support for C3 on SMP
33 * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
86 pr_notice("%s detected - limiting to C%ld max_cstate." in set_max_cstate()
87 " Override with \"processor.max_cstate=%d\"\n", id->ident, in set_max_cstate()
88 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); in set_max_cstate()
90 max_cstate = (long)id->driver_data; in set_max_cstate()
101 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
135 struct acpi_processor_power *pwr = &pr->power; in lapic_timer_check_state()
138 if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) in lapic_timer_check_state()
145 * Check, if one of the previous states already marked the lapic in lapic_timer_check_state()
148 if (pwr->timer_broadcast_on_state < state) in lapic_timer_check_state()
151 if (cx->type >= type) in lapic_timer_check_state()
152 pr->power.timer_broadcast_on_state = state; in lapic_timer_check_state()
159 if (pr->power.timer_broadcast_on_state < INT_MAX) in __lapic_timer_propagate_broadcast()
167 smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast, in lapic_timer_propagate_broadcast()
175 return cx - pr->power.states >= pr->power.timer_broadcast_on_state; in lapic_timer_needs_broadcast()
203 * C/P/S0/S1 states when this bit is set. in tsc_check_state()
221 if (!pr->pblk) in acpi_processor_get_power_info_fadt()
222 return -ENODEV; in acpi_processor_get_power_info_fadt()
225 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; in acpi_processor_get_power_info_fadt()
226 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; in acpi_processor_get_power_info_fadt()
235 return -ENODEV; in acpi_processor_get_power_info_fadt()
239 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; in acpi_processor_get_power_info_fadt()
240 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; in acpi_processor_get_power_info_fadt()
243 pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; in acpi_processor_get_power_info_fadt()
244 pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; in acpi_processor_get_power_info_fadt()
251 acpi_handle_debug(pr->handle, "C2 latency too large [%d]\n", in acpi_processor_get_power_info_fadt()
254 pr->power.states[ACPI_STATE_C2].address = 0; in acpi_processor_get_power_info_fadt()
262 acpi_handle_debug(pr->handle, "C3 latency too large [%d]\n", in acpi_processor_get_power_info_fadt()
265 pr->power.states[ACPI_STATE_C3].address = 0; in acpi_processor_get_power_info_fadt()
268 acpi_handle_debug(pr->handle, "lvl2[0x%08x] lvl3[0x%08x]\n", in acpi_processor_get_power_info_fadt()
269 pr->power.states[ACPI_STATE_C2].address, in acpi_processor_get_power_info_fadt()
270 pr->power.states[ACPI_STATE_C3].address); in acpi_processor_get_power_info_fadt()
272 snprintf(pr->power.states[ACPI_STATE_C2].desc, in acpi_processor_get_power_info_fadt()
274 pr->power.states[ACPI_STATE_C2].address); in acpi_processor_get_power_info_fadt()
275 snprintf(pr->power.states[ACPI_STATE_C3].desc, in acpi_processor_get_power_info_fadt()
277 pr->power.states[ACPI_STATE_C3].address); in acpi_processor_get_power_info_fadt()
279 if (!pr->power.states[ACPI_STATE_C2].address && in acpi_processor_get_power_info_fadt()
280 !pr->power.states[ACPI_STATE_C3].address) in acpi_processor_get_power_info_fadt()
281 return -ENODEV; in acpi_processor_get_power_info_fadt()
288 if (!pr->power.states[ACPI_STATE_C1].valid) { in acpi_processor_get_power_info_default()
289 /* set the first C-State to C1 */ in acpi_processor_get_power_info_default()
291 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; in acpi_processor_get_power_info_default()
292 pr->power.states[ACPI_STATE_C1].valid = 1; in acpi_processor_get_power_info_default()
293 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; in acpi_processor_get_power_info_default()
295 snprintf(pr->power.states[ACPI_STATE_C1].desc, in acpi_processor_get_power_info_default()
299 pr->power.states[ACPI_STATE_C0].valid = 1; in acpi_processor_get_power_info_default()
308 return -ENODEV; in acpi_processor_get_power_info_cst()
310 ret = acpi_processor_evaluate_cst(pr->handle, pr->id, &pr->power); in acpi_processor_get_power_info_cst()
314 if (!pr->power.count) in acpi_processor_get_power_info_cst()
315 return -EFAULT; in acpi_processor_get_power_info_cst()
317 pr->flags.has_cst = 1; in acpi_processor_get_power_info_cst()
324 static int bm_check_flag = -1; in acpi_processor_power_verify_c3()
325 static int bm_control_flag = -1; in acpi_processor_power_verify_c3()
328 if (!cx->address) in acpi_processor_power_verify_c3()
332 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) in acpi_processor_power_verify_c3()
334 * Note that we could disable Type-F DMA (as recommended by in acpi_processor_power_verify_c3()
339 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
340 "C3 not supported on PIIX4 with Type-F DMA\n"); in acpi_processor_power_verify_c3()
345 if (bm_check_flag == -1) { in acpi_processor_power_verify_c3()
347 acpi_processor_power_init_bm_check(&(pr->flags), pr->id); in acpi_processor_power_verify_c3()
348 bm_check_flag = pr->flags.bm_check; in acpi_processor_power_verify_c3()
349 bm_control_flag = pr->flags.bm_control; in acpi_processor_power_verify_c3()
351 pr->flags.bm_check = bm_check_flag; in acpi_processor_power_verify_c3()
352 pr->flags.bm_control = bm_control_flag; in acpi_processor_power_verify_c3()
355 if (pr->flags.bm_check) { in acpi_processor_power_verify_c3()
356 if (!pr->flags.bm_control) { in acpi_processor_power_verify_c3()
357 if (pr->flags.has_cst != 1) { in acpi_processor_power_verify_c3()
359 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
364 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
374 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
387 cx->valid = 1; in acpi_processor_power_verify_c3()
400 static void acpi_cst_latency_sort(struct acpi_processor_cx *states, size_t length) in acpi_cst_latency_sort() argument
405 if (!states[i].valid) in acpi_cst_latency_sort()
408 for (j = i - 1, k = i; j >= 0; j--) { in acpi_cst_latency_sort()
409 if (!states[j].valid) in acpi_cst_latency_sort()
412 if (states[j].latency > states[k].latency) in acpi_cst_latency_sort()
413 swap(states[j].latency, states[k].latency); in acpi_cst_latency_sort()
428 pr->power.timer_broadcast_on_state = INT_MAX; in acpi_processor_power_verify()
431 struct acpi_processor_cx *cx = &pr->power.states[i]; in acpi_processor_power_verify()
433 switch (cx->type) { in acpi_processor_power_verify()
435 cx->valid = 1; in acpi_processor_power_verify()
439 if (!cx->address) in acpi_processor_power_verify()
441 cx->valid = 1; in acpi_processor_power_verify()
448 if (!cx->valid) in acpi_processor_power_verify()
450 if (cx->type >= last_type && cx->latency < last_latency) in acpi_processor_power_verify()
452 last_latency = cx->latency; in acpi_processor_power_verify()
453 last_type = cx->type; in acpi_processor_power_verify()
456 tsc_check_state(cx->type); in acpi_processor_power_verify()
461 pr_notice("FW issue: working around C-state latencies out of order\n"); in acpi_processor_power_verify()
462 acpi_cst_latency_sort(&pr->power.states[1], max_cstate); in acpi_processor_power_verify()
477 /* Zero initialize all the C-states info. */ in acpi_processor_get_cstate_info()
478 memset(pr->power.states, 0, sizeof(pr->power.states)); in acpi_processor_get_cstate_info()
481 if (result == -ENODEV) in acpi_processor_get_cstate_info()
489 pr->power.count = acpi_processor_power_verify(pr); in acpi_processor_get_cstate_info()
490 pr->flags.power = 1; in acpi_processor_get_cstate_info()
496 * acpi_idle_bm_check - checks if bus master activity was detected
523 /* IO port based C-state */ in io_idle()
534 * that the motivating chipset issue was Intel-only. in io_idle()
540 * Dummy wait op - must do something useless after P_LVL2 read in io_idle()
555 * acpi_idle_do_entry - enter idle state using the appropriate method
564 if (cx->entry_method == ACPI_CSTATE_FFH) { in acpi_idle_do_entry()
565 /* Call into architectural FFH based C-state */ in acpi_idle_do_entry()
567 } else if (cx->entry_method == ACPI_CSTATE_HALT) { in acpi_idle_do_entry()
570 io_idle(cx->address); in acpi_idle_do_entry()
577 * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining)
583 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_play_dead()
589 if (cx->entry_method == ACPI_CSTATE_HALT) in acpi_idle_play_dead()
591 else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { in acpi_idle_play_dead()
592 io_idle(cx->address); in acpi_idle_play_dead()
593 } else if (cx->entry_method == ACPI_CSTATE_FFH) { in acpi_idle_play_dead()
602 return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst && in acpi_idle_fallback_to_c1()
610 * acpi_idle_enter_bm - enters C3 with proper BM handling
633 bool dis_bm = pr->flags.bm_control; in acpi_idle_enter_bm()
638 if (!cx->bm_sts_skip && acpi_idle_bm_check()) { in acpi_idle_enter_bm()
640 index = drv->safe_state_index; in acpi_idle_enter_bm()
645 index = -EBUSY; in acpi_idle_enter_bm()
664 /* Re-enable bus master arbitration */ in acpi_idle_enter_bm()
668 c3_cpu_count--; in acpi_idle_enter_bm()
680 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter()
685 return -EINVAL; in acpi_idle_enter()
687 if (cx->type != ACPI_STATE_C1) { in acpi_idle_enter()
688 if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) in acpi_idle_enter()
694 cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter()
698 if (cx->type == ACPI_STATE_C3) in acpi_idle_enter()
709 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter_s2idle()
711 if (cx->type == ACPI_STATE_C3) { in acpi_idle_enter_s2idle()
717 if (pr->flags.bm_check) { in acpi_idle_enter_s2idle()
718 u8 bm_sts_skip = cx->bm_sts_skip; in acpi_idle_enter_s2idle()
721 cx->bm_sts_skip = 1; in acpi_idle_enter_s2idle()
723 cx->bm_sts_skip = bm_sts_skip; in acpi_idle_enter_s2idle()
746 state = &acpi_idle_driver.states[count]; in acpi_processor_setup_cpuidle_cx()
747 cx = &pr->power.states[i]; in acpi_processor_setup_cpuidle_cx()
749 if (!cx->valid) in acpi_processor_setup_cpuidle_cx()
752 per_cpu(acpi_cstate[count], dev->cpu) = cx; in acpi_processor_setup_cpuidle_cx()
755 state->flags |= CPUIDLE_FLAG_TIMER_STOP; in acpi_processor_setup_cpuidle_cx()
757 if (cx->type == ACPI_STATE_C3) { in acpi_processor_setup_cpuidle_cx()
758 state->flags |= CPUIDLE_FLAG_TLB_FLUSHED; in acpi_processor_setup_cpuidle_cx()
759 if (pr->flags.bm_check) in acpi_processor_setup_cpuidle_cx()
760 state->flags |= CPUIDLE_FLAG_RCU_IDLE; in acpi_processor_setup_cpuidle_cx()
769 return -EINVAL; in acpi_processor_setup_cpuidle_cx()
792 cx = &pr->power.states[i]; in acpi_processor_setup_cstates()
794 if (!cx->valid) in acpi_processor_setup_cstates()
797 state = &drv->states[count]; in acpi_processor_setup_cstates()
798 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); in acpi_processor_setup_cstates()
799 strscpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); in acpi_processor_setup_cstates()
800 state->exit_latency = cx->latency; in acpi_processor_setup_cstates()
801 state->target_residency = cx->latency * latency_factor; in acpi_processor_setup_cstates()
802 state->enter = acpi_idle_enter; in acpi_processor_setup_cstates()
804 state->flags = 0; in acpi_processor_setup_cstates()
806 state->enter_dead = acpi_idle_play_dead; in acpi_processor_setup_cstates()
808 if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2) in acpi_processor_setup_cstates()
809 drv->safe_state_index = count; in acpi_processor_setup_cstates()
812 * Halt-induced C1 is not good for ->enter_s2idle, because it in acpi_processor_setup_cstates()
813 * re-enables interrupts on exit. Moreover, C1 is generally not in acpi_processor_setup_cstates()
814 * particularly interesting from the suspend-to-idle angle, so in acpi_processor_setup_cstates()
818 if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) in acpi_processor_setup_cstates()
819 state->enter_s2idle = acpi_idle_enter_s2idle; in acpi_processor_setup_cstates()
826 drv->state_count = count; in acpi_processor_setup_cstates()
829 return -EINVAL; in acpi_processor_setup_cstates()
843 pr_notice("processor limited to max C-state %d\n", max_cstate); in acpi_processor_cstate_first_run_checks()
858 return -ENODEV; in acpi_processor_get_cstate_info()
864 return -EINVAL; in acpi_processor_setup_cpuidle_cx()
869 return -EINVAL; in acpi_processor_setup_cstates()
883 if (obj->type != ACPI_TYPE_INTEGER) in obj_get_integer()
884 return -EINVAL; in obj_get_integer()
886 *value = obj->integer.value; in obj_get_integer()
903 return -ENODEV; in acpi_processor_evaluate_lpi()
909 if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE || in acpi_processor_evaluate_lpi()
910 lpi_data->package.count < 4) { in acpi_processor_evaluate_lpi()
912 ret = -ENODATA; in acpi_processor_evaluate_lpi()
916 pkg_count = lpi_data->package.elements[2].integer.value; in acpi_processor_evaluate_lpi()
918 /* Validate number of power states. */ in acpi_processor_evaluate_lpi()
919 if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) { in acpi_processor_evaluate_lpi()
921 ret = -ENODATA; in acpi_processor_evaluate_lpi()
927 ret = -ENOMEM; in acpi_processor_evaluate_lpi()
931 info->size = pkg_count; in acpi_processor_evaluate_lpi()
932 info->entries = lpi_state; in acpi_processor_evaluate_lpi()
934 /* LPI States start at index 3 */ in acpi_processor_evaluate_lpi()
938 element = &lpi_data->package.elements[loop]; in acpi_processor_evaluate_lpi()
939 if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7) in acpi_processor_evaluate_lpi()
942 pkg_elem = element->package.elements; in acpi_processor_evaluate_lpi()
945 if (obj->type == ACPI_TYPE_BUFFER) { in acpi_processor_evaluate_lpi()
948 reg = (struct acpi_power_register *)obj->buffer.pointer; in acpi_processor_evaluate_lpi()
949 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && in acpi_processor_evaluate_lpi()
950 reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) in acpi_processor_evaluate_lpi()
953 lpi_state->address = reg->address; in acpi_processor_evaluate_lpi()
954 lpi_state->entry_method = in acpi_processor_evaluate_lpi()
955 reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ? in acpi_processor_evaluate_lpi()
957 } else if (obj->type == ACPI_TYPE_INTEGER) { in acpi_processor_evaluate_lpi()
958 lpi_state->entry_method = ACPI_CSTATE_INTEGER; in acpi_processor_evaluate_lpi()
959 lpi_state->address = obj->integer.value; in acpi_processor_evaluate_lpi()
967 if (obj->type == ACPI_TYPE_STRING) in acpi_processor_evaluate_lpi()
968 strscpy(lpi_state->desc, obj->string.pointer, in acpi_processor_evaluate_lpi()
971 lpi_state->index = state_idx; in acpi_processor_evaluate_lpi()
972 if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) { in acpi_processor_evaluate_lpi()
974 lpi_state->min_residency = 10; in acpi_processor_evaluate_lpi()
977 if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) { in acpi_processor_evaluate_lpi()
979 lpi_state->wake_latency = 10; in acpi_processor_evaluate_lpi()
982 if (obj_get_integer(pkg_elem + 2, &lpi_state->flags)) in acpi_processor_evaluate_lpi()
983 lpi_state->flags = 0; in acpi_processor_evaluate_lpi()
985 if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags)) in acpi_processor_evaluate_lpi()
986 lpi_state->arch_flags = 0; in acpi_processor_evaluate_lpi()
988 if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq)) in acpi_processor_evaluate_lpi()
989 lpi_state->res_cnt_freq = 1; in acpi_processor_evaluate_lpi()
991 if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state)) in acpi_processor_evaluate_lpi()
992 lpi_state->enable_parent_state = 0; in acpi_processor_evaluate_lpi()
995 acpi_handle_debug(handle, "Found %d power states\n", state_idx); in acpi_processor_evaluate_lpi()
1002 * combine_lpi_states - combine local and parent LPI states to form a composite LPI state
1012 if (parent->entry_method == ACPI_CSTATE_INTEGER) { in combine_lpi_states()
1013 if (!parent->address) /* 0 means autopromotable */ in combine_lpi_states()
1015 result->address = local->address + parent->address; in combine_lpi_states()
1017 result->address = parent->address; in combine_lpi_states()
1020 result->min_residency = max(local->min_residency, parent->min_residency); in combine_lpi_states()
1021 result->wake_latency = local->wake_latency + parent->wake_latency; in combine_lpi_states()
1022 result->enable_parent_state = parent->enable_parent_state; in combine_lpi_states()
1023 result->entry_method = local->entry_method; in combine_lpi_states()
1025 result->flags = parent->flags; in combine_lpi_states()
1026 result->arch_flags = parent->arch_flags; in combine_lpi_states()
1027 result->index = parent->index; in combine_lpi_states()
1029 strscpy(result->desc, local->desc, ACPI_CX_DESC_LEN); in combine_lpi_states()
1030 strlcat(result->desc, "+", ACPI_CX_DESC_LEN); in combine_lpi_states()
1031 strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN); in combine_lpi_states()
1040 curr_level->composite_states[curr_level->composite_states_size++] = t; in stash_composite_state()
1048 int i, j, state_count = curr_level->size; in flatten_lpi_states()
1049 struct acpi_lpi_state *p, *t = curr_level->entries; in flatten_lpi_states() local
1051 curr_level->composite_states_size = 0; in flatten_lpi_states()
1055 if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED)) in flatten_lpi_states()
1059 pr_warn("Limiting number of LPI states to max (%d)\n", in flatten_lpi_states()
1065 flpi = &pr->power.lpi_states[flat_state_cnt]; in flatten_lpi_states()
1074 for (i = 0; i < prev_level->composite_states_size; i++) { in flatten_lpi_states()
1075 p = prev_level->composite_states[i]; in flatten_lpi_states()
1076 if (t->index <= p->enable_parent_state && in flatten_lpi_states()
1077 combine_lpi_states(p, t, flpi)) { in flatten_lpi_states()
1085 kfree(curr_level->entries); in flatten_lpi_states()
1091 return -EOPNOTSUPP; in acpi_processor_ffh_lpi_probe()
1098 acpi_handle handle = pr->handle, pr_ahandle; in acpi_processor_get_lpi_info()
1104 ret = acpi_processor_ffh_lpi_probe(pr->id); in acpi_processor_get_lpi_info()
1105 if (ret == -EOPNOTSUPP) in acpi_processor_get_lpi_info()
1109 return -EOPNOTSUPP; in acpi_processor_get_lpi_info()
1112 return -EINVAL; in acpi_processor_get_lpi_info()
1116 handle = pr->handle; in acpi_processor_get_lpi_info()
1141 /* flatten all the LPI states in this level of hierarchy */ in acpi_processor_get_lpi_info()
1151 pr->power.lpi_states[i].index = i; in acpi_processor_get_lpi_info()
1153 pr->power.count = state_count; in acpi_processor_get_lpi_info()
1156 pr->flags.has_lpi = 1; in acpi_processor_get_lpi_info()
1157 pr->flags.power = 1; in acpi_processor_get_lpi_info()
1164 return -ENODEV; in acpi_processor_ffh_lpi_enter()
1168 * acpi_idle_lpi_enter - enters an ACPI any LPI state
1184 return -EINVAL; in acpi_idle_lpi_enter()
1186 lpi = &pr->power.lpi_states[index]; in acpi_idle_lpi_enter()
1187 if (lpi->entry_method == ACPI_CSTATE_FFH) in acpi_idle_lpi_enter()
1190 return -EINVAL; in acpi_idle_lpi_enter()
1200 if (!pr->flags.has_lpi) in acpi_processor_setup_lpi_states()
1201 return -EOPNOTSUPP; in acpi_processor_setup_lpi_states()
1203 for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { in acpi_processor_setup_lpi_states()
1204 lpi = &pr->power.lpi_states[i]; in acpi_processor_setup_lpi_states()
1206 state = &drv->states[i]; in acpi_processor_setup_lpi_states()
1207 snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i); in acpi_processor_setup_lpi_states()
1208 strscpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN); in acpi_processor_setup_lpi_states()
1209 state->exit_latency = lpi->wake_latency; in acpi_processor_setup_lpi_states()
1210 state->target_residency = lpi->min_residency; in acpi_processor_setup_lpi_states()
1211 state->flags |= arch_get_idle_state_flags(lpi->arch_flags); in acpi_processor_setup_lpi_states()
1212 if (i != 0 && lpi->entry_method == ACPI_CSTATE_FFH) in acpi_processor_setup_lpi_states()
1213 state->flags |= CPUIDLE_FLAG_RCU_IDLE; in acpi_processor_setup_lpi_states()
1214 state->enter = acpi_idle_lpi_enter; in acpi_processor_setup_lpi_states()
1215 drv->safe_state_index = i; in acpi_processor_setup_lpi_states()
1218 drv->state_count = i; in acpi_processor_setup_lpi_states()
1224 * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle
1234 if (!pr->flags.power_setup_done || !pr->flags.power) in acpi_processor_setup_cpuidle_states()
1235 return -EINVAL; in acpi_processor_setup_cpuidle_states()
1237 drv->safe_state_index = -1; in acpi_processor_setup_cpuidle_states()
1239 drv->states[i].name[0] = '\0'; in acpi_processor_setup_cpuidle_states()
1240 drv->states[i].desc[0] = '\0'; in acpi_processor_setup_cpuidle_states()
1243 if (pr->flags.has_lpi) in acpi_processor_setup_cpuidle_states()
1250 * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE
1251 * device i.e. per-cpu data
1259 if (!pr->flags.power_setup_done || !pr->flags.power || !dev) in acpi_processor_setup_cpuidle_dev()
1260 return -EINVAL; in acpi_processor_setup_cpuidle_dev()
1262 dev->cpu = pr->id; in acpi_processor_setup_cpuidle_dev()
1263 if (pr->flags.has_lpi) in acpi_processor_setup_cpuidle_dev()
1264 return acpi_processor_ffh_lpi_probe(pr->id); in acpi_processor_setup_cpuidle_dev()
1288 if (!pr->flags.power_setup_done) in acpi_processor_hotplug()
1289 return -ENODEV; in acpi_processor_hotplug()
1291 dev = per_cpu(acpi_cpuidle_device, pr->id); in acpi_processor_hotplug()
1295 if (!ret && pr->flags.power) { in acpi_processor_hotplug()
1313 if (!pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1314 return -ENODEV; in acpi_processor_power_state_has_changed()
1318 * system instead of once per-cpu. This condition is a hack in acpi_processor_power_state_has_changed()
1319 * to make the code that updates C-States be called once. in acpi_processor_power_state_has_changed()
1322 if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { in acpi_processor_power_state_has_changed()
1324 /* Protect against cpu-hotplug */ in acpi_processor_power_state_has_changed()
1331 if (!_pr || !_pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1337 /* Populate Updated C-state information */ in acpi_processor_power_state_has_changed()
1344 if (!_pr || !_pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1347 if (_pr->flags.power) { in acpi_processor_power_state_has_changed()
1363 int ret = -ENODEV; in acpi_processor_register_idle_driver()
1379 pr->flags.power_setup_done = 1; in acpi_processor_register_idle_driver()
1420 pr->flags.power_setup_done = 1; in acpi_processor_power_init()
1422 if (!pr->flags.power) in acpi_processor_power_init()
1429 per_cpu(acpi_cpuidle_device, pr->id) = dev; in acpi_processor_power_init()
1438 per_cpu(acpi_cpuidle_device, pr->id) = NULL; in acpi_processor_power_init()
1445 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); in acpi_processor_power_exit()
1450 if (pr->flags.power) { in acpi_processor_power_exit()
1455 pr->flags.power_setup_done = 0; in acpi_processor_power_exit()