[linux.git] / drivers / sfi / sfi_core.c

/* sfi_core.c Simple Firmware Interface - core internals */

/*

  This file is provided under a dual BSD/GPLv2 license.  When using or
  redistributing this file, you may do so under either license.

  GPL LICENSE SUMMARY

  Copyright(c) 2009 Intel Corporation. All rights reserved.

  This program is free software; you can redistribute it and/or modify
  it under the terms of version 2 of the GNU General Public License as
  published by the Free Software Foundation.

  This program is distributed in the hope that it will be useful, but
  WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
  The full GNU General Public License is included in this distribution
  in the file called LICENSE.GPL.

  BSD LICENSE

  Copyright(c) 2009 Intel Corporation. All rights reserved.

  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions
  are met:

    * Redistributions of source code must retain the above copyright
      notice, this list of conditions and the following disclaimer.
    * Redistributions in binary form must reproduce the above copyright
      notice, this list of conditions and the following disclaimer in
      the documentation and/or other materials provided with the
      distribution.
    * Neither the name of Intel Corporation nor the names of its
      contributors may be used to endorse or promote products derived
      from this software without specific prior written permission.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*/

#define KMSG_COMPONENT "SFI"
#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt

#include <linux/bootmem.h>
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/errno.h>
#include <linux/types.h>
#include <linux/acpi.h>
#include <linux/init.h>
#include <linux/sfi.h>

#include "sfi_core.h"

#define ON_SAME_PAGE(addr1, addr2) \
	(((unsigned long)(addr1) & PAGE_MASK) == \
	((unsigned long)(addr2) & PAGE_MASK))
#define TABLE_ON_PAGE(page, table, size) (ON_SAME_PAGE(page, table) && \
				ON_SAME_PAGE(page, table + size))

int sfi_disabled __read_mostly;
EXPORT_SYMBOL(sfi_disabled);

static u64 syst_pa __read_mostly;
static struct sfi_table_simple *syst_va __read_mostly;

/*
 * FW creates and saves the SFI tables in memory. When these tables get
 * used, they may need to be mapped to virtual address space, and the mapping
 * can happen before or after the ioremap() is ready, so a flag is needed
 * to indicating this
 */
static u32 sfi_use_ioremap __read_mostly;

/*
 * sfi_un/map_memory calls early_ioremap/iounmap which is a __init function
 * and introduces section mismatch. So use __ref to make it calm.
 */
static void __iomem * __ref sfi_map_memory(u64 phys, u32 size)
{
	if (!phys || !size)
		return NULL;

	if (sfi_use_ioremap)
		return ioremap(phys, size);
	else
		return early_ioremap(phys, size);
}

static void __ref sfi_unmap_memory(void __iomem *virt, u32 size)
{
	if (!virt || !size)
		return;

	if (sfi_use_ioremap)
		iounmap(virt);
	else
		early_iounmap(virt, size);
}

static void sfi_print_table_header(unsigned long long pa,
				struct sfi_table_header *header)
{
	pr_info("%4.4s %llX, %04X (v%d %6.6s %8.8s)\n",
		header->sig, pa,
		header->len, header->rev, header->oem_id,
		header->oem_table_id);
}

/*
 * sfi_verify_table()
 * Sanity check table lengh, calculate checksum
 */
static int sfi_verify_table(struct sfi_table_header *table)
{

	u8 checksum = 0;
	u8 *puchar = (u8 *)table;
	u32 length = table->len;

	/* Sanity check table length against arbitrary 1MB limit */
	if (length > 0x100000) {
		pr_err("Invalid table length 0x%x\n", length);
		return -1;
	}

	while (length--)
		checksum += *puchar++;

	if (checksum) {
		pr_err("Checksum %2.2X should be %2.2X\n",
			table->csum, table->csum - checksum);
		return -1;
	}
	return 0;
}

/*
 * sfi_map_table()
 *
 * Return address of mapped table
 * Check for common case that we can re-use mapping to SYST,
 * which requires syst_pa, syst_va to be initialized.
 */
struct sfi_table_header *sfi_map_table(u64 pa)
{
	struct sfi_table_header *th;
	u32 length;

