blob: 93e52039321b1f6bcb2a89c335c3c9b4ef1c1104 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * arch/s390/kernel/smp.c
3 *
Hans-Joachim Picht155af2f2009-06-16 10:30:52 +02004 * Copyright IBM Corp. 1999, 2009
Linus Torvalds1da177e2005-04-16 15:20:36 -07005 * Author(s): Denis Joseph Barrow (djbarrow@de.ibm.com,barrow_dj@yahoo.com),
Heiko Carstens39ce0102007-04-27 16:02:00 +02006 * Martin Schwidefsky (schwidefsky@de.ibm.com)
7 * Heiko Carstens (heiko.carstens@de.ibm.com)
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 *
Heiko Carstens39ce0102007-04-27 16:02:00 +02009 * based on other smp stuff by
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 * (c) 1995 Alan Cox, CymruNET Ltd <alan@cymru.net>
11 * (c) 1998 Ingo Molnar
12 *
13 * We work with logical cpu numbering everywhere we can. The only
14 * functions using the real cpu address (got from STAP) are the sigp
15 * functions. For all other functions we use the identity mapping.
16 * That means that cpu_number_map[i] == i for every cpu. cpu_number_map is
17 * used e.g. to find the idle task belonging to a logical cpu. Every array
18 * in the kernel is sorted by the logical cpu number and not by the physical
19 * one which is causing all the confusion with __cpu_logical_map and
20 * cpu_number_map in other architectures.
21 */
22
Martin Schwidefsky395d31d2008-12-25 13:39:50 +010023#define KMSG_COMPONENT "cpu"
24#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
25
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/module.h>
27#include <linux/init.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070028#include <linux/mm.h>
Alexey Dobriyan4e950f62007-07-30 02:36:13 +040029#include <linux/err.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070030#include <linux/spinlock.h>
31#include <linux/kernel_stat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070032#include <linux/delay.h>
33#include <linux/cache.h>
34#include <linux/interrupt.h>
Christian Borntraeger3324e602009-03-26 15:23:56 +010035#include <linux/irqflags.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <linux/cpu.h>
Heiko Carstens2b67fc42007-02-05 21:16:47 +010037#include <linux/timex.h>
Michael Holzheu411ed322007-04-27 16:01:49 +020038#include <linux/bootmem.h>
Michael Holzheu46b05d22007-02-21 10:55:21 +010039#include <asm/ipl.h>
Heiko Carstens2b67fc42007-02-05 21:16:47 +010040#include <asm/setup.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070041#include <asm/sigp.h>
42#include <asm/pgalloc.h>
43#include <asm/irq.h>
44#include <asm/s390_ext.h>
45#include <asm/cpcmd.h>
46#include <asm/tlbflush.h>
Heiko Carstens2b67fc42007-02-05 21:16:47 +010047#include <asm/timer.h>
Michael Holzheu411ed322007-04-27 16:01:49 +020048#include <asm/lowcore.h>
Heiko Carstens08d07962008-01-26 14:10:56 +010049#include <asm/sclp.h>
Martin Schwidefsky76d4e002009-06-12 10:26:21 +020050#include <asm/cputime.h>
Martin Schwidefskyc742b312008-12-31 15:11:42 +010051#include <asm/vdso.h>
Heiko Carstens4bb5e072009-09-11 10:29:03 +020052#include <asm/cpu.h>
Heiko Carstensa8061702008-04-17 07:46:26 +020053#include "entry.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070054
Linus Torvalds1da177e2005-04-16 15:20:36 -070055static struct task_struct *current_set[NR_CPUS];
56
Heiko Carstens08d07962008-01-26 14:10:56 +010057static u8 smp_cpu_type;
58static int smp_use_sigp_detection;
59
60enum s390_cpu_state {
61 CPU_STATE_STANDBY,
62 CPU_STATE_CONFIGURED,
63};
64
Heiko Carstensdbd70fb2008-04-17 07:46:12 +020065DEFINE_MUTEX(smp_cpu_state_mutex);
Heiko Carstensc10fde02008-04-17 07:46:13 +020066int smp_cpu_polarization[NR_CPUS];
Heiko Carstens08d07962008-01-26 14:10:56 +010067static int smp_cpu_state[NR_CPUS];
Heiko Carstensc10fde02008-04-17 07:46:13 +020068static int cpu_management;
Heiko Carstens08d07962008-01-26 14:10:56 +010069
70static DEFINE_PER_CPU(struct cpu, cpu_devices);
Heiko Carstens08d07962008-01-26 14:10:56 +010071
Linus Torvalds1da177e2005-04-16 15:20:36 -070072static void smp_ext_bitcall(int, ec_bit_sig);
Linus Torvalds1da177e2005-04-16 15:20:36 -070073
Heiko Carstens5c0b9122009-09-11 10:29:05 +020074static int cpu_stopped(int cpu)
75{
76 __u32 status;
77
78 switch (signal_processor_ps(&status, 0, cpu, sigp_sense)) {
Heiko Carstens5c0b9122009-09-11 10:29:05 +020079 case sigp_status_stored:
80 /* Check for stopped and check stop state */
81 if (status & 0x50)
82 return 1;
83 break;
84 default:
85 break;
86 }
87 return 0;
88}
89
Heiko Carstens677d7622007-11-20 11:13:37 +010090void smp_send_stop(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070091{
Heiko Carstens39ce0102007-04-27 16:02:00 +020092 int cpu, rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -070093
Heiko Carstens677d7622007-11-20 11:13:37 +010094 /* Disable all interrupts/machine checks */
95 __load_psw_mask(psw_kernel_bits & ~PSW_MASK_MCHECK);
Christian Borntraeger3324e602009-03-26 15:23:56 +010096 trace_hardirqs_off();
Heiko Carstens677d7622007-11-20 11:13:37 +010097
Heiko Carstens39ce0102007-04-27 16:02:00 +020098 /* stop all processors */
Linus Torvalds1da177e2005-04-16 15:20:36 -070099 for_each_online_cpu(cpu) {
100 if (cpu == smp_processor_id())
101 continue;
102 do {
103 rc = signal_processor(cpu, sigp_stop);
104 } while (rc == sigp_busy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700105
Heiko Carstens5c0b9122009-09-11 10:29:05 +0200106 while (!cpu_stopped(cpu))
Heiko Carstensc6b5b842006-12-04 15:40:33 +0100107 cpu_relax();
108 }
109}
110
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111/*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 * This is the main routine where commands issued by other
113 * cpus are handled.
114 */
115
Heiko Carstens2b67fc42007-02-05 21:16:47 +0100116static void do_ext_call_interrupt(__u16 code)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700117{
Heiko Carstens39ce0102007-04-27 16:02:00 +0200118 unsigned long bits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119
Heiko Carstens39ce0102007-04-27 16:02:00 +0200120 /*
121 * handle bit signal external calls
122 *
123 * For the ec_schedule signal we have to do nothing. All the work
124 * is done automatically when we return from the interrupt.
125 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 bits = xchg(&S390_lowcore.ext_call_fast, 0);
127
Heiko Carstens39ce0102007-04-27 16:02:00 +0200128 if (test_bit(ec_call_function, &bits))
Heiko Carstensca9fc752008-12-25 13:38:39 +0100129 generic_smp_call_function_interrupt();
130
131 if (test_bit(ec_call_function_single, &bits))
132 generic_smp_call_function_single_interrupt();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133}
134
135/*
136 * Send an external call sigp to another cpu and return without waiting
137 * for its completion.
138 */
139static void smp_ext_bitcall(int cpu, ec_bit_sig sig)
140{
Heiko Carstens39ce0102007-04-27 16:02:00 +0200141 /*
142 * Set signaling bit in lowcore of target cpu and kick it
143 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 set_bit(sig, (unsigned long *) &lowcore_ptr[cpu]->ext_call_fast);
Heiko Carstens39ce0102007-04-27 16:02:00 +0200145 while (signal_processor(cpu, sigp_emergency_signal) == sigp_busy)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700146 udelay(10);
147}
148
Rusty Russell630cd042009-09-24 09:34:45 -0600149void arch_send_call_function_ipi_mask(const struct cpumask *mask)
Heiko Carstensca9fc752008-12-25 13:38:39 +0100150{
151 int cpu;
152
Rusty Russell630cd042009-09-24 09:34:45 -0600153 for_each_cpu(cpu, mask)
Heiko Carstensca9fc752008-12-25 13:38:39 +0100154 smp_ext_bitcall(cpu, ec_call_function);
155}
156
157void arch_send_call_function_single_ipi(int cpu)
158{
159 smp_ext_bitcall(cpu, ec_call_function_single);
160}
161
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800162#ifndef CONFIG_64BIT
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163/*
164 * this function sends a 'purge tlb' signal to another CPU.
165 */
Heiko Carstensa8061702008-04-17 07:46:26 +0200166static void smp_ptlb_callback(void *info)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167{
Martin Schwidefskyba8a9222007-10-22 12:52:44 +0200168 __tlb_flush_local();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700169}
170
171void smp_ptlb_all(void)
172{
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200173 on_each_cpu(smp_ptlb_callback, NULL, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174}
175EXPORT_SYMBOL(smp_ptlb_all);
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800176#endif /* ! CONFIG_64BIT */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177
178/*
179 * this function sends a 'reschedule' IPI to another CPU.
180 * it goes straight through and wastes no time serializing
181 * anything. Worst case is that we lose a reschedule ...
182 */
183void smp_send_reschedule(int cpu)
184{
Heiko Carstens39ce0102007-04-27 16:02:00 +0200185 smp_ext_bitcall(cpu, ec_schedule);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700186}
187
188/*
189 * parameter area for the set/clear control bit callbacks
190 */
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200191struct ec_creg_mask_parms {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 unsigned long orvals[16];
193 unsigned long andvals[16];
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200194};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700195
196/*
197 * callback for setting/clearing control bits
198 */
Heiko Carstens39ce0102007-04-27 16:02:00 +0200199static void smp_ctl_bit_callback(void *info)
200{
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200201 struct ec_creg_mask_parms *pp = info;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 unsigned long cregs[16];
203 int i;
Heiko Carstens39ce0102007-04-27 16:02:00 +0200204
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200205 __ctl_store(cregs, 0, 15);
206 for (i = 0; i <= 15; i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 cregs[i] = (cregs[i] & pp->andvals[i]) | pp->orvals[i];
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200208 __ctl_load(cregs, 0, 15);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700209}
210
211/*
212 * Set a bit in a control register of all cpus
213 */
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200214void smp_ctl_set_bit(int cr, int bit)
215{
216 struct ec_creg_mask_parms parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200218 memset(&parms.orvals, 0, sizeof(parms.orvals));
219 memset(&parms.andvals, 0xff, sizeof(parms.andvals));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700220 parms.orvals[cr] = 1 << bit;
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200221 on_each_cpu(smp_ctl_bit_callback, &parms, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222}
Heiko Carstens39ce0102007-04-27 16:02:00 +0200223EXPORT_SYMBOL(smp_ctl_set_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224
225/*
226 * Clear a bit in a control register of all cpus
227 */
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200228void smp_ctl_clear_bit(int cr, int bit)
229{
230 struct ec_creg_mask_parms parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200232 memset(&parms.orvals, 0, sizeof(parms.orvals));
233 memset(&parms.andvals, 0xff, sizeof(parms.andvals));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 parms.andvals[cr] = ~(1L << bit);
Jens Axboe15c8b6c2008-05-09 09:39:44 +0200235 on_each_cpu(smp_ctl_bit_callback, &parms, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236}
Heiko Carstens39ce0102007-04-27 16:02:00 +0200237EXPORT_SYMBOL(smp_ctl_clear_bit);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238
Heiko Carstens08d07962008-01-26 14:10:56 +0100239/*
240 * In early ipl state a temp. logically cpu number is needed, so the sigp
241 * functions can be used to sense other cpus. Since NR_CPUS is >= 2 on
242 * CONFIG_SMP and the ipl cpu is logical cpu 0, it must be 1.
243 */
244#define CPU_INIT_NO 1
245
Michael Holzheu59f2e692009-03-26 15:24:46 +0100246#ifdef CONFIG_ZFCPDUMP
Michael Holzheu411ed322007-04-27 16:01:49 +0200247
248/*
249 * zfcpdump_prefix_array holds prefix registers for the following scenario:
250 * 64 bit zfcpdump kernel and 31 bit kernel which is to be dumped. We have to
251 * save its prefix registers, since they get lost, when switching from 31 bit
252 * to 64 bit.
253 */
254unsigned int zfcpdump_prefix_array[NR_CPUS + 1] \
255 __attribute__((__section__(".data")));
256
Heiko Carstens285f6722007-07-10 11:24:13 +0200257static void __init smp_get_save_area(unsigned int cpu, unsigned int phy_cpu)
Michael Holzheu411ed322007-04-27 16:01:49 +0200258{
Michael Holzheu411ed322007-04-27 16:01:49 +0200259 if (ipl_info.type != IPL_TYPE_FCP_DUMP)
260 return;
Heiko Carstens285f6722007-07-10 11:24:13 +0200261 if (cpu >= NR_CPUS) {
Martin Schwidefsky395d31d2008-12-25 13:39:50 +0100262 pr_warning("CPU %i exceeds the maximum %i and is excluded from "
263 "the dump\n", cpu, NR_CPUS - 1);
Heiko Carstens285f6722007-07-10 11:24:13 +0200264 return;
Michael Holzheu411ed322007-04-27 16:01:49 +0200265 }
Heiko Carstens48483b32008-01-26 14:11:05 +0100266 zfcpdump_save_areas[cpu] = kmalloc(sizeof(union save_area), GFP_KERNEL);
Heiko Carstens08d07962008-01-26 14:10:56 +0100267 __cpu_logical_map[CPU_INIT_NO] = (__u16) phy_cpu;
268 while (signal_processor(CPU_INIT_NO, sigp_stop_and_store_status) ==
269 sigp_busy)
Heiko Carstens285f6722007-07-10 11:24:13 +0200270 cpu_relax();
271 memcpy(zfcpdump_save_areas[cpu],
272 (void *)(unsigned long) store_prefix() + SAVE_AREA_BASE,
273 SAVE_AREA_SIZE);
274#ifdef CONFIG_64BIT
275 /* copy original prefix register */
276 zfcpdump_save_areas[cpu]->s390x.pref_reg = zfcpdump_prefix_array[cpu];
277#endif
Michael Holzheu411ed322007-04-27 16:01:49 +0200278}
279
280union save_area *zfcpdump_save_areas[NR_CPUS + 1];
281EXPORT_SYMBOL_GPL(zfcpdump_save_areas);
282
283#else
Heiko Carstens285f6722007-07-10 11:24:13 +0200284
285static inline void smp_get_save_area(unsigned int cpu, unsigned int phy_cpu) { }
286
Michael Holzheu59f2e692009-03-26 15:24:46 +0100287#endif /* CONFIG_ZFCPDUMP */
Michael Holzheu411ed322007-04-27 16:01:49 +0200288
Heiko Carstens08d07962008-01-26 14:10:56 +0100289static int cpu_known(int cpu_id)
290{
291 int cpu;
292
293 for_each_present_cpu(cpu) {
294 if (__cpu_logical_map[cpu] == cpu_id)
295 return 1;
296 }
297 return 0;
298}
299
300static int smp_rescan_cpus_sigp(cpumask_t avail)
301{
302 int cpu_id, logical_cpu;
303
Rusty Russell93632d12009-03-26 15:24:59 +0100304 logical_cpu = cpumask_first(&avail);
305 if (logical_cpu >= nr_cpu_ids)
Heiko Carstens08d07962008-01-26 14:10:56 +0100306 return 0;
Heiko Carstens4bb5e072009-09-11 10:29:03 +0200307 for (cpu_id = 0; cpu_id <= MAX_CPU_ADDRESS; cpu_id++) {
Heiko Carstens08d07962008-01-26 14:10:56 +0100308 if (cpu_known(cpu_id))
309 continue;
310 __cpu_logical_map[logical_cpu] = cpu_id;
Heiko Carstensc10fde02008-04-17 07:46:13 +0200311 smp_cpu_polarization[logical_cpu] = POLARIZATION_UNKNWN;
Heiko Carstens08d07962008-01-26 14:10:56 +0100312 if (!cpu_stopped(logical_cpu))
313 continue;
314 cpu_set(logical_cpu, cpu_present_map);
315 smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED;
Rusty Russell93632d12009-03-26 15:24:59 +0100316 logical_cpu = cpumask_next(logical_cpu, &avail);
317 if (logical_cpu >= nr_cpu_ids)
Heiko Carstens08d07962008-01-26 14:10:56 +0100318 break;
319 }
320 return 0;
321}
322
Heiko Carstens48483b32008-01-26 14:11:05 +0100323static int smp_rescan_cpus_sclp(cpumask_t avail)
Heiko Carstens08d07962008-01-26 14:10:56 +0100324{
325 struct sclp_cpu_info *info;
326 int cpu_id, logical_cpu, cpu;
327 int rc;
328
Rusty Russell93632d12009-03-26 15:24:59 +0100329 logical_cpu = cpumask_first(&avail);
330 if (logical_cpu >= nr_cpu_ids)
Heiko Carstens08d07962008-01-26 14:10:56 +0100331 return 0;
Heiko Carstens48483b32008-01-26 14:11:05 +0100332 info = kmalloc(sizeof(*info), GFP_KERNEL);
Heiko Carstens08d07962008-01-26 14:10:56 +0100333 if (!info)
334 return -ENOMEM;
335 rc = sclp_get_cpu_info(info);
336 if (rc)
337 goto out;
338 for (cpu = 0; cpu < info->combined; cpu++) {
339 if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type)
340 continue;
341 cpu_id = info->cpu[cpu].address;
342 if (cpu_known(cpu_id))
343 continue;
344 __cpu_logical_map[logical_cpu] = cpu_id;
Heiko Carstensc10fde02008-04-17 07:46:13 +0200345 smp_cpu_polarization[logical_cpu] = POLARIZATION_UNKNWN;
Heiko Carstens08d07962008-01-26 14:10:56 +0100346 cpu_set(logical_cpu, cpu_present_map);
347 if (cpu >= info->configured)
348 smp_cpu_state[logical_cpu] = CPU_STATE_STANDBY;
349 else
350 smp_cpu_state[logical_cpu] = CPU_STATE_CONFIGURED;
Rusty Russell93632d12009-03-26 15:24:59 +0100351 logical_cpu = cpumask_next(logical_cpu, &avail);
352 if (logical_cpu >= nr_cpu_ids)
Heiko Carstens08d07962008-01-26 14:10:56 +0100353 break;
354 }
355out:
Heiko Carstens48483b32008-01-26 14:11:05 +0100356 kfree(info);
Heiko Carstens08d07962008-01-26 14:10:56 +0100357 return rc;
358}
359
Heiko Carstens1e489512008-04-30 13:38:37 +0200360static int __smp_rescan_cpus(void)
Heiko Carstens08d07962008-01-26 14:10:56 +0100361{
362 cpumask_t avail;
363
Heiko Carstens48483b32008-01-26 14:11:05 +0100364 cpus_xor(avail, cpu_possible_map, cpu_present_map);
Heiko Carstens08d07962008-01-26 14:10:56 +0100365 if (smp_use_sigp_detection)
366 return smp_rescan_cpus_sigp(avail);
367 else
368 return smp_rescan_cpus_sclp(avail);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369}
370
Heiko Carstens48483b32008-01-26 14:11:05 +0100371static void __init smp_detect_cpus(void)
372{
373 unsigned int cpu, c_cpus, s_cpus;
374 struct sclp_cpu_info *info;
375 u16 boot_cpu_addr, cpu_addr;
376
377 c_cpus = 1;
378 s_cpus = 0;
Martin Schwidefsky7b468482009-03-26 15:24:42 +0100379 boot_cpu_addr = __cpu_logical_map[0];
Heiko Carstens48483b32008-01-26 14:11:05 +0100380 info = kmalloc(sizeof(*info), GFP_KERNEL);
381 if (!info)
382 panic("smp_detect_cpus failed to allocate memory\n");
383 /* Use sigp detection algorithm if sclp doesn't work. */
384 if (sclp_get_cpu_info(info)) {
385 smp_use_sigp_detection = 1;
Heiko Carstens4bb5e072009-09-11 10:29:03 +0200386 for (cpu = 0; cpu <= MAX_CPU_ADDRESS; cpu++) {
Heiko Carstens48483b32008-01-26 14:11:05 +0100387 if (cpu == boot_cpu_addr)
388 continue;
389 __cpu_logical_map[CPU_INIT_NO] = cpu;
390 if (!cpu_stopped(CPU_INIT_NO))
391 continue;
392 smp_get_save_area(c_cpus, cpu);
393 c_cpus++;
394 }
395 goto out;
396 }
397
398 if (info->has_cpu_type) {
399 for (cpu = 0; cpu < info->combined; cpu++) {
400 if (info->cpu[cpu].address == boot_cpu_addr) {
401 smp_cpu_type = info->cpu[cpu].type;
402 break;
403 }
404 }
405 }
406
407 for (cpu = 0; cpu < info->combined; cpu++) {
408 if (info->has_cpu_type && info->cpu[cpu].type != smp_cpu_type)
409 continue;
410 cpu_addr = info->cpu[cpu].address;
411 if (cpu_addr == boot_cpu_addr)
412 continue;
413 __cpu_logical_map[CPU_INIT_NO] = cpu_addr;
414 if (!cpu_stopped(CPU_INIT_NO)) {
415 s_cpus++;
416 continue;
417 }
418 smp_get_save_area(c_cpus, cpu_addr);
419 c_cpus++;
420 }
421out:
422 kfree(info);
Martin Schwidefsky395d31d2008-12-25 13:39:50 +0100423 pr_info("%d configured CPUs, %d standby CPUs\n", c_cpus, s_cpus);
Martin Schwidefsky9d40d2e2008-01-26 14:11:31 +0100424 get_online_cpus();
Heiko Carstens1e489512008-04-30 13:38:37 +0200425 __smp_rescan_cpus();
Martin Schwidefsky9d40d2e2008-01-26 14:11:31 +0100426 put_online_cpus();
Heiko Carstens48483b32008-01-26 14:11:05 +0100427}
428
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429/*
Heiko Carstens39ce0102007-04-27 16:02:00 +0200430 * Activate a secondary processor.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 */
Heiko Carstensea1f4ee2007-05-31 17:38:05 +0200432int __cpuinit start_secondary(void *cpuvoid)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700433{
Heiko Carstens39ce0102007-04-27 16:02:00 +0200434 /* Setup the cpu */
435 cpu_init();
Nick Piggin5bfb5d62005-11-08 21:39:01 -0800436 preempt_disable();
Martin Schwidefskyd54853e2007-02-05 21:18:19 +0100437 /* Enable TOD clock interrupts on the secondary cpu. */
Heiko Carstens39ce0102007-04-27 16:02:00 +0200438 init_cpu_timer();
Martin Schwidefskyd54853e2007-02-05 21:18:19 +0100439 /* Enable cpu timer interrupts on the secondary cpu. */
Heiko Carstens39ce0102007-04-27 16:02:00 +0200440 init_cpu_vtimer();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 /* Enable pfault pseudo page faults on this cpu. */
Heiko Carstens29b08d22006-12-04 15:40:40 +0100442 pfault_init();
443
Manfred Spraule545a612008-09-07 16:57:22 +0200444 /* call cpu notifiers */
445 notify_cpu_starting(smp_processor_id());
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446 /* Mark this cpu as online */
Heiko Carstensca9fc752008-12-25 13:38:39 +0100447 ipi_call_lock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 cpu_set(smp_processor_id(), cpu_online_map);
Heiko Carstensca9fc752008-12-25 13:38:39 +0100449 ipi_call_unlock();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 /* Switch on interrupts */
451 local_irq_enable();
Heiko Carstens39ce0102007-04-27 16:02:00 +0200452 /* Print info about this processor */
Martin Schwidefsky7b468482009-03-26 15:24:42 +0100453 print_cpu_info();
Heiko Carstens39ce0102007-04-27 16:02:00 +0200454 /* cpu_idle will call schedule for us */
455 cpu_idle();
456 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457}
458
459static void __init smp_create_idle(unsigned int cpu)
460{
461 struct task_struct *p;
462
463 /*
464 * don't care about the psw and regs settings since we'll never
465 * reschedule the forked task.
466 */
467 p = fork_idle(cpu);
468 if (IS_ERR(p))
469 panic("failed fork for CPU %u: %li", cpu, PTR_ERR(p));
470 current_set[cpu] = p;
471}
472
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100473static int __cpuinit smp_alloc_lowcore(int cpu)
474{
475 unsigned long async_stack, panic_stack;
476 struct _lowcore *lowcore;
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100477
Heiko Carstens3fd26a72009-09-22 22:58:49 +0200478 lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, LC_ORDER);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100479 if (!lowcore)
480 return -ENOMEM;
481 async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100482 panic_stack = __get_free_page(GFP_KERNEL);
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100483 if (!panic_stack || !async_stack)
484 goto out;
Heiko Carstens98c7b382008-03-05 12:37:09 +0100485 memcpy(lowcore, &S390_lowcore, 512);
486 memset((char *)lowcore + 512, 0, sizeof(*lowcore) - 512);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100487 lowcore->async_stack = async_stack + ASYNC_SIZE;
488 lowcore->panic_stack = panic_stack + PAGE_SIZE;
489
490#ifndef CONFIG_64BIT
491 if (MACHINE_HAS_IEEE) {
492 unsigned long save_area;
493
494 save_area = get_zeroed_page(GFP_KERNEL);
495 if (!save_area)
Martin Schwidefsky33b1d092008-12-25 13:39:27 +0100496 goto out;
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100497 lowcore->extended_save_area_addr = (u32) save_area;
498 }
Martin Schwidefskyc742b312008-12-31 15:11:42 +0100499#else
500 if (vdso_alloc_per_cpu(cpu, lowcore))
501 goto out;
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100502#endif
503 lowcore_ptr[cpu] = lowcore;
504 return 0;
505
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100506out:
Martin Schwidefsky33b1d092008-12-25 13:39:27 +0100507 free_page(panic_stack);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100508 free_pages(async_stack, ASYNC_ORDER);
Heiko Carstens3fd26a72009-09-22 22:58:49 +0200509 free_pages((unsigned long) lowcore, LC_ORDER);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100510 return -ENOMEM;
511}
512
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100513static void smp_free_lowcore(int cpu)
514{
515 struct _lowcore *lowcore;
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100516
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100517 lowcore = lowcore_ptr[cpu];
518#ifndef CONFIG_64BIT
519 if (MACHINE_HAS_IEEE)
520 free_page((unsigned long) lowcore->extended_save_area_addr);
Martin Schwidefskyc742b312008-12-31 15:11:42 +0100521#else
522 vdso_free_per_cpu(cpu, lowcore);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100523#endif
524 free_page(lowcore->panic_stack - PAGE_SIZE);
525 free_pages(lowcore->async_stack - ASYNC_SIZE, ASYNC_ORDER);
Heiko Carstens3fd26a72009-09-22 22:58:49 +0200526 free_pages((unsigned long) lowcore, LC_ORDER);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100527 lowcore_ptr[cpu] = NULL;
528}
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100529
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530/* Upping and downing of CPUs */
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100531int __cpuinit __cpu_up(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532{
533 struct task_struct *idle;
Heiko Carstens39ce0102007-04-27 16:02:00 +0200534 struct _lowcore *cpu_lowcore;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 struct stack_frame *sf;
Heiko Carstens39ce0102007-04-27 16:02:00 +0200536 sigp_ccode ccode;
Heiko Carstensd0d3cdf2009-03-26 15:24:53 +0100537 u32 lowcore;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700538
Heiko Carstens08d07962008-01-26 14:10:56 +0100539 if (smp_cpu_state[cpu] != CPU_STATE_CONFIGURED)
540 return -EIO;
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100541 if (smp_alloc_lowcore(cpu))
542 return -ENOMEM;
Heiko Carstensd0d3cdf2009-03-26 15:24:53 +0100543 do {
544 ccode = signal_processor(cpu, sigp_initial_cpu_reset);
545 if (ccode == sigp_busy)
546 udelay(10);
547 if (ccode == sigp_not_operational)
548 goto err_out;
549 } while (ccode == sigp_busy);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
Heiko Carstensd0d3cdf2009-03-26 15:24:53 +0100551 lowcore = (u32)(unsigned long)lowcore_ptr[cpu];
552 while (signal_processor_p(lowcore, cpu, sigp_set_prefix) == sigp_busy)
553 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554
555 idle = current_set[cpu];
Heiko Carstens39ce0102007-04-27 16:02:00 +0200556 cpu_lowcore = lowcore_ptr[cpu];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700557 cpu_lowcore->kernel_stack = (unsigned long)
Heiko Carstens39ce0102007-04-27 16:02:00 +0200558 task_stack_page(idle) + THREAD_SIZE;
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100559 cpu_lowcore->thread_info = (unsigned long) task_thread_info(idle);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 sf = (struct stack_frame *) (cpu_lowcore->kernel_stack
561 - sizeof(struct pt_regs)
562 - sizeof(struct stack_frame));
563 memset(sf, 0, sizeof(struct stack_frame));
564 sf->gprs[9] = (unsigned long) sf;
565 cpu_lowcore->save_area[15] = (unsigned long) sf;
Segher Boessenkool24d3e212008-06-10 10:03:23 +0200566 __ctl_store(cpu_lowcore->cregs_save_area, 0, 15);
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200567 asm volatile(
568 " stam 0,15,0(%0)"
569 : : "a" (&cpu_lowcore->access_regs_save_area) : "memory");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700570 cpu_lowcore->percpu_offset = __per_cpu_offset[cpu];
Heiko Carstens39ce0102007-04-27 16:02:00 +0200571 cpu_lowcore->current_task = (unsigned long) idle;
Martin Schwidefsky7b468482009-03-26 15:24:42 +0100572 cpu_lowcore->cpu_nr = cpu;
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100573 cpu_lowcore->kernel_asce = S390_lowcore.kernel_asce;
Christian Ehrhardt25097bf2009-04-14 15:36:16 +0200574 cpu_lowcore->machine_flags = S390_lowcore.machine_flags;
Heiko Carstensdfd9f7a2009-06-12 10:26:44 +0200575 cpu_lowcore->ftrace_func = S390_lowcore.ftrace_func;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 eieio();
Michael Ryan699ff132006-03-24 03:15:17 -0800577
Heiko Carstens39ce0102007-04-27 16:02:00 +0200578 while (signal_processor(cpu, sigp_restart) == sigp_busy)
Michael Ryan699ff132006-03-24 03:15:17 -0800579 udelay(10);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700580
581 while (!cpu_online(cpu))
582 cpu_relax();
583 return 0;
Heiko Carstensd0d3cdf2009-03-26 15:24:53 +0100584
585err_out:
586 smp_free_lowcore(cpu);
587 return -EIO;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700588}
589
Heiko Carstens37a33022006-02-17 13:52:47 -0800590static int __init setup_possible_cpus(char *s)
591{
Heiko Carstens48483b32008-01-26 14:11:05 +0100592 int pcpus, cpu;
593
594 pcpus = simple_strtoul(s, NULL, 0);
Heiko Carstens88e01282009-04-14 15:36:25 +0200595 init_cpu_possible(cpumask_of(0));
596 for (cpu = 1; cpu < pcpus && cpu < nr_cpu_ids; cpu++)
Rusty Russelldef6cfb2009-03-26 15:25:00 +0100597 set_cpu_possible(cpu, true);
Heiko Carstens37a33022006-02-17 13:52:47 -0800598 return 0;
599}
600early_param("possible_cpus", setup_possible_cpus);
601
Heiko Carstens48483b32008-01-26 14:11:05 +0100602#ifdef CONFIG_HOTPLUG_CPU
603
Heiko Carstens39ce0102007-04-27 16:02:00 +0200604int __cpu_disable(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700605{
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200606 struct ec_creg_mask_parms cr_parms;
Zwane Mwaikambof3705132005-06-25 14:54:50 -0700607 int cpu = smp_processor_id();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608
Zwane Mwaikambof3705132005-06-25 14:54:50 -0700609 cpu_clear(cpu, cpu_online_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611 /* Disable pfault pseudo page faults on this cpu. */
Heiko Carstens29b08d22006-12-04 15:40:40 +0100612 pfault_fini();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700613
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200614 memset(&cr_parms.orvals, 0, sizeof(cr_parms.orvals));
615 memset(&cr_parms.andvals, 0xff, sizeof(cr_parms.andvals));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700616
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200617 /* disable all external interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700618 cr_parms.orvals[0] = 0;
Heiko Carstens39ce0102007-04-27 16:02:00 +0200619 cr_parms.andvals[0] = ~(1 << 15 | 1 << 14 | 1 << 13 | 1 << 12 |
620 1 << 11 | 1 << 10 | 1 << 6 | 1 << 4);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 /* disable all I/O interrupts */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 cr_parms.orvals[6] = 0;
Heiko Carstens39ce0102007-04-27 16:02:00 +0200623 cr_parms.andvals[6] = ~(1 << 31 | 1 << 30 | 1 << 29 | 1 << 28 |
624 1 << 27 | 1 << 26 | 1 << 25 | 1 << 24);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /* disable most machine checks */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700626 cr_parms.orvals[14] = 0;
Heiko Carstens39ce0102007-04-27 16:02:00 +0200627 cr_parms.andvals[14] = ~(1 << 28 | 1 << 27 | 1 << 26 |
628 1 << 25 | 1 << 24);
Martin Schwidefsky94c12cc2006-09-28 16:56:43 +0200629
Linus Torvalds1da177e2005-04-16 15:20:36 -0700630 smp_ctl_bit_callback(&cr_parms);
631
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 return 0;
633}
634
Heiko Carstens39ce0102007-04-27 16:02:00 +0200635void __cpu_die(unsigned int cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636{
637 /* Wait until target cpu is down */
Heiko Carstens5c0b9122009-09-11 10:29:05 +0200638 while (!cpu_stopped(cpu))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 cpu_relax();
Heiko Carstens4f8048e2009-10-29 15:04:09 +0100640 while (signal_processor_p(0, cpu, sigp_set_prefix) == sigp_busy)
641 udelay(10);
Heiko Carstens1cb6bb42008-01-26 14:11:14 +0100642 smp_free_lowcore(cpu);
Martin Schwidefsky395d31d2008-12-25 13:39:50 +0100643 pr_info("Processor %d stopped\n", cpu);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644}
645
Heiko Carstens39ce0102007-04-27 16:02:00 +0200646void cpu_die(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647{
648 idle_task_exit();
Heiko Carstensf8501ba2009-10-29 15:04:13 +0100649 while (signal_processor(smp_processor_id(), sigp_stop) == sigp_busy)
650 cpu_relax();
Heiko Carstens39ce0102007-04-27 16:02:00 +0200651 for (;;);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
Heiko Carstens255acee2006-02-17 13:52:46 -0800654#endif /* CONFIG_HOTPLUG_CPU */
655
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656void __init smp_prepare_cpus(unsigned int max_cpus)
657{
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100658#ifndef CONFIG_64BIT
659 unsigned long save_area = 0;
660#endif
661 unsigned long async_stack, panic_stack;
662 struct _lowcore *lowcore;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 unsigned int cpu;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664
Heiko Carstens48483b32008-01-26 14:11:05 +0100665 smp_detect_cpus();
666
Heiko Carstens39ce0102007-04-27 16:02:00 +0200667 /* request the 0x1201 emergency signal external interrupt */
668 if (register_external_interrupt(0x1201, do_ext_call_interrupt) != 0)
669 panic("Couldn't request external interrupt 0x1201");
Martin Schwidefsky7b468482009-03-26 15:24:42 +0100670 print_cpu_info();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700671
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100672 /* Reallocate current lowcore, but keep its contents. */
Heiko Carstens3fd26a72009-09-22 22:58:49 +0200673 lowcore = (void *) __get_free_pages(GFP_KERNEL | GFP_DMA, LC_ORDER);
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100674 panic_stack = __get_free_page(GFP_KERNEL);
675 async_stack = __get_free_pages(GFP_KERNEL, ASYNC_ORDER);
Martin Schwidefskyc742b312008-12-31 15:11:42 +0100676 BUG_ON(!lowcore || !panic_stack || !async_stack);
Martin Schwidefsky347a8dc2006-01-06 00:19:28 -0800677#ifndef CONFIG_64BIT
Heiko Carstens77fa2242005-06-25 14:55:30 -0700678 if (MACHINE_HAS_IEEE)
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100679 save_area = get_zeroed_page(GFP_KERNEL);
Heiko Carstens77fa2242005-06-25 14:55:30 -0700680#endif
Heiko Carstens591bb4f2008-02-19 15:29:29 +0100681 local_irq_disable();
682 local_mcck_disable();
683 lowcore_ptr[smp_processor_id()] = lowcore;
684 *lowcore = S390_lowcore;
685 lowcore->panic_stack = panic_stack + PAGE_SIZE;
686 lowcore->async_stack = async_stack + ASYNC_SIZE;
687#ifndef CONFIG_64BIT
688 if (MACHINE_HAS_IEEE)
689 lowcore->extended_save_area_addr = (u32) save_area;
690#endif
691 set_prefix((u32)(unsigned long) lowcore);
692 local_mcck_enable();
693 local_irq_enable();
Heiko Carstens3a6ba462009-07-24 12:39:51 +0200694#ifdef CONFIG_64BIT
695 if (vdso_alloc_per_cpu(smp_processor_id(), &S390_lowcore))
696 BUG();
697#endif
KAMEZAWA Hiroyuki97db7fb2006-03-31 02:30:26 -0800698 for_each_possible_cpu(cpu)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 if (cpu != smp_processor_id())
700 smp_create_idle(cpu);
701}
702
Heiko Carstensea1f4ee2007-05-31 17:38:05 +0200703void __init smp_prepare_boot_cpu(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700704{
705 BUG_ON(smp_processor_id() != 0);
706
Heiko Carstens48483b32008-01-26 14:11:05 +0100707 current_thread_info()->cpu = 0;
708 cpu_set(0, cpu_present_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 cpu_set(0, cpu_online_map);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 S390_lowcore.percpu_offset = __per_cpu_offset[0];
711 current_set[0] = current;
Heiko Carstens08d07962008-01-26 14:10:56 +0100712 smp_cpu_state[0] = CPU_STATE_CONFIGURED;
Heiko Carstensc10fde02008-04-17 07:46:13 +0200713 smp_cpu_polarization[0] = POLARIZATION_UNKNWN;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714}
715
Heiko Carstensea1f4ee2007-05-31 17:38:05 +0200716void __init smp_cpus_done(unsigned int max_cpus)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700717{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718}
719
720/*
721 * the frequency of the profiling timer can be changed
722 * by writing a multiplier value into /proc/profile.
723 *
724 * usually you want to run this on all CPUs ;)
725 */
726int setup_profiling_timer(unsigned int multiplier)
727{
Heiko Carstens39ce0102007-04-27 16:02:00 +0200728 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729}
730
Heiko Carstens08d07962008-01-26 14:10:56 +0100731#ifdef CONFIG_HOTPLUG_CPU
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200732static ssize_t cpu_configure_show(struct sys_device *dev,
733 struct sysdev_attribute *attr, char *buf)
Heiko Carstens08d07962008-01-26 14:10:56 +0100734{
735 ssize_t count;
736
737 mutex_lock(&smp_cpu_state_mutex);
738 count = sprintf(buf, "%d\n", smp_cpu_state[dev->id]);
739 mutex_unlock(&smp_cpu_state_mutex);
740 return count;
741}
742
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200743static ssize_t cpu_configure_store(struct sys_device *dev,
744 struct sysdev_attribute *attr,
745 const char *buf, size_t count)
Heiko Carstens08d07962008-01-26 14:10:56 +0100746{
747 int cpu = dev->id;
748 int val, rc;
749 char delim;
750
751 if (sscanf(buf, "%d %c", &val, &delim) != 1)
752 return -EINVAL;
753 if (val != 0 && val != 1)
754 return -EINVAL;
755
Martin Schwidefsky9d40d2e2008-01-26 14:11:31 +0100756 get_online_cpus();
Heiko Carstens0b18d312008-04-30 13:38:36 +0200757 mutex_lock(&smp_cpu_state_mutex);
Heiko Carstens08d07962008-01-26 14:10:56 +0100758 rc = -EBUSY;
759 if (cpu_online(cpu))
760 goto out;
761 rc = 0;
762 switch (val) {
763 case 0:
764 if (smp_cpu_state[cpu] == CPU_STATE_CONFIGURED) {
765 rc = sclp_cpu_deconfigure(__cpu_logical_map[cpu]);
Heiko Carstensc10fde02008-04-17 07:46:13 +0200766 if (!rc) {
Heiko Carstens08d07962008-01-26 14:10:56 +0100767 smp_cpu_state[cpu] = CPU_STATE_STANDBY;
Heiko Carstensc10fde02008-04-17 07:46:13 +0200768 smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN;
769 }
Heiko Carstens08d07962008-01-26 14:10:56 +0100770 }
771 break;
772 case 1:
773 if (smp_cpu_state[cpu] == CPU_STATE_STANDBY) {
774 rc = sclp_cpu_configure(__cpu_logical_map[cpu]);
Heiko Carstensc10fde02008-04-17 07:46:13 +0200775 if (!rc) {
Heiko Carstens08d07962008-01-26 14:10:56 +0100776 smp_cpu_state[cpu] = CPU_STATE_CONFIGURED;
Heiko Carstensc10fde02008-04-17 07:46:13 +0200777 smp_cpu_polarization[cpu] = POLARIZATION_UNKNWN;
778 }
Heiko Carstens08d07962008-01-26 14:10:56 +0100779 }
780 break;
781 default:
782 break;
783 }
784out:
Heiko Carstens08d07962008-01-26 14:10:56 +0100785 mutex_unlock(&smp_cpu_state_mutex);
Heiko Carstens0b18d312008-04-30 13:38:36 +0200786 put_online_cpus();
Heiko Carstens08d07962008-01-26 14:10:56 +0100787 return rc ? rc : count;
788}
789static SYSDEV_ATTR(configure, 0644, cpu_configure_show, cpu_configure_store);
790#endif /* CONFIG_HOTPLUG_CPU */
791
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200792static ssize_t cpu_polarization_show(struct sys_device *dev,
793 struct sysdev_attribute *attr, char *buf)
Heiko Carstensc10fde02008-04-17 07:46:13 +0200794{
795 int cpu = dev->id;
796 ssize_t count;
797
798 mutex_lock(&smp_cpu_state_mutex);
799 switch (smp_cpu_polarization[cpu]) {
800 case POLARIZATION_HRZ:
801 count = sprintf(buf, "horizontal\n");
802 break;
803 case POLARIZATION_VL:
804 count = sprintf(buf, "vertical:low\n");
805 break;
806 case POLARIZATION_VM:
807 count = sprintf(buf, "vertical:medium\n");
808 break;
809 case POLARIZATION_VH:
810 count = sprintf(buf, "vertical:high\n");
811 break;
812 default:
813 count = sprintf(buf, "unknown\n");
814 break;
815 }
816 mutex_unlock(&smp_cpu_state_mutex);
817 return count;
818}
819static SYSDEV_ATTR(polarization, 0444, cpu_polarization_show, NULL);
820
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200821static ssize_t show_cpu_address(struct sys_device *dev,
822 struct sysdev_attribute *attr, char *buf)
Heiko Carstens08d07962008-01-26 14:10:56 +0100823{
824 return sprintf(buf, "%d\n", __cpu_logical_map[dev->id]);
825}
826static SYSDEV_ATTR(address, 0444, show_cpu_address, NULL);
827
828
829static struct attribute *cpu_common_attrs[] = {
830#ifdef CONFIG_HOTPLUG_CPU
831 &attr_configure.attr,
832#endif
833 &attr_address.attr,
Heiko Carstensc10fde02008-04-17 07:46:13 +0200834 &attr_polarization.attr,
Heiko Carstens08d07962008-01-26 14:10:56 +0100835 NULL,
836};
837
838static struct attribute_group cpu_common_attr_group = {
839 .attrs = cpu_common_attrs,
840};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200842static ssize_t show_capability(struct sys_device *dev,
843 struct sysdev_attribute *attr, char *buf)
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +0200844{
845 unsigned int capability;
846 int rc;
847
848 rc = get_cpu_capability(&capability);
849 if (rc)
850 return rc;
851 return sprintf(buf, "%u\n", capability);
852}
853static SYSDEV_ATTR(capability, 0444, show_capability, NULL);
854
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200855static ssize_t show_idle_count(struct sys_device *dev,
856 struct sysdev_attribute *attr, char *buf)
Heiko Carstensfae8b222007-10-22 12:52:39 +0200857{
858 struct s390_idle_data *idle;
859 unsigned long long idle_count;
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200860 unsigned int sequence;
Heiko Carstensfae8b222007-10-22 12:52:39 +0200861
862 idle = &per_cpu(s390_idle, dev->id);
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200863repeat:
864 sequence = idle->sequence;
865 smp_rmb();
866 if (sequence & 1)
867 goto repeat;
Heiko Carstensfae8b222007-10-22 12:52:39 +0200868 idle_count = idle->idle_count;
Martin Schwidefsky6f430922008-12-31 15:11:40 +0100869 if (idle->idle_enter)
870 idle_count++;
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200871 smp_rmb();
872 if (idle->sequence != sequence)
873 goto repeat;
Heiko Carstensfae8b222007-10-22 12:52:39 +0200874 return sprintf(buf, "%llu\n", idle_count);
875}
876static SYSDEV_ATTR(idle_count, 0444, show_idle_count, NULL);
877
Andi Kleen4a0b2b42008-07-01 18:48:41 +0200878static ssize_t show_idle_time(struct sys_device *dev,
879 struct sysdev_attribute *attr, char *buf)
Heiko Carstensfae8b222007-10-22 12:52:39 +0200880{
881 struct s390_idle_data *idle;
Martin Schwidefsky6f430922008-12-31 15:11:40 +0100882 unsigned long long now, idle_time, idle_enter;
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200883 unsigned int sequence;
Heiko Carstensfae8b222007-10-22 12:52:39 +0200884
885 idle = &per_cpu(s390_idle, dev->id);
Martin Schwidefsky6f430922008-12-31 15:11:40 +0100886 now = get_clock();
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200887repeat:
888 sequence = idle->sequence;
889 smp_rmb();
890 if (sequence & 1)
891 goto repeat;
Martin Schwidefsky6f430922008-12-31 15:11:40 +0100892 idle_time = idle->idle_time;
893 idle_enter = idle->idle_enter;
894 if (idle_enter != 0ULL && idle_enter < now)
895 idle_time += now - idle_enter;
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200896 smp_rmb();
897 if (idle->sequence != sequence)
898 goto repeat;
Martin Schwidefsky6f430922008-12-31 15:11:40 +0100899 return sprintf(buf, "%llu\n", idle_time >> 12);
Heiko Carstensfae8b222007-10-22 12:52:39 +0200900}
Heiko Carstens69d39d62007-11-05 11:10:13 +0100901static SYSDEV_ATTR(idle_time_us, 0444, show_idle_time, NULL);
Heiko Carstensfae8b222007-10-22 12:52:39 +0200902
Heiko Carstens08d07962008-01-26 14:10:56 +0100903static struct attribute *cpu_online_attrs[] = {
Heiko Carstensfae8b222007-10-22 12:52:39 +0200904 &attr_capability.attr,
905 &attr_idle_count.attr,
Heiko Carstens69d39d62007-11-05 11:10:13 +0100906 &attr_idle_time_us.attr,
Heiko Carstensfae8b222007-10-22 12:52:39 +0200907 NULL,
908};
909
Heiko Carstens08d07962008-01-26 14:10:56 +0100910static struct attribute_group cpu_online_attr_group = {
911 .attrs = cpu_online_attrs,
Heiko Carstensfae8b222007-10-22 12:52:39 +0200912};
913
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +0200914static int __cpuinit smp_cpu_notify(struct notifier_block *self,
915 unsigned long action, void *hcpu)
916{
917 unsigned int cpu = (unsigned int)(long)hcpu;
918 struct cpu *c = &per_cpu(cpu_devices, cpu);
919 struct sys_device *s = &c->sysdev;
Heiko Carstensfae8b222007-10-22 12:52:39 +0200920 struct s390_idle_data *idle;
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +0200921
922 switch (action) {
923 case CPU_ONLINE:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700924 case CPU_ONLINE_FROZEN:
Heiko Carstensfae8b222007-10-22 12:52:39 +0200925 idle = &per_cpu(s390_idle, cpu);
Martin Schwidefskye98bbaa2009-06-22 12:08:20 +0200926 memset(idle, 0, sizeof(struct s390_idle_data));
Heiko Carstens08d07962008-01-26 14:10:56 +0100927 if (sysfs_create_group(&s->kobj, &cpu_online_attr_group))
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +0200928 return NOTIFY_BAD;
929 break;
930 case CPU_DEAD:
Rafael J. Wysocki8bb78442007-05-09 02:35:10 -0700931 case CPU_DEAD_FROZEN:
Heiko Carstens08d07962008-01-26 14:10:56 +0100932 sysfs_remove_group(&s->kobj, &cpu_online_attr_group);
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +0200933 break;
934 }
935 return NOTIFY_OK;
936}
937
938static struct notifier_block __cpuinitdata smp_cpu_nb = {
Heiko Carstens39ce0102007-04-27 16:02:00 +0200939 .notifier_call = smp_cpu_notify,
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +0200940};
941
Heiko Carstens2bc89b52008-02-05 16:50:40 +0100942static int __devinit smp_add_present_cpu(int cpu)
Heiko Carstens08d07962008-01-26 14:10:56 +0100943{
944 struct cpu *c = &per_cpu(cpu_devices, cpu);
945 struct sys_device *s = &c->sysdev;
946 int rc;
947
948 c->hotpluggable = 1;
949 rc = register_cpu(c, cpu);
950 if (rc)
951 goto out;
952 rc = sysfs_create_group(&s->kobj, &cpu_common_attr_group);
953 if (rc)
954 goto out_cpu;
955 if (!cpu_online(cpu))
956 goto out;
957 rc = sysfs_create_group(&s->kobj, &cpu_online_attr_group);
958 if (!rc)
959 return 0;
960 sysfs_remove_group(&s->kobj, &cpu_common_attr_group);
961out_cpu:
962#ifdef CONFIG_HOTPLUG_CPU
963 unregister_cpu(c);
964#endif
965out:
966 return rc;
967}
968
969#ifdef CONFIG_HOTPLUG_CPU
Heiko Carstens1e489512008-04-30 13:38:37 +0200970
Heiko Carstens67060d92008-05-30 10:03:27 +0200971int __ref smp_rescan_cpus(void)
Heiko Carstens08d07962008-01-26 14:10:56 +0100972{
973 cpumask_t newcpus;
974 int cpu;
975 int rc;
976
Martin Schwidefsky9d40d2e2008-01-26 14:11:31 +0100977 get_online_cpus();
Heiko Carstens0b18d312008-04-30 13:38:36 +0200978 mutex_lock(&smp_cpu_state_mutex);
Heiko Carstens08d07962008-01-26 14:10:56 +0100979 newcpus = cpu_present_map;
Heiko Carstens1e489512008-04-30 13:38:37 +0200980 rc = __smp_rescan_cpus();
Heiko Carstens08d07962008-01-26 14:10:56 +0100981 if (rc)
982 goto out;
983 cpus_andnot(newcpus, cpu_present_map, newcpus);
984 for_each_cpu_mask(cpu, newcpus) {
985 rc = smp_add_present_cpu(cpu);
986 if (rc)
987 cpu_clear(cpu, cpu_present_map);
988 }
989 rc = 0;
990out:
Heiko Carstens08d07962008-01-26 14:10:56 +0100991 mutex_unlock(&smp_cpu_state_mutex);
Heiko Carstens0b18d312008-04-30 13:38:36 +0200992 put_online_cpus();
Heiko Carstensc10fde02008-04-17 07:46:13 +0200993 if (!cpus_empty(newcpus))
994 topology_schedule_update();
Heiko Carstens1e489512008-04-30 13:38:37 +0200995 return rc;
996}
997
Heiko Carstensda5aae72008-10-28 11:10:16 +0100998static ssize_t __ref rescan_store(struct sysdev_class *class, const char *buf,
Heiko Carstens1e489512008-04-30 13:38:37 +0200999 size_t count)
1000{
1001 int rc;
1002
1003 rc = smp_rescan_cpus();
Heiko Carstens08d07962008-01-26 14:10:56 +01001004 return rc ? rc : count;
1005}
Heiko Carstensda5aae72008-10-28 11:10:16 +01001006static SYSDEV_CLASS_ATTR(rescan, 0200, NULL, rescan_store);
Heiko Carstens08d07962008-01-26 14:10:56 +01001007#endif /* CONFIG_HOTPLUG_CPU */
1008
Heiko Carstensda5aae72008-10-28 11:10:16 +01001009static ssize_t dispatching_show(struct sysdev_class *class, char *buf)
Heiko Carstensc10fde02008-04-17 07:46:13 +02001010{
1011 ssize_t count;
1012
1013 mutex_lock(&smp_cpu_state_mutex);
1014 count = sprintf(buf, "%d\n", cpu_management);
1015 mutex_unlock(&smp_cpu_state_mutex);
1016 return count;
1017}
1018
Heiko Carstensda5aae72008-10-28 11:10:16 +01001019static ssize_t dispatching_store(struct sysdev_class *dev, const char *buf,
1020 size_t count)
Heiko Carstensc10fde02008-04-17 07:46:13 +02001021{
1022 int val, rc;
1023 char delim;
1024
1025 if (sscanf(buf, "%d %c", &val, &delim) != 1)
1026 return -EINVAL;
1027 if (val != 0 && val != 1)
1028 return -EINVAL;
1029 rc = 0;
Heiko Carstensc10fde02008-04-17 07:46:13 +02001030 get_online_cpus();
Heiko Carstens0b18d312008-04-30 13:38:36 +02001031 mutex_lock(&smp_cpu_state_mutex);
Heiko Carstensc10fde02008-04-17 07:46:13 +02001032 if (cpu_management == val)
1033 goto out;
1034 rc = topology_set_cpu_management(val);
1035 if (!rc)
1036 cpu_management = val;
1037out:
Heiko Carstensc10fde02008-04-17 07:46:13 +02001038 mutex_unlock(&smp_cpu_state_mutex);
Heiko Carstens0b18d312008-04-30 13:38:36 +02001039 put_online_cpus();
Heiko Carstensc10fde02008-04-17 07:46:13 +02001040 return rc ? rc : count;
1041}
Heiko Carstensda5aae72008-10-28 11:10:16 +01001042static SYSDEV_CLASS_ATTR(dispatching, 0644, dispatching_show,
1043 dispatching_store);
Heiko Carstensc10fde02008-04-17 07:46:13 +02001044
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045static int __init topology_init(void)
1046{
1047 int cpu;
Heiko Carstensfae8b222007-10-22 12:52:39 +02001048 int rc;
Heiko Carstens2fc2d1e2007-04-27 16:01:56 +02001049
1050 register_cpu_notifier(&smp_cpu_nb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001051
Heiko Carstens08d07962008-01-26 14:10:56 +01001052#ifdef CONFIG_HOTPLUG_CPU
Heiko Carstensda5aae72008-10-28 11:10:16 +01001053 rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_rescan);
Heiko Carstens08d07962008-01-26 14:10:56 +01001054 if (rc)
1055 return rc;
1056#endif
Heiko Carstensda5aae72008-10-28 11:10:16 +01001057 rc = sysdev_class_create_file(&cpu_sysdev_class, &attr_dispatching);
Heiko Carstensc10fde02008-04-17 07:46:13 +02001058 if (rc)
1059 return rc;
Heiko Carstens08d07962008-01-26 14:10:56 +01001060 for_each_present_cpu(cpu) {
1061 rc = smp_add_present_cpu(cpu);
Heiko Carstensfae8b222007-10-22 12:52:39 +02001062 if (rc)
1063 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001064 }
1065 return 0;
1066}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067subsys_initcall(topology_init);