xref: /device/soc/rockchip/common/sdk_linux/kernel/cpu.c

157     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
163     if (st->fail == state) {
164         st->fail = CPUHP_INVALID;
179         trace_cpuhp_enter(cpu, st->target, state, cb);
181         trace_cpuhp_exit(cpu, st->state, state, ret);
192         trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
194         trace_cpuhp_exit(cpu, st->state, state, ret);
206         trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
208         trace_cpuhp_exit(cpu, st->state, state, ret);
236         trace_cpuhp_multi_enter(cpu, st->target, state, cbm, node);
238         trace_cpuhp_exit(cpu, st->state, state, ret);
257 static inline void wait_for_ap_thread(struct cpuhp_cpu_state *st, bool bringup)
259     struct completion *done = bringup ? &st->done_up : &st->done_down;
263 static inline void complete_ap_thread(struct cpuhp_cpu_state *st, bool bringup)
265     struct completion *done = bringup ? &st->done_up : &st->done_down;
480 static inline enum cpuhp_state cpuhp_set_state(struct cpuhp_cpu_state *st, enum cpuhp_state target)
482     enum cpuhp_state prev_state = st->state;
484     st->rollback = false;
485     st->last = NULL;
487     st->target = target;
488     st->single = false;
489     st->bringup = st->state < target;
494 static inline void cpuhp_reset_state(struct cpuhp_cpu_state *st, enum cpuhp_state prev_state)
496     st->rollback = true;
499      * If we have st->last we need to undo partial multi_instance of this
502     if (!st->last) {
503         if (st->bringup) {
504             st->state--;
506             st->state++;
510     st->target = prev_state;
511     st->bringup = !st->bringup;
515 static void _cpuhp_kick_ap(struct cpuhp_cpu_state *st)
517     if (!st->single && st->state == st->target) {
521     st->result = 0;
527     st->should_run = true;
528     wake_up_process(st->thread);
529     wait_for_ap_thread(st, st->bringup);
532 static int cpuhp_kick_ap(struct cpuhp_cpu_state *st, enum cpuhp_state target)
537     prev_state = cpuhp_set_state(st, target);
538     _cpuhp_kick_ap(st);
539     if ((ret = st->result)) {
540         cpuhp_reset_state(st, prev_state);
541         _cpuhp_kick_ap(st);
549     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
552     wait_for_ap_thread(st, true);
558     kthread_unpark(st->thread);
571     if (st->target <= CPUHP_AP_ONLINE_IDLE) {
575     return cpuhp_kick_ap(st, st->target);
625 static void undo_cpu_up(unsigned int cpu, struct cpuhp_cpu_state *st)
627     for (st->state--; st->state > st->target; st->state--) {
628         cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
632 static inline bool can_rollback_cpu(struct cpuhp_cpu_state *st)
644     return st->state <= CPUHP_BRINGUP_CPU;
647 static int cpuhp_up_callbacks(unsigned int cpu, struct cpuhp_cpu_state *st, enum cpuhp_state target)
649     enum cpuhp_state prev_state = st->state;
652     while (st->state < target) {
653         st->state++;
654         ret = cpuhp_invoke_callback(cpu, st->state, true, NULL, NULL);
656             if (can_rollback_cpu(st)) {
657                 st->target = prev_state;
658                 undo_cpu_up(cpu, st);
671     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
673     init_completion(&st->done_up);
674     init_completion(&st->done_down);
679     struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
681     return st->should_run;
692  *  - single: runs st->cb_state
693  *  - up:     runs ++st->state, while st->state < st->target
694  *  - down:   runs st->state--, while st->state > st->target
700     struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
701     bool bringup = st->bringup;
704     if (WARN_ON_ONCE(!st->should_run)) {
722     if (st->single) {
723         state = st->cb_state;
724         st->should_run = false;
727             st->state++;
728             state = st->state;
729             st->should_run = (st->state < st->target);
730             WARN_ON_ONCE(st->state > st->target);
732             state = st->state;
733             st->state--;
734             st->should_run = (st->state > st->target);
735             WARN_ON_ONCE(st->state < st->target);
743         st->result = cpuhp_invoke_callback(cpu, state, bringup, st->node, &st->last);
749         WARN_ON_ONCE(st->result);
751         st->result = cpuhp_invoke_callback(cpu, state, bringup, st->node, &st->last);
754     if (st->result) {
760         WARN_ON_ONCE(st->rollback);
761         st->should_run = false;
767     if (!st->should_run) {
768         complete_ap_thread(st, bringup);
775     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
792     if (!st->thread) {
796     st->rollback = false;
797     st->last = NULL;
799     st->node = node;
800     st->bringup = bringup;
801     st->cb_state = state;
802     st->single = true;
804     _cpuhp_kick_ap(st);
809     if ((ret = st->result) && st->last) {
810         st->rollback = true;
811         st->bringup = !bringup;
813         _cpuhp_kick_ap(st);
820     st->node = st->last = NULL;
826     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
827     enum cpuhp_state prev_state = st->state;
836     trace_cpuhp_enter(cpu, st->target, prev_state, cpuhp_kick_ap_work);
837     ret = cpuhp_kick_ap(st, st->target);
838     trace_cpuhp_exit(cpu, st->state, prev_state, ret);
956     struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
957     enum cpuhp_state target = max((int)st->target, CPUHP_AP_OFFLINE);
971     WARN_ON(st->state != CPUHP_TEARDOWN_CPU);
972     st->state--;
974     for (; st->state > target; st->state--) {
975         ret = cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
993     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1025     wait_for_ap_thread(st, false);
1026     BUG_ON(st->state != CPUHP_AP_IDLE_DEAD);
1042     struct cpuhp_cpu_state *st = arg;
1044     complete_ap_thread(st, false);
1049     struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
1051     BUG_ON(st->state != CPUHP_AP_OFFLINE);
1053     st->state = CPUHP_AP_IDLE_DEAD;
1058     smp_call_function_single(cpumask_first(cpu_online_mask), cpuhp_complete_idle_dead, st, 0);
1061 static void undo_cpu_down(unsigned int cpu, struct cpuhp_cpu_state *st)
1063     for (st->state++; st->state < st->target; st->state++) {
1064         cpuhp_invoke_callback(cpu, st->state, true, NULL, NULL);
1068 static int cpuhp_down_callbacks(unsigned int cpu, struct cpuhp_cpu_state *st, enum cpuhp_state target)
1070     enum cpuhp_state prev_state = st->state;
1073     for (; st->state > target; st->state--) {
1074         ret = cpuhp_invoke_callback(cpu, st->state, false, NULL, NULL);
1076             st->target = prev_state;
1077             if (st->state < prev_state) {
1078                 undo_cpu_down(cpu, st);
1089     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1110     prev_state = cpuhp_set_state(st, target);
1115     if (st->state > CPUHP_TEARDOWN_CPU) {
1116         st->target = max((int)target, CPUHP_TEARDOWN_CPU);
1130         if (st->state > CPUHP_TEARDOWN_CPU) {
1134         st->target = target;
1140     ret = cpuhp_down_callbacks(cpu, st, target);
1141     if (ret && st->state == CPUHP_TEARDOWN_CPU && st->state < prev_state) {
1142         cpuhp_reset_state(st, prev_state);
1143         _cpuhp_kick_ap(st);
1258     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1259     enum cpuhp_state target = min((int)st->target, CPUHP_AP_ONLINE);
1264     while (st->state < target) {
1265         st->state++;
1266         ret = cpuhp_invoke_callback(cpu, st->state, true, NULL, NULL);
1281     struct cpuhp_cpu_state *st = this_cpu_ptr(&cpuhp_state);
1294     st->state = CPUHP_AP_ONLINE_IDLE;
1295     complete_ap_thread(st, true);
1301     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1316     if (st->state >= target) {
1320     if (st->state == CPUHP_OFFLINE) {
1331     cpuhp_set_state(st, target);
1336     if (st->state > CPUHP_BRINGUP_CPU) {
1353     ret = cpuhp_up_callbacks(cpu, st, target);
1950         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1951         int cpustate = st->state;
1989         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
1990         int cpustate = st->state;
2073         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
2074         int cpustate = st->state;
2138         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
2139         int cpustate = st->state;
2191         struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, cpu);
2192         int cpustate = st->state;
2294     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2296     return sprintf(buf, "%d\n", st->state);
2302     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2334     if (st->state < target) {
2346     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2348     return sprintf(buf, "%d\n", st->target);
2354     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2387     st->fail = fail;
2394     struct cpuhp_cpu_state *st = per_cpu_ptr(&cpuhp_state, dev->id);
2396     return sprintf(buf, "%d\n", st->fail);

Indexes created Thu Nov 07 10:32:03 CST 2024