	if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header)))
		th = sfi_map_memory(pa, sizeof(struct sfi_table_header));
	else
		th = (void *)syst_va + (pa - syst_pa);

	 /* If table fits on same page as its header, we are done */
	if (TABLE_ON_PAGE(th, th, th->len))
		return th;

	/* Entire table does not fit on same page as SYST */
	length = th->len;
	if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header)))
		sfi_unmap_memory(th, sizeof(struct sfi_table_header));

	return sfi_map_memory(pa, length);
}

/*
 * sfi_unmap_table()
 *
 * Undoes effect of sfi_map_table() by unmapping table
 * if it did not completely fit on same page as SYST.
 */
void sfi_unmap_table(struct sfi_table_header *th)
{
	if (!TABLE_ON_PAGE(syst_va, th, th->len))
		sfi_unmap_memory(th, TABLE_ON_PAGE(th, th, th->len) ?
					sizeof(*th) : th->len);
}

static int sfi_table_check_key(struct sfi_table_header *th,
				struct sfi_table_key *key)
{

	if (strncmp(th->sig, key->sig, SFI_SIGNATURE_SIZE)
		|| (key->oem_id && strncmp(th->oem_id,
				key->oem_id, SFI_OEM_ID_SIZE))
		|| (key->oem_table_id && strncmp(th->oem_table_id,
				key->oem_table_id, SFI_OEM_TABLE_ID_SIZE)))
		return -1;

	return 0;
}

/*
 * This function will be used in 2 cases:
 * 1. used to enumerate and verify the tables addressed by SYST/XSDT,
 *    thus no signature will be given (in kernel boot phase)
 * 2. used to parse one specific table, signature must exist, and
 *    the mapped virt address will be returned, and the virt space
 *    will be released by call sfi_put_table() later
 *
 * This two cases are from two different functions with two different
 * sections and causes section mismatch warning. So use __ref to tell
 * modpost not to make any noise.
 *
 * Return value:
 *	NULL:			when can't find a table matching the key
 *	ERR_PTR(error):		error value
 *	virt table address:	when a matched table is found
 */
struct sfi_table_header *
 __ref sfi_check_table(u64 pa, struct sfi_table_key *key)
{
	struct sfi_table_header *th;
	void *ret = NULL;

	th = sfi_map_table(pa);
	if (!th)
		return ERR_PTR(-ENOMEM);

	if (!key->sig) {
		sfi_print_table_header(pa, th);
		if (sfi_verify_table(th))
			ret = ERR_PTR(-EINVAL);
	} else {
		if (!sfi_table_check_key(th, key))
			return th;	/* Success */
	}

	sfi_unmap_table(th);
	return ret;
}

/*
 * sfi_get_table()
 *
 * Search SYST for the specified table with the signature in
 * the key, and return the mapped table
 */
struct sfi_table_header *sfi_get_table(struct sfi_table_key *key)
{
	struct sfi_table_header *th;
	u32 tbl_cnt, i;

	tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
	for (i = 0; i < tbl_cnt; i++) {
		th = sfi_check_table(syst_va->pentry[i], key);
		if (!IS_ERR(th) && th)
			return th;
	}

	return NULL;
}

void sfi_put_table(struct sfi_table_header *th)
{
	sfi_unmap_table(th);
}

/* Find table with signature, run handler on it */
int sfi_table_parse(char *signature, char *oem_id, char *oem_table_id,
			sfi_table_handler handler)
{
	struct sfi_table_header *table = NULL;
	struct sfi_table_key key;
	int ret = -EINVAL;

	if (sfi_disabled || !handler || !signature)
		goto exit;

	key.sig = signature;
	key.oem_id = oem_id;
	key.oem_table_id = oem_table_id;

	table = sfi_get_table(&key);
	if (!table)
		goto exit;

	ret = handler(table);
	sfi_put_table(table);
exit:
	return ret;
}
EXPORT_SYMBOL_GPL(sfi_table_parse);

/*
 * sfi_parse_syst()
 * Checksum all the tables in SYST and print their headers
 *
 * success: set syst_va, return 0
 */
