[linux-2.6-block.git] / arch / arm64 / kernel / acpi.c

/*
 *  ARM64 Specific Low-Level ACPI Boot Support
 *
 *  Copyright (C) 2013-2014, Linaro Ltd.
 *	Author: Al Stone <al.stone@linaro.org>
 *	Author: Graeme Gregory <graeme.gregory@linaro.org>
 *	Author: Hanjun Guo <hanjun.guo@linaro.org>
 *	Author: Tomasz Nowicki <tomasz.nowicki@linaro.org>
 *	Author: Naresh Bhat <naresh.bhat@linaro.org>
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License version 2 as
 *  published by the Free Software Foundation.
 */

#define pr_fmt(fmt) "ACPI: " fmt

#include <linux/acpi.h>
#include <linux/bootmem.h>
#include <linux/cpumask.h>
#include <linux/init.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/memblock.h>
#include <linux/of_fdt.h>
#include <linux/smp.h>

#include <asm/cputype.h>
#include <asm/cpu_ops.h>
#include <asm/smp_plat.h>

int acpi_noirq = 1;		/* skip ACPI IRQ initialization */
int acpi_disabled = 1;
EXPORT_SYMBOL(acpi_disabled);

int acpi_pci_disabled = 1;	/* skip ACPI PCI scan and IRQ initialization */
EXPORT_SYMBOL(acpi_pci_disabled);

/* Processors with enabled flag and sane MPIDR */
static int enabled_cpus;

/* Boot CPU is valid or not in MADT */
static bool bootcpu_valid  __initdata;

static bool param_acpi_off __initdata;
bool param_acpi_force __initdata;

static int __init parse_acpi(char *arg)
{
	if (!arg)
		return -EINVAL;

	/* "acpi=off" disables both ACPI table parsing and interpreter */
	if (strcmp(arg, "off") == 0)
		param_acpi_off = true;
	else if (strcmp(arg, "force") == 0) /* force ACPI to be enabled */
		param_acpi_force = true;
	else
		return -EINVAL;	/* Core will print when we return error */

	return 0;
}
early_param("acpi", parse_acpi);

static int __init dt_scan_depth1_nodes(unsigned long node,
				       const char *uname, int depth,
				       void *data)
{
	/*
	 * Return 1 as soon as we encounter a node at depth 1 that is
	 * not the /chosen node.
	 */
	if (depth == 1 && (strcmp(uname, "chosen") != 0))
		return 1;
	return 0;
}

/*
 * __acpi_map_table() will be called before page_init(), so early_ioremap()
 * or early_memremap() should be called here to for ACPI table mapping.
 */
char *__init __acpi_map_table(unsigned long phys, unsigned long size)
{
	if (!size)
		return NULL;

	return early_memremap(phys, size);
}

void __init __acpi_unmap_table(char *map, unsigned long size)
{
	if (!map || !size)
		return;

	early_memunmap(map, size);
}

/**
 * acpi_map_gic_cpu_interface - generates a logical cpu number
 * and map to MPIDR represented by GICC structure
 * @mpidr: CPU's hardware id to register, MPIDR represented in MADT
 * @enabled: this cpu is enabled or not
 *
 * Returns the logical cpu number which maps to MPIDR
 */
static int __init acpi_map_gic_cpu_interface(u64 mpidr, u8 enabled)
{
	int i;

	if (mpidr == INVALID_HWID) {
		pr_info("Skip MADT cpu entry with invalid MPIDR\n");
		return -EINVAL;
	}

	total_cpus++;
	if (!enabled)
		return -EINVAL;

	if (enabled_cpus >=  NR_CPUS) {
		pr_warn("NR_CPUS limit of %d reached, Processor %d/0x%llx ignored.\n",
			NR_CPUS, total_cpus, mpidr);
		return -EINVAL;
	}

	/* Check if GICC structure of boot CPU is available in the MADT */
	if (cpu_logical_map(0) == mpidr) {
		if (bootcpu_valid) {
			pr_err("Firmware bug, duplicate CPU MPIDR: 0x%llx in MADT\n",
			       mpidr);
			return -EINVAL;
		}

		bootcpu_valid = true;
	}

	/*
	 * Duplicate MPIDRs are a recipe for disaster. Scan
	 * all initialized entries and check for
	 * duplicates. If any is found just ignore the CPU.
	 */
	for (i = 1; i < enabled_cpus; i++) {
		if (cpu_logical_map(i) == mpidr) {
			pr_err("Firmware bug, duplicate CPU MPIDR: 0x%llx in MADT\n",
			       mpidr);
			return -EINVAL;
		}
	}

	if (!acpi_psci_present())
		return -EOPNOTSUPP;

	cpu_ops[enabled_cpus] = cpu_get_ops("psci");
	/* CPU 0 was already initialized */
	if (enabled_cpus) {
		if (!cpu_ops[enabled_cpus])
			return -EINVAL;

		if (cpu_ops[enabled_cpus]->cpu_init(NULL, enabled_cpus))
			return -EOPNOTSUPP;

		/* map the logical cpu id to cpu MPIDR */
		cpu_logical_map(enabled_cpus) = mpidr;
	}

	enabled_cpus++;
	return enabled_cpus;
}

