drivers/sfi/sfi_core.c

   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>
  65 #include <linux/errno.h>
  66 #include <linux/types.h>
  67 #include <linux/acpi.h>
  68 #include <linux/init.h>
  69 #include <linux/sfi.h>
  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
  93 static void __iomem *sfi_map_memory(u64 phys, u32 size)
  94 {
  95         if (!phys || !size)
  96                 return NULL;
  97
  98         if (sfi_use_ioremap)
  99                 return ioremap(phys, size);
 100         else
 101                 return early_ioremap(phys, size);
 102 }
 103
 104 static void sfi_unmap_memory(void __iomem *virt, u32 size)
 105 {
 106         if (!virt || !size)
 107                 return;
 108
 109         if (sfi_use_ioremap)
 110                 iounmap(virt);
 111         else
 112                 early_iounmap(virt, size);
 113 }
 114
 115 static void sfi_print_table_header(unsigned long long pa,
 116                                 struct sfi_table_header *header)
 117 {
 118         pr_info("%4.4s %llX, %04X (v%d %6.6s %8.8s)\n",
 119                 header->sig, pa,
 120                 header->len, header->rev, header->oem_id,
 121                 header->oem_table_id);
 122 }
 123
 124 /*
 125  * sfi_verify_table()
 126  * Sanity check table lengh, calculate checksum
 127  */
 128 static __init int sfi_verify_table(struct sfi_table_header *table)
 129 {
 130
 131         u8 checksum = 0;
 132         u8 *puchar = (u8 *)table;
 133         u32 length = table->len;
 134
 135         /* Sanity check table length against arbitrary 1MB limit */
 136         if (length > 0x100000) {
 137                 pr_err("Invalid table length 0x%x\n", length);
 138                 return -1;
 139         }
 140
 141         while (length--)
 142                 checksum += *puchar++;
 143
 144         if (checksum) {
 145                 pr_err("Checksum %2.2X should be %2.2X\n",
 146                         table->csum, table->csum - checksum);
 147                 return -1;
 148         }
 149         return 0;
 150 }
 151
 152 /*
 153  * sfi_map_table()
 154  *
 155  * Return address of mapped table
 156  * Check for common case that we can re-use mapping to SYST,
 157  * which requires syst_pa, syst_va to be initialized.
 158  */
 159 struct sfi_table_header *sfi_map_table(u64 pa)
 160 {
 161         struct sfi_table_header *th;
 162         u32 length;
 163
 164         if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header)))
 165                 th = sfi_map_memory(pa, sizeof(struct sfi_table_header));
 166         else
 167                 th = (void *)syst_va + (pa - syst_pa);
 168
 169          /* If table fits on same page as its header, we are done */
 170         if (TABLE_ON_PAGE(th, th, th->len))
 171                 return th;
 172
 173         /* Entire table does not fit on same page as SYST */
 174         length = th->len;
 175         if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header)))
 176                 sfi_unmap_memory(th, sizeof(struct sfi_table_header));
 177
 178         return sfi_map_memory(pa, length);
 179 }
 180
 181 /*
 182  * sfi_unmap_table()
 183  *
 184  * Undoes effect of sfi_map_table() by unmapping table
 185  * if it did not completely fit on same page as SYST.
 186  */
 187 void sfi_unmap_table(struct sfi_table_header *th)
 188 {
 189         if (!TABLE_ON_PAGE(syst_va, th, th->len))
 190                 sfi_unmap_memory(th, TABLE_ON_PAGE(th, th, th->len) ?
 191                                         sizeof(*th) : th->len);
 192 }
 193
 194 static int sfi_table_check_key(struct sfi_table_header *th,
 195                                 struct sfi_table_key *key)
 196 {
 197
 198         if (strncmp(th->sig, key->sig, SFI_SIGNATURE_SIZE)
 199                 || (key->oem_id && strncmp(th->oem_id,
 200                                 key->oem_id, SFI_OEM_ID_SIZE))
 201                 || (key->oem_table_id && strncmp(th->oem_table_id,
 202                                 key->oem_table_id, SFI_OEM_TABLE_ID_SIZE)))
 203                 return -1;
 204
 205         return 0;
 206 }
 207
 208 /*
 209  * This function will be used in 2 cases:
 210  * 1. used to enumerate and verify the tables addressed by SYST/XSDT,
 211  *    thus no signature will be given (in kernel boot phase)
 212  * 2. used to parse one specific table, signature must exist, and
 213  *    the mapped virt address will be returned, and the virt space
 214  *    will be released by call sfi_put_table() later
 215  *
 216  * Return value:
 217  *      NULL:                   when can't find a table matching the key
 218  *      ERR_PTR(error):         error value
 219  *      virt table address:     when a matched table is found
 220  */
 221 struct sfi_table_header *sfi_check_table(u64 pa, struct sfi_table_key *key)
 222 {
 223         struct sfi_table_header *th;
 224         void *ret = NULL;
 225
 226         th = sfi_map_table(pa);
 227         if (!th)
 228                 return ERR_PTR(-ENOMEM);
 229
 230         if (!key->sig) {
 231                 sfi_print_table_header(pa, th);
 232                 if (sfi_verify_table(th))
 233                         ret = ERR_PTR(-EINVAL);
 234         } else {
 235                 if (!sfi_table_check_key(th, key))
 236                         return th;      /* Success */
 237         }
 238
 239         sfi_unmap_table(th);
 240         return ret;
 241 }
 242
 243 /*
 244  * sfi_get_table()
 245  *
 246  * Search SYST for the specified table with the signature in
 247  * the key, and return the mapped table
 248  */
 249 struct sfi_table_header *sfi_get_table(struct sfi_table_key *key)
 250 {
 251         struct sfi_table_header *th;
 252         u32 tbl_cnt, i;
 253
 254         tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
 255         for (i = 0; i < tbl_cnt; i++) {
 256                 th = sfi_check_table(syst_va->pentry[i], key);
 257                 if (!IS_ERR(th) && th)
 258                         return th;
 259         }
 260
 261         return NULL;
 262 }
 263
 264 void sfi_put_table(struct sfi_table_header *th)
 265 {
 266         sfi_unmap_table(th);
 267 }
 268
 269 /* Find table with signature, run handler on it */
 270 int sfi_table_parse(char *signature, char *oem_id, char *oem_table_id,
 271                         sfi_table_handler handler)
 272 {
 273         struct sfi_table_header *table = NULL;
 274         struct sfi_table_key key;
 275         int ret = -EINVAL;
 276
 277         if (sfi_disabled || !handler || !signature)
 278                 goto exit;
 279
 280         key.sig = signature;
 281         key.oem_id = oem_id;
 282         key.oem_table_id = oem_table_id;
 283
 284         table = sfi_get_table(&key);
 285         if (!table)
 286                 goto exit;
 287
 288         ret = handler(table);
 289         sfi_put_table(table);
 290 exit:
 291         return ret;
 292 }
 293 EXPORT_SYMBOL_GPL(sfi_table_parse);
 294
 295 /*
 296  * sfi_parse_syst()
 297  * Checksum all the tables in SYST and print their headers
 298  *
 299  * success: set syst_va, return 0
 300  */
 301 static int __init sfi_parse_syst(void)
 302 {
 303         struct sfi_table_key key = SFI_ANY_KEY;
 304         int tbl_cnt, i;
 305         void *ret;
 306
 307         syst_va = sfi_map_memory(syst_pa, sizeof(struct sfi_table_simple));
 308         if (!syst_va)
 309                 return -ENOMEM;
 310
 311         tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64);
 312         for (i = 0; i < tbl_cnt; i++) {
 313                 ret = sfi_check_table(syst_va->pentry[i], &key);
 314                 if (IS_ERR(ret))
 315                         return PTR_ERR(ret);
 316         }
 317
 318         return 0;
 319 }
 320
 321 /*
 322  * The OS finds the System Table by searching 16-byte boundaries between
 323  * physical address 0x000E0000 and 0x000FFFFF. The OS shall search this region
 324  * starting at the low address and shall stop searching when the 1st valid SFI
 325  * System Table is found.
 326  *
 327  * success: set syst_pa, return 0
 328  * fail: return -1
 329  */
 330 static __init int sfi_find_syst(void)
 331 {
 332         unsigned long offset, len;
 333         void *start;
 334
 335         len = SFI_SYST_SEARCH_END - SFI_SYST_SEARCH_BEGIN;
 336         start = sfi_map_memory(SFI_SYST_SEARCH_BEGIN, len);
 337         if (!start)
 338                 return -1;
 339
 340         for (offset = 0; offset < len; offset += 16) {
 341                 struct sfi_table_header *syst_hdr;
 342
 343                 syst_hdr = start + offset;
 344                 if (strncmp(syst_hdr->sig, SFI_SIG_SYST,
 345                                 SFI_SIGNATURE_SIZE))
 346                         continue;
 347
 348                 if (syst_hdr->len > PAGE_SIZE)
 349                         continue;
 350
 351                 sfi_print_table_header(SFI_SYST_SEARCH_BEGIN + offset,
 352                                         syst_hdr);
 353
 354                 if (sfi_verify_table(syst_hdr))
 355                         continue;
 356
 357                 /*
 358                  * Enforce SFI spec mandate that SYST reside within a page.
 359                  */
 360                 if (!ON_SAME_PAGE(syst_pa, syst_pa + syst_hdr->len)) {
 361                         pr_info("SYST 0x%llx + 0x%x crosses page\n",
 362                                         syst_pa, syst_hdr->len);
 363                         continue;
 364                 }
 365
 366                 /* Success */
 367                 syst_pa = SFI_SYST_SEARCH_BEGIN + offset;
 368                 sfi_unmap_memory(start, len);
 369                 return 0;
 370         }
 371
 372         sfi_unmap_memory(start, len);
 373         return -1;
 374 }
 375
 376 void __init sfi_init(void)
 377 {
 378         if (!acpi_disabled)
 379                 disable_sfi();
 380
 381         if (sfi_disabled)
 382                 return;
 383
 384         pr_info("Simple Firmware Interface v0.7 http://simplefirmware.org\n");
 385
 386         if (sfi_find_syst() || sfi_parse_syst() || sfi_platform_init())
 387                 disable_sfi();
 388
 389         return;
 390 }
 391
 392 void __init sfi_init_late(void)
 393 {
 394         int length;
 395
 396         if (sfi_disabled)
 397                 return;
 398
 399         length = syst_va->header.len;
 400         sfi_unmap_memory(syst_va, sizeof(struct sfi_table_simple));
 401
 402         /* Use ioremap now after it is ready */
 403         sfi_use_ioremap = 1;
 404         syst_va = sfi_map_memory(syst_pa, length);
 405
 406         sfi_acpi_init();
 407 }