Root/
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 | #include <linux/slab.h> |
71 | |
72 | #include "sfi_core.h" |
73 | |
74 | #define ON_SAME_PAGE(addr1, addr2) \ |
75 | (((unsigned long)(addr1) & PAGE_MASK) == \ |
76 | ((unsigned long)(addr2) & PAGE_MASK)) |
77 | #define TABLE_ON_PAGE(page, table, size) (ON_SAME_PAGE(page, table) && \ |
78 | ON_SAME_PAGE(page, table + size)) |
79 | |
80 | int sfi_disabled __read_mostly; |
81 | EXPORT_SYMBOL(sfi_disabled); |
82 | |
83 | static u64 syst_pa __read_mostly; |
84 | static struct sfi_table_simple *syst_va __read_mostly; |
85 | |
86 | /* |
87 | * FW creates and saves the SFI tables in memory. When these tables get |
88 | * used, they may need to be mapped to virtual address space, and the mapping |
89 | * can happen before or after the ioremap() is ready, so a flag is needed |
90 | * to indicating this |
91 | */ |
92 | static u32 sfi_use_ioremap __read_mostly; |
93 | |
94 | /* |
95 | * sfi_un/map_memory calls early_ioremap/iounmap which is a __init function |
96 | * and introduces section mismatch. So use __ref to make it calm. |
97 | */ |
98 | static void __iomem * __ref sfi_map_memory(u64 phys, u32 size) |
99 | { |
100 | if (!phys || !size) |
101 | return NULL; |
102 | |
103 | if (sfi_use_ioremap) |
104 | return ioremap_cache(phys, size); |
105 | else |
106 | return early_ioremap(phys, size); |
107 | } |
108 | |
109 | static void __ref sfi_unmap_memory(void __iomem *virt, u32 size) |
110 | { |
111 | if (!virt || !size) |
112 | return; |
113 | |
114 | if (sfi_use_ioremap) |
115 | iounmap(virt); |
116 | else |
117 | early_iounmap(virt, size); |
118 | } |
119 | |
120 | static void sfi_print_table_header(unsigned long long pa, |
121 | struct sfi_table_header *header) |
122 | { |
123 | pr_info("%4.4s %llX, %04X (v%d %6.6s %8.8s)\n", |
124 | header->sig, pa, |
125 | header->len, header->rev, header->oem_id, |
126 | header->oem_table_id); |
127 | } |
128 | |
129 | /* |
130 | * sfi_verify_table() |
131 | * Sanity check table lengh, calculate checksum |
132 | */ |
133 | static int sfi_verify_table(struct sfi_table_header *table) |
134 | { |
135 | |
136 | u8 checksum = 0; |
137 | u8 *puchar = (u8 *)table; |
138 | u32 length = table->len; |
139 | |
140 | /* Sanity check table length against arbitrary 1MB limit */ |
141 | if (length > 0x100000) { |
142 | pr_err("Invalid table length 0x%x\n", length); |
143 | return -1; |
144 | } |
145 | |
146 | while (length--) |
147 | checksum += *puchar++; |
148 | |
149 | if (checksum) { |
150 | pr_err("Checksum %2.2X should be %2.2X\n", |
151 | table->csum, table->csum - checksum); |
152 | return -1; |
153 | } |
154 | return 0; |
155 | } |
156 | |
157 | /* |
158 | * sfi_map_table() |
159 | * |
160 | * Return address of mapped table |
161 | * Check for common case that we can re-use mapping to SYST, |
162 | * which requires syst_pa, syst_va to be initialized. |
163 | */ |
164 | struct sfi_table_header *sfi_map_table(u64 pa) |
165 | { |
166 | struct sfi_table_header *th; |
167 | u32 length; |
168 | |
169 | if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header))) |
170 | th = sfi_map_memory(pa, sizeof(struct sfi_table_header)); |
171 | else |
172 | th = (void *)syst_va + (pa - syst_pa); |
173 | |
174 | /* If table fits on same page as its header, we are done */ |
175 | if (TABLE_ON_PAGE(th, th, th->len)) |
176 | return th; |
177 | |
178 | /* Entire table does not fit on same page as SYST */ |
179 | length = th->len; |
180 | if (!TABLE_ON_PAGE(syst_pa, pa, sizeof(struct sfi_table_header))) |
181 | sfi_unmap_memory(th, sizeof(struct sfi_table_header)); |
182 | |
183 | return sfi_map_memory(pa, length); |
184 | } |
185 | |
186 | /* |
187 | * sfi_unmap_table() |
188 | * |
189 | * Undoes effect of sfi_map_table() by unmapping table |
190 | * if it did not completely fit on same page as SYST. |
191 | */ |
192 | void sfi_unmap_table(struct sfi_table_header *th) |
193 | { |
194 | if (!TABLE_ON_PAGE(syst_va, th, th->len)) |
195 | sfi_unmap_memory(th, TABLE_ON_PAGE(th, th, th->len) ? |
196 | sizeof(*th) : th->len); |
197 | } |
198 | |
199 | static int sfi_table_check_key(struct sfi_table_header *th, |
200 | struct sfi_table_key *key) |
201 | { |
202 | |
203 | if (strncmp(th->sig, key->sig, SFI_SIGNATURE_SIZE) |
204 | || (key->oem_id && strncmp(th->oem_id, |
205 | key->oem_id, SFI_OEM_ID_SIZE)) |
206 | || (key->oem_table_id && strncmp(th->oem_table_id, |
207 | key->oem_table_id, SFI_OEM_TABLE_ID_SIZE))) |
208 | return -1; |
209 | |
210 | return 0; |
211 | } |
212 | |
213 | /* |
214 | * This function will be used in 2 cases: |
215 | * 1. used to enumerate and verify the tables addressed by SYST/XSDT, |
216 | * thus no signature will be given (in kernel boot phase) |
217 | * 2. used to parse one specific table, signature must exist, and |
218 | * the mapped virt address will be returned, and the virt space |
219 | * will be released by call sfi_put_table() later |
220 | * |
221 | * This two cases are from two different functions with two different |
222 | * sections and causes section mismatch warning. So use __ref to tell |
223 | * modpost not to make any noise. |
224 | * |
225 | * Return value: |
226 | * NULL: when can't find a table matching the key |
227 | * ERR_PTR(error): error value |
228 | * virt table address: when a matched table is found |
229 | */ |
230 | struct sfi_table_header * |
231 | __ref sfi_check_table(u64 pa, struct sfi_table_key *key) |
232 | { |
233 | struct sfi_table_header *th; |
234 | void *ret = NULL; |
235 | |
236 | th = sfi_map_table(pa); |
237 | if (!th) |
238 | return ERR_PTR(-ENOMEM); |
239 | |
240 | if (!key->sig) { |
241 | sfi_print_table_header(pa, th); |
242 | if (sfi_verify_table(th)) |
243 | ret = ERR_PTR(-EINVAL); |
244 | } else { |
245 | if (!sfi_table_check_key(th, key)) |
246 | return th; /* Success */ |
247 | } |
248 | |
249 | sfi_unmap_table(th); |
250 | return ret; |
251 | } |
252 | |
253 | /* |
254 | * sfi_get_table() |
255 | * |
256 | * Search SYST for the specified table with the signature in |
257 | * the key, and return the mapped table |
258 | */ |
259 | struct sfi_table_header *sfi_get_table(struct sfi_table_key *key) |
260 | { |
261 | struct sfi_table_header *th; |
262 | u32 tbl_cnt, i; |
263 | |
264 | tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64); |
265 | for (i = 0; i < tbl_cnt; i++) { |
266 | th = sfi_check_table(syst_va->pentry[i], key); |
267 | if (!IS_ERR(th) && th) |
268 | return th; |
269 | } |
270 | |
271 | return NULL; |
272 | } |
273 | |
274 | void sfi_put_table(struct sfi_table_header *th) |
275 | { |
276 | sfi_unmap_table(th); |
277 | } |
278 | |
279 | /* Find table with signature, run handler on it */ |
280 | int sfi_table_parse(char *signature, char *oem_id, char *oem_table_id, |
281 | sfi_table_handler handler) |
282 | { |
283 | struct sfi_table_header *table = NULL; |
284 | struct sfi_table_key key; |
285 | int ret = -EINVAL; |
286 | |
287 | if (sfi_disabled || !handler || !signature) |
288 | goto exit; |
289 | |
290 | key.sig = signature; |
291 | key.oem_id = oem_id; |
292 | key.oem_table_id = oem_table_id; |
293 | |
294 | table = sfi_get_table(&key); |
295 | if (!table) |
296 | goto exit; |
297 | |
298 | ret = handler(table); |
299 | sfi_put_table(table); |
300 | exit: |
301 | return ret; |
302 | } |
303 | EXPORT_SYMBOL_GPL(sfi_table_parse); |
304 | |
305 | /* |
306 | * sfi_parse_syst() |
307 | * Checksum all the tables in SYST and print their headers |
308 | * |
309 | * success: set syst_va, return 0 |
310 | */ |
311 | static int __init sfi_parse_syst(void) |
312 | { |
313 | struct sfi_table_key key = SFI_ANY_KEY; |
314 | int tbl_cnt, i; |
315 | void *ret; |
316 | |
317 | syst_va = sfi_map_memory(syst_pa, sizeof(struct sfi_table_simple)); |
318 | if (!syst_va) |
319 | return -ENOMEM; |
320 | |
321 | tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64); |
322 | for (i = 0; i < tbl_cnt; i++) { |
323 | ret = sfi_check_table(syst_va->pentry[i], &key); |
324 | if (IS_ERR(ret)) |
325 | return PTR_ERR(ret); |
326 | } |
327 | |
328 | return 0; |
329 | } |
330 | |
331 | /* |
332 | * The OS finds the System Table by searching 16-byte boundaries between |
333 | * physical address 0x000E0000 and 0x000FFFFF. The OS shall search this region |
334 | * starting at the low address and shall stop searching when the 1st valid SFI |
335 | * System Table is found. |
336 | * |
337 | * success: set syst_pa, return 0 |
338 | * fail: return -1 |
339 | */ |
340 | static __init int sfi_find_syst(void) |
341 | { |
342 | unsigned long offset, len; |
343 | void *start; |
344 | |
345 | len = SFI_SYST_SEARCH_END - SFI_SYST_SEARCH_BEGIN; |
346 | start = sfi_map_memory(SFI_SYST_SEARCH_BEGIN, len); |
347 | if (!start) |
348 | return -1; |
349 | |
350 | for (offset = 0; offset < len; offset += 16) { |
351 | struct sfi_table_header *syst_hdr; |
352 | |
353 | syst_hdr = start + offset; |
354 | if (strncmp(syst_hdr->sig, SFI_SIG_SYST, |
355 | SFI_SIGNATURE_SIZE)) |
356 | continue; |
357 | |
358 | if (syst_hdr->len > PAGE_SIZE) |
359 | continue; |
360 | |
361 | sfi_print_table_header(SFI_SYST_SEARCH_BEGIN + offset, |
362 | syst_hdr); |
363 | |
364 | if (sfi_verify_table(syst_hdr)) |
365 | continue; |
366 | |
367 | /* |
368 | * Enforce SFI spec mandate that SYST reside within a page. |
369 | */ |
370 | if (!ON_SAME_PAGE(syst_pa, syst_pa + syst_hdr->len)) { |
371 | pr_info("SYST 0x%llx + 0x%x crosses page\n", |
372 | syst_pa, syst_hdr->len); |
373 | continue; |
374 | } |
375 | |
376 | /* Success */ |
377 | syst_pa = SFI_SYST_SEARCH_BEGIN + offset; |
378 | sfi_unmap_memory(start, len); |
379 | return 0; |
380 | } |
381 | |
382 | sfi_unmap_memory(start, len); |
383 | return -1; |
384 | } |
385 | |
386 | static struct kobject *sfi_kobj; |
387 | static struct kobject *tables_kobj; |
388 | |
389 | static ssize_t sfi_table_show(struct file *filp, struct kobject *kobj, |
390 | struct bin_attribute *bin_attr, char *buf, |
391 | loff_t offset, size_t count) |
392 | { |
393 | struct sfi_table_attr *tbl_attr = |
394 | container_of(bin_attr, struct sfi_table_attr, attr); |
395 | struct sfi_table_header *th = NULL; |
396 | struct sfi_table_key key; |
397 | ssize_t cnt; |
398 | |
399 | key.sig = tbl_attr->name; |
400 | key.oem_id = NULL; |
401 | key.oem_table_id = NULL; |
402 | |
403 | if (strncmp(SFI_SIG_SYST, tbl_attr->name, SFI_SIGNATURE_SIZE)) { |
404 | th = sfi_get_table(&key); |
405 | if (!th) |
406 | return 0; |
407 | |
408 | cnt = memory_read_from_buffer(buf, count, &offset, |
409 | th, th->len); |
410 | sfi_put_table(th); |
411 | } else |
412 | cnt = memory_read_from_buffer(buf, count, &offset, |
413 | syst_va, syst_va->header.len); |
414 | |
415 | return cnt; |
416 | } |
417 | |
418 | struct sfi_table_attr __init *sfi_sysfs_install_table(u64 pa) |
419 | { |
420 | struct sfi_table_attr *tbl_attr; |
421 | struct sfi_table_header *th; |
422 | int ret; |
423 | |
424 | tbl_attr = kzalloc(sizeof(struct sfi_table_attr), GFP_KERNEL); |
425 | if (!tbl_attr) |
426 | return NULL; |
427 | |
428 | th = sfi_map_table(pa); |
429 | if (!th || !th->sig[0]) { |
430 | kfree(tbl_attr); |
431 | return NULL; |
432 | } |
433 | |
434 | sysfs_attr_init(&tbl_attr->attr.attr); |
435 | memcpy(tbl_attr->name, th->sig, SFI_SIGNATURE_SIZE); |
436 | |
437 | tbl_attr->attr.size = 0; |
438 | tbl_attr->attr.read = sfi_table_show; |
439 | tbl_attr->attr.attr.name = tbl_attr->name; |
440 | tbl_attr->attr.attr.mode = 0400; |
441 | |
442 | ret = sysfs_create_bin_file(tables_kobj, |
443 | &tbl_attr->attr); |
444 | if (ret) { |
445 | kfree(tbl_attr); |
446 | tbl_attr = NULL; |
447 | } |
448 | |
449 | sfi_unmap_table(th); |
450 | return tbl_attr; |
451 | } |
452 | |
453 | static int __init sfi_sysfs_init(void) |
454 | { |
455 | int tbl_cnt, i; |
456 | |
457 | if (sfi_disabled) |
458 | return 0; |
459 | |
460 | sfi_kobj = kobject_create_and_add("sfi", firmware_kobj); |
461 | if (!sfi_kobj) |
462 | return 0; |
463 | |
464 | tables_kobj = kobject_create_and_add("tables", sfi_kobj); |
465 | if (!tables_kobj) { |
466 | kobject_put(sfi_kobj); |
467 | return 0; |
468 | } |
469 | |
470 | sfi_sysfs_install_table(syst_pa); |
471 | |
472 | tbl_cnt = SFI_GET_NUM_ENTRIES(syst_va, u64); |
473 | |
474 | for (i = 0; i < tbl_cnt; i++) |
475 | sfi_sysfs_install_table(syst_va->pentry[i]); |
476 | |
477 | sfi_acpi_sysfs_init(); |
478 | kobject_uevent(sfi_kobj, KOBJ_ADD); |
479 | kobject_uevent(tables_kobj, KOBJ_ADD); |
480 | pr_info("SFI sysfs interfaces init success\n"); |
481 | return 0; |
482 | } |
483 | |
484 | void __init sfi_init(void) |
485 | { |
486 | if (!acpi_disabled) |
487 | disable_sfi(); |
488 | |
489 | if (sfi_disabled) |
490 | return; |
491 | |
492 | pr_info("Simple Firmware Interface v0.81 http://simplefirmware.org\n"); |
493 | |
494 | if (sfi_find_syst() || sfi_parse_syst() || sfi_platform_init()) |
495 | disable_sfi(); |
496 | |
497 | return; |
498 | } |
499 | |
500 | void __init sfi_init_late(void) |
501 | { |
502 | int length; |
503 | |
504 | if (sfi_disabled) |
505 | return; |
506 | |
507 | length = syst_va->header.len; |
508 | sfi_unmap_memory(syst_va, sizeof(struct sfi_table_simple)); |
509 | |
510 | /* Use ioremap now after it is ready */ |
511 | sfi_use_ioremap = 1; |
512 | syst_va = sfi_map_memory(syst_pa, length); |
513 | |
514 | sfi_acpi_init(); |
515 | } |
516 | |
517 | /* |
518 | * The reason we put it here because we need wait till the /sys/firmware |
519 | * is setup, then our interface can be registered in /sys/firmware/sfi |
520 | */ |
521 | core_initcall(sfi_sysfs_init); |
522 |
Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.11
jz-3.12
jz-3.13
jz-3.15
jz-3.16
jz-3.18-dt
jz-3.2
jz-3.3
jz-3.4
jz-3.5
jz-3.6
jz-3.6-rc2-pwm
jz-3.9
jz-3.9-clk
jz-3.9-rc8
jz47xx
jz47xx-2.6.38
master
Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7
v3.9