static int __init
acpi_parse_gic_cpu_interface(struct acpi_subtable_header *header,
				const unsigned long end)
{
	struct acpi_madt_generic_interrupt *processor;

	processor = (struct acpi_madt_generic_interrupt *)header;

	if (BAD_MADT_ENTRY(processor, end))
		return -EINVAL;

	acpi_table_print_madt_entry(header);

	acpi_map_gic_cpu_interface(processor->arm_mpidr & MPIDR_HWID_BITMASK,
		processor->flags & ACPI_MADT_ENABLED);

	return 0;
}

/* Parse GIC cpu interface entries in MADT for SMP init */
void __init acpi_init_cpus(void)
{
	int count, i;

	/*
	 * do a partial walk of MADT to determine how many CPUs
	 * we have including disabled CPUs, and get information
	 * we need for SMP init
	 */
	count = acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT,
			acpi_parse_gic_cpu_interface, 0);

	if (!count) {
		pr_err("No GIC CPU interface entries present\n");
		return;
	} else if (count < 0) {
		pr_err("Error parsing GIC CPU interface entry\n");
		return;
	}

	if (!bootcpu_valid) {
		pr_err("MADT missing boot CPU MPIDR, not enabling secondaries\n");
		return;
	}

	for (i = 0; i < enabled_cpus; i++)
		set_cpu_possible(i, true);

	/* Make boot-up look pretty */
	pr_info("%d CPUs enabled, %d CPUs total\n", enabled_cpus, total_cpus);
}

static int __init acpi_parse_fadt(struct acpi_table_header *table)
{
	struct acpi_table_fadt *fadt = (struct acpi_table_fadt *)table;

	/*
	 * Revision in table header is the FADT Major revision, and there
	 * is a minor revision of FADT which was introduced by ACPI 5.1,
	 * we only deal with ACPI 5.1 or newer revision to get GIC and SMP
	 * boot protocol configuration data, or we will disable ACPI.
	 */
	if (table->revision > 5 ||
	    (table->revision == 5 && fadt->minor_revision >= 1)) {
		if (!acpi_gbl_reduced_hardware) {
			pr_err("Not hardware reduced ACPI mode, will not be supported\n");
			goto disable_acpi;
		}

		/*
		 * ACPI 5.1 only has two explicit methods to boot up SMP,
		 * PSCI and Parking protocol, but the Parking protocol is
		 * only specified for ARMv7 now, so make PSCI as the only
		 * way for the SMP boot protocol before some updates for
		 * the Parking protocol spec.
		 */
		if (acpi_psci_present())
			return 0;

		pr_warn("No PSCI support, will not bring up secondary CPUs\n");
		return -EOPNOTSUPP;
	}

	pr_warn("Unsupported FADT revision %d.%d, should be 5.1+, will disable ACPI\n",
		table->revision, fadt->minor_revision);

disable_acpi:
	disable_acpi();
	return -EINVAL;
}

/*
 * acpi_boot_table_init() called from setup_arch(), always.
 *	1. find RSDP and get its address, and then find XSDT
 *	2. extract all tables and checksums them all
 *	3. check ACPI FADT revision
 *
 * We can parse ACPI boot-time tables such as MADT after
 * this function is called.
 */
void __init acpi_boot_table_init(void)
{
	/*
	 * Enable ACPI instead of device tree unless
	 * - ACPI has been disabled explicitly (acpi=off), or
	 * - the device tree is not empty (it has more than just a /chosen node)
	 *   and ACPI has not been force enabled (acpi=force)
	 */
	if (param_acpi_off ||
	    (!param_acpi_force && of_scan_flat_dt(dt_scan_depth1_nodes, NULL)))
		return;

	enable_acpi();

	/* Initialize the ACPI boot-time table parser. */
	if (acpi_table_init()) {
		disable_acpi();
		return;
	}

	if (acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt)) {
		/* disable ACPI if no FADT is found */
		disable_acpi();
		pr_err("Can't find FADT\n");
	}
}

