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
31 * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
78 pr_notice("%s detected - limiting to C%ld max_cstate." in set_max_cstate()
79 " Override with \"processor.max_cstate=%d\"\n", id->ident, in set_max_cstate()
80 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); in set_max_cstate()
82 max_cstate = (long)id->driver_data; in set_max_cstate()
93 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
127 struct acpi_processor_power *pwr = &pr->power; in lapic_timer_check_state()
130 if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) in lapic_timer_check_state()
137 * Check, if one of the previous states already marked the lapic in lapic_timer_check_state()
140 if (pwr->timer_broadcast_on_state < state) in lapic_timer_check_state()
143 if (cx->type >= type) in lapic_timer_check_state()
144 pr->power.timer_broadcast_on_state = state; in lapic_timer_check_state()
151 if (pr->power.timer_broadcast_on_state < INT_MAX) in __lapic_timer_propagate_broadcast()
159 smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast, in lapic_timer_propagate_broadcast()
167 return cx - pr->power.states >= pr->power.timer_broadcast_on_state; in lapic_timer_needs_broadcast()
195 * C/P/S0/S1 states when this bit is set. in tsc_check_state()
213 if (!pr->pblk) in acpi_processor_get_power_info_fadt()
214 return -ENODEV; in acpi_processor_get_power_info_fadt()
217 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; in acpi_processor_get_power_info_fadt()
218 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; in acpi_processor_get_power_info_fadt()
227 return -ENODEV; in acpi_processor_get_power_info_fadt()
231 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; in acpi_processor_get_power_info_fadt()
232 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; in acpi_processor_get_power_info_fadt()
235 pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; in acpi_processor_get_power_info_fadt()
236 pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; in acpi_processor_get_power_info_fadt()
243 acpi_handle_debug(pr->handle, "C2 latency too large [%d]\n", in acpi_processor_get_power_info_fadt()
246 pr->power.states[ACPI_STATE_C2].address = 0; in acpi_processor_get_power_info_fadt()
254 acpi_handle_debug(pr->handle, "C3 latency too large [%d]\n", in acpi_processor_get_power_info_fadt()
257 pr->power.states[ACPI_STATE_C3].address = 0; in acpi_processor_get_power_info_fadt()
260 acpi_handle_debug(pr->handle, "lvl2[0x%08x] lvl3[0x%08x]\n", in acpi_processor_get_power_info_fadt()
261 pr->power.states[ACPI_STATE_C2].address, in acpi_processor_get_power_info_fadt()
262 pr->power.states[ACPI_STATE_C3].address); in acpi_processor_get_power_info_fadt()
264 snprintf(pr->power.states[ACPI_STATE_C2].desc, in acpi_processor_get_power_info_fadt()
266 pr->power.states[ACPI_STATE_C2].address); in acpi_processor_get_power_info_fadt()
267 snprintf(pr->power.states[ACPI_STATE_C3].desc, in acpi_processor_get_power_info_fadt()
269 pr->power.states[ACPI_STATE_C3].address); in acpi_processor_get_power_info_fadt()
271 if (!pr->power.states[ACPI_STATE_C2].address && in acpi_processor_get_power_info_fadt()
272 !pr->power.states[ACPI_STATE_C3].address) in acpi_processor_get_power_info_fadt()
273 return -ENODEV; in acpi_processor_get_power_info_fadt()
280 if (!pr->power.states[ACPI_STATE_C1].valid) { in acpi_processor_get_power_info_default()
281 /* set the first C-State to C1 */ in acpi_processor_get_power_info_default()
283 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; in acpi_processor_get_power_info_default()
284 pr->power.states[ACPI_STATE_C1].valid = 1; in acpi_processor_get_power_info_default()
285 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; in acpi_processor_get_power_info_default()
287 snprintf(pr->power.states[ACPI_STATE_C1].desc, in acpi_processor_get_power_info_default()
291 pr->power.states[ACPI_STATE_C0].valid = 1; in acpi_processor_get_power_info_default()
300 return -ENODEV; in acpi_processor_get_power_info_cst()
302 ret = acpi_processor_evaluate_cst(pr->handle, pr->id, &pr->power); in acpi_processor_get_power_info_cst()
306 if (!pr->power.count) in acpi_processor_get_power_info_cst()
307 return -EFAULT; in acpi_processor_get_power_info_cst()
309 pr->flags.has_cst = 1; in acpi_processor_get_power_info_cst()
316 static int bm_check_flag = -1; in acpi_processor_power_verify_c3()
317 static int bm_control_flag = -1; in acpi_processor_power_verify_c3()
320 if (!cx->address) in acpi_processor_power_verify_c3()
324 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) in acpi_processor_power_verify_c3()
326 * Note that we could disable Type-F DMA (as recommended by in acpi_processor_power_verify_c3()
331 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
332 "C3 not supported on PIIX4 with Type-F DMA\n"); in acpi_processor_power_verify_c3()
337 if (bm_check_flag == -1) { in acpi_processor_power_verify_c3()
339 acpi_processor_power_init_bm_check(&(pr->flags), pr->id); in acpi_processor_power_verify_c3()
340 bm_check_flag = pr->flags.bm_check; in acpi_processor_power_verify_c3()
341 bm_control_flag = pr->flags.bm_control; in acpi_processor_power_verify_c3()
343 pr->flags.bm_check = bm_check_flag; in acpi_processor_power_verify_c3()
344 pr->flags.bm_control = bm_control_flag; in acpi_processor_power_verify_c3()
347 if (pr->flags.bm_check) { in acpi_processor_power_verify_c3()
348 if (!pr->flags.bm_control) { in acpi_processor_power_verify_c3()
349 if (pr->flags.has_cst != 1) { in acpi_processor_power_verify_c3()
351 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
356 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
366 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
379 cx->valid = 1; in acpi_processor_power_verify_c3()
392 static void acpi_cst_latency_sort(struct acpi_processor_cx *states, size_t length) in acpi_cst_latency_sort() argument
397 if (!states[i].valid) in acpi_cst_latency_sort()
400 for (j = i - 1, k = i; j >= 0; j--) { in acpi_cst_latency_sort()
401 if (!states[j].valid) in acpi_cst_latency_sort()
404 if (states[j].latency > states[k].latency) in acpi_cst_latency_sort()
405 swap(states[j].latency, states[k].latency); in acpi_cst_latency_sort()
420 pr->power.timer_broadcast_on_state = INT_MAX; in acpi_processor_power_verify()
423 struct acpi_processor_cx *cx = &pr->power.states[i]; in acpi_processor_power_verify()
425 switch (cx->type) { in acpi_processor_power_verify()
427 cx->valid = 1; in acpi_processor_power_verify()
431 if (!cx->address) in acpi_processor_power_verify()
433 cx->valid = 1; in acpi_processor_power_verify()
440 if (!cx->valid) in acpi_processor_power_verify()
442 if (cx->type >= last_type && cx->latency < last_latency) in acpi_processor_power_verify()
444 last_latency = cx->latency; in acpi_processor_power_verify()
445 last_type = cx->type; in acpi_processor_power_verify()
448 tsc_check_state(cx->type); in acpi_processor_power_verify()
453 pr_notice("FW issue: working around C-state latencies out of order\n"); in acpi_processor_power_verify()
454 acpi_cst_latency_sort(&pr->power.states[1], max_cstate); in acpi_processor_power_verify()
471 /* Zero initialize all the C-states info. */ in acpi_processor_get_cstate_info()
472 memset(pr->power.states, 0, sizeof(pr->power.states)); in acpi_processor_get_cstate_info()
475 if (result == -ENODEV) in acpi_processor_get_cstate_info()
483 pr->power.count = acpi_processor_power_verify(pr); in acpi_processor_get_cstate_info()
490 if (pr->power.states[i].valid) { in acpi_processor_get_cstate_info()
491 pr->power.count = i; in acpi_processor_get_cstate_info()
492 pr->flags.power = 1; in acpi_processor_get_cstate_info()
500 * acpi_idle_bm_check - checks if bus master activity was detected
527 /* IO port based C-state */ in io_idle()
538 * that the motivating chipset issue was Intel-only. in io_idle()
544 * Dummy wait op - must do something useless after P_LVL2 read in io_idle()
559 * acpi_idle_do_entry - enter idle state using the appropriate method
568 if (cx->entry_method == ACPI_CSTATE_FFH) { in acpi_idle_do_entry()
569 /* Call into architectural FFH based C-state */ in acpi_idle_do_entry()
571 } else if (cx->entry_method == ACPI_CSTATE_HALT) { in acpi_idle_do_entry()
574 io_idle(cx->address); in acpi_idle_do_entry()
581 * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining)
587 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_play_dead()
593 if (cx->entry_method == ACPI_CSTATE_HALT) in acpi_idle_play_dead()
595 else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { in acpi_idle_play_dead()
596 io_idle(cx->address); in acpi_idle_play_dead()
604 return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst && in acpi_idle_fallback_to_c1()
612 * acpi_idle_enter_bm - enters C3 with proper BM handling
635 bool dis_bm = pr->flags.bm_control; in acpi_idle_enter_bm()
640 if (!cx->bm_sts_skip && acpi_idle_bm_check()) { in acpi_idle_enter_bm()
642 index = drv->safe_state_index; in acpi_idle_enter_bm()
647 index = -EBUSY; in acpi_idle_enter_bm()
666 /* Re-enable bus master arbitration */ in acpi_idle_enter_bm()
670 c3_cpu_count--; in acpi_idle_enter_bm()
682 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter()
687 return -EINVAL; in acpi_idle_enter()
689 if (cx->type != ACPI_STATE_C1) { in acpi_idle_enter()
690 if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) in acpi_idle_enter()
696 cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter()
700 if (cx->type == ACPI_STATE_C3) in acpi_idle_enter()
711 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter_s2idle()
713 if (cx->type == ACPI_STATE_C3) { in acpi_idle_enter_s2idle()
719 if (pr->flags.bm_check) { in acpi_idle_enter_s2idle()
720 u8 bm_sts_skip = cx->bm_sts_skip; in acpi_idle_enter_s2idle()
723 cx->bm_sts_skip = 1; in acpi_idle_enter_s2idle()
725 cx->bm_sts_skip = bm_sts_skip; in acpi_idle_enter_s2idle()
748 state = &acpi_idle_driver.states[count]; in acpi_processor_setup_cpuidle_cx()
749 cx = &pr->power.states[i]; in acpi_processor_setup_cpuidle_cx()
751 if (!cx->valid) in acpi_processor_setup_cpuidle_cx()
754 per_cpu(acpi_cstate[count], dev->cpu) = cx; in acpi_processor_setup_cpuidle_cx()
757 state->flags |= CPUIDLE_FLAG_TIMER_STOP; in acpi_processor_setup_cpuidle_cx()
759 if (cx->type == ACPI_STATE_C3) { in acpi_processor_setup_cpuidle_cx()
760 state->flags |= CPUIDLE_FLAG_TLB_FLUSHED; in acpi_processor_setup_cpuidle_cx()
761 if (pr->flags.bm_check) in acpi_processor_setup_cpuidle_cx()
762 state->flags |= CPUIDLE_FLAG_RCU_IDLE; in acpi_processor_setup_cpuidle_cx()
771 return -EINVAL; in acpi_processor_setup_cpuidle_cx()
794 cx = &pr->power.states[i]; in acpi_processor_setup_cstates()
796 if (!cx->valid) in acpi_processor_setup_cstates()
799 state = &drv->states[count]; in acpi_processor_setup_cstates()
800 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); in acpi_processor_setup_cstates()
801 strscpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); in acpi_processor_setup_cstates()
802 state->exit_latency = cx->latency; in acpi_processor_setup_cstates()
803 state->target_residency = cx->latency * latency_factor; in acpi_processor_setup_cstates()
804 state->enter = acpi_idle_enter; in acpi_processor_setup_cstates()
806 state->flags = 0; in acpi_processor_setup_cstates()
808 state->enter_dead = acpi_idle_play_dead; in acpi_processor_setup_cstates()
810 if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2) in acpi_processor_setup_cstates()
811 drv->safe_state_index = count; in acpi_processor_setup_cstates()
814 * Halt-induced C1 is not good for ->enter_s2idle, because it in acpi_processor_setup_cstates()
815 * re-enables interrupts on exit. Moreover, C1 is generally not in acpi_processor_setup_cstates()
816 * particularly interesting from the suspend-to-idle angle, so in acpi_processor_setup_cstates()
820 if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) in acpi_processor_setup_cstates()
821 state->enter_s2idle = acpi_idle_enter_s2idle; in acpi_processor_setup_cstates()
828 drv->state_count = count; in acpi_processor_setup_cstates()
831 return -EINVAL; in acpi_processor_setup_cstates()
845 pr_notice("processor limited to max C-state %d\n", max_cstate); in acpi_processor_cstate_first_run_checks()
860 return -ENODEV; in acpi_processor_get_cstate_info()
866 return -EINVAL; in acpi_processor_setup_cpuidle_cx()
871 return -EINVAL; in acpi_processor_setup_cstates()
885 if (obj->type != ACPI_TYPE_INTEGER) in obj_get_integer()
886 return -EINVAL; in obj_get_integer()
888 *value = obj->integer.value; in obj_get_integer()
905 return -ENODEV; in acpi_processor_evaluate_lpi()
911 if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE || in acpi_processor_evaluate_lpi()
912 lpi_data->package.count < 4) { in acpi_processor_evaluate_lpi()
914 ret = -ENODATA; in acpi_processor_evaluate_lpi()
918 pkg_count = lpi_data->package.elements[2].integer.value; in acpi_processor_evaluate_lpi()
920 /* Validate number of power states. */ in acpi_processor_evaluate_lpi()
921 if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) { in acpi_processor_evaluate_lpi()
923 ret = -ENODATA; in acpi_processor_evaluate_lpi()
929 ret = -ENOMEM; in acpi_processor_evaluate_lpi()
933 info->size = pkg_count; in acpi_processor_evaluate_lpi()
934 info->entries = lpi_state; in acpi_processor_evaluate_lpi()
936 /* LPI States start at index 3 */ in acpi_processor_evaluate_lpi()
940 element = &lpi_data->package.elements[loop]; in acpi_processor_evaluate_lpi()
941 if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7) in acpi_processor_evaluate_lpi()
944 pkg_elem = element->package.elements; in acpi_processor_evaluate_lpi()
947 if (obj->type == ACPI_TYPE_BUFFER) { in acpi_processor_evaluate_lpi()
950 reg = (struct acpi_power_register *)obj->buffer.pointer; in acpi_processor_evaluate_lpi()
951 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && in acpi_processor_evaluate_lpi()
952 reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) in acpi_processor_evaluate_lpi()
955 lpi_state->address = reg->address; in acpi_processor_evaluate_lpi()
956 lpi_state->entry_method = in acpi_processor_evaluate_lpi()
957 reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ? in acpi_processor_evaluate_lpi()
959 } else if (obj->type == ACPI_TYPE_INTEGER) { in acpi_processor_evaluate_lpi()
960 lpi_state->entry_method = ACPI_CSTATE_INTEGER; in acpi_processor_evaluate_lpi()
961 lpi_state->address = obj->integer.value; in acpi_processor_evaluate_lpi()
969 if (obj->type == ACPI_TYPE_STRING) in acpi_processor_evaluate_lpi()
970 strscpy(lpi_state->desc, obj->string.pointer, in acpi_processor_evaluate_lpi()
973 lpi_state->index = state_idx; in acpi_processor_evaluate_lpi()
974 if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) { in acpi_processor_evaluate_lpi()
976 lpi_state->min_residency = 10; in acpi_processor_evaluate_lpi()
979 if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) { in acpi_processor_evaluate_lpi()
981 lpi_state->wake_latency = 10; in acpi_processor_evaluate_lpi()
984 if (obj_get_integer(pkg_elem + 2, &lpi_state->flags)) in acpi_processor_evaluate_lpi()
985 lpi_state->flags = 0; in acpi_processor_evaluate_lpi()
987 if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags)) in acpi_processor_evaluate_lpi()
988 lpi_state->arch_flags = 0; in acpi_processor_evaluate_lpi()
990 if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq)) in acpi_processor_evaluate_lpi()
991 lpi_state->res_cnt_freq = 1; in acpi_processor_evaluate_lpi()
993 if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state)) in acpi_processor_evaluate_lpi()
994 lpi_state->enable_parent_state = 0; in acpi_processor_evaluate_lpi()
997 acpi_handle_debug(handle, "Found %d power states\n", state_idx); in acpi_processor_evaluate_lpi()
1004 * flat_state_cnt - the number of composite LPI states after the process of flattening
1009 * combine_lpi_states - combine local and parent LPI states to form a composite LPI state
1019 if (parent->entry_method == ACPI_CSTATE_INTEGER) { in combine_lpi_states()
1020 if (!parent->address) /* 0 means autopromotable */ in combine_lpi_states()
1022 result->address = local->address + parent->address; in combine_lpi_states()
1024 result->address = parent->address; in combine_lpi_states()
1027 result->min_residency = max(local->min_residency, parent->min_residency); in combine_lpi_states()
1028 result->wake_latency = local->wake_latency + parent->wake_latency; in combine_lpi_states()
1029 result->enable_parent_state = parent->enable_parent_state; in combine_lpi_states()
1030 result->entry_method = local->entry_method; in combine_lpi_states()
1032 result->flags = parent->flags; in combine_lpi_states()
1033 result->arch_flags = parent->arch_flags; in combine_lpi_states()
1034 result->index = parent->index; in combine_lpi_states()
1036 strscpy(result->desc, local->desc, ACPI_CX_DESC_LEN); in combine_lpi_states()
1037 strlcat(result->desc, "+", ACPI_CX_DESC_LEN); in combine_lpi_states()
1038 strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN); in combine_lpi_states()
1047 curr_level->composite_states[curr_level->composite_states_size++] = t; in stash_composite_state()
1054 int i, j, state_count = curr_level->size; in flatten_lpi_states()
1055 struct acpi_lpi_state *p, *t = curr_level->entries; in flatten_lpi_states() local
1057 curr_level->composite_states_size = 0; in flatten_lpi_states()
1061 if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED)) in flatten_lpi_states()
1065 pr_warn("Limiting number of LPI states to max (%d)\n", in flatten_lpi_states()
1071 flpi = &pr->power.lpi_states[flat_state_cnt]; in flatten_lpi_states()
1080 for (i = 0; i < prev_level->composite_states_size; i++) { in flatten_lpi_states()
1081 p = prev_level->composite_states[i]; in flatten_lpi_states()
1082 if (t->index <= p->enable_parent_state && in flatten_lpi_states()
1083 combine_lpi_states(p, t, flpi)) { in flatten_lpi_states()
1091 kfree(curr_level->entries); in flatten_lpi_states()
1097 return -EOPNOTSUPP; in acpi_processor_ffh_lpi_probe()
1104 acpi_handle handle = pr->handle, pr_ahandle; in acpi_processor_get_lpi_info()
1109 ret = acpi_processor_ffh_lpi_probe(pr->id); in acpi_processor_get_lpi_info()
1110 if (ret == -EOPNOTSUPP) in acpi_processor_get_lpi_info()
1114 return -EOPNOTSUPP; in acpi_processor_get_lpi_info()
1117 return -EINVAL; in acpi_processor_get_lpi_info()
1122 handle = pr->handle; in acpi_processor_get_lpi_info()
1147 /* flatten all the LPI states in this level of hierarchy */ in acpi_processor_get_lpi_info()
1155 pr->power.count = flat_state_cnt; in acpi_processor_get_lpi_info()
1157 for (i = 0; i < pr->power.count; i++) in acpi_processor_get_lpi_info()
1158 pr->power.lpi_states[i].index = i; in acpi_processor_get_lpi_info()
1161 pr->flags.has_lpi = 1; in acpi_processor_get_lpi_info()
1162 pr->flags.power = 1; in acpi_processor_get_lpi_info()
1169 return -ENODEV; in acpi_processor_ffh_lpi_enter()
1173 * acpi_idle_lpi_enter - enters an ACPI any LPI state
1189 return -EINVAL; in acpi_idle_lpi_enter()
1191 lpi = &pr->power.lpi_states[index]; in acpi_idle_lpi_enter()
1192 if (lpi->entry_method == ACPI_CSTATE_FFH) in acpi_idle_lpi_enter()
1195 return -EINVAL; in acpi_idle_lpi_enter()
1205 if (!pr->flags.has_lpi) in acpi_processor_setup_lpi_states()
1206 return -EOPNOTSUPP; in acpi_processor_setup_lpi_states()
1208 for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { in acpi_processor_setup_lpi_states()
1209 lpi = &pr->power.lpi_states[i]; in acpi_processor_setup_lpi_states()
1211 state = &drv->states[i]; in acpi_processor_setup_lpi_states()
1212 snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i); in acpi_processor_setup_lpi_states()
1213 strscpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN); in acpi_processor_setup_lpi_states()
1214 state->exit_latency = lpi->wake_latency; in acpi_processor_setup_lpi_states()
1215 state->target_residency = lpi->min_residency; in acpi_processor_setup_lpi_states()
1216 state->flags |= arch_get_idle_state_flags(lpi->arch_flags); in acpi_processor_setup_lpi_states()
1217 if (i != 0 && lpi->entry_method == ACPI_CSTATE_FFH) in acpi_processor_setup_lpi_states()
1218 state->flags |= CPUIDLE_FLAG_RCU_IDLE; in acpi_processor_setup_lpi_states()
1219 state->enter = acpi_idle_lpi_enter; in acpi_processor_setup_lpi_states()
1220 drv->safe_state_index = i; in acpi_processor_setup_lpi_states()
1223 drv->state_count = i; in acpi_processor_setup_lpi_states()
1229 * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle
1239 if (!pr->flags.power_setup_done || !pr->flags.power) in acpi_processor_setup_cpuidle_states()
1240 return -EINVAL; in acpi_processor_setup_cpuidle_states()
1242 drv->safe_state_index = -1; in acpi_processor_setup_cpuidle_states()
1244 drv->states[i].name[0] = '\0'; in acpi_processor_setup_cpuidle_states()
1245 drv->states[i].desc[0] = '\0'; in acpi_processor_setup_cpuidle_states()
1248 if (pr->flags.has_lpi) in acpi_processor_setup_cpuidle_states()
1255 * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE
1256 * device i.e. per-cpu data
1264 if (!pr->flags.power_setup_done || !pr->flags.power || !dev) in acpi_processor_setup_cpuidle_dev()
1265 return -EINVAL; in acpi_processor_setup_cpuidle_dev()
1267 dev->cpu = pr->id; in acpi_processor_setup_cpuidle_dev()
1268 if (pr->flags.has_lpi) in acpi_processor_setup_cpuidle_dev()
1269 return acpi_processor_ffh_lpi_probe(pr->id); in acpi_processor_setup_cpuidle_dev()
1293 if (!pr->flags.power_setup_done) in acpi_processor_hotplug()
1294 return -ENODEV; in acpi_processor_hotplug()
1296 dev = per_cpu(acpi_cpuidle_device, pr->id); in acpi_processor_hotplug()
1300 if (!ret && pr->flags.power) { in acpi_processor_hotplug()
1318 if (!pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1319 return -ENODEV; in acpi_processor_power_state_has_changed()
1323 * system instead of once per-cpu. This condition is a hack in acpi_processor_power_state_has_changed()
1324 * to make the code that updates C-States be called once. in acpi_processor_power_state_has_changed()
1327 if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { in acpi_processor_power_state_has_changed()
1329 /* Protect against cpu-hotplug */ in acpi_processor_power_state_has_changed()
1336 if (!_pr || !_pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1342 /* Populate Updated C-state information */ in acpi_processor_power_state_has_changed()
1349 if (!_pr || !_pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1352 if (_pr->flags.power) { in acpi_processor_power_state_has_changed()
1378 pr->flags.power_setup_done = 1; in acpi_processor_power_init()
1385 if (pr->flags.power) { in acpi_processor_power_init()
1398 return -ENOMEM; in acpi_processor_power_init()
1399 per_cpu(acpi_cpuidle_device, pr->id) = dev; in acpi_processor_power_init()
1403 /* Register per-cpu cpuidle_device. Cpuidle driver in acpi_processor_power_init()
1419 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); in acpi_processor_power_exit()
1424 if (pr->flags.power) { in acpi_processor_power_exit()
1426 acpi_processor_registered--; in acpi_processor_power_exit()
1433 pr->flags.power_setup_done = 0; in acpi_processor_power_exit()