static int __init sfi_parse_syst(void)
{
	struct sfi_table_key key = SFI_ANY_KEY;
	int tbl_cnt, i;
	void *ret;

	syst_va = sfi_map_memory(syst_pa, sizeof(struct sfi_table_simple));
	if (!syst_va)
		return -ENOMEM;

	tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
	for (i = 0; i < tbl_cnt; i++) {
		ret = sfi_check_table(syst_va->pentry[i], &key);
		if (IS_ERR(ret))
			return PTR_ERR(ret);
	}

	return 0;
}

/*
 * The OS finds the System Table by searching 16-byte boundaries between
 * physical address 0x000E0000 and 0x000FFFFF. The OS shall search this region
 * starting at the low address and shall stop searching when the 1st valid SFI
 * System Table is found.
 *
 * success: set syst_pa, return 0
 * fail: return -1
 */
static __init int sfi_find_syst(void)
{
	unsigned long offset, len;
	void *start;

	len = SFI_SYST_SEARCH_END - SFI_SYST_SEARCH_BEGIN;
	start = sfi_map_memory(SFI_SYST_SEARCH_BEGIN, len);
	if (!start)
		return -1;

	for (offset = 0; offset < len; offset += 16) {
		struct sfi_table_header *syst_hdr;

		syst_hdr = start + offset;
		if (strncmp(syst_hdr->sig, SFI_SIG_SYST,
				SFI_SIGNATURE_SIZE))
			continue;

		if (syst_hdr->len > PAGE_SIZE)
			continue;

		sfi_print_table_header(SFI_SYST_SEARCH_BEGIN + offset,
					syst_hdr);

		if (sfi_verify_table(syst_hdr))
			continue;

		/*
		 * Enforce SFI spec mandate that SYST reside within a page.
		 */
		if (!ON_SAME_PAGE(syst_pa, syst_pa + syst_hdr->len)) {
			pr_info("SYST 0x%llx + 0x%x crosses page\n",
					syst_pa, syst_hdr->len);
			continue;
		}

		/* Success */
		syst_pa = SFI_SYST_SEARCH_BEGIN + offset;
		sfi_unmap_memory(start, len);
		return 0;
	}

	sfi_unmap_memory(start, len);
	return -1;
}

void __init sfi_init(void)
{
	if (!acpi_disabled)
		disable_sfi();

	if (sfi_disabled)
		return;

	pr_info("Simple Firmware Interface v0.7 http://simplefirmware.org\n");

	if (sfi_find_syst() || sfi_parse_syst() || sfi_platform_init())
		disable_sfi();

	return;
}

void __init sfi_init_late(void)
{
	int length;

	if (sfi_disabled)
		return;

	length = syst_va->header.len;
	sfi_unmap_memory(syst_va, sizeof(struct sfi_table_simple));

	/* Use ioremap now after it is ready */
	sfi_use_ioremap = 1;
	syst_va = sfi_map_memory(syst_pa, length);

	sfi_acpi_init();
}
Commit	Line	Data
6ae6996a FT	1	/* sfi_core.c Simple Firmware Interface - core internals */
	2
	3	/*
	4
	5	This file is provided under a dual BSD/GPLv2 license. When using or
	6	redistributing this file, you may do so under either license.
	7
	8	GPL LICENSE SUMMARY
	9
	10	Copyright(c) 2009 Intel Corporation. All rights reserved.
	11
	12	This program is free software; you can redistribute it and/or modify
	13	it under the terms of version 2 of the GNU General Public License as
	14	published by the Free Software Foundation.
	15
	16	This program is distributed in the hope that it will be useful, but
	17	WITHOUT ANY WARRANTY; without even the implied warranty of
	18	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	19	General Public License for more details.
	20
	21	You should have received a copy of the GNU General Public License
	22	along with this program; if not, write to the Free Software
	23	Foundation, Inc., 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA.
	24	The full GNU General Public License is included in this distribution
	25	in the file called LICENSE.GPL.
	26
	27	BSD LICENSE
	28
	29	Copyright(c) 2009 Intel Corporation. All rights reserved.
	30
	31	Redistribution and use in source and binary forms, with or without
	32	modification, are permitted provided that the following conditions
	33	are met:
	34
	35	* Redistributions of source code must retain the above copyright
	36	notice, this list of conditions and the following disclaimer.
	37	* Redistributions in binary form must reproduce the above copyright
	38	notice, this list of conditions and the following disclaimer in
	39	the documentation and/or other materials provided with the
	40	distribution.
	41	* Neither the name of Intel Corporation nor the names of its
	42	contributors may be used to endorse or promote products derived
	43	from this software without specific prior written permission.
	44
	45	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
	46	"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
	47	LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
	48	A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
	49	OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
	50	SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
	51	LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
	52	DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
	53	THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	54	(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
	55	OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	56
	57	*/
	58
	59	#define KMSG_COMPONENT "SFI"
	60	#define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
	61
	62	#include <linux/bootmem.h>
	63	#include <linux/kernel.h>
	64	#include <linux/module.h>