void __init acpi_gic_init(void)
{
	struct acpi_table_header *table;
	acpi_status status;
	acpi_size tbl_size;
	int err;

	if (acpi_disabled)
		return;

	status = acpi_get_table_with_size(ACPI_SIG_MADT, 0, &table, &tbl_size);
	if (ACPI_FAILURE(status)) {
		const char *msg = acpi_format_exception(status);

		pr_err("Failed to get MADT table, %s\n", msg);
		return;
	}

	err = gic_v2_acpi_init(table);
	if (err)
		pr_err("Failed to initialize GIC IRQ controller");

	early_acpi_os_unmap_memory((char *)table, tbl_size);
}
Commit	Line	Data
37655163 AS	1	/*
	2	* ARM64 Specific Low-Level ACPI Boot Support
	3	*
	4	* Copyright (C) 2013-2014, Linaro Ltd.
	5	* Author: Al Stone <al.stone@linaro.org>
	6	* Author: Graeme Gregory <graeme.gregory@linaro.org>
	7	* Author: Hanjun Guo <hanjun.guo@linaro.org>
	8	* Author: Tomasz Nowicki <tomasz.nowicki@linaro.org>
	9	* Author: Naresh Bhat <naresh.bhat@linaro.org>
	10	*
	11	* This program is free software; you can redistribute it and/or modify
	12	* it under the terms of the GNU General Public License version 2 as
	13	* published by the Free Software Foundation.
	14	*/
	15
	16	#define pr_fmt(fmt) "ACPI: " fmt
	17
	18	#include <linux/acpi.h>
	19	#include <linux/bootmem.h>
	20	#include <linux/cpumask.h>
	21	#include <linux/init.h>
	22	#include <linux/irq.h>
	23	#include <linux/irqdomain.h>
	24	#include <linux/memblock.h>
b10d79f7	25	#include <linux/of_fdt.h>
37655163 AS	26	#include <linux/smp.h>
37655163 AS	27
fccb9a81 HG	28	#include <asm/cputype.h>
	29	#include <asm/cpu_ops.h>
	30	#include <asm/smp_plat.h>
	31
b10d79f7 AS	32	int acpi_noirq = 1; /* skip ACPI IRQ initialization */
b10d79f7 AS	33	int acpi_disabled = 1;
37655163 AS	34	EXPORT_SYMBOL(acpi_disabled);
37655163 AS	35
b10d79f7	36	int acpi_pci_disabled = 1; /* skip ACPI PCI scan and IRQ initialization */
37655163 AS	37	EXPORT_SYMBOL(acpi_pci_disabled);
37655163 AS	38
fccb9a81 HG	39	/* Processors with enabled flag and sane MPIDR */
	40	static int enabled_cpus;
	41
	42	/* Boot CPU is valid or not in MADT */
	43	static bool bootcpu_valid __initdata;
	44
b10d79f7	45	static bool param_acpi_off __initdata;
33757ded	46	bool param_acpi_force __initdata;
b10d79f7 AS	47
	48	static int __init parse_acpi(char *arg)
	49	{
	50	if (!arg)
	51	return -EINVAL;
	52
	53	/* "acpi=off" disables both ACPI table parsing and interpreter */
	54	if (strcmp(arg, "off") == 0)
	55	param_acpi_off = true;
	56	else if (strcmp(arg, "force") == 0) /* force ACPI to be enabled */
	57	param_acpi_force = true;
	58	else
	59	return -EINVAL; /* Core will print when we return error */
	60
	61	return 0;
	62	}
	63	early_param("acpi", parse_acpi);
	64
	65	static int __init dt_scan_depth1_nodes(unsigned long node,
	66	const char *uname, int depth,
	67	void *data)
	68	{
	69	/*
	70	* Return 1 as soon as we encounter a node at depth 1 that is
	71	* not the /chosen node.
	72	*/
	73	if (depth == 1 && (strcmp(uname, "chosen") != 0))
	74	return 1;
	75	return 0;
	76	}
	77
