1/*
  2 * Default generic APIC driver. This handles up to 8 CPUs.
  3 *
  4 * Copyright 2003 Andi Kleen, SuSE Labs.
  5 * Subject to the GNU Public License, v.2
  6 *
  7 * Generic x86 APIC driver probe layer.
  8 */
  9#include <linux/threads.h>
 10#include <linux/cpumask.h>
 11#include <linux/export.h>
 12#include <linux/string.h>
 13#include <linux/kernel.h>
 14#include <linux/ctype.h>
 15#include <linux/init.h>
 16#include <linux/errno.h>
 17#include <asm/fixmap.h>
 18#include <asm/mpspec.h>
 19#include <asm/apicdef.h>
 20#include <asm/apic.h>
 21#include <asm/setup.h>
 22
 23#include <linux/smp.h>
 24#include <asm/ipi.h>
 25
 26#include <linux/interrupt.h>
 27#include <asm/acpi.h>
 28#include <asm/e820/api.h>
 29
 30#ifdef CONFIG_HOTPLUG_CPU
 31#define DEFAULT_SEND_IPI	(1)
 32#else
 33#define DEFAULT_SEND_IPI	(0)
 34#endif
 35
 36int no_broadcast = DEFAULT_SEND_IPI;
 37
 38static __init int no_ipi_broadcast(char *str)
 39{
 40	get_option(&str, &no_broadcast);
 41	pr_info("Using %s mode\n",
 42		no_broadcast ? "No IPI Broadcast" : "IPI Broadcast");
 43	return 1;
 44}
 45__setup("no_ipi_broadcast=", no_ipi_broadcast);
 46
 47static int __init print_ipi_mode(void)
 48{
 49	pr_info("Using IPI %s mode\n",
 50		no_broadcast ? "No-Shortcut" : "Shortcut");
 51	return 0;
 52}
 53late_initcall(print_ipi_mode);
 54
 55static int default_x86_32_early_logical_apicid(int cpu)
 56{
 57	return 1 << cpu;
 58}
 59
 60static void setup_apic_flat_routing(void)
 61{
 62#ifdef CONFIG_X86_IO_APIC
 63	printk(KERN_INFO
 64		"Enabling APIC mode:  Flat.  Using %d I/O APICs\n",
 65		nr_ioapics);
 66#endif
 67}
 68
 69static int default_apic_id_registered(void)
 70{
 71	return physid_isset(read_apic_id(), phys_cpu_present_map);
 72}
 73
 74/*
 75 * Set up the logical destination ID.  Intel recommends to set DFR, LDR and
 76 * TPR before enabling an APIC.  See e.g. "AP-388 82489DX User's Manual"
 77 * (Intel document number 292116).
 78 */
 79static void default_init_apic_ldr(void)
 80{
 81	unsigned long val;
 82
 83	apic_write(APIC_DFR, APIC_DFR_VALUE);
 84	val = apic_read(APIC_LDR) & ~APIC_LDR_MASK;
 85	val |= SET_APIC_LOGICAL_ID(1UL << smp_processor_id());
 86	apic_write(APIC_LDR, val);
 87}
 88
 89static int default_phys_pkg_id(int cpuid_apic, int index_msb)
 90{
 91	return cpuid_apic >> index_msb;
 92}
 93
 94/* should be called last. */
 95static int probe_default(void)
 96{
 97	return 1;
 98}
 99
