| /* |
| * Secondary cpu support |
| * |
| * Copyright 2016 Suraj Jitindar Singh, IBM. |
| * |
| * This work is licensed under the terms of the GNU LGPL, version 2. |
| */ |
| |
| #include <devicetree.h> |
| #include <asm/setup.h> |
| #include <asm/rtas.h> |
| #include <asm/smp.h> |
| |
| int nr_threads; |
| |
| struct secondary_entry_data { |
| secondary_entry_fn entry; |
| uint64_t r3; |
| int nr_started; |
| }; |
| |
| /* |
| * Start stopped thread cpu_id at entry |
| * Returns: <0 on failure to start stopped cpu |
| * 0 on success |
| * >0 on cpu not in stopped state |
| */ |
| int start_thread(int cpu_id, secondary_entry_fn entry, uint32_t r3) |
| { |
| uint32_t query_token, start_token; |
| int outputs[1], ret; |
| |
| ret = rtas_token("query-cpu-stopped-state", &query_token); |
| assert(ret == 0); |
| ret = rtas_token("start-cpu", &start_token); |
| assert(ret == 0); |
| |
| ret = rtas_call(query_token, 1, 2, outputs, cpu_id); |
| if (ret) { |
| printf("query-cpu-stopped-state failed for cpu %d\n", cpu_id); |
| } else if (!outputs[0]) { /* cpu in stopped state */ |
| ret = rtas_call(start_token, 3, 1, NULL, cpu_id, entry, r3); |
| if (ret) |
| printf("failed to start cpu %d\n", cpu_id); |
| } else { /* cpu not in stopped state */ |
| ret = outputs[0]; |
| } |
| |
| return ret; |
| } |
| |
| /* |
| * Start all stopped threads (vcpus) on cpu_node |
| * Returns: Number of stopped cpus which were successfully started |
| */ |
| struct start_threads start_cpu(int cpu_node, secondary_entry_fn entry, |
| uint32_t r3) |
| { |
| int len, i, nr_threads, nr_started = 0; |
| const struct fdt_property *prop; |
| u32 *threads; |
| |
| /* Get the id array of threads on this cpu_node */ |
| prop = fdt_get_property(dt_fdt(), cpu_node, |
| "ibm,ppc-interrupt-server#s", &len); |
| assert(prop); |
| |
| nr_threads = len >> 2; /* Divide by 4 since 4 bytes per thread */ |
| threads = (u32 *)prop->data; /* Array of valid ids */ |
| |
| for (i = 0; i < nr_threads; i++) { |
| if (!start_thread(fdt32_to_cpu(threads[i]), entry, r3)) |
| nr_started++; |
| } |
| |
| return (struct start_threads) { nr_threads, nr_started }; |
| } |
| |
| static void start_each_secondary(int fdtnode, u64 regval __unused, void *info) |
| { |
| struct secondary_entry_data *datap = info; |
| struct start_threads ret = start_cpu(fdtnode, datap->entry, datap->r3); |
| |
| nr_threads += ret.nr_threads; |
| datap->nr_started += ret.nr_started; |
| } |
| |
| /* |
| * Start all stopped cpus on the guest at entry with register 3 set to r3 |
| * We expect that we come in with only one thread currently started |
| * Returns: TRUE on success |
| * FALSE on failure |
| */ |
| bool start_all_cpus(secondary_entry_fn entry, uint32_t r3) |
| { |
| struct secondary_entry_data data = { entry, r3, 0 }; |
| int ret; |
| |
| ret = dt_for_each_cpu_node(start_each_secondary, &data); |
| assert(ret == 0); |
| |
| /* We expect that we come in with one thread already started */ |
| return data.nr_started == nr_threads - 1; |
| } |