Lines Matching +full:c +full:- +full:states
1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * processor_idle - idle state submodule to the ACPI processor driver
5 * Copyright (C) 2001, 2002 Andy Grover <andrew.grover@intel.com>
6 * Copyright (C) 2001, 2002 Paul Diefenbaugh <paul.s.diefenbaugh@intel.com>
7 * Copyright (C) 2004, 2005 Dominik Brodowski <linux@brodo.de>
8 * Copyright (C) 2004 Anil S Keshavamurthy <anil.s.keshavamurthy@intel.com>
9 * - Added processor hotplug support
10 * Copyright (C) 2005 Venkatesh Pallipadi <venkatesh.pallipadi@intel.com>
11 * - Added support for C3 on SMP
32 * creating an empty asm-ia64/apic.h would just trade pest vs. cholera.
79 pr_notice("%s detected - limiting to C%ld max_cstate." in set_max_cstate()
80 " Override with \"processor.max_cstate=%d\"\n", id->ident, in set_max_cstate()
81 (long)id->driver_data, ACPI_PROCESSOR_MAX_POWER + 1); in set_max_cstate()
83 max_cstate = (long)id->driver_data; in set_max_cstate()
91 DMI_MATCH(DMI_BIOS_VERSION,"SHE845M0.86C.0013.D.0302131307")},
94 DMI_MATCH(DMI_SYS_VENDOR, "Hewlett-Packard"),
128 struct acpi_processor_power *pwr = &pr->power; in lapic_timer_check_state()
131 if (cpu_has(&cpu_data(pr->id), X86_FEATURE_ARAT)) in lapic_timer_check_state()
138 * Check, if one of the previous states already marked the lapic in lapic_timer_check_state()
141 if (pwr->timer_broadcast_on_state < state) in lapic_timer_check_state()
144 if (cx->type >= type) in lapic_timer_check_state()
145 pr->power.timer_broadcast_on_state = state; in lapic_timer_check_state()
152 if (pr->power.timer_broadcast_on_state < INT_MAX) in __lapic_timer_propagate_broadcast()
160 smp_call_function_single(pr->id, __lapic_timer_propagate_broadcast, in lapic_timer_propagate_broadcast()
164 /* Power(C) State timer broadcast control */
168 return cx - pr->power.states >= pr->power.timer_broadcast_on_state; in lapic_timer_needs_broadcast()
196 * C/P/S0/S1 states when this bit is set. in tsc_check_state()
214 if (!pr->pblk) in acpi_processor_get_power_info_fadt()
215 return -ENODEV; in acpi_processor_get_power_info_fadt()
218 pr->power.states[ACPI_STATE_C2].type = ACPI_STATE_C2; in acpi_processor_get_power_info_fadt()
219 pr->power.states[ACPI_STATE_C3].type = ACPI_STATE_C3; in acpi_processor_get_power_info_fadt()
228 return -ENODEV; in acpi_processor_get_power_info_fadt()
232 pr->power.states[ACPI_STATE_C2].address = pr->pblk + 4; in acpi_processor_get_power_info_fadt()
233 pr->power.states[ACPI_STATE_C3].address = pr->pblk + 5; in acpi_processor_get_power_info_fadt()
236 pr->power.states[ACPI_STATE_C2].latency = acpi_gbl_FADT.c2_latency; in acpi_processor_get_power_info_fadt()
237 pr->power.states[ACPI_STATE_C3].latency = acpi_gbl_FADT.c3_latency; in acpi_processor_get_power_info_fadt()
244 acpi_handle_debug(pr->handle, "C2 latency too large [%d]\n", in acpi_processor_get_power_info_fadt()
247 pr->power.states[ACPI_STATE_C2].address = 0; in acpi_processor_get_power_info_fadt()
255 acpi_handle_debug(pr->handle, "C3 latency too large [%d]\n", in acpi_processor_get_power_info_fadt()
258 pr->power.states[ACPI_STATE_C3].address = 0; in acpi_processor_get_power_info_fadt()
261 acpi_handle_debug(pr->handle, "lvl2[0x%08x] lvl3[0x%08x]\n", in acpi_processor_get_power_info_fadt()
262 pr->power.states[ACPI_STATE_C2].address, in acpi_processor_get_power_info_fadt()
263 pr->power.states[ACPI_STATE_C3].address); in acpi_processor_get_power_info_fadt()
265 snprintf(pr->power.states[ACPI_STATE_C2].desc, in acpi_processor_get_power_info_fadt()
267 pr->power.states[ACPI_STATE_C2].address); in acpi_processor_get_power_info_fadt()
268 snprintf(pr->power.states[ACPI_STATE_C3].desc, in acpi_processor_get_power_info_fadt()
270 pr->power.states[ACPI_STATE_C3].address); in acpi_processor_get_power_info_fadt()
277 if (!pr->power.states[ACPI_STATE_C1].valid) { in acpi_processor_get_power_info_default()
278 /* set the first C-State to C1 */ in acpi_processor_get_power_info_default()
280 pr->power.states[ACPI_STATE_C1].type = ACPI_STATE_C1; in acpi_processor_get_power_info_default()
281 pr->power.states[ACPI_STATE_C1].valid = 1; in acpi_processor_get_power_info_default()
282 pr->power.states[ACPI_STATE_C1].entry_method = ACPI_CSTATE_HALT; in acpi_processor_get_power_info_default()
284 snprintf(pr->power.states[ACPI_STATE_C1].desc, in acpi_processor_get_power_info_default()
288 pr->power.states[ACPI_STATE_C0].valid = 1; in acpi_processor_get_power_info_default()
297 return -ENODEV; in acpi_processor_get_power_info_cst()
299 ret = acpi_processor_evaluate_cst(pr->handle, pr->id, &pr->power); in acpi_processor_get_power_info_cst()
303 if (!pr->power.count) in acpi_processor_get_power_info_cst()
304 return -EFAULT; in acpi_processor_get_power_info_cst()
306 pr->flags.has_cst = 1; in acpi_processor_get_power_info_cst()
313 static int bm_check_flag = -1; in acpi_processor_power_verify_c3()
314 static int bm_control_flag = -1; in acpi_processor_power_verify_c3()
317 if (!cx->address) in acpi_processor_power_verify_c3()
321 * PIIX4 Erratum #18: We don't support C3 when Type-F (fast) in acpi_processor_power_verify_c3()
323 * Note that we could disable Type-F DMA (as recommended by in acpi_processor_power_verify_c3()
328 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
329 "C3 not supported on PIIX4 with Type-F DMA\n"); in acpi_processor_power_verify_c3()
334 if (bm_check_flag == -1) { in acpi_processor_power_verify_c3()
336 acpi_processor_power_init_bm_check(&(pr->flags), pr->id); in acpi_processor_power_verify_c3()
337 bm_check_flag = pr->flags.bm_check; in acpi_processor_power_verify_c3()
338 bm_control_flag = pr->flags.bm_control; in acpi_processor_power_verify_c3()
340 pr->flags.bm_check = bm_check_flag; in acpi_processor_power_verify_c3()
341 pr->flags.bm_control = bm_control_flag; in acpi_processor_power_verify_c3()
344 if (pr->flags.bm_check) { in acpi_processor_power_verify_c3()
345 if (!pr->flags.bm_control) { in acpi_processor_power_verify_c3()
346 if (pr->flags.has_cst != 1) { in acpi_processor_power_verify_c3()
348 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
353 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
363 acpi_handle_debug(pr->handle, in acpi_processor_power_verify_c3()
376 cx->valid = 1; in acpi_processor_power_verify_c3()
393 if (!(x->valid && y->valid)) in acpi_cst_latency_cmp()
395 if (x->latency > y->latency) in acpi_cst_latency_cmp()
397 if (x->latency < y->latency) in acpi_cst_latency_cmp()
398 return -1; in acpi_cst_latency_cmp()
405 if (!(x->valid && y->valid)) in acpi_cst_latency_swap()
407 swap(x->latency, y->latency); in acpi_cst_latency_swap()
418 pr->power.timer_broadcast_on_state = INT_MAX; in acpi_processor_power_verify()
421 struct acpi_processor_cx *cx = &pr->power.states[i]; in acpi_processor_power_verify()
423 switch (cx->type) { in acpi_processor_power_verify()
425 cx->valid = 1; in acpi_processor_power_verify()
429 if (!cx->address) in acpi_processor_power_verify()
431 cx->valid = 1; in acpi_processor_power_verify()
438 if (!cx->valid) in acpi_processor_power_verify()
440 if (cx->type >= last_type && cx->latency < last_latency) in acpi_processor_power_verify()
442 last_latency = cx->latency; in acpi_processor_power_verify()
443 last_type = cx->type; in acpi_processor_power_verify()
446 tsc_check_state(cx->type); in acpi_processor_power_verify()
451 pr_notice("FW issue: working around C-state latencies out of order\n"); in acpi_processor_power_verify()
452 sort(&pr->power.states[1], max_cstate, in acpi_processor_power_verify()
472 /* Zero initialize all the C-states info. */ in acpi_processor_get_cstate_info()
473 memset(pr->power.states, 0, sizeof(pr->power.states)); in acpi_processor_get_cstate_info()
476 if (result == -ENODEV) in acpi_processor_get_cstate_info()
484 pr->power.count = acpi_processor_power_verify(pr); in acpi_processor_get_cstate_info()
491 if (pr->power.states[i].valid) { in acpi_processor_get_cstate_info()
492 pr->power.count = i; in acpi_processor_get_cstate_info()
493 pr->flags.power = 1; in acpi_processor_get_cstate_info()
501 * acpi_idle_bm_check - checks if bus master activity was detected
528 /* IO port based C-state */ in io_idle()
539 * that the motivating chipset issue was Intel-only. in io_idle()
545 * Dummy wait op - must do something useless after P_LVL2 read in io_idle()
560 * acpi_idle_do_entry - enter idle state using the appropriate method
569 if (cx->entry_method == ACPI_CSTATE_FFH) { in acpi_idle_do_entry()
570 /* Call into architectural FFH based C-state */ in acpi_idle_do_entry()
572 } else if (cx->entry_method == ACPI_CSTATE_HALT) { in acpi_idle_do_entry()
575 io_idle(cx->address); in acpi_idle_do_entry()
582 * acpi_idle_play_dead - enters an ACPI state for long-term idle (i.e. off-lining)
588 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_play_dead()
594 if (cx->entry_method == ACPI_CSTATE_HALT) in acpi_idle_play_dead()
596 else if (cx->entry_method == ACPI_CSTATE_SYSTEMIO) { in acpi_idle_play_dead()
597 io_idle(cx->address); in acpi_idle_play_dead()
599 return -ENODEV; in acpi_idle_play_dead()
608 return IS_ENABLED(CONFIG_HOTPLUG_CPU) && !pr->flags.has_cst && in acpi_idle_fallback_to_c1()
616 * acpi_idle_enter_bm - enters C3 with proper BM handling
639 bool dis_bm = pr->flags.bm_control; in acpi_idle_enter_bm()
644 if (!cx->bm_sts_skip && acpi_idle_bm_check()) { in acpi_idle_enter_bm()
646 index = drv->safe_state_index; in acpi_idle_enter_bm()
651 index = -EBUSY; in acpi_idle_enter_bm()
670 /* Re-enable bus master arbitration */ in acpi_idle_enter_bm()
674 c3_cpu_count--; in acpi_idle_enter_bm()
686 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter()
691 return -EINVAL; in acpi_idle_enter()
693 if (cx->type != ACPI_STATE_C1) { in acpi_idle_enter()
694 if (cx->type == ACPI_STATE_C3 && pr->flags.bm_check) in acpi_idle_enter()
700 cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter()
704 if (cx->type == ACPI_STATE_C3) in acpi_idle_enter()
715 struct acpi_processor_cx *cx = per_cpu(acpi_cstate[index], dev->cpu); in acpi_idle_enter_s2idle()
717 if (cx->type == ACPI_STATE_C3) { in acpi_idle_enter_s2idle()
723 if (pr->flags.bm_check) { in acpi_idle_enter_s2idle()
724 u8 bm_sts_skip = cx->bm_sts_skip; in acpi_idle_enter_s2idle()
727 cx->bm_sts_skip = 1; in acpi_idle_enter_s2idle()
729 cx->bm_sts_skip = bm_sts_skip; in acpi_idle_enter_s2idle()
752 state = &acpi_idle_driver.states[count]; in acpi_processor_setup_cpuidle_cx()
753 cx = &pr->power.states[i]; in acpi_processor_setup_cpuidle_cx()
755 if (!cx->valid) in acpi_processor_setup_cpuidle_cx()
758 per_cpu(acpi_cstate[count], dev->cpu) = cx; in acpi_processor_setup_cpuidle_cx()
761 state->flags |= CPUIDLE_FLAG_TIMER_STOP; in acpi_processor_setup_cpuidle_cx()
763 if (cx->type == ACPI_STATE_C3) { in acpi_processor_setup_cpuidle_cx()
764 state->flags |= CPUIDLE_FLAG_TLB_FLUSHED; in acpi_processor_setup_cpuidle_cx()
765 if (pr->flags.bm_check) in acpi_processor_setup_cpuidle_cx()
766 state->flags |= CPUIDLE_FLAG_RCU_IDLE; in acpi_processor_setup_cpuidle_cx()
775 return -EINVAL; in acpi_processor_setup_cpuidle_cx()
798 cx = &pr->power.states[i]; in acpi_processor_setup_cstates()
800 if (!cx->valid) in acpi_processor_setup_cstates()
803 state = &drv->states[count]; in acpi_processor_setup_cstates()
804 snprintf(state->name, CPUIDLE_NAME_LEN, "C%d", i); in acpi_processor_setup_cstates()
805 strscpy(state->desc, cx->desc, CPUIDLE_DESC_LEN); in acpi_processor_setup_cstates()
806 state->exit_latency = cx->latency; in acpi_processor_setup_cstates()
807 state->target_residency = cx->latency * latency_factor; in acpi_processor_setup_cstates()
808 state->enter = acpi_idle_enter; in acpi_processor_setup_cstates()
810 state->flags = 0; in acpi_processor_setup_cstates()
811 if (cx->type == ACPI_STATE_C1 || cx->type == ACPI_STATE_C2 || in acpi_processor_setup_cstates()
812 cx->type == ACPI_STATE_C3) { in acpi_processor_setup_cstates()
813 state->enter_dead = acpi_idle_play_dead; in acpi_processor_setup_cstates()
814 if (cx->type != ACPI_STATE_C3) in acpi_processor_setup_cstates()
815 drv->safe_state_index = count; in acpi_processor_setup_cstates()
818 * Halt-induced C1 is not good for ->enter_s2idle, because it in acpi_processor_setup_cstates()
819 * re-enables interrupts on exit. Moreover, C1 is generally not in acpi_processor_setup_cstates()
820 * particularly interesting from the suspend-to-idle angle, so in acpi_processor_setup_cstates()
824 if (cx->type != ACPI_STATE_C1 && !acpi_idle_fallback_to_c1(pr)) in acpi_processor_setup_cstates()
825 state->enter_s2idle = acpi_idle_enter_s2idle; in acpi_processor_setup_cstates()
832 drv->state_count = count; in acpi_processor_setup_cstates()
835 return -EINVAL; in acpi_processor_setup_cstates()
849 pr_notice("processor limited to max C-state %d\n", max_cstate); in acpi_processor_cstate_first_run_checks()
864 return -ENODEV; in acpi_processor_get_cstate_info()
870 return -EINVAL; in acpi_processor_setup_cpuidle_cx()
875 return -EINVAL; in acpi_processor_setup_cstates()
889 if (obj->type != ACPI_TYPE_INTEGER) in obj_get_integer()
890 return -EINVAL; in obj_get_integer()
892 *value = obj->integer.value; in obj_get_integer()
909 return -ENODEV; in acpi_processor_evaluate_lpi()
915 if (!lpi_data || lpi_data->type != ACPI_TYPE_PACKAGE || in acpi_processor_evaluate_lpi()
916 lpi_data->package.count < 4) { in acpi_processor_evaluate_lpi()
918 ret = -ENODATA; in acpi_processor_evaluate_lpi()
922 pkg_count = lpi_data->package.elements[2].integer.value; in acpi_processor_evaluate_lpi()
924 /* Validate number of power states. */ in acpi_processor_evaluate_lpi()
925 if (pkg_count < 1 || pkg_count != lpi_data->package.count - 3) { in acpi_processor_evaluate_lpi()
927 ret = -ENODATA; in acpi_processor_evaluate_lpi()
933 ret = -ENOMEM; in acpi_processor_evaluate_lpi()
937 info->size = pkg_count; in acpi_processor_evaluate_lpi()
938 info->entries = lpi_state; in acpi_processor_evaluate_lpi()
940 /* LPI States start at index 3 */ in acpi_processor_evaluate_lpi()
944 element = &lpi_data->package.elements[loop]; in acpi_processor_evaluate_lpi()
945 if (element->type != ACPI_TYPE_PACKAGE || element->package.count < 7) in acpi_processor_evaluate_lpi()
948 pkg_elem = element->package.elements; in acpi_processor_evaluate_lpi()
951 if (obj->type == ACPI_TYPE_BUFFER) { in acpi_processor_evaluate_lpi()
954 reg = (struct acpi_power_register *)obj->buffer.pointer; in acpi_processor_evaluate_lpi()
955 if (reg->space_id != ACPI_ADR_SPACE_SYSTEM_IO && in acpi_processor_evaluate_lpi()
956 reg->space_id != ACPI_ADR_SPACE_FIXED_HARDWARE) in acpi_processor_evaluate_lpi()
959 lpi_state->address = reg->address; in acpi_processor_evaluate_lpi()
960 lpi_state->entry_method = in acpi_processor_evaluate_lpi()
961 reg->space_id == ACPI_ADR_SPACE_FIXED_HARDWARE ? in acpi_processor_evaluate_lpi()
963 } else if (obj->type == ACPI_TYPE_INTEGER) { in acpi_processor_evaluate_lpi()
964 lpi_state->entry_method = ACPI_CSTATE_INTEGER; in acpi_processor_evaluate_lpi()
965 lpi_state->address = obj->integer.value; in acpi_processor_evaluate_lpi()
973 if (obj->type == ACPI_TYPE_STRING) in acpi_processor_evaluate_lpi()
974 strscpy(lpi_state->desc, obj->string.pointer, in acpi_processor_evaluate_lpi()
977 lpi_state->index = state_idx; in acpi_processor_evaluate_lpi()
978 if (obj_get_integer(pkg_elem + 0, &lpi_state->min_residency)) { in acpi_processor_evaluate_lpi()
980 lpi_state->min_residency = 10; in acpi_processor_evaluate_lpi()
983 if (obj_get_integer(pkg_elem + 1, &lpi_state->wake_latency)) { in acpi_processor_evaluate_lpi()
985 lpi_state->wake_latency = 10; in acpi_processor_evaluate_lpi()
988 if (obj_get_integer(pkg_elem + 2, &lpi_state->flags)) in acpi_processor_evaluate_lpi()
989 lpi_state->flags = 0; in acpi_processor_evaluate_lpi()
991 if (obj_get_integer(pkg_elem + 3, &lpi_state->arch_flags)) in acpi_processor_evaluate_lpi()
992 lpi_state->arch_flags = 0; in acpi_processor_evaluate_lpi()
994 if (obj_get_integer(pkg_elem + 4, &lpi_state->res_cnt_freq)) in acpi_processor_evaluate_lpi()
995 lpi_state->res_cnt_freq = 1; in acpi_processor_evaluate_lpi()
997 if (obj_get_integer(pkg_elem + 5, &lpi_state->enable_parent_state)) in acpi_processor_evaluate_lpi()
998 lpi_state->enable_parent_state = 0; in acpi_processor_evaluate_lpi()
1001 acpi_handle_debug(handle, "Found %d power states\n", state_idx); in acpi_processor_evaluate_lpi()
1008 * flat_state_cnt - the number of composite LPI states after the process of flattening
1013 * combine_lpi_states - combine local and parent LPI states to form a composite LPI state
1023 if (parent->entry_method == ACPI_CSTATE_INTEGER) { in combine_lpi_states()
1024 if (!parent->address) /* 0 means autopromotable */ in combine_lpi_states()
1026 result->address = local->address + parent->address; in combine_lpi_states()
1028 result->address = parent->address; in combine_lpi_states()
1031 result->min_residency = max(local->min_residency, parent->min_residency); in combine_lpi_states()
1032 result->wake_latency = local->wake_latency + parent->wake_latency; in combine_lpi_states()
1033 result->enable_parent_state = parent->enable_parent_state; in combine_lpi_states()
1034 result->entry_method = local->entry_method; in combine_lpi_states()
1036 result->flags = parent->flags; in combine_lpi_states()
1037 result->arch_flags = parent->arch_flags; in combine_lpi_states()
1038 result->index = parent->index; in combine_lpi_states()
1040 strscpy(result->desc, local->desc, ACPI_CX_DESC_LEN); in combine_lpi_states()
1041 strlcat(result->desc, "+", ACPI_CX_DESC_LEN); in combine_lpi_states()
1042 strlcat(result->desc, parent->desc, ACPI_CX_DESC_LEN); in combine_lpi_states()
1051 curr_level->composite_states[curr_level->composite_states_size++] = t; in stash_composite_state()
1058 int i, j, state_count = curr_level->size; in flatten_lpi_states()
1059 struct acpi_lpi_state *p, *t = curr_level->entries; in flatten_lpi_states()
1061 curr_level->composite_states_size = 0; in flatten_lpi_states()
1065 if (!(t->flags & ACPI_LPI_STATE_FLAGS_ENABLED)) in flatten_lpi_states()
1069 pr_warn("Limiting number of LPI states to max (%d)\n", in flatten_lpi_states()
1075 flpi = &pr->power.lpi_states[flat_state_cnt]; in flatten_lpi_states()
1084 for (i = 0; i < prev_level->composite_states_size; i++) { in flatten_lpi_states()
1085 p = prev_level->composite_states[i]; in flatten_lpi_states()
1086 if (t->index <= p->enable_parent_state && in flatten_lpi_states()
1095 kfree(curr_level->entries); in flatten_lpi_states()
1101 return -EOPNOTSUPP; in acpi_processor_ffh_lpi_probe()
1108 acpi_handle handle = pr->handle, pr_ahandle; in acpi_processor_get_lpi_info()
1113 ret = acpi_processor_ffh_lpi_probe(pr->id); in acpi_processor_get_lpi_info()
1114 if (ret == -EOPNOTSUPP) in acpi_processor_get_lpi_info()
1118 return -EOPNOTSUPP; in acpi_processor_get_lpi_info()
1121 return -EINVAL; in acpi_processor_get_lpi_info()
1126 handle = pr->handle; in acpi_processor_get_lpi_info()
1151 /* flatten all the LPI states in this level of hierarchy */ in acpi_processor_get_lpi_info()
1159 pr->power.count = flat_state_cnt; in acpi_processor_get_lpi_info()
1161 for (i = 0; i < pr->power.count; i++) in acpi_processor_get_lpi_info()
1162 pr->power.lpi_states[i].index = i; in acpi_processor_get_lpi_info()
1165 pr->flags.has_lpi = 1; in acpi_processor_get_lpi_info()
1166 pr->flags.power = 1; in acpi_processor_get_lpi_info()
1173 return -ENODEV; in acpi_processor_ffh_lpi_enter()
1177 * acpi_idle_lpi_enter - enters an ACPI any LPI state
1193 return -EINVAL; in acpi_idle_lpi_enter()
1195 lpi = &pr->power.lpi_states[index]; in acpi_idle_lpi_enter()
1196 if (lpi->entry_method == ACPI_CSTATE_FFH) in acpi_idle_lpi_enter()
1199 return -EINVAL; in acpi_idle_lpi_enter()
1209 if (!pr->flags.has_lpi) in acpi_processor_setup_lpi_states()
1210 return -EOPNOTSUPP; in acpi_processor_setup_lpi_states()
1212 for (i = 0; i < pr->power.count && i < CPUIDLE_STATE_MAX; i++) { in acpi_processor_setup_lpi_states()
1213 lpi = &pr->power.lpi_states[i]; in acpi_processor_setup_lpi_states()
1215 state = &drv->states[i]; in acpi_processor_setup_lpi_states()
1216 snprintf(state->name, CPUIDLE_NAME_LEN, "LPI-%d", i); in acpi_processor_setup_lpi_states()
1217 strscpy(state->desc, lpi->desc, CPUIDLE_DESC_LEN); in acpi_processor_setup_lpi_states()
1218 state->exit_latency = lpi->wake_latency; in acpi_processor_setup_lpi_states()
1219 state->target_residency = lpi->min_residency; in acpi_processor_setup_lpi_states()
1220 state->flags |= arch_get_idle_state_flags(lpi->arch_flags); in acpi_processor_setup_lpi_states()
1221 if (i != 0 && lpi->entry_method == ACPI_CSTATE_FFH) in acpi_processor_setup_lpi_states()
1222 state->flags |= CPUIDLE_FLAG_RCU_IDLE; in acpi_processor_setup_lpi_states()
1223 state->enter = acpi_idle_lpi_enter; in acpi_processor_setup_lpi_states()
1224 drv->safe_state_index = i; in acpi_processor_setup_lpi_states()
1227 drv->state_count = i; in acpi_processor_setup_lpi_states()
1233 * acpi_processor_setup_cpuidle_states- prepares and configures cpuidle
1243 if (!pr->flags.power_setup_done || !pr->flags.power) in acpi_processor_setup_cpuidle_states()
1244 return -EINVAL; in acpi_processor_setup_cpuidle_states()
1246 drv->safe_state_index = -1; in acpi_processor_setup_cpuidle_states()
1248 drv->states[i].name[0] = '\0'; in acpi_processor_setup_cpuidle_states()
1249 drv->states[i].desc[0] = '\0'; in acpi_processor_setup_cpuidle_states()
1252 if (pr->flags.has_lpi) in acpi_processor_setup_cpuidle_states()
1259 * acpi_processor_setup_cpuidle_dev - prepares and configures CPUIDLE
1260 * device i.e. per-cpu data
1268 if (!pr->flags.power_setup_done || !pr->flags.power || !dev) in acpi_processor_setup_cpuidle_dev()
1269 return -EINVAL; in acpi_processor_setup_cpuidle_dev()
1271 dev->cpu = pr->id; in acpi_processor_setup_cpuidle_dev()
1272 if (pr->flags.has_lpi) in acpi_processor_setup_cpuidle_dev()
1273 return acpi_processor_ffh_lpi_probe(pr->id); in acpi_processor_setup_cpuidle_dev()
1297 if (!pr->flags.power_setup_done) in acpi_processor_hotplug()
1298 return -ENODEV; in acpi_processor_hotplug()
1300 dev = per_cpu(acpi_cpuidle_device, pr->id); in acpi_processor_hotplug()
1304 if (!ret && pr->flags.power) { in acpi_processor_hotplug()
1322 if (!pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1323 return -ENODEV; in acpi_processor_power_state_has_changed()
1327 * system instead of once per-cpu. This condition is a hack in acpi_processor_power_state_has_changed()
1328 * to make the code that updates C-States be called once. in acpi_processor_power_state_has_changed()
1331 if (pr->id == 0 && cpuidle_get_driver() == &acpi_idle_driver) { in acpi_processor_power_state_has_changed()
1333 /* Protect against cpu-hotplug */ in acpi_processor_power_state_has_changed()
1340 if (!_pr || !_pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1346 /* Populate Updated C-state information */ in acpi_processor_power_state_has_changed()
1353 if (!_pr || !_pr->flags.power_setup_done) in acpi_processor_power_state_has_changed()
1356 if (_pr->flags.power) { in acpi_processor_power_state_has_changed()
1382 pr->flags.power_setup_done = 1; in acpi_processor_power_init()
1389 if (pr->flags.power) { in acpi_processor_power_init()
1402 return -ENOMEM; in acpi_processor_power_init()
1403 per_cpu(acpi_cpuidle_device, pr->id) = dev; in acpi_processor_power_init()
1407 /* Register per-cpu cpuidle_device. Cpuidle driver in acpi_processor_power_init()
1423 struct cpuidle_device *dev = per_cpu(acpi_cpuidle_device, pr->id); in acpi_processor_power_exit()
1428 if (pr->flags.power) { in acpi_processor_power_exit()
1430 acpi_processor_registered--; in acpi_processor_power_exit()
1437 pr->flags.power_setup_done = 0; in acpi_processor_power_exit()