37655163 AS	78	/*
	79	* __acpi_map_table() will be called before page_init(), so early_ioremap()
	80	* or early_memremap() should be called here to for ACPI table mapping.
	81	*/
	82	char *__init __acpi_map_table(unsigned long phys, unsigned long size)
	83	{
	84	if (!size)
	85	return NULL;
	86
	87	return early_memremap(phys, size);
	88	}
	89
	90	void __init __acpi_unmap_table(char *map, unsigned long size)
	91	{
	92	if (!map \|\| !size)
	93	return;
	94
	95	early_memunmap(map, size);
	96	}
	97
fccb9a81 HG	98	/**
	99	* acpi_map_gic_cpu_interface - generates a logical cpu number
	100	* and map to MPIDR represented by GICC structure
	101	* @mpidr: CPU's hardware id to register, MPIDR represented in MADT
	102	* @enabled: this cpu is enabled or not
	103	*
	104	* Returns the logical cpu number which maps to MPIDR
	105	*/
	106	static int __init acpi_map_gic_cpu_interface(u64 mpidr, u8 enabled)
	107	{
	108	int i;
	109
	110	if (mpidr == INVALID_HWID) {
	111	pr_info("Skip MADT cpu entry with invalid MPIDR\n");
	112	return -EINVAL;
	113	}
	114
	115	total_cpus++;
	116	if (!enabled)
	117	return -EINVAL;
	118
	119	if (enabled_cpus >= NR_CPUS) {
	120	pr_warn("NR_CPUS limit of %d reached, Processor %d/0x%llx ignored.\n",
	121	NR_CPUS, total_cpus, mpidr);
	122	return -EINVAL;
	123	}
	124
	125	/* Check if GICC structure of boot CPU is available in the MADT */
	126	if (cpu_logical_map(0) == mpidr) {
	127	if (bootcpu_valid) {
	128	pr_err("Firmware bug, duplicate CPU MPIDR: 0x%llx in MADT\n",
	129	mpidr);
	130	return -EINVAL;
	131	}
	132
	133	bootcpu_valid = true;
	134	}
	135
	136	/*
	137	* Duplicate MPIDRs are a recipe for disaster. Scan
	138	* all initialized entries and check for
	139	* duplicates. If any is found just ignore the CPU.
	140	*/
	141	for (i = 1; i < enabled_cpus; i++) {
	142	if (cpu_logical_map(i) == mpidr) {
	143	pr_err("Firmware bug, duplicate CPU MPIDR: 0x%llx in MADT\n",
	144	mpidr);
	145	return -EINVAL;
	146	}
	147	}
	148
	149	if (!acpi_psci_present())
	150	return -EOPNOTSUPP;
	151
	152	cpu_ops[enabled_cpus] = cpu_get_ops("psci");
	153	/* CPU 0 was already initialized */
	154	if (enabled_cpus) {
	155	if (!cpu_ops[enabled_cpus])
	156	return -EINVAL;
	157
	158	if (cpu_ops[enabled_cpus]->cpu_init(NULL, enabled_cpus))
	159	return -EOPNOTSUPP;
	160
	161	/* map the logical cpu id to cpu MPIDR */
162	cpu_logical_map(enabled_cpus) = mpidr;
163	}
164
165	enabled_cpus++;
166	return enabled_cpus;
167	}
168
169	static int __init
170	acpi_parse_gic_cpu_interface(struct acpi_subtable_header *header,
171	const unsigned long end)
172	{
173	struct acpi_madt_generic_interrupt *processor;
174
175	processor = (struct acpi_madt_generic_interrupt *)header;
176
177	if (BAD_MADT_ENTRY(processor, end))
178	return -EINVAL;
179
180	acpi_table_print_madt_entry(header);
181
182	acpi_map_gic_cpu_interface(processor->arm_mpidr & MPIDR_HWID_BITMASK,
183	processor->flags & ACPI_MADT_ENABLED);
184
185	return 0;
186	}
187
188	/* Parse GIC cpu interface entries in MADT for SMP init */
189	void __init acpi_init_cpus(void)
190	{
191	int count, i;
192
193	/*
194	* do a partial walk of MADT to determine how many CPUs
195	* we have including disabled CPUs, and get information
196	* we need for SMP init
197	*/
198	count = acpi_table_parse_madt(ACPI_MADT_TYPE_GENERIC_INTERRUPT,
199	acpi_parse_gic_cpu_interface, 0);
200
201	if (!count) {
202	pr_err("No GIC CPU interface entries present\n");
203	return;
204	} else if (count < 0) {
205	pr_err("Error parsing GIC CPU interface entry\n");
206	return;
207	}
208
209	if (!bootcpu_valid) {
210	pr_err("MADT missing boot CPU MPIDR, not enabling secondaries\n");
211	return;
212	}
213
214	for (i = 0; i < enabled_cpus; i++)
215	set_cpu_possible(i, true);
216
217	/* Make boot-up look pretty */
218	pr_info("%d CPUs enabled, %d CPUs total\n", enabled_cpus, total_cpus);
219	}
220
37655163 AS	221	static int __init acpi_parse_fadt(struct acpi_table_header *table)
	222	{
	223	struct acpi_table_fadt fadt = (struct acpi_table_fadt )table;
	224
	225	/*
	226	* Revision in table header is the FADT Major revision, and there
	227	* is a minor revision of FADT which was introduced by ACPI 5.1,
	228	* we only deal with ACPI 5.1 or newer revision to get GIC and SMP
	229	* boot protocol configuration data, or we will disable ACPI.
	230	*/
	231	if (table->revision > 5 \|\|
fccb9a81	232	(table->revision == 5 && fadt->minor_revision >= 1)) {
6933de0c AS	233	if (!acpi_gbl_reduced_hardware) {
	234	pr_err("Not hardware reduced ACPI mode, will not be supported\n");
	235	goto disable_acpi;
	236	}
	237
fccb9a81 HG	238	/*
	239	* ACPI 5.1 only has two explicit methods to boot up SMP,
	240	* PSCI and Parking protocol, but the Parking protocol is
	241	* only specified for ARMv7 now, so make PSCI as the only
	242	* way for the SMP boot protocol before some updates for
	243	* the Parking protocol spec.
	244	*/
	245	if (acpi_psci_present())
	246	return 0;
	247
	248	pr_warn("No PSCI support, will not bring up secondary CPUs\n");
	249	return -EOPNOTSUPP;
	250	}
37655163 AS	251
	252	pr_warn("Unsupported FADT revision %d.%d, should be 5.1+, will disable ACPI\n",
	253	table->revision, fadt->minor_revision);
37655163	254
6933de0c AS	255	disable_acpi:
6933de0c AS	256	disable_acpi();
37655163 AS	257	return -EINVAL;
	258	}
	259
	260	/*
	261	* acpi_boot_table_init() called from setup_arch(), always.
	262	* 1. find RSDP and get its address, and then find XSDT
	263	* 2. extract all tables and checksums them all
	264	* 3. check ACPI FADT revision
	265	*
	266	* We can parse ACPI boot-time tables such as MADT after
	267	* this function is called.
	268	*/
	269	void __init acpi_boot_table_init(void)
	270	{
b10d79f7 AS	271	/*
	272	* Enable ACPI instead of device tree unless
	273	* - ACPI has been disabled explicitly (acpi=off), or
	274	* - the device tree is not empty (it has more than just a /chosen node)
	275	* and ACPI has not been force enabled (acpi=force)
	276	*/
	277	if (param_acpi_off \|\|
	278	(!param_acpi_force && of_scan_flat_dt(dt_scan_depth1_nodes, NULL)))
37655163 AS	279	return;
37655163 AS	280
b10d79f7 AS	281	enable_acpi();
b10d79f7 AS	282
37655163 AS	283	/* Initialize the ACPI boot-time table parser. */
	284	if (acpi_table_init()) {
	285	disable_acpi();
	286	return;
	287	}
	288
	289	if (acpi_table_parse(ACPI_SIG_FADT, acpi_parse_fadt)) {
	290	/* disable ACPI if no FADT is found */
	291	disable_acpi();
	292	pr_err("Can't find FADT\n");
	293	}
	294	}
d60fc389 TN	295
	296	void __init acpi_gic_init(void)
	297	{
	298	struct acpi_table_header *table;
	299	acpi_status status;
	300	acpi_size tbl_size;
	301	int err;
	302
	303	if (acpi_disabled)
	304	return;
	305
	306	status = acpi_get_table_with_size(ACPI_SIG_MADT, 0, &table, &tbl_size);
	307	if (ACPI_FAILURE(status)) {
	308	const char *msg = acpi_format_exception(status);
	309
	310	pr_err("Failed to get MADT table, %s\n", msg);
	311	return;
	312	}
	313
	314	err = gic_v2_acpi_init(table);
	315	if (err)
	316	pr_err("Failed to initialize GIC IRQ controller");
	317
	318	early_acpi_os_unmap_memory((char *)table, tbl_size);
	319	}