probe_32.c 5.33 KB
Newer Older
1
/*
2 3
 * Default generic APIC driver. This handles up to 8 CPUs.
 *
4 5 6
 * Copyright 2003 Andi Kleen, SuSE Labs.
 * Subject to the GNU Public License, v.2
 *
Linus Torvalds's avatar
Linus Torvalds committed
7
 * Generic x86 APIC driver probe layer.
8
 */
Linus Torvalds's avatar
Linus Torvalds committed
9 10
#include <linux/threads.h>
#include <linux/cpumask.h>
11
#include <linux/module.h>
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15
#include <linux/string.h>
#include <linux/kernel.h>
#include <linux/ctype.h>
#include <linux/init.h>
16
#include <linux/errno.h>
Linus Torvalds's avatar
Linus Torvalds committed
17 18 19
#include <asm/fixmap.h>
#include <asm/mpspec.h>
#include <asm/apicdef.h>
Ingo Molnar's avatar
Ingo Molnar committed
20
#include <asm/apic.h>
21
#include <asm/setup.h>
Linus Torvalds's avatar
Linus Torvalds committed
22

23 24 25
#include <linux/smp.h>
#include <asm/ipi.h>

26 27 28 29 30 31 32 33 34 35 36 37
#include <linux/interrupt.h>
#include <asm/acpi.h>
#include <asm/e820.h>

#ifdef CONFIG_HOTPLUG_CPU
#define DEFAULT_SEND_IPI	(1)
#else
#define DEFAULT_SEND_IPI	(0)
#endif

int no_broadcast = DEFAULT_SEND_IPI;

38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53
static __init int no_ipi_broadcast(char *str)
{
	get_option(&str, &no_broadcast);
	pr_info("Using %s mode\n",
		no_broadcast ? "No IPI Broadcast" : "IPI Broadcast");
	return 1;
}
__setup("no_ipi_broadcast=", no_ipi_broadcast);

static int __init print_ipi_mode(void)
{
	pr_info("Using IPI %s mode\n",
		no_broadcast ? "No-Shortcut" : "Shortcut");
	return 0;
}
late_initcall(print_ipi_mode);
54

55 56 57 58 59
static int default_x86_32_early_logical_apicid(int cpu)
{
	return 1 << cpu;
}

60
static void setup_apic_flat_routing(void)
Ingo Molnar's avatar
Ingo Molnar committed
61 62 63 64 65 66 67 68
{
#ifdef CONFIG_X86_IO_APIC
	printk(KERN_INFO
		"Enabling APIC mode:  Flat.  Using %d I/O APICs\n",
		nr_ioapics);
#endif
}

69 70 71 72 73 74
/* should be called last. */
static int probe_default(void)
{
	return 1;
}

75
static struct apic apic_default = {
76 77 78 79

	.name				= "default",
	.probe				= probe_default,
	.acpi_madt_oem_check		= NULL,
80
	.apic_id_valid			= default_apic_id_valid,
81 82 83 84 85 86 87 88 89 90 91
	.apic_id_registered		= default_apic_id_registered,

	.irq_delivery_mode		= dest_LowestPrio,
	/* logical delivery broadcast to all CPUs: */
	.irq_dest_mode			= 1,

	.target_cpus			= default_target_cpus,
	.disable_esr			= 0,
	.dest_logical			= APIC_DEST_LOGICAL,
	.check_apicid_used		= default_check_apicid_used,

92
	.vector_allocation_domain	= flat_vector_allocation_domain,
93 94 95
	.init_apic_ldr			= default_init_apic_ldr,

	.ioapic_phys_id_map		= default_ioapic_phys_id_map,
96
	.setup_apic_routing		= setup_apic_flat_routing,
97
	.cpu_present_to_apicid		= default_cpu_present_to_apicid,
98
	.apicid_to_cpu_present		= physid_set_mask_of_physid,
99 100 101 102 103 104 105
	.check_phys_apicid_present	= default_check_phys_apicid_present,
	.phys_pkg_id			= default_phys_pkg_id,

	.get_apic_id			= default_get_apic_id,
	.set_apic_id			= NULL,
	.apic_id_mask			= 0x0F << 24,

106
	.cpu_mask_to_apicid_and		= flat_cpu_mask_to_apicid_and,
107

108
	.send_IPI			= default_send_IPI_single,
109 110
	.send_IPI_mask			= default_send_IPI_mask_logical,
	.send_IPI_mask_allbutself	= default_send_IPI_mask_allbutself_logical,
111 112
	.send_IPI_allbutself		= default_send_IPI_allbutself,
	.send_IPI_all			= default_send_IPI_all,
113
	.send_IPI_self			= default_send_IPI_self,
114 115