100static struct apic apic_default __ro_after_init = {
101
102	.name				= "default",
103	.probe				= probe_default,
104	.acpi_madt_oem_check		= NULL,
105	.apic_id_valid			= default_apic_id_valid,
106	.apic_id_registered		= default_apic_id_registered,
107
108	.irq_delivery_mode		= dest_Fixed,
109	/* logical delivery broadcast to all CPUs: */
110	.irq_dest_mode			= 1,
111
 
112	.disable_esr			= 0,
113	.dest_logical			= APIC_DEST_LOGICAL,
114	.check_apicid_used		= default_check_apicid_used,
 
115
 
116	.init_apic_ldr			= default_init_apic_ldr,
117
118	.ioapic_phys_id_map		= default_ioapic_phys_id_map,
119	.setup_apic_routing		= setup_apic_flat_routing,
 
120	.cpu_present_to_apicid		= default_cpu_present_to_apicid,
121	.apicid_to_cpu_present		= physid_set_mask_of_physid,
 
122	.check_phys_apicid_present	= default_check_phys_apicid_present,
 
123	.phys_pkg_id			= default_phys_pkg_id,
 
124
125	.get_apic_id			= default_get_apic_id,
126	.set_apic_id			= NULL,
 
127
128	.calc_dest_apicid		= apic_flat_calc_apicid,
 
129
130	.send_IPI			= default_send_IPI_single,
131	.send_IPI_mask			= default_send_IPI_mask_logical,
132	.send_IPI_mask_allbutself	= default_send_IPI_mask_allbutself_logical,
133	.send_IPI_allbutself		= default_send_IPI_allbutself,
134	.send_IPI_all			= default_send_IPI_all,
135	.send_IPI_self			= default_send_IPI_self,
136
 
 
 
 
 
 
137	.inquire_remote_apic		= default_inquire_remote_apic,
138
139	.read				= native_apic_mem_read,
140	.write				= native_apic_mem_write,
141	.eoi_write			= native_apic_mem_write,
142	.icr_read			= native_apic_icr_read,
143	.icr_write			= native_apic_icr_write,
144	.wait_icr_idle			= native_apic_wait_icr_idle,
145	.safe_wait_icr_idle		= native_safe_apic_wait_icr_idle,
146
147	.x86_32_early_logical_apicid	= default_x86_32_early_logical_apicid,
148};
149
150apic_driver(apic_default);
151
152struct apic *apic __ro_after_init = &apic_default;
153EXPORT_SYMBOL_GPL(apic);
154
155static int cmdline_apic __initdata;
156static int __init parse_apic(char *arg)
157{
158	struct apic **drv;
159
160	if (!arg)
161		return -EINVAL;
162
163	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
164		if (!strcmp((*drv)->name, arg)) {
165			apic = *drv;
166			cmdline_apic = 1;
167			return 0;
168		}
169	}
170
171	/* Parsed again by __setup for debug/verbose */
172	return 0;
173}
174early_param("apic", parse_apic);
175
176void __init default_setup_apic_routing(void)
177{
178	int version = boot_cpu_apic_version;
179
180	if (num_possible_cpus() > 8) {
181		switch (boot_cpu_data.x86_vendor) {
182		case X86_VENDOR_INTEL:
183			if (!APIC_XAPIC(version)) {
184				def_to_bigsmp = 0;
185				break;
186			}
187			/* If P4 and above fall through */
188		case X86_VENDOR_AMD:
189			def_to_bigsmp = 1;
190		}
191	}
192
193#ifdef CONFIG_X86_BIGSMP
194	/*
195	 * This is used to switch to bigsmp mode when
196	 * - There is no apic= option specified by the user
197	 * - generic_apic_probe() has chosen apic_default as the sub_arch
198	 * - we find more than 8 CPUs in acpi LAPIC listing with xAPIC support
199	 */
200
201	if (!cmdline_apic && apic == &apic_default)
202		generic_bigsmp_probe();
203#endif
204
205	if (apic->setup_apic_routing)
206		apic->setup_apic_routing();
207
208	if (x86_platform.apic_post_init)
209		x86_platform.apic_post_init();
210}
211
212void __init generic_apic_probe(void)
213{
214	if (!cmdline_apic) {
215		struct apic **drv;
216
217		for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
218			if ((*drv)->probe()) {
219				apic = *drv;
220				break;
221			}
222		}
223		/* Not visible without early console */
224		if (drv == __apicdrivers_end)
225			panic("Didn't find an APIC driver");
226	}
227	printk(KERN_INFO "Using APIC driver %s\n", apic->name);
228}
229
230/* This function can switch the APIC even after the initial ->probe() */
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
231int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
232{
233	struct apic **drv;
234
235	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
236		if (!(*drv)->acpi_madt_oem_check)
237			continue;
238		if (!(*drv)->acpi_madt_oem_check(oem_id, oem_table_id))
239			continue;
240
241		if (!cmdline_apic) {
242			apic = *drv;
243			printk(KERN_INFO "Switched to APIC driver `%s'.\n",
244			       apic->name);
245		}
246		return 1;
247	}
248	return 0;
249}

  1/*
  2 * Default generic APIC driver. This handles up to 8 CPUs.
  3 *
  4 * Copyright 2003 Andi Kleen, SuSE Labs.
  5 * Subject to the GNU Public License, v.2
  6 *
  7 * Generic x86 APIC driver probe layer.
  8 */
  9#include <linux/threads.h>
 10#include <linux/cpumask.h>
 11#include <linux/module.h>
 12#include <linux/string.h>
 13#include <linux/kernel.h>
 14#include <linux/ctype.h>
 15#include <linux/init.h>
 16#include <linux/errno.h>
 17#include <asm/fixmap.h>
 18#include <asm/mpspec.h>
 19#include <asm/apicdef.h>
 20#include <asm/apic.h>
 21#include <asm/setup.h>
 22
 23#include <linux/smp.h>
 24#include <asm/ipi.h>
 25
 26#include <linux/interrupt.h>
 27#include <asm/acpi.h>
 28#include <asm/e820.h>
 29
 30#ifdef CONFIG_HOTPLUG_CPU
 31#define DEFAULT_SEND_IPI	(1)
 32#else
 33#define DEFAULT_SEND_IPI	(0)
 34#endif
 35
 36int no_broadcast = DEFAULT_SEND_IPI;
 37
 38static __init int no_ipi_broadcast(char *str)
 39{
 40	get_option(&str, &no_broadcast);
 41	pr_info("Using %s mode\n",
 42		no_broadcast ? "No IPI Broadcast" : "IPI Broadcast");
 43	return 1;
 44}
 45__setup("no_ipi_broadcast=", no_ipi_broadcast);
 46
 47static int __init print_ipi_mode(void)
 48{
 49	pr_info("Using IPI %s mode\n",
 50		no_broadcast ? "No-Shortcut" : "Shortcut");
 51	return 0;
 52}
 53late_initcall(print_ipi_mode);
 54
 55static int default_x86_32_early_logical_apicid(int cpu)
 56{
 57	return 1 << cpu;
 58}
 59
 60static void setup_apic_flat_routing(void)
 61{
 62#ifdef CONFIG_X86_IO_APIC
 63	printk(KERN_INFO
 64		"Enabling APIC mode:  Flat.  Using %d I/O APICs\n",
 65		nr_ioapics);
 66#endif
 67}
 68
 69static void default_vector_allocation_domain(int cpu, struct cpumask *retmask)
 70{
 71	/*
 72	 * Careful. Some cpus do not strictly honor the set of cpus
 73	 * specified in the interrupt destination when using lowest
 74	 * priority interrupt delivery mode.
 75	 *
 76	 * In particular there was a hyperthreading cpu observed to
 77	 * deliver interrupts to the wrong hyperthread when only one
 78	 * hyperthread was specified in the interrupt desitination.
 79	 */
 80	cpumask_clear(retmask);
 81	cpumask_bits(retmask)[0] = APIC_ALL_CPUS;
 
 
 
 
 
 
 
 
 
 
 82}
 83
 84/* should be called last. */
 85static int probe_default(void)
 86{
 87	return 1;
 88}
 89
 90static struct apic apic_default = {
 91
 92	.name				= "default",
 93	.probe				= probe_default,
 94	.acpi_madt_oem_check		= NULL,
 95	.apic_id_valid			= default_apic_id_valid,
 96	.apic_id_registered		= default_apic_id_registered,
 97
 98	.irq_delivery_mode		= dest_LowestPrio,
 99	/* logical delivery broadcast to all CPUs: */
100	.irq_dest_mode			= 1,
101
102	.target_cpus			= default_target_cpus,
103	.disable_esr			= 0,
104	.dest_logical			= APIC_DEST_LOGICAL,
105	.check_apicid_used		= default_check_apicid_used,
106	.check_apicid_present		= default_check_apicid_present,
107
108	.vector_allocation_domain	= default_vector_allocation_domain,
109	.init_apic_ldr			= default_init_apic_ldr,
110
111	.ioapic_phys_id_map		= default_ioapic_phys_id_map,
112	.setup_apic_routing		= setup_apic_flat_routing,
113	.multi_timer_check		= NULL,
114	.cpu_present_to_apicid		= default_cpu_present_to_apicid,
115	.apicid_to_cpu_present		= physid_set_mask_of_physid,
116	.setup_portio_remap		= NULL,
117	.check_phys_apicid_present	= default_check_phys_apicid_present,
118	.enable_apic_mode		= NULL,
119	.phys_pkg_id			= default_phys_pkg_id,
120	.mps_oem_check			= NULL,
121
122	.get_apic_id			= default_get_apic_id,
123	.set_apic_id			= NULL,
124	.apic_id_mask			= 0x0F << 24,
125
126	.cpu_mask_to_apicid		= default_cpu_mask_to_apicid,
127	.cpu_mask_to_apicid_and		= default_cpu_mask_to_apicid_and,
128
 
129	.send_IPI_mask			= default_send_IPI_mask_logical,
130	.send_IPI_mask_allbutself	= default_send_IPI_mask_allbutself_logical,
131	.send_IPI_allbutself		= default_send_IPI_allbutself,
132	.send_IPI_all			= default_send_IPI_all,
133	.send_IPI_self			= default_send_IPI_self,
134
135	.trampoline_phys_low		= DEFAULT_TRAMPOLINE_PHYS_LOW,
136	.trampoline_phys_high		= DEFAULT_TRAMPOLINE_PHYS_HIGH,
137
138	.wait_for_init_deassert		= default_wait_for_init_deassert,
139
140	.smp_callin_clear_local_apic	= NULL,
141	.inquire_remote_apic		= default_inquire_remote_apic,
142
143	.read				= native_apic_mem_read,
144	.write				= native_apic_mem_write,
145	.eoi_write			= native_apic_mem_write,
146	.icr_read			= native_apic_icr_read,
147	.icr_write			= native_apic_icr_write,
148	.wait_icr_idle			= native_apic_wait_icr_idle,
149	.safe_wait_icr_idle		= native_safe_apic_wait_icr_idle,
150
151	.x86_32_early_logical_apicid	= default_x86_32_early_logical_apicid,
152};
153
154apic_driver(apic_default);
155
156struct apic *apic = &apic_default;
157EXPORT_SYMBOL_GPL(apic);
158
159static int cmdline_apic __initdata;
160static int __init parse_apic(char *arg)
161{
162	struct apic **drv;
163
164	if (!arg)
165		return -EINVAL;
166
167	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
168		if (!strcmp((*drv)->name, arg)) {
169			apic = *drv;
170			cmdline_apic = 1;
171			return 0;
172		}
173	}
174
175	/* Parsed again by __setup for debug/verbose */
176	return 0;
177}
178early_param("apic", parse_apic);
179
180void __init default_setup_apic_routing(void)
181{
182	int version = apic_version[boot_cpu_physical_apicid];
183
184	if (num_possible_cpus() > 8) {
185		switch (boot_cpu_data.x86_vendor) {
186		case X86_VENDOR_INTEL:
187			if (!APIC_XAPIC(version)) {
188				def_to_bigsmp = 0;
189				break;
190			}
191			/* If P4 and above fall through */
192		case X86_VENDOR_AMD:
193			def_to_bigsmp = 1;
194		}
195	}
196
197#ifdef CONFIG_X86_BIGSMP
198	/*
199	 * This is used to switch to bigsmp mode when
200	 * - There is no apic= option specified by the user
201	 * - generic_apic_probe() has chosen apic_default as the sub_arch
202	 * - we find more than 8 CPUs in acpi LAPIC listing with xAPIC support
203	 */
204
205	if (!cmdline_apic && apic == &apic_default)
206		generic_bigsmp_probe();
207#endif
208
209	if (apic->setup_apic_routing)
210		apic->setup_apic_routing();
 
 
 
211}
212
213void __init generic_apic_probe(void)
214{
215	if (!cmdline_apic) {
216		struct apic **drv;
217
218		for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
219			if ((*drv)->probe()) {
220				apic = *drv;
221				break;
222			}
223		}
224		/* Not visible without early console */
225		if (drv == __apicdrivers_end)
226			panic("Didn't find an APIC driver");
227	}
228	printk(KERN_INFO "Using APIC driver %s\n", apic->name);
229}
230
231/* These functions can switch the APIC even after the initial ->probe() */
232
233int __init
234generic_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
235{
236	struct apic **drv;
237
238	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
239		if (!((*drv)->mps_oem_check))
240			continue;
241		if (!(*drv)->mps_oem_check(mpc, oem, productid))
242			continue;
243
244		if (!cmdline_apic) {
245			apic = *drv;
246			printk(KERN_INFO "Switched to APIC driver `%s'.\n",
247			       apic->name);
248		}
249		return 1;
250	}
251	return 0;
252}
253
254int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
255{
256	struct apic **drv;
257
258	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
259		if (!(*drv)->acpi_madt_oem_check)
260			continue;
261		if (!(*drv)->acpi_madt_oem_check(oem_id, oem_table_id))
262			continue;
263
264		if (!cmdline_apic) {
265			apic = *drv;
266			printk(KERN_INFO "Switched to APIC driver `%s'.\n",
267			       apic->name);
268		}
269		return 1;
270	}
271	return 0;
272}