1457c8996SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only
21da177e4SLinus Torvalds /*
31da177e4SLinus Torvalds * SMP boot-related support
41da177e4SLinus Torvalds *
582975115SDavid Mosberger-Tang * Copyright (C) 1998-2003, 2005 Hewlett-Packard Co
61da177e4SLinus Torvalds * David Mosberger-Tang <davidm@hpl.hp.com>
7e927ecb0SSuresh Siddha * Copyright (C) 2001, 2004-2005 Intel Corp
8e927ecb0SSuresh Siddha * Rohit Seth <rohit.seth@intel.com>
9e927ecb0SSuresh Siddha * Suresh Siddha <suresh.b.siddha@intel.com>
10e927ecb0SSuresh Siddha * Gordon Jin <gordon.jin@intel.com>
11e927ecb0SSuresh Siddha * Ashok Raj <ashok.raj@intel.com>
121da177e4SLinus Torvalds *
131da177e4SLinus Torvalds * 01/05/16 Rohit Seth <rohit.seth@intel.com> Moved SMP booting functions from smp.c to here.
141da177e4SLinus Torvalds * 01/04/27 David Mosberger <davidm@hpl.hp.com> Added ITC synching code.
151da177e4SLinus Torvalds * 02/07/31 David Mosberger <davidm@hpl.hp.com> Switch over to hotplug-CPU boot-sequence.
161da177e4SLinus Torvalds * smp_boot_cpus()/smp_commence() is replaced by
171da177e4SLinus Torvalds * smp_prepare_cpus()/__cpu_up()/smp_cpus_done().
18b8d8b883SAshok Raj * 04/06/21 Ashok Raj <ashok.raj@intel.com> Added CPU Hotplug Support
19e927ecb0SSuresh Siddha * 04/12/26 Jin Gordon <gordon.jin@intel.com>
20e927ecb0SSuresh Siddha * 04/12/26 Rohit Seth <rohit.seth@intel.com>
21e927ecb0SSuresh Siddha * Add multi-threading and multi-core detection
22e927ecb0SSuresh Siddha * 05/01/30 Suresh Siddha <suresh.b.siddha@intel.com>
23e927ecb0SSuresh Siddha * Setup cpu_sibling_map and cpu_core_map
241da177e4SLinus Torvalds */
251da177e4SLinus Torvalds
261da177e4SLinus Torvalds #include <linux/module.h>
271da177e4SLinus Torvalds #include <linux/acpi.h>
2857c8a661SMike Rapoport #include <linux/memblock.h>
291da177e4SLinus Torvalds #include <linux/cpu.h>
301da177e4SLinus Torvalds #include <linux/delay.h>
311da177e4SLinus Torvalds #include <linux/init.h>
321da177e4SLinus Torvalds #include <linux/interrupt.h>
331da177e4SLinus Torvalds #include <linux/irq.h>
341da177e4SLinus Torvalds #include <linux/kernel.h>
351da177e4SLinus Torvalds #include <linux/kernel_stat.h>
361da177e4SLinus Torvalds #include <linux/mm.h>
371da177e4SLinus Torvalds #include <linux/notifier.h>
381da177e4SLinus Torvalds #include <linux/smp.h>
391da177e4SLinus Torvalds #include <linux/spinlock.h>
401da177e4SLinus Torvalds #include <linux/efi.h>
411da177e4SLinus Torvalds #include <linux/percpu.h>
421da177e4SLinus Torvalds #include <linux/bitops.h>
431da177e4SLinus Torvalds
4460063497SArun Sharma #include <linux/atomic.h>
451da177e4SLinus Torvalds #include <asm/cache.h>
461da177e4SLinus Torvalds #include <asm/current.h>
471da177e4SLinus Torvalds #include <asm/delay.h>
48*8ff059b8SArd Biesheuvel #include <asm/efi.h>
491da177e4SLinus Torvalds #include <asm/io.h>
501da177e4SLinus Torvalds #include <asm/irq.h>
511da177e4SLinus Torvalds #include <asm/mca.h>
521da177e4SLinus Torvalds #include <asm/page.h>
531da177e4SLinus Torvalds #include <asm/processor.h>
541da177e4SLinus Torvalds #include <asm/ptrace.h>
551da177e4SLinus Torvalds #include <asm/sal.h>
561da177e4SLinus Torvalds #include <asm/tlbflush.h>
571da177e4SLinus Torvalds #include <asm/unistd.h>
581da177e4SLinus Torvalds
591da177e4SLinus Torvalds #define SMP_DEBUG 0
601da177e4SLinus Torvalds
611da177e4SLinus Torvalds #if SMP_DEBUG
621da177e4SLinus Torvalds #define Dprintk(x...) printk(x)
631da177e4SLinus Torvalds #else
641da177e4SLinus Torvalds #define Dprintk(x...)
651da177e4SLinus Torvalds #endif
661da177e4SLinus Torvalds
67b8d8b883SAshok Raj #ifdef CONFIG_HOTPLUG_CPU
68ff741906SAshok Raj #ifdef CONFIG_PERMIT_BSP_REMOVE
69ff741906SAshok Raj #define bsp_remove_ok 1
70ff741906SAshok Raj #else
71ff741906SAshok Raj #define bsp_remove_ok 0
72ff741906SAshok Raj #endif
73ff741906SAshok Raj
74b8d8b883SAshok Raj /*
75b8d8b883SAshok Raj * Global array allocated for NR_CPUS at boot time
76b8d8b883SAshok Raj */
77b8d8b883SAshok Raj struct sal_to_os_boot sal_boot_rendez_state[NR_CPUS];
78b8d8b883SAshok Raj
79b8d8b883SAshok Raj /*
80b8d8b883SAshok Raj * start_ap in head.S uses this to store current booting cpu
81b8d8b883SAshok Raj * info.
82b8d8b883SAshok Raj */
83b8d8b883SAshok Raj struct sal_to_os_boot *sal_state_for_booting_cpu = &sal_boot_rendez_state[0];
84b8d8b883SAshok Raj
85b8d8b883SAshok Raj #define set_brendez_area(x) (sal_state_for_booting_cpu = &sal_boot_rendez_state[(x)]);
86b8d8b883SAshok Raj
87b8d8b883SAshok Raj #else
88b8d8b883SAshok Raj #define set_brendez_area(x)
89b8d8b883SAshok Raj #endif
90b8d8b883SAshok Raj
911da177e4SLinus Torvalds
921da177e4SLinus Torvalds /*
931da177e4SLinus Torvalds * ITC synchronization related stuff:
941da177e4SLinus Torvalds */
95ff741906SAshok Raj #define MASTER (0)
961da177e4SLinus Torvalds #define SLAVE (SMP_CACHE_BYTES/8)
971da177e4SLinus Torvalds
981da177e4SLinus Torvalds #define NUM_ROUNDS 64 /* magic value */
991da177e4SLinus Torvalds #define NUM_ITERS 5 /* likewise */
1001da177e4SLinus Torvalds
1011da177e4SLinus Torvalds static DEFINE_SPINLOCK(itc_sync_lock);
1021da177e4SLinus Torvalds static volatile unsigned long go[SLAVE + 1];
1031da177e4SLinus Torvalds
1041da177e4SLinus Torvalds #define DEBUG_ITC_SYNC 0
1051da177e4SLinus Torvalds
1061da177e4SLinus Torvalds extern void start_ap (void);
1071da177e4SLinus Torvalds extern unsigned long ia64_iobase;
1081da177e4SLinus Torvalds
10936c8b586SIngo Molnar struct task_struct *task_for_booting_cpu;
1101da177e4SLinus Torvalds
1111da177e4SLinus Torvalds /*
1121da177e4SLinus Torvalds * State for each CPU
1131da177e4SLinus Torvalds */
1141da177e4SLinus Torvalds DEFINE_PER_CPU(int, cpu_state);
1151da177e4SLinus Torvalds
116e927ecb0SSuresh Siddha cpumask_t cpu_core_map[NR_CPUS] __cacheline_aligned;
11742aca483SRobin Holt EXPORT_SYMBOL(cpu_core_map);
118d5a7430dSMike Travis DEFINE_PER_CPU_SHARED_ALIGNED(cpumask_t, cpu_sibling_map);
119d5a7430dSMike Travis EXPORT_PER_CPU_SYMBOL(cpu_sibling_map);
120d5a7430dSMike Travis
121e927ecb0SSuresh Siddha int smp_num_siblings = 1;
122e927ecb0SSuresh Siddha
1231da177e4SLinus Torvalds /* which logical CPU number maps to which CPU (physical APIC ID) */
1241da177e4SLinus Torvalds volatile int ia64_cpu_to_sapicid[NR_CPUS];
1251da177e4SLinus Torvalds EXPORT_SYMBOL(ia64_cpu_to_sapicid);
1261da177e4SLinus Torvalds
1275eda7861SRusty Russell static cpumask_t cpu_callin_map;
1281da177e4SLinus Torvalds
1291da177e4SLinus Torvalds struct smp_boot_data smp_boot_data __initdata;
1301da177e4SLinus Torvalds
1311da177e4SLinus Torvalds unsigned long ap_wakeup_vector = -1; /* External Int use to wakeup APs */
1321da177e4SLinus Torvalds
1331da177e4SLinus Torvalds char __initdata no_int_routing;
1341da177e4SLinus Torvalds
1351da177e4SLinus Torvalds unsigned char smp_int_redirect; /* are INT and IPI redirectable by the chipset? */
1361da177e4SLinus Torvalds
137ff741906SAshok Raj #ifdef CONFIG_FORCE_CPEI_RETARGET
138ff741906SAshok Raj #define CPEI_OVERRIDE_DEFAULT (1)
139ff741906SAshok Raj #else
140ff741906SAshok Raj #define CPEI_OVERRIDE_DEFAULT (0)
141ff741906SAshok Raj #endif
142ff741906SAshok Raj
143ff741906SAshok Raj unsigned int force_cpei_retarget = CPEI_OVERRIDE_DEFAULT;
144ff741906SAshok Raj
145ff741906SAshok Raj static int __init
cmdl_force_cpei(char * str)146ff741906SAshok Raj cmdl_force_cpei(char *str)
147ff741906SAshok Raj {
148ff741906SAshok Raj int value=0;
149ff741906SAshok Raj
150ff741906SAshok Raj get_option (&str, &value);
151ff741906SAshok Raj force_cpei_retarget = value;
152ff741906SAshok Raj
153ff741906SAshok Raj return 1;
154ff741906SAshok Raj }
155ff741906SAshok Raj
156ff741906SAshok Raj __setup("force_cpei=", cmdl_force_cpei);
157ff741906SAshok Raj
1581da177e4SLinus Torvalds static int __init
nointroute(char * str)1591da177e4SLinus Torvalds nointroute (char *str)
1601da177e4SLinus Torvalds {
1611da177e4SLinus Torvalds no_int_routing = 1;
1621da177e4SLinus Torvalds printk ("no_int_routing on\n");
1631da177e4SLinus Torvalds return 1;
1641da177e4SLinus Torvalds }
1651da177e4SLinus Torvalds
1661da177e4SLinus Torvalds __setup("nointroute", nointroute);
1671da177e4SLinus Torvalds
fix_b0_for_bsp(void)168ff741906SAshok Raj static void fix_b0_for_bsp(void)
169ff741906SAshok Raj {
170ff741906SAshok Raj #ifdef CONFIG_HOTPLUG_CPU
171ff741906SAshok Raj int cpuid;
172ff741906SAshok Raj static int fix_bsp_b0 = 1;
173ff741906SAshok Raj
174ff741906SAshok Raj cpuid = smp_processor_id();
175ff741906SAshok Raj
176ff741906SAshok Raj /*
177ff741906SAshok Raj * Cache the b0 value on the first AP that comes up
178ff741906SAshok Raj */
179ff741906SAshok Raj if (!(fix_bsp_b0 && cpuid))
180ff741906SAshok Raj return;
181ff741906SAshok Raj
182ff741906SAshok Raj sal_boot_rendez_state[0].br[0] = sal_boot_rendez_state[cpuid].br[0];
183ff741906SAshok Raj printk ("Fixed BSP b0 value from CPU %d\n", cpuid);
184ff741906SAshok Raj
185ff741906SAshok Raj fix_bsp_b0 = 0;
186ff741906SAshok Raj #endif
187ff741906SAshok Raj }
188ff741906SAshok Raj
1891da177e4SLinus Torvalds void
sync_master(void * arg)1901da177e4SLinus Torvalds sync_master (void *arg)
1911da177e4SLinus Torvalds {
1921da177e4SLinus Torvalds unsigned long flags, i;
1931da177e4SLinus Torvalds
1941da177e4SLinus Torvalds go[MASTER] = 0;
1951da177e4SLinus Torvalds
1961da177e4SLinus Torvalds local_irq_save(flags);
1971da177e4SLinus Torvalds {
1981da177e4SLinus Torvalds for (i = 0; i < NUM_ROUNDS*NUM_ITERS; ++i) {
19982975115SDavid Mosberger-Tang while (!go[MASTER])
20082975115SDavid Mosberger-Tang cpu_relax();
2011da177e4SLinus Torvalds go[MASTER] = 0;
2021da177e4SLinus Torvalds go[SLAVE] = ia64_get_itc();
2031da177e4SLinus Torvalds }
2041da177e4SLinus Torvalds }
2051da177e4SLinus Torvalds local_irq_restore(flags);
2061da177e4SLinus Torvalds }
2071da177e4SLinus Torvalds
2081da177e4SLinus Torvalds /*
2091da177e4SLinus Torvalds * Return the number of cycles by which our itc differs from the itc on the master
2101da177e4SLinus Torvalds * (time-keeper) CPU. A positive number indicates our itc is ahead of the master,
2111da177e4SLinus Torvalds * negative that it is behind.
2121da177e4SLinus Torvalds */
2131da177e4SLinus Torvalds static inline long
get_delta(long * rt,long * master)2141da177e4SLinus Torvalds get_delta (long *rt, long *master)
2151da177e4SLinus Torvalds {
2161da177e4SLinus Torvalds unsigned long best_t0 = 0, best_t1 = ~0UL, best_tm = 0;
2171da177e4SLinus Torvalds unsigned long tcenter, t0, t1, tm;
2181da177e4SLinus Torvalds long i;
2191da177e4SLinus Torvalds
2201da177e4SLinus Torvalds for (i = 0; i < NUM_ITERS; ++i) {
2211da177e4SLinus Torvalds t0 = ia64_get_itc();
2221da177e4SLinus Torvalds go[MASTER] = 1;
22382975115SDavid Mosberger-Tang while (!(tm = go[SLAVE]))
22482975115SDavid Mosberger-Tang cpu_relax();
2251da177e4SLinus Torvalds go[SLAVE] = 0;
2261da177e4SLinus Torvalds t1 = ia64_get_itc();
2271da177e4SLinus Torvalds
2281da177e4SLinus Torvalds if (t1 - t0 < best_t1 - best_t0)
2291da177e4SLinus Torvalds best_t0 = t0, best_t1 = t1, best_tm = tm;
2301da177e4SLinus Torvalds }
2311da177e4SLinus Torvalds
2321da177e4SLinus Torvalds *rt = best_t1 - best_t0;
2331da177e4SLinus Torvalds *master = best_tm - best_t0;
2341da177e4SLinus Torvalds
2351da177e4SLinus Torvalds /* average best_t0 and best_t1 without overflow: */
2361da177e4SLinus Torvalds tcenter = (best_t0/2 + best_t1/2);
2371da177e4SLinus Torvalds if (best_t0 % 2 + best_t1 % 2 == 2)
2381da177e4SLinus Torvalds ++tcenter;
2391da177e4SLinus Torvalds return tcenter - best_tm;
2401da177e4SLinus Torvalds }
2411da177e4SLinus Torvalds
2421da177e4SLinus Torvalds /*
2431da177e4SLinus Torvalds * Synchronize ar.itc of the current (slave) CPU with the ar.itc of the MASTER CPU
2441da177e4SLinus Torvalds * (normally the time-keeper CPU). We use a closed loop to eliminate the possibility of
2451da177e4SLinus Torvalds * unaccounted-for errors (such as getting a machine check in the middle of a calibration
2461da177e4SLinus Torvalds * step). The basic idea is for the slave to ask the master what itc value it has and to
2471da177e4SLinus Torvalds * read its own itc before and after the master responds. Each iteration gives us three
2481da177e4SLinus Torvalds * timestamps:
2491da177e4SLinus Torvalds *
2501da177e4SLinus Torvalds * slave master
2511da177e4SLinus Torvalds *
2521da177e4SLinus Torvalds * t0 ---\
2531da177e4SLinus Torvalds * ---\
2541da177e4SLinus Torvalds * --->
2551da177e4SLinus Torvalds * tm
2561da177e4SLinus Torvalds * /---
2571da177e4SLinus Torvalds * /---
2581da177e4SLinus Torvalds * t1 <---
2591da177e4SLinus Torvalds *
2601da177e4SLinus Torvalds *
2611da177e4SLinus Torvalds * The goal is to adjust the slave's ar.itc such that tm falls exactly half-way between t0
2621da177e4SLinus Torvalds * and t1. If we achieve this, the clocks are synchronized provided the interconnect
2631da177e4SLinus Torvalds * between the slave and the master is symmetric. Even if the interconnect were
2641da177e4SLinus Torvalds * asymmetric, we would still know that the synchronization error is smaller than the
2651da177e4SLinus Torvalds * roundtrip latency (t0 - t1).
2661da177e4SLinus Torvalds *
2671da177e4SLinus Torvalds * When the interconnect is quiet and symmetric, this lets us synchronize the itc to
2681da177e4SLinus Torvalds * within one or two cycles. However, we can only *guarantee* that the synchronization is
2691da177e4SLinus Torvalds * accurate to within a round-trip time, which is typically in the range of several
2701da177e4SLinus Torvalds * hundred cycles (e.g., ~500 cycles). In practice, this means that the itc's are usually
2711da177e4SLinus Torvalds * almost perfectly synchronized, but we shouldn't assume that the accuracy is much better
2721da177e4SLinus Torvalds * than half a micro second or so.
2731da177e4SLinus Torvalds */
2741da177e4SLinus Torvalds void
ia64_sync_itc(unsigned int master)2751da177e4SLinus Torvalds ia64_sync_itc (unsigned int master)
2761da177e4SLinus Torvalds {
2771da177e4SLinus Torvalds long i, delta, adj, adjust_latency = 0, done = 0;
2781da177e4SLinus Torvalds unsigned long flags, rt, master_time_stamp, bound;
2791da177e4SLinus Torvalds #if DEBUG_ITC_SYNC
2801da177e4SLinus Torvalds struct {
2811da177e4SLinus Torvalds long rt; /* roundtrip time */
2821da177e4SLinus Torvalds long master; /* master's timestamp */
2831da177e4SLinus Torvalds long diff; /* difference between midpoint and master's timestamp */
2841da177e4SLinus Torvalds long lat; /* estimate of itc adjustment latency */
2851da177e4SLinus Torvalds } t[NUM_ROUNDS];
2861da177e4SLinus Torvalds #endif
2871da177e4SLinus Torvalds
2881da177e4SLinus Torvalds /*
2891da177e4SLinus Torvalds * Make sure local timer ticks are disabled while we sync. If
2901da177e4SLinus Torvalds * they were enabled, we'd have to worry about nasty issues
2911da177e4SLinus Torvalds * like setting the ITC ahead of (or a long time before) the
2921da177e4SLinus Torvalds * next scheduled tick.
2931da177e4SLinus Torvalds */
2941da177e4SLinus Torvalds BUG_ON((ia64_get_itv() & (1 << 16)) == 0);
2951da177e4SLinus Torvalds
2961da177e4SLinus Torvalds go[MASTER] = 1;
2971da177e4SLinus Torvalds
2988691e5a8SJens Axboe if (smp_call_function_single(master, sync_master, NULL, 0) < 0) {
2991da177e4SLinus Torvalds printk(KERN_ERR "sync_itc: failed to get attention of CPU %u!\n", master);
3001da177e4SLinus Torvalds return;
3011da177e4SLinus Torvalds }
3021da177e4SLinus Torvalds
30382975115SDavid Mosberger-Tang while (go[MASTER])
30482975115SDavid Mosberger-Tang cpu_relax(); /* wait for master to be ready */
3051da177e4SLinus Torvalds
3061da177e4SLinus Torvalds spin_lock_irqsave(&itc_sync_lock, flags);
3071da177e4SLinus Torvalds {
3081da177e4SLinus Torvalds for (i = 0; i < NUM_ROUNDS; ++i) {
3091da177e4SLinus Torvalds delta = get_delta(&rt, &master_time_stamp);
3101da177e4SLinus Torvalds if (delta == 0) {
3111da177e4SLinus Torvalds done = 1; /* let's lock on to this... */
3121da177e4SLinus Torvalds bound = rt;
3131da177e4SLinus Torvalds }
3141da177e4SLinus Torvalds
3151da177e4SLinus Torvalds if (!done) {
3161da177e4SLinus Torvalds if (i > 0) {
3171da177e4SLinus Torvalds adjust_latency += -delta;
3181da177e4SLinus Torvalds adj = -delta + adjust_latency/4;
3191da177e4SLinus Torvalds } else
3201da177e4SLinus Torvalds adj = -delta;
3211da177e4SLinus Torvalds
3221da177e4SLinus Torvalds ia64_set_itc(ia64_get_itc() + adj);
3231da177e4SLinus Torvalds }
3241da177e4SLinus Torvalds #if DEBUG_ITC_SYNC
3251da177e4SLinus Torvalds t[i].rt = rt;
3261da177e4SLinus Torvalds t[i].master = master_time_stamp;
3271da177e4SLinus Torvalds t[i].diff = delta;
3281da177e4SLinus Torvalds t[i].lat = adjust_latency/4;
3291da177e4SLinus Torvalds #endif
3301da177e4SLinus Torvalds }
3311da177e4SLinus Torvalds }
3321da177e4SLinus Torvalds spin_unlock_irqrestore(&itc_sync_lock, flags);
3331da177e4SLinus Torvalds
3341da177e4SLinus Torvalds #if DEBUG_ITC_SYNC
3351da177e4SLinus Torvalds for (i = 0; i < NUM_ROUNDS; ++i)
3361da177e4SLinus Torvalds printk("rt=%5ld master=%5ld diff=%5ld adjlat=%5ld\n",
3371da177e4SLinus Torvalds t[i].rt, t[i].master, t[i].diff, t[i].lat);
3381da177e4SLinus Torvalds #endif
3391da177e4SLinus Torvalds
3401da177e4SLinus Torvalds printk(KERN_INFO "CPU %d: synchronized ITC with CPU %u (last diff %ld cycles, "
3411da177e4SLinus Torvalds "maxerr %lu cycles)\n", smp_processor_id(), master, delta, rt);
3421da177e4SLinus Torvalds }
3431da177e4SLinus Torvalds
3441da177e4SLinus Torvalds /*
3451da177e4SLinus Torvalds * Ideally sets up per-cpu profiling hooks. Doesn't do much now...
3461da177e4SLinus Torvalds */
smp_setup_percpu_timer(void)3475b5e76e9SGreg Kroah-Hartman static inline void smp_setup_percpu_timer(void)
3481da177e4SLinus Torvalds {
3491da177e4SLinus Torvalds }
3501da177e4SLinus Torvalds
351ccce9bb8SPaul Gortmaker static void
smp_callin(void)3521da177e4SLinus Torvalds smp_callin (void)
3531da177e4SLinus Torvalds {
354ff741906SAshok Raj int cpuid, phys_id, itc_master;
355ead6caaeSJack Steiner struct cpuinfo_ia64 *last_cpuinfo, *this_cpuinfo;
3561da177e4SLinus Torvalds extern void ia64_init_itm(void);
357ff741906SAshok Raj extern volatile int time_keeper_id;
3581da177e4SLinus Torvalds
3591da177e4SLinus Torvalds cpuid = smp_processor_id();
3601da177e4SLinus Torvalds phys_id = hard_smp_processor_id();
361ff741906SAshok Raj itc_master = time_keeper_id;
3621da177e4SLinus Torvalds
3631da177e4SLinus Torvalds if (cpu_online(cpuid)) {
3641da177e4SLinus Torvalds printk(KERN_ERR "huh, phys CPU#0x%x, CPU#0x%x already present??\n",
3651da177e4SLinus Torvalds phys_id, cpuid);
3661da177e4SLinus Torvalds BUG();
3671da177e4SLinus Torvalds }
3681da177e4SLinus Torvalds
369ff741906SAshok Raj fix_b0_for_bsp();
370ff741906SAshok Raj
3713bccd996SLee Schermerhorn /*
3723bccd996SLee Schermerhorn * numa_node_id() works after this.
3733bccd996SLee Schermerhorn */
3743bccd996SLee Schermerhorn set_numa_node(cpu_to_node_map[cpuid]);
375fd1197f1SLee Schermerhorn set_numa_mem(local_memory_node(cpu_to_node_map[cpuid]));
3763bccd996SLee Schermerhorn
377e1b30a39SYasuaki Ishimatsu spin_lock(&vector_lock);
378e1b30a39SYasuaki Ishimatsu /* Setup the per cpu irq handling data structures */
379e1b30a39SYasuaki Ishimatsu __setup_vector_irq(cpuid);
380e545a614SManfred Spraul notify_cpu_starting(cpuid);
3817d7f9848SSrivatsa S. Bhat set_cpu_online(cpuid, true);
382a9fa06c2SShaohua Li per_cpu(cpu_state, cpuid) = CPU_ONLINE;
383e1b30a39SYasuaki Ishimatsu spin_unlock(&vector_lock);
3841da177e4SLinus Torvalds
3851da177e4SLinus Torvalds smp_setup_percpu_timer();
3861da177e4SLinus Torvalds
3871da177e4SLinus Torvalds ia64_mca_cmc_vector_setup(); /* Setup vector on AP */
3881da177e4SLinus Torvalds
3891da177e4SLinus Torvalds local_irq_enable();
3901da177e4SLinus Torvalds
3911da177e4SLinus Torvalds if (!(sal_platform_features & IA64_SAL_PLATFORM_FEATURE_ITC_DRIFT)) {
3921da177e4SLinus Torvalds /*
3931da177e4SLinus Torvalds * Synchronize the ITC with the BP. Need to do this after irqs are
3941da177e4SLinus Torvalds * enabled because ia64_sync_itc() calls smp_call_function_single(), which
3951da177e4SLinus Torvalds * calls spin_unlock_bh(), which calls spin_unlock_bh(), which calls
3961da177e4SLinus Torvalds * local_bh_enable(), which bugs out if irqs are not enabled...
3971da177e4SLinus Torvalds */
398ff741906SAshok Raj Dprintk("Going to syncup ITC with ITC Master.\n");
399ff741906SAshok Raj ia64_sync_itc(itc_master);
4001da177e4SLinus Torvalds }
4011da177e4SLinus Torvalds
4021da177e4SLinus Torvalds /*
4031da177e4SLinus Torvalds * Get our bogomips.
4041da177e4SLinus Torvalds */
4051da177e4SLinus Torvalds ia64_init_itm();
406ead6caaeSJack Steiner
407ead6caaeSJack Steiner /*
408ead6caaeSJack Steiner * Delay calibration can be skipped if new processor is identical to the
409ead6caaeSJack Steiner * previous processor.
410ead6caaeSJack Steiner */
411ead6caaeSJack Steiner last_cpuinfo = cpu_data(cpuid - 1);
412ead6caaeSJack Steiner this_cpuinfo = local_cpu_data;
413ead6caaeSJack Steiner if (last_cpuinfo->itc_freq != this_cpuinfo->itc_freq ||
414ead6caaeSJack Steiner last_cpuinfo->proc_freq != this_cpuinfo->proc_freq ||
415ead6caaeSJack Steiner last_cpuinfo->features != this_cpuinfo->features ||
416ead6caaeSJack Steiner last_cpuinfo->revision != this_cpuinfo->revision ||
417ead6caaeSJack Steiner last_cpuinfo->family != this_cpuinfo->family ||
418ead6caaeSJack Steiner last_cpuinfo->archrev != this_cpuinfo->archrev ||
419ead6caaeSJack Steiner last_cpuinfo->model != this_cpuinfo->model)
4201da177e4SLinus Torvalds calibrate_delay();
4211da177e4SLinus Torvalds local_cpu_data->loops_per_jiffy = loops_per_jiffy;
4221da177e4SLinus Torvalds
4231da177e4SLinus Torvalds /*
4241da177e4SLinus Torvalds * Allow the master to continue.
4251da177e4SLinus Torvalds */
4265d2068daSRusty Russell cpumask_set_cpu(cpuid, &cpu_callin_map);
4271da177e4SLinus Torvalds Dprintk("Stack on CPU %d at about %p\n",cpuid, &cpuid);
4281da177e4SLinus Torvalds }
4291da177e4SLinus Torvalds
4301da177e4SLinus Torvalds
4311da177e4SLinus Torvalds /*
4321da177e4SLinus Torvalds * Activate a secondary processor. head.S calls this.
4331da177e4SLinus Torvalds */
434ccce9bb8SPaul Gortmaker int
start_secondary(void * unused)4351da177e4SLinus Torvalds start_secondary (void *unused)
4361da177e4SLinus Torvalds {
4371da177e4SLinus Torvalds /* Early console may use I/O ports */
4381da177e4SLinus Torvalds ia64_set_kr(IA64_KR_IO_BASE, __pa(ia64_iobase));
43910617bbeSTony Luck #ifndef CONFIG_PRINTK_TIME
4401da177e4SLinus Torvalds Dprintk("start_secondary: starting CPU 0x%x\n", hard_smp_processor_id());
44110617bbeSTony Luck #endif
4421da177e4SLinus Torvalds efi_map_pal_code();
4431da177e4SLinus Torvalds cpu_init();
4441da177e4SLinus Torvalds smp_callin();
4451da177e4SLinus Torvalds
446fc6d73d6SThomas Gleixner cpu_startup_entry(CPUHP_AP_ONLINE_IDLE);
4471da177e4SLinus Torvalds return 0;
4481da177e4SLinus Torvalds }
4491da177e4SLinus Torvalds
450ccce9bb8SPaul Gortmaker static int
do_boot_cpu(int sapicid,int cpu,struct task_struct * idle)45113583bf1SThomas Gleixner do_boot_cpu (int sapicid, int cpu, struct task_struct *idle)
4521da177e4SLinus Torvalds {
4531da177e4SLinus Torvalds int timeout;
454b8d8b883SAshok Raj
45513583bf1SThomas Gleixner task_for_booting_cpu = idle;
4561da177e4SLinus Torvalds Dprintk("Sending wakeup vector %lu to AP 0x%x/0x%x.\n", ap_wakeup_vector, cpu, sapicid);
4571da177e4SLinus Torvalds
458b8d8b883SAshok Raj set_brendez_area(cpu);
45905933aacSChristoph Hellwig ia64_send_ipi(cpu, ap_wakeup_vector, IA64_IPI_DM_INT, 0);
4601da177e4SLinus Torvalds
4611da177e4SLinus Torvalds /*
4621da177e4SLinus Torvalds * Wait 10s total for the AP to start
4631da177e4SLinus Torvalds */
4641da177e4SLinus Torvalds Dprintk("Waiting on callin_map ...");
4651da177e4SLinus Torvalds for (timeout = 0; timeout < 100000; timeout++) {
4665d2068daSRusty Russell if (cpumask_test_cpu(cpu, &cpu_callin_map))
4671da177e4SLinus Torvalds break; /* It has booted */
4685eda7861SRusty Russell barrier(); /* Make sure we re-read cpu_callin_map */
4691da177e4SLinus Torvalds udelay(100);
4701da177e4SLinus Torvalds }
4711da177e4SLinus Torvalds Dprintk("\n");
4721da177e4SLinus Torvalds
4735d2068daSRusty Russell if (!cpumask_test_cpu(cpu, &cpu_callin_map)) {
4741da177e4SLinus Torvalds printk(KERN_ERR "Processor 0x%x/0x%x is stuck.\n", cpu, sapicid);
4751da177e4SLinus Torvalds ia64_cpu_to_sapicid[cpu] = -1;
4767d7f9848SSrivatsa S. Bhat set_cpu_online(cpu, false); /* was set in smp_callin() */
4771da177e4SLinus Torvalds return -EINVAL;
4781da177e4SLinus Torvalds }
4791da177e4SLinus Torvalds return 0;
4801da177e4SLinus Torvalds }
4811da177e4SLinus Torvalds
4821da177e4SLinus Torvalds static int __init
decay(char * str)4831da177e4SLinus Torvalds decay (char *str)
4841da177e4SLinus Torvalds {
4851da177e4SLinus Torvalds int ticks;
4861da177e4SLinus Torvalds get_option (&str, &ticks);
4871da177e4SLinus Torvalds return 1;
4881da177e4SLinus Torvalds }
4891da177e4SLinus Torvalds
4901da177e4SLinus Torvalds __setup("decay=", decay);
4911da177e4SLinus Torvalds
4921da177e4SLinus Torvalds /*
4931da177e4SLinus Torvalds * Initialize the logical CPU number to SAPICID mapping
4941da177e4SLinus Torvalds */
4951da177e4SLinus Torvalds void __init
smp_build_cpu_map(void)4961da177e4SLinus Torvalds smp_build_cpu_map (void)
4971da177e4SLinus Torvalds {
4981da177e4SLinus Torvalds int sapicid, cpu, i;
4991da177e4SLinus Torvalds int boot_cpu_id = hard_smp_processor_id();
5001da177e4SLinus Torvalds
5011da177e4SLinus Torvalds for (cpu = 0; cpu < NR_CPUS; cpu++) {
5021da177e4SLinus Torvalds ia64_cpu_to_sapicid[cpu] = -1;
5031da177e4SLinus Torvalds }
5041da177e4SLinus Torvalds
5051da177e4SLinus Torvalds ia64_cpu_to_sapicid[0] = boot_cpu_id;
5067d7f9848SSrivatsa S. Bhat init_cpu_present(cpumask_of(0));
5072af51a3fSRusty Russell set_cpu_possible(0, true);
5081da177e4SLinus Torvalds for (cpu = 1, i = 0; i < smp_boot_data.cpu_count; i++) {
5091da177e4SLinus Torvalds sapicid = smp_boot_data.cpu_phys_id[i];
5101da177e4SLinus Torvalds if (sapicid == boot_cpu_id)
5111da177e4SLinus Torvalds continue;
5122af51a3fSRusty Russell set_cpu_present(cpu, true);
5132af51a3fSRusty Russell set_cpu_possible(cpu, true);
5141da177e4SLinus Torvalds ia64_cpu_to_sapicid[cpu] = sapicid;
5151da177e4SLinus Torvalds cpu++;
5161da177e4SLinus Torvalds }
5171da177e4SLinus Torvalds }
5181da177e4SLinus Torvalds
5191da177e4SLinus Torvalds /*
5201da177e4SLinus Torvalds * Cycle through the APs sending Wakeup IPIs to boot each.
5211da177e4SLinus Torvalds */
5221da177e4SLinus Torvalds void __init
smp_prepare_cpus(unsigned int max_cpus)5231da177e4SLinus Torvalds smp_prepare_cpus (unsigned int max_cpus)
5241da177e4SLinus Torvalds {
5251da177e4SLinus Torvalds int boot_cpu_id = hard_smp_processor_id();
5261da177e4SLinus Torvalds
5271da177e4SLinus Torvalds /*
5281da177e4SLinus Torvalds * Initialize the per-CPU profiling counter/multiplier
5291da177e4SLinus Torvalds */
5301da177e4SLinus Torvalds
5311da177e4SLinus Torvalds smp_setup_percpu_timer();
5321da177e4SLinus Torvalds
5335d2068daSRusty Russell cpumask_set_cpu(0, &cpu_callin_map);
5341da177e4SLinus Torvalds
5351da177e4SLinus Torvalds local_cpu_data->loops_per_jiffy = loops_per_jiffy;
5361da177e4SLinus Torvalds ia64_cpu_to_sapicid[0] = boot_cpu_id;
5371da177e4SLinus Torvalds
5381da177e4SLinus Torvalds printk(KERN_INFO "Boot processor id 0x%x/0x%x\n", 0, boot_cpu_id);
5391da177e4SLinus Torvalds
5401da177e4SLinus Torvalds current_thread_info()->cpu = 0;
5411da177e4SLinus Torvalds
5421da177e4SLinus Torvalds /*
5431da177e4SLinus Torvalds * If SMP should be disabled, then really disable it!
5441da177e4SLinus Torvalds */
5451da177e4SLinus Torvalds if (!max_cpus) {
5461da177e4SLinus Torvalds printk(KERN_INFO "SMP mode deactivated.\n");
5472af51a3fSRusty Russell init_cpu_online(cpumask_of(0));
5482af51a3fSRusty Russell init_cpu_present(cpumask_of(0));
5492af51a3fSRusty Russell init_cpu_possible(cpumask_of(0));
5501da177e4SLinus Torvalds return;
5511da177e4SLinus Torvalds }
5521da177e4SLinus Torvalds }
5531da177e4SLinus Torvalds
smp_prepare_boot_cpu(void)5545b5e76e9SGreg Kroah-Hartman void smp_prepare_boot_cpu(void)
5551da177e4SLinus Torvalds {
5567d7f9848SSrivatsa S. Bhat set_cpu_online(smp_processor_id(), true);
5575d2068daSRusty Russell cpumask_set_cpu(smp_processor_id(), &cpu_callin_map);
5583bccd996SLee Schermerhorn set_numa_node(cpu_to_node_map[smp_processor_id()]);
559a9fa06c2SShaohua Li per_cpu(cpu_state, smp_processor_id()) = CPU_ONLINE;
5601da177e4SLinus Torvalds }
5611da177e4SLinus Torvalds
5621da177e4SLinus Torvalds #ifdef CONFIG_HOTPLUG_CPU
563e927ecb0SSuresh Siddha static inline void
clear_cpu_sibling_map(int cpu)564e927ecb0SSuresh Siddha clear_cpu_sibling_map(int cpu)
565e927ecb0SSuresh Siddha {
566e927ecb0SSuresh Siddha int i;
567e927ecb0SSuresh Siddha
5685d2068daSRusty Russell for_each_cpu(i, &per_cpu(cpu_sibling_map, cpu))
5695d2068daSRusty Russell cpumask_clear_cpu(cpu, &per_cpu(cpu_sibling_map, i));
5705d2068daSRusty Russell for_each_cpu(i, &cpu_core_map[cpu])
5715d2068daSRusty Russell cpumask_clear_cpu(cpu, &cpu_core_map[i]);
572e927ecb0SSuresh Siddha
573d5a7430dSMike Travis per_cpu(cpu_sibling_map, cpu) = cpu_core_map[cpu] = CPU_MASK_NONE;
574e927ecb0SSuresh Siddha }
575e927ecb0SSuresh Siddha
576e927ecb0SSuresh Siddha static void
remove_siblinginfo(int cpu)577e927ecb0SSuresh Siddha remove_siblinginfo(int cpu)
578e927ecb0SSuresh Siddha {
579e927ecb0SSuresh Siddha if (cpu_data(cpu)->threads_per_core == 1 &&
580e927ecb0SSuresh Siddha cpu_data(cpu)->cores_per_socket == 1) {
5815d2068daSRusty Russell cpumask_clear_cpu(cpu, &cpu_core_map[cpu]);
5825d2068daSRusty Russell cpumask_clear_cpu(cpu, &per_cpu(cpu_sibling_map, cpu));
583e927ecb0SSuresh Siddha return;
584e927ecb0SSuresh Siddha }
585e927ecb0SSuresh Siddha
586e927ecb0SSuresh Siddha /* remove it from all sibling map's */
587e927ecb0SSuresh Siddha clear_cpu_sibling_map(cpu);
588e927ecb0SSuresh Siddha }
589e927ecb0SSuresh Siddha
5901da177e4SLinus Torvalds extern void fixup_irqs(void);
591ff741906SAshok Raj
migrate_platform_irqs(unsigned int cpu)592ff741906SAshok Raj int migrate_platform_irqs(unsigned int cpu)
593ff741906SAshok Raj {
594ff741906SAshok Raj int new_cpei_cpu;
595097e98b4SThomas Gleixner struct irq_data *data = NULL;
5960de26520SRusty Russell const struct cpumask *mask;
597ff741906SAshok Raj int retval = 0;
598ff741906SAshok Raj
599ff741906SAshok Raj /*
600ff741906SAshok Raj * dont permit CPEI target to removed.
601ff741906SAshok Raj */
602ff741906SAshok Raj if (cpe_vector > 0 && is_cpu_cpei_target(cpu)) {
603ff741906SAshok Raj printk ("CPU (%d) is CPEI Target\n", cpu);
604ff741906SAshok Raj if (can_cpei_retarget()) {
605ff741906SAshok Raj /*
606ff741906SAshok Raj * Now re-target the CPEI to a different processor
607ff741906SAshok Raj */
6087d7f9848SSrivatsa S. Bhat new_cpei_cpu = cpumask_any(cpu_online_mask);
6090de26520SRusty Russell mask = cpumask_of(new_cpei_cpu);
610ff741906SAshok Raj set_cpei_target_cpu(new_cpei_cpu);
611097e98b4SThomas Gleixner data = irq_get_irq_data(ia64_cpe_irq);
612ff741906SAshok Raj /*
61372fdbdceSSimon Arlott * Switch for now, immediately, we need to do fake intr
614ff741906SAshok Raj * as other interrupts, but need to study CPEI behaviour with
615ff741906SAshok Raj * polling before making changes.
616ff741906SAshok Raj */
617097e98b4SThomas Gleixner if (data && data->chip) {
618097e98b4SThomas Gleixner data->chip->irq_disable(data);
619097e98b4SThomas Gleixner data->chip->irq_set_affinity(data, mask, false);
620097e98b4SThomas Gleixner data->chip->irq_enable(data);
62125985edcSLucas De Marchi printk ("Re-targeting CPEI to cpu %d\n", new_cpei_cpu);
622ff741906SAshok Raj }
623ff741906SAshok Raj }
624097e98b4SThomas Gleixner if (!data) {
625ff741906SAshok Raj printk ("Unable to retarget CPEI, offline cpu [%d] failed\n", cpu);
626ff741906SAshok Raj retval = -EBUSY;
627ff741906SAshok Raj }
628ff741906SAshok Raj }
629ff741906SAshok Raj return retval;
630ff741906SAshok Raj }
631ff741906SAshok Raj
6321da177e4SLinus Torvalds /* must be called with cpucontrol mutex held */
__cpu_disable(void)6331da177e4SLinus Torvalds int __cpu_disable(void)
6341da177e4SLinus Torvalds {
6351da177e4SLinus Torvalds int cpu = smp_processor_id();
6361da177e4SLinus Torvalds
6371da177e4SLinus Torvalds /*
6381da177e4SLinus Torvalds * dont permit boot processor for now
6391da177e4SLinus Torvalds */
640ff741906SAshok Raj if (cpu == 0 && !bsp_remove_ok) {
641ff741906SAshok Raj printk ("Your platform does not support removal of BSP\n");
642ff741906SAshok Raj return (-EBUSY);
643ff741906SAshok Raj }
644ff741906SAshok Raj
6457d7f9848SSrivatsa S. Bhat set_cpu_online(cpu, false);
64666db2e63SAlex Chiang
647ff741906SAshok Raj if (migrate_platform_irqs(cpu)) {
6487d7f9848SSrivatsa S. Bhat set_cpu_online(cpu, true);
649c0acdea2SAlex Chiang return -EBUSY;
650ff741906SAshok Raj }
6511da177e4SLinus Torvalds
652e927ecb0SSuresh Siddha remove_siblinginfo(cpu);
65366db2e63SAlex Chiang fixup_irqs();
6541da177e4SLinus Torvalds local_flush_tlb_all();
6555d2068daSRusty Russell cpumask_clear_cpu(cpu, &cpu_callin_map);
6561da177e4SLinus Torvalds return 0;
6571da177e4SLinus Torvalds }
6581da177e4SLinus Torvalds
__cpu_die(unsigned int cpu)6591da177e4SLinus Torvalds void __cpu_die(unsigned int cpu)
6601da177e4SLinus Torvalds {
6611da177e4SLinus Torvalds unsigned int i;
6621da177e4SLinus Torvalds
6631da177e4SLinus Torvalds for (i = 0; i < 100; i++) {
6641da177e4SLinus Torvalds /* They ack this in play_dead by setting CPU_DEAD */
6651da177e4SLinus Torvalds if (per_cpu(cpu_state, cpu) == CPU_DEAD)
6661da177e4SLinus Torvalds {
667b8d8b883SAshok Raj printk ("CPU %d is now offline\n", cpu);
6681da177e4SLinus Torvalds return;
6691da177e4SLinus Torvalds }
6701da177e4SLinus Torvalds msleep(100);
6711da177e4SLinus Torvalds }
6721da177e4SLinus Torvalds printk(KERN_ERR "CPU %u didn't die...\n", cpu);
6731da177e4SLinus Torvalds }
6741da177e4SLinus Torvalds #endif /* CONFIG_HOTPLUG_CPU */
6751da177e4SLinus Torvalds
6761da177e4SLinus Torvalds void
smp_cpus_done(unsigned int dummy)6771da177e4SLinus Torvalds smp_cpus_done (unsigned int dummy)
6781da177e4SLinus Torvalds {
6791da177e4SLinus Torvalds int cpu;
6801da177e4SLinus Torvalds unsigned long bogosum = 0;
6811da177e4SLinus Torvalds
6821da177e4SLinus Torvalds /*
6831da177e4SLinus Torvalds * Allow the user to impress friends.
6841da177e4SLinus Torvalds */
6851da177e4SLinus Torvalds
686dc565b52Shawkes@sgi.com for_each_online_cpu(cpu) {
6871da177e4SLinus Torvalds bogosum += cpu_data(cpu)->loops_per_jiffy;
688dc565b52Shawkes@sgi.com }
6891da177e4SLinus Torvalds
6901da177e4SLinus Torvalds printk(KERN_INFO "Total of %d processors activated (%lu.%02lu BogoMIPS).\n",
6911da177e4SLinus Torvalds (int)num_online_cpus(), bogosum/(500000/HZ), (bogosum/(5000/HZ))%100);
6921da177e4SLinus Torvalds }
6931da177e4SLinus Torvalds
set_cpu_sibling_map(int cpu)6945b5e76e9SGreg Kroah-Hartman static inline void set_cpu_sibling_map(int cpu)
695e927ecb0SSuresh Siddha {
696e927ecb0SSuresh Siddha int i;
697e927ecb0SSuresh Siddha
698e927ecb0SSuresh Siddha for_each_online_cpu(i) {
699e927ecb0SSuresh Siddha if ((cpu_data(cpu)->socket_id == cpu_data(i)->socket_id)) {
7005d2068daSRusty Russell cpumask_set_cpu(i, &cpu_core_map[cpu]);
7015d2068daSRusty Russell cpumask_set_cpu(cpu, &cpu_core_map[i]);
702e927ecb0SSuresh Siddha if (cpu_data(cpu)->core_id == cpu_data(i)->core_id) {
7035d2068daSRusty Russell cpumask_set_cpu(i,
7045d2068daSRusty Russell &per_cpu(cpu_sibling_map, cpu));
7055d2068daSRusty Russell cpumask_set_cpu(cpu,
7065d2068daSRusty Russell &per_cpu(cpu_sibling_map, i));
707e927ecb0SSuresh Siddha }
708e927ecb0SSuresh Siddha }
709e927ecb0SSuresh Siddha }
710e927ecb0SSuresh Siddha }
711e927ecb0SSuresh Siddha
712ccce9bb8SPaul Gortmaker int
__cpu_up(unsigned int cpu,struct task_struct * tidle)7138239c25fSThomas Gleixner __cpu_up(unsigned int cpu, struct task_struct *tidle)
7141da177e4SLinus Torvalds {
7151da177e4SLinus Torvalds int ret;
7161da177e4SLinus Torvalds int sapicid;
7171da177e4SLinus Torvalds
7181da177e4SLinus Torvalds sapicid = ia64_cpu_to_sapicid[cpu];
7191da177e4SLinus Torvalds if (sapicid == -1)
7201da177e4SLinus Torvalds return -EINVAL;
7211da177e4SLinus Torvalds
7221da177e4SLinus Torvalds /*
723b8d8b883SAshok Raj * Already booted cpu? not valid anymore since we dont
724b8d8b883SAshok Raj * do idle loop tightspin anymore.
7251da177e4SLinus Torvalds */
7265d2068daSRusty Russell if (cpumask_test_cpu(cpu, &cpu_callin_map))
727b8d8b883SAshok Raj return -EINVAL;
728b8d8b883SAshok Raj
729a9fa06c2SShaohua Li per_cpu(cpu_state, cpu) = CPU_UP_PREPARE;
7301da177e4SLinus Torvalds /* Processor goes to start_secondary(), sets online flag */
73113583bf1SThomas Gleixner ret = do_boot_cpu(sapicid, cpu, tidle);
7321da177e4SLinus Torvalds if (ret < 0)
7331da177e4SLinus Torvalds return ret;
7341da177e4SLinus Torvalds
735e927ecb0SSuresh Siddha if (cpu_data(cpu)->threads_per_core == 1 &&
736e927ecb0SSuresh Siddha cpu_data(cpu)->cores_per_socket == 1) {
7375d2068daSRusty Russell cpumask_set_cpu(cpu, &per_cpu(cpu_sibling_map, cpu));
7385d2068daSRusty Russell cpumask_set_cpu(cpu, &cpu_core_map[cpu]);
739e927ecb0SSuresh Siddha return 0;
740e927ecb0SSuresh Siddha }
741e927ecb0SSuresh Siddha
742e927ecb0SSuresh Siddha set_cpu_sibling_map(cpu);
743e927ecb0SSuresh Siddha
7441da177e4SLinus Torvalds return 0;
7451da177e4SLinus Torvalds }
7461da177e4SLinus Torvalds
7471da177e4SLinus Torvalds /*
74872fdbdceSSimon Arlott * Assume that CPUs have been discovered by some platform-dependent interface. For
7491da177e4SLinus Torvalds * SoftSDV/Lion, that would be ACPI.
7501da177e4SLinus Torvalds *
7511da177e4SLinus Torvalds * Setup of the IPI irq handler is done in irq.c:init_IRQ_SMP().
7521da177e4SLinus Torvalds */
7531da177e4SLinus Torvalds void __init
init_smp_config(void)7541da177e4SLinus Torvalds init_smp_config(void)
7551da177e4SLinus Torvalds {
7561da177e4SLinus Torvalds struct fptr {
7571da177e4SLinus Torvalds unsigned long fp;
7581da177e4SLinus Torvalds unsigned long gp;
7591da177e4SLinus Torvalds } *ap_startup;
7601da177e4SLinus Torvalds long sal_ret;
7611da177e4SLinus Torvalds
76272fdbdceSSimon Arlott /* Tell SAL where to drop the APs. */
7631da177e4SLinus Torvalds ap_startup = (struct fptr *) start_ap;
7641da177e4SLinus Torvalds sal_ret = ia64_sal_set_vectors(SAL_VECTOR_OS_BOOT_RENDEZ,
7651da177e4SLinus Torvalds ia64_tpa(ap_startup->fp), ia64_tpa(ap_startup->gp), 0, 0, 0, 0);
7661da177e4SLinus Torvalds if (sal_ret < 0)
7671da177e4SLinus Torvalds printk(KERN_ERR "SMP: Can't set SAL AP Boot Rendezvous: %s\n",
7681da177e4SLinus Torvalds ia64_sal_strerror(sal_ret));
7691da177e4SLinus Torvalds }
7701da177e4SLinus Torvalds
771e927ecb0SSuresh Siddha /*
772e927ecb0SSuresh Siddha * identify_siblings(cpu) gets called from identify_cpu. This populates the
773e927ecb0SSuresh Siddha * information related to logical execution units in per_cpu_data structure.
774e927ecb0SSuresh Siddha */
identify_siblings(struct cpuinfo_ia64 * c)7755b5e76e9SGreg Kroah-Hartman void identify_siblings(struct cpuinfo_ia64 *c)
776e927ecb0SSuresh Siddha {
777e088a4adSMatthew Wilcox long status;
778e927ecb0SSuresh Siddha u16 pltid;
779e927ecb0SSuresh Siddha pal_logical_to_physical_t info;
780e927ecb0SSuresh Siddha
7816ff0bc94SAlex Chiang status = ia64_pal_logical_to_phys(-1, &info);
7826ff0bc94SAlex Chiang if (status != PAL_STATUS_SUCCESS) {
783113134fcSAlex Chiang if (status != PAL_STATUS_UNIMPLEMENTED) {
784113134fcSAlex Chiang printk(KERN_ERR
785113134fcSAlex Chiang "ia64_pal_logical_to_phys failed with %ld\n",
786e927ecb0SSuresh Siddha status);
787e927ecb0SSuresh Siddha return;
788e927ecb0SSuresh Siddha }
789113134fcSAlex Chiang
790113134fcSAlex Chiang info.overview_ppid = 0;
791113134fcSAlex Chiang info.overview_cpp = 1;
792113134fcSAlex Chiang info.overview_tpc = 1;
793113134fcSAlex Chiang }
7946ff0bc94SAlex Chiang
7956ff0bc94SAlex Chiang status = ia64_sal_physical_id_info(&pltid);
7966ff0bc94SAlex Chiang if (status != PAL_STATUS_SUCCESS) {
7976ff0bc94SAlex Chiang if (status != PAL_STATUS_UNIMPLEMENTED)
7986ff0bc94SAlex Chiang printk(KERN_ERR
7996ff0bc94SAlex Chiang "ia64_sal_pltid failed with %ld\n",
8006ff0bc94SAlex Chiang status);
801e927ecb0SSuresh Siddha return;
802e927ecb0SSuresh Siddha }
803e927ecb0SSuresh Siddha
804e927ecb0SSuresh Siddha c->socket_id = (pltid << 8) | info.overview_ppid;
805113134fcSAlex Chiang
806113134fcSAlex Chiang if (info.overview_cpp == 1 && info.overview_tpc == 1)
807113134fcSAlex Chiang return;
808113134fcSAlex Chiang
809e927ecb0SSuresh Siddha c->cores_per_socket = info.overview_cpp;
810e927ecb0SSuresh Siddha c->threads_per_core = info.overview_tpc;
8114129a953SFenghua Yu c->num_log = info.overview_num_log;
812e927ecb0SSuresh Siddha
813e927ecb0SSuresh Siddha c->core_id = info.log1_cid;
814e927ecb0SSuresh Siddha c->thread_id = info.log1_tid;
815e927ecb0SSuresh Siddha }
816dd562c05SStephane Eranian
817dd562c05SStephane Eranian /*
818dd562c05SStephane Eranian * returns non zero, if multi-threading is enabled
819dd562c05SStephane Eranian * on at least one physical package. Due to hotplug cpu
820dd562c05SStephane Eranian * and (maxcpus=), all threads may not necessarily be enabled
821dd562c05SStephane Eranian * even though the processor supports multi-threading.
822dd562c05SStephane Eranian */
is_multithreading_enabled(void)823dd562c05SStephane Eranian int is_multithreading_enabled(void)
824dd562c05SStephane Eranian {
825dd562c05SStephane Eranian int i, j;
826dd562c05SStephane Eranian
827dd562c05SStephane Eranian for_each_present_cpu(i) {
828dd562c05SStephane Eranian for_each_present_cpu(j) {
829dd562c05SStephane Eranian if (j == i)
830dd562c05SStephane Eranian continue;
831dd562c05SStephane Eranian if ((cpu_data(j)->socket_id == cpu_data(i)->socket_id)) {
832dd562c05SStephane Eranian if (cpu_data(j)->core_id == cpu_data(i)->core_id)
833dd562c05SStephane Eranian return 1;
834dd562c05SStephane Eranian }
835dd562c05SStephane Eranian }
836dd562c05SStephane Eranian }
837dd562c05SStephane Eranian return 0;
838dd562c05SStephane Eranian }
839dd562c05SStephane Eranian EXPORT_SYMBOL_GPL(is_multithreading_enabled);
840