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

 
  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
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 69/* should be called last. */
 70static int probe_default(void)
 71{
 72	return 1;
 73}
 74
 75static struct apic apic_default = {
 76
 77	.name				= "default",
 78	.probe				= probe_default,
 79	.acpi_madt_oem_check		= NULL,
 80	.apic_id_valid			= default_apic_id_valid,
 81	.apic_id_registered		= default_apic_id_registered,
 82
 83	.irq_delivery_mode		= dest_LowestPrio,
 84	/* logical delivery broadcast to all CPUs: */
 85	.irq_dest_mode			= 1,
 86
 87	.target_cpus			= default_target_cpus,
 88	.disable_esr			= 0,
 89	.dest_logical			= APIC_DEST_LOGICAL,
 90	.check_apicid_used		= default_check_apicid_used,
 91	.check_apicid_present		= default_check_apicid_present,
 92
 93	.vector_allocation_domain	= flat_vector_allocation_domain,
 94	.init_apic_ldr			= default_init_apic_ldr,
 95
 96	.ioapic_phys_id_map		= default_ioapic_phys_id_map,
 97	.setup_apic_routing		= setup_apic_flat_routing,
 98	.multi_timer_check		= NULL,
 99	.cpu_present_to_apicid		= default_cpu_present_to_apicid,
100	.apicid_to_cpu_present		= physid_set_mask_of_physid,
101	.setup_portio_remap		= NULL,
102	.check_phys_apicid_present	= default_check_phys_apicid_present,
103	.enable_apic_mode		= NULL,
104	.phys_pkg_id			= default_phys_pkg_id,
105	.mps_oem_check			= NULL,
106
107	.get_apic_id			= default_get_apic_id,
108	.set_apic_id			= NULL,
109	.apic_id_mask			= 0x0F << 24,
110
111	.cpu_mask_to_apicid_and		= flat_cpu_mask_to_apicid_and,
112
 
113	.send_IPI_mask			= default_send_IPI_mask_logical,
114	.send_IPI_mask_allbutself	= default_send_IPI_mask_allbutself_logical,
115	.send_IPI_allbutself		= default_send_IPI_allbutself,
116	.send_IPI_all			= default_send_IPI_all,
117	.send_IPI_self			= default_send_IPI_self,
118
119	.trampoline_phys_low		= DEFAULT_TRAMPOLINE_PHYS_LOW,
120	.trampoline_phys_high		= DEFAULT_TRAMPOLINE_PHYS_HIGH,
121
122	.wait_for_init_deassert		= true,
123	.smp_callin_clear_local_apic	= NULL,
124	.inquire_remote_apic		= default_inquire_remote_apic,
125
126	.read				= native_apic_mem_read,
127	.write				= native_apic_mem_write,
128	.eoi_write			= native_apic_mem_write,
129	.icr_read			= native_apic_icr_read,
130	.icr_write			= native_apic_icr_write,
131	.wait_icr_idle			= native_apic_wait_icr_idle,
132	.safe_wait_icr_idle		= native_safe_apic_wait_icr_idle,
133
134	.x86_32_early_logical_apicid	= default_x86_32_early_logical_apicid,
135};
136
137apic_driver(apic_default);
138
139struct apic *apic = &apic_default;
140EXPORT_SYMBOL_GPL(apic);
141
142static int cmdline_apic __initdata;
143static int __init parse_apic(char *arg)
144{
145	struct apic **drv;
146
147	if (!arg)
148		return -EINVAL;
149
150	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
151		if (!strcmp((*drv)->name, arg)) {
152			apic = *drv;
153			cmdline_apic = 1;
154			return 0;
155		}
156	}
157
158	/* Parsed again by __setup for debug/verbose */
159	return 0;
160}
161early_param("apic", parse_apic);
162
163void __init default_setup_apic_routing(void)
164{
165	int version = apic_version[boot_cpu_physical_apicid];
166
167	if (num_possible_cpus() > 8) {
168		switch (boot_cpu_data.x86_vendor) {
169		case X86_VENDOR_INTEL:
170			if (!APIC_XAPIC(version)) {
171				def_to_bigsmp = 0;
172				break;
173			}
174			/* If P4 and above fall through */
 
 
175		case X86_VENDOR_AMD:
176			def_to_bigsmp = 1;
177		}
178	}
179
180#ifdef CONFIG_X86_BIGSMP
181	/*
182	 * This is used to switch to bigsmp mode when
183	 * - There is no apic= option specified by the user
184	 * - generic_apic_probe() has chosen apic_default as the sub_arch
185	 * - we find more than 8 CPUs in acpi LAPIC listing with xAPIC support
186	 */
187
188	if (!cmdline_apic && apic == &apic_default)
189		generic_bigsmp_probe();
190#endif
191
192	if (apic->setup_apic_routing)
193		apic->setup_apic_routing();
194
195	if (x86_platform.apic_post_init)
196		x86_platform.apic_post_init();
197}
198
199void __init generic_apic_probe(void)
200{
201	if (!cmdline_apic) {
202		struct apic **drv;
203
204		for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
205			if ((*drv)->probe()) {
206				apic = *drv;
207				break;
208			}
209		}
210		/* Not visible without early console */
211		if (drv == __apicdrivers_end)
212			panic("Didn't find an APIC driver");
213	}
214	printk(KERN_INFO "Using APIC driver %s\n", apic->name);
215}
216
217/* These functions can switch the APIC even after the initial ->probe() */
218
219int __init
220generic_mps_oem_check(struct mpc_table *mpc, char *oem, char *productid)
221{
222	struct apic **drv;
223
224	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
225		if (!((*drv)->mps_oem_check))
226			continue;
227		if (!(*drv)->mps_oem_check(mpc, oem, productid))
228			continue;
229
230		if (!cmdline_apic) {
231			apic = *drv;
232			printk(KERN_INFO "Switched to APIC driver `%s'.\n",
233			       apic->name);
234		}
235		return 1;
236	}
237	return 0;
238}
239
240int __init default_acpi_madt_oem_check(char *oem_id, char *oem_table_id)
241{
242	struct apic **drv;
243
244	for (drv = __apicdrivers; drv < __apicdrivers_end; drv++) {
245		if (!(*drv)->acpi_madt_oem_check)
246			continue;
247		if (!(*drv)->acpi_madt_oem_check(oem_id, oem_table_id))
248			continue;
249
250		if (!cmdline_apic) {
251			apic = *drv;
252			printk(KERN_INFO "Switched to APIC driver `%s'.\n",
253			       apic->name);
254		}
255		return 1;
256	}
257	return 0;
258}