	.inquire_remote_apic		= default_inquire_remote_apic,
Yinghai Lu's avatar
Yinghai Lu committed
116 117 118

	.read				= native_apic_mem_read,
	.write				= native_apic_mem_write,
119
	.eoi_write			= native_apic_mem_write,
Yinghai Lu's avatar
Yinghai Lu committed
120 121 122 123
	.icr_read			= native_apic_icr_read,
	.icr_write			= native_apic_icr_write,
	.wait_icr_idle			= native_apic_wait_icr_idle,
	.safe_wait_icr_idle		= native_safe_apic_wait_icr_idle,
124

125
	.x86_32_early_logical_apicid	= default_x86_32_early_logical_apicid,
126 127
};

128 129
apic_driver(apic_default);

130
struct apic *apic = &apic_default;
131
EXPORT_SYMBOL_GPL(apic);
Linus Torvalds's avatar
Linus Torvalds committed
132

133 134 135
static int cmdline_apic __initdata;
static int __init parse_apic(char *arg)
{
136
	struct apic **drv;
137 138 139 140

	if (!arg)
		return -EINVAL;

141 142 143
	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
		if (!strcmp((*drv)->name, arg)) {
			apic = *drv;
144 145 146 147
			cmdline_apic = 1;
			return 0;
		}
	}
148 149 150

	/* Parsed again by __setup for debug/verbose */
	return 0;
151 152
}
early_param("apic", parse_apic);
153

154
void __init default_setup_apic_routing(void)
155
{
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170
	int version = apic_version[boot_cpu_physical_apicid];

	if (num_possible_cpus() > 8) {
		switch (boot_cpu_data.x86_vendor) {
		case X86_VENDOR_INTEL:
			if (!APIC_XAPIC(version)) {
				def_to_bigsmp = 0;
				break;
			}
			/* If P4 and above fall through */
		case X86_VENDOR_AMD:
			def_to_bigsmp = 1;
		}
	}

171
#ifdef CONFIG_X86_BIGSMP
172
	/*
173
	 * This is used to switch to bigsmp mode when
174
	 * - There is no apic= option specified by the user
Simon Arlott's avatar
Simon Arlott committed
175
	 * - generic_apic_probe() has chosen apic_default as the sub_arch
176 177 178
	 * - we find more than 8 CPUs in acpi LAPIC listing with xAPIC support
	 */

179 180
	if (!cmdline_apic && apic == &apic_default)
		generic_bigsmp_probe();
181
#endif
182 183 184

	if (apic->setup_apic_routing)
		apic->setup_apic_routing();
185 186 187

	if (x86_platform.apic_post_init)
		x86_platform.apic_post_init();
188 189
}

190
void __init generic_apic_probe(void)
191
{
192
	if (!cmdline_apic) {
193 194 195 196 197
		struct apic **drv;

		for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
			if ((*drv)->probe()) {
				apic = *drv;
198
				break;
Linus Torvalds's avatar
Linus Torvalds committed
199 200
			}
		}
201
		/* Not visible without early console */
202
		if (drv == __apicdrivers_end)
203
			panic("Didn't find an APIC driver");
Linus Torvalds's avatar
Linus Torvalds committed
204
	}
Ingo Molnar's avatar
Ingo Molnar committed
205
	printk(KERN_INFO "Using APIC driver %s\n", apic->name);
206
}
Linus Torvalds's avatar
Linus Torvalds committed
207

208
/* This function can switch the APIC even after the initial ->probe() */
209
int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
Linus Torvalds's avatar
Linus Torvalds committed
210
{
211
	struct apic **drv;
212

213 214
	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
		if (!(*drv)->acpi_madt_oem_check)
215
			continue;
216
		if (!(*drv)->acpi_madt_oem_check(oem_id, oem_table_id))
217 218 219
			continue;

		if (!cmdline_apic) {
220
			apic = *drv;
221 222
			printk(KERN_INFO "Switched to APIC driver `%s'.\n",
			       apic->name);
223
		}
224
		return 1;
225 226
	}
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
227
}