6ae6996a FT	65	#include <linux/errno.h>
	66	#include <linux/types.h>
	67	#include <linux/acpi.h>
	68	#include <linux/init.h>
6ae6996a	69	#include <linux/sfi.h>
6ae6996a FT	70
	71	#include "sfi_core.h"
	72
	73	#define ON_SAME_PAGE(addr1, addr2) \
	74	(((unsigned long)(addr1) & PAGE_MASK) == \
	75	((unsigned long)(addr2) & PAGE_MASK))
	76	#define TABLE_ON_PAGE(page, table, size) (ON_SAME_PAGE(page, table) && \
	77	ON_SAME_PAGE(page, table + size))
	78
	79	int sfi_disabled __read_mostly;
	80	EXPORT_SYMBOL(sfi_disabled);
	81
	82	static u64 syst_pa __read_mostly;
	83	static struct sfi_table_simple *syst_va __read_mostly;
	84
	85	/*
	86	* FW creates and saves the SFI tables in memory. When these tables get
	87	* used, they may need to be mapped to virtual address space, and the mapping
	88	* can happen before or after the ioremap() is ready, so a flag is needed
	89	* to indicating this
	90	*/
	91	static u32 sfi_use_ioremap __read_mostly;
	92
01674da6 RM	93	/*
	94	* sfi_un/map_memory calls early_ioremap/iounmap which is a __init function
	95	* and introduces section mismatch. So use __ref to make it calm.
	96	*/
	97	static void __iomem * __ref sfi_map_memory(u64 phys, u32 size)
6ae6996a FT	98	{
	99	if (!phys \|\| !size)
	100	return NULL;
	101
	102	if (sfi_use_ioremap)
	103	return ioremap(phys, size);
	104	else
	105	return early_ioremap(phys, size);
	106	}
	107
01674da6	108	static void __ref sfi_unmap_memory(void __iomem *virt, u32 size)
6ae6996a FT	109	{
	110	if (!virt \|\| !size)
	111	return;
	112
	113	if (sfi_use_ioremap)
	114	iounmap(virt);
	115	else
	116	early_iounmap(virt, size);
	117	}
	118
	119	static void sfi_print_table_header(unsigned long long pa,
	120	struct sfi_table_header *header)
	121	{
	122	pr_info("%4.4s %llX, %04X (v%d %6.6s %8.8s)\n",
	123	header->sig, pa,
	124	header->len, header->rev, header->oem_id,
	125	header->oem_table_id);
	126	}
	127
	128	/*
	129	* sfi_verify_table()
	130	* Sanity check table lengh, calculate checksum
	131	*/
011a606d	132	static int sfi_verify_table(struct sfi_table_header *table)
6ae6996a FT	133	{
	134
	135	u8 checksum = 0;
	136	u8 puchar = (u8 )table;
	137	u32 length = table->len;
	138
	139	/* Sanity check table length against arbitrary 1MB limit */
	140	if (length > 0x100000) {
	141	pr_err("Invalid table length 0x%x\n", length);
	142	return -1;
	143	}
	144
	145	while (length--)
	146	checksum += *puchar++;
	147
	148	if (checksum) {
	149	pr_err("Checksum %2.2X should be %2.2X\n",
	150	table->csum, table->csum - checksum);
	151	return -1;
	152	}
	153	return 0;
	154	}
	155
	156	/*
	157	* sfi_map_table()
	158	*
	159	* Return address of mapped table
	160	* Check for common case that we can re-use mapping to SYST,
	161	* which requires syst_pa, syst_va to be initialized.
	162	*/
	163	struct sfi_table_header *sfi_map_table(u64 pa)
	164	{
	165	struct sfi_table_header *th;
	166	u32 length;
	167
	168	if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header)))
	169	th = sfi_map_memory(pa, sizeof(struct sfi_table_header));
	170	else
	171	th = (void *)syst_va + (pa - syst_pa);
	172
	173	/* If table fits on same page as its header, we are done */
	174	if (TABLE_ON_PAGE(th, th, th->len))
	175	return th;
	176
	177	/* Entire table does not fit on same page as SYST */
	178	length = th->len;
	179	if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header)))
	180	sfi_unmap_memory(th, sizeof(struct sfi_table_header));
	181
	182	return sfi_map_memory(pa, length);
	183	}
	184
	185	/*
	186	* sfi_unmap_table()
	187	*
	188	* Undoes effect of sfi_map_table() by unmapping table
	189	* if it did not completely fit on same page as SYST.
	190	*/
	191	void sfi_unmap_table(struct sfi_table_header *th)
	192	{
	193	if (!TABLE_ON_PAGE(syst_va, th, th->len))
	194	sfi_unmap_memory(th, TABLE_ON_PAGE(th, th, th->len) ?
	195	sizeof(*th) : th->len);
	196	}
197
198	static int sfi_table_check_key(struct sfi_table_header *th,
199	struct sfi_table_key *key)
200	{
201
202	if (strncmp(th->sig, key->sig, SFI_SIGNATURE_SIZE)
203	\|\| (key->oem_id && strncmp(th->oem_id,
204	key->oem_id, SFI_OEM_ID_SIZE))
205	\|\| (key->oem_table_id && strncmp(th->oem_table_id,
206	key->oem_table_id, SFI_OEM_TABLE_ID_SIZE)))
207	return -1;
208
209	return 0;
210	}
211
212	/*
213	* This function will be used in 2 cases:
214	* 1. used to enumerate and verify the tables addressed by SYST/XSDT,
215	* thus no signature will be given (in kernel boot phase)
216	* 2. used to parse one specific table, signature must exist, and
217	* the mapped virt address will be returned, and the virt space
218	* will be released by call sfi_put_table() later
219	*
01674da6 RM	220	* This two cases are from two different functions with two different
	221	* sections and causes section mismatch warning. So use __ref to tell
	222	* modpost not to make any noise.
	223	*
6ae6996a FT	224	* Return value:
	225	* NULL: when can't find a table matching the key
	226	* ERR_PTR(error): error value
	227	* virt table address: when a matched table is found
	228	*/
01674da6 RM	229	struct sfi_table_header *
01674da6 RM	230	__ref sfi_check_table(u64 pa, struct sfi_table_key *key)
6ae6996a FT	231	{
	232	struct sfi_table_header *th;
	233	void *ret = NULL;
	234
	235	th = sfi_map_table(pa);
	236	if (!th)
	237	return ERR_PTR(-ENOMEM);
	238
	239	if (!key->sig) {
	240	sfi_print_table_header(pa, th);
	241	if (sfi_verify_table(th))
	242	ret = ERR_PTR(-EINVAL);
	243	} else {
	244	if (!sfi_table_check_key(th, key))
	245	return th; /* Success */
	246	}
	247
	248	sfi_unmap_table(th);
	249	return ret;
	250	}
	251
	252	/*
	253	* sfi_get_table()
	254	*
	255	* Search SYST for the specified table with the signature in
	256	* the key, and return the mapped table
	257	*/
	258	struct sfi_table_header sfi_get_table(struct sfi_table_key key)
	259	{
	260	struct sfi_table_header *th;
	261	u32 tbl_cnt, i;
	262
	263	tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
	264	for (i = 0; i < tbl_cnt; i++) {
	265	th = sfi_check_table(syst_va->pentry[i], key);
	266	if (!IS_ERR(th) && th)
	267	return th;
	268	}
	269
	270	return NULL;
	271	}
	272
	273	void sfi_put_table(struct sfi_table_header *th)
	274	{
	275	sfi_unmap_table(th);
	276	}
	277
	278	/* Find table with signature, run handler on it */
	279	int sfi_table_parse(char signature, char oem_id, char *oem_table_id,
	280	sfi_table_handler handler)
	281	{
	282	struct sfi_table_header *table = NULL;
	283	struct sfi_table_key key;
	284	int ret = -EINVAL;
	285
	286	if (sfi_disabled \|\| !handler \|\| !signature)
	287	goto exit;
	288
	289	key.sig = signature;
	290	key.oem_id = oem_id;
	291	key.oem_table_id = oem_table_id;
	292
	293	table = sfi_get_table(&key);
	294	if (!table)
295	goto exit;
296
297	ret = handler(table);
298	sfi_put_table(table);
299	exit:
300	return ret;
301	}
302	EXPORT_SYMBOL_GPL(sfi_table_parse);
303
304	/*
305	* sfi_parse_syst()
306	* Checksum all the tables in SYST and print their headers
307	*
308	* success: set syst_va, return 0
309	*/
310	static int __init sfi_parse_syst(void)
311	{
312	struct sfi_table_key key = SFI_ANY_KEY;
313	int tbl_cnt, i;
314	void *ret;
315
316	syst_va = sfi_map_memory(syst_pa, sizeof(struct sfi_table_simple));
317	if (!syst_va)
318	return -ENOMEM;
319
320	tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
321	for (i = 0; i < tbl_cnt; i++) {
322	ret = sfi_check_table(syst_va->pentry[i], &key);
323	if (IS_ERR(ret))
324	return PTR_ERR(ret);
325	}
326
327	return 0;
328	}
329
330	/*
331	* The OS finds the System Table by searching 16-byte boundaries between
332	* physical address 0x000E0000 and 0x000FFFFF. The OS shall search this region
333	* starting at the low address and shall stop searching when the 1st valid SFI
334	* System Table is found.
335	*
336	* success: set syst_pa, return 0
337	* fail: return -1
338	*/
339	static __init int sfi_find_syst(void)
340	{
341	unsigned long offset, len;
342	void *start;
343
344	len = SFI_SYST_SEARCH_END - SFI_SYST_SEARCH_BEGIN;
345	start = sfi_map_memory(SFI_SYST_SEARCH_BEGIN, len);
346	if (!start)
347	return -1;
348
349	for (offset = 0; offset < len; offset += 16) {
350	struct sfi_table_header *syst_hdr;
351
352	syst_hdr = start + offset;
353	if (strncmp(syst_hdr->sig, SFI_SIG_SYST,
354	SFI_SIGNATURE_SIZE))
355	continue;
356
357	if (syst_hdr->len > PAGE_SIZE)
358	continue;
359
360	sfi_print_table_header(SFI_SYST_SEARCH_BEGIN + offset,
361	syst_hdr);
362
363	if (sfi_verify_table(syst_hdr))
364	continue;
365
366	/*
367	* Enforce SFI spec mandate that SYST reside within a page.
368	*/
369	if (!ON_SAME_PAGE(syst_pa, syst_pa + syst_hdr->len)) {
370	pr_info("SYST 0x%llx + 0x%x crosses page\n",
371	syst_pa, syst_hdr->len);
372	continue;
373	}
374
375	/* Success */
376	syst_pa = SFI_SYST_SEARCH_BEGIN + offset;
377	sfi_unmap_memory(start, len);
378	return 0;
379	}
380
381	sfi_unmap_memory(start, len);
382	return -1;
383	}
384
385	void __init sfi_init(void)
386	{
387	if (!acpi_disabled)
388	disable_sfi();
389
390	if (sfi_disabled)
391	return;
392
393	pr_info("Simple Firmware Interface v0.7 http://simplefirmware.org\n");
394
395	if (sfi_find_syst() \|\| sfi_parse_syst() \|\| sfi_platform_init())
396	disable_sfi();
397
398	return;
399	}
400
401	void __init sfi_init_late(void)
402	{
403	int length;
404
405	if (sfi_disabled)
406	return;
407
408	length = syst_va->header.len;
409	sfi_unmap_memory(syst_va, sizeof(struct sfi_table_simple));
410
411	/* Use ioremap now after it is ready */
412	sfi_use_ioremap = 1;
413	syst_va = sfi_map_memory(syst_pa, length);
414
415	sfi_acpi_init();
416	}