ia64/xen-unstable

view xen/drivers/acpi/tables/tbfadt.c @ 18896:f7f8f44b9292

tools: Fix a few error-path memory leaks.

Signed-off-by: Keir Fraser <keir.fraser@citrix.com>
author Keir Fraser <keir.fraser@citrix.com>
date Tue Dec 09 12:53:19 2008 +0000 (2008-12-09)
parents ae29cd95ba7d
children
line source
1 /******************************************************************************
2 *
3 * Module Name: tbfadt - FADT table utilities
4 *
5 *****************************************************************************/
7 /*
8 * Copyright (C) 2000 - 2008, Intel Corp.
9 * All rights reserved.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions, and the following disclaimer,
16 * without modification.
17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
18 * substantially similar to the "NO WARRANTY" disclaimer below
19 * ("Disclaimer") and any redistribution must be conditioned upon
20 * including a substantially similar Disclaimer requirement for further
21 * binary redistribution.
22 * 3. Neither the names of the above-listed copyright holders nor the names
23 * of any contributors may be used to endorse or promote products derived
24 * from this software without specific prior written permission.
25 *
26 * Alternatively, this software may be distributed under the terms of the
27 * GNU General Public License ("GPL") version 2 as published by the Free
28 * Software Foundation.
29 *
30 * NO WARRANTY
31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
41 * POSSIBILITY OF SUCH DAMAGES.
42 */
44 #include <xen/config.h>
45 #include <xen/init.h>
46 #include <acpi/acpi.h>
47 #include <acpi/actables.h>
49 #define _COMPONENT ACPI_TABLES
50 ACPI_MODULE_NAME("tbfadt")
52 /* Local prototypes */
53 static void inline
54 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
55 u8 bit_width, u64 address);
57 static void acpi_tb_convert_fadt(void);
59 static void acpi_tb_validate_fadt(void);
61 /* Table for conversion of FADT to common internal format and FADT validation */
63 typedef struct acpi_fadt_info {
64 char *name;
65 u8 target;
66 u8 source;
67 u8 length;
68 u8 type;
70 } acpi_fadt_info;
72 #define ACPI_FADT_REQUIRED 1
73 #define ACPI_FADT_SEPARATE_LENGTH 2
75 static struct acpi_fadt_info __initdata fadt_info_table[] = {
76 {"Pm1aEventBlock", ACPI_FADT_OFFSET(xpm1a_event_block),
77 ACPI_FADT_OFFSET(pm1a_event_block),
78 ACPI_FADT_OFFSET(pm1_event_length), ACPI_FADT_REQUIRED},
80 {"Pm1bEventBlock", ACPI_FADT_OFFSET(xpm1b_event_block),
81 ACPI_FADT_OFFSET(pm1b_event_block),
82 ACPI_FADT_OFFSET(pm1_event_length), 0},
84 {"Pm1aControlBlock", ACPI_FADT_OFFSET(xpm1a_control_block),
85 ACPI_FADT_OFFSET(pm1a_control_block),
86 ACPI_FADT_OFFSET(pm1_control_length), ACPI_FADT_REQUIRED},
88 {"Pm1bControlBlock", ACPI_FADT_OFFSET(xpm1b_control_block),
89 ACPI_FADT_OFFSET(pm1b_control_block),
90 ACPI_FADT_OFFSET(pm1_control_length), 0},
92 {"Pm2ControlBlock", ACPI_FADT_OFFSET(xpm2_control_block),
93 ACPI_FADT_OFFSET(pm2_control_block),
94 ACPI_FADT_OFFSET(pm2_control_length), ACPI_FADT_SEPARATE_LENGTH},
96 {"PmTimerBlock", ACPI_FADT_OFFSET(xpm_timer_block),
97 ACPI_FADT_OFFSET(pm_timer_block),
98 ACPI_FADT_OFFSET(pm_timer_length), ACPI_FADT_REQUIRED},
100 {"Gpe0Block", ACPI_FADT_OFFSET(xgpe0_block),
101 ACPI_FADT_OFFSET(gpe0_block),
102 ACPI_FADT_OFFSET(gpe0_block_length), ACPI_FADT_SEPARATE_LENGTH},
104 {"Gpe1Block", ACPI_FADT_OFFSET(xgpe1_block),
105 ACPI_FADT_OFFSET(gpe1_block),
106 ACPI_FADT_OFFSET(gpe1_block_length), ACPI_FADT_SEPARATE_LENGTH}
107 };
109 #define ACPI_FADT_INFO_ENTRIES (sizeof (fadt_info_table) / sizeof (struct acpi_fadt_info))
111 /*******************************************************************************
112 *
113 * FUNCTION: acpi_tb_init_generic_address
114 *
115 * PARAMETERS: generic_address - GAS struct to be initialized
116 * bit_width - Width of this register
117 * Address - Address of the register
118 *
119 * RETURN: None
120 *
121 * DESCRIPTION: Initialize a Generic Address Structure (GAS)
122 * See the ACPI specification for a full description and
123 * definition of this structure.
124 *
125 ******************************************************************************/
127 static void inline
128 acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
129 u8 bit_width, u64 address)
130 {
132 /*
133 * The 64-bit Address field is non-aligned in the byte packed
134 * GAS struct.
135 */
136 ACPI_MOVE_64_TO_64(&generic_address->address, &address);
138 /* All other fields are byte-wide */
140 generic_address->space_id = ACPI_ADR_SPACE_SYSTEM_IO;
141 generic_address->bit_width = bit_width;
142 generic_address->bit_offset = 0;
143 generic_address->access_width = 0;
144 }
146 /*******************************************************************************
147 *
148 * FUNCTION: acpi_tb_parse_fadt
149 *
150 * PARAMETERS: table_index - Index for the FADT
151 * Flags - Flags
152 *
153 * RETURN: None
154 *
155 * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
156 * (FADT contains the addresses of the DSDT and FACS)
157 *
158 ******************************************************************************/
160 void __init acpi_tb_parse_fadt(acpi_native_uint table_index, u8 flags)
161 {
162 u32 length;
163 struct acpi_table_header *table;
165 /*
166 * The FADT has multiple versions with different lengths,
167 * and it contains pointers to both the DSDT and FACS tables.
168 *
169 * Get a local copy of the FADT and convert it to a common format
170 * Map entire FADT, assumed to be smaller than one page.
171 */
172 length = acpi_gbl_root_table_list.tables[table_index].length;
174 table =
175 acpi_os_map_memory(acpi_gbl_root_table_list.tables[table_index].
176 address, length);
177 if (!table) {
178 return;
179 }
181 /*
182 * Validate the FADT checksum before we copy the table. Ignore
183 * checksum error as we want to try to get the DSDT and FACS.
184 */
185 (void)acpi_tb_verify_checksum(table, length);
187 /* Obtain a local copy of the FADT in common ACPI 2.0+ format */
189 acpi_tb_create_local_fadt(table, length);
191 /* All done with the real FADT, unmap it */
193 acpi_os_unmap_memory(table, length);
195 /* Obtain the DSDT and FACS tables via their addresses within the FADT */
197 acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt,
198 flags, ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
200 acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xfacs,
201 flags, ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS);
202 }
204 /*******************************************************************************
205 *
206 * FUNCTION: acpi_tb_create_local_fadt
207 *
208 * PARAMETERS: Table - Pointer to BIOS FADT
209 * Length - Length of the table
210 *
211 * RETURN: None
212 *
213 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
214 * Performs validation on some important FADT fields.
215 *
216 * NOTE: We create a local copy of the FADT regardless of the version.
217 *
218 ******************************************************************************/
220 void __init acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
221 {
223 /*
224 * Check if the FADT is larger than the largest table that we expect
225 * (the ACPI 2.0/3.0 version). If so, truncate the table, and issue
226 * a warning.
227 */
228 if (length > sizeof(struct acpi_table_fadt)) {
229 ACPI_WARNING((AE_INFO,
230 "FADT (revision %u) is longer than ACPI 2.0 version, truncating length 0x%X to 0x%zX",
231 table->revision, (unsigned)length,
232 sizeof(struct acpi_table_fadt)));
233 }
235 /* Clear the entire local FADT */
237 ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt));
239 /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */
241 ACPI_MEMCPY(&acpi_gbl_FADT, table,
242 ACPI_MIN(length, sizeof(struct acpi_table_fadt)));
244 /*
245 * 1) Convert the local copy of the FADT to the common internal format
246 * 2) Validate some of the important values within the FADT
247 */
248 acpi_tb_convert_fadt();
249 acpi_tb_validate_fadt();
250 }
252 /*******************************************************************************
253 *
254 * FUNCTION: acpi_tb_convert_fadt
255 *
256 * PARAMETERS: None, uses acpi_gbl_FADT
257 *
258 * RETURN: None
259 *
260 * DESCRIPTION: Converts all versions of the FADT to a common internal format.
261 * Expand all 32-bit addresses to 64-bit.
262 *
263 * NOTE: acpi_gbl_FADT must be of size (struct acpi_table_fadt),
264 * and must contain a copy of the actual FADT.
265 *
266 * ACPICA will use the "X" fields of the FADT for all addresses.
267 *
268 * "X" fields are optional extensions to the original V1.0 fields. Even if
269 * they are present in the structure, they can be optionally not used by
270 * setting them to zero. Therefore, we must selectively expand V1.0 fields
271 * if the corresponding X field is zero.
272 *
273 * For ACPI 1.0 FADTs, all address fields are expanded to the corresponding
274 * "X" fields.
275 *
276 * For ACPI 2.0 FADTs, any "X" fields that are NULL are filled in by
277 * expanding the corresponding ACPI 1.0 field.
278 *
279 ******************************************************************************/
281 static void __init acpi_tb_convert_fadt(void)
282 {
283 u8 pm1_register_length;
284 struct acpi_generic_address *target;
285 acpi_native_uint i;
287 /* Update the local FADT table header length */
289 acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
291 /* Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary */
293 if (!acpi_gbl_FADT.Xfacs) {
294 acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
295 }
297 if (!acpi_gbl_FADT.Xdsdt) {
298 acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
299 }
301 /*
302 * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
303 * should be zero are indeed zero. This will workaround BIOSs that
304 * inadvertently place values in these fields.
305 *
306 * The ACPI 1.0 reserved fields that will be zeroed are the bytes located at
307 * offset 45, 55, 95, and the word located at offset 109, 110.
308 */
309 if (acpi_gbl_FADT.header.revision < 3) {
310 acpi_gbl_FADT.preferred_profile = 0;
311 acpi_gbl_FADT.pstate_control = 0;
312 acpi_gbl_FADT.cst_control = 0;
313 acpi_gbl_FADT.boot_flags = 0;
314 }
316 /*
317 * Expand the ACPI 1.0 32-bit V1.0 addresses to the ACPI 2.0 64-bit "X"
318 * generic address structures as necessary.
319 */
320 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
321 target =
322 ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT,
323 fadt_info_table[i].target);
325 /* Expand only if the X target is null */
327 if (!target->address) {
328 acpi_tb_init_generic_address(target,
329 *ACPI_ADD_PTR(u8,
330 &acpi_gbl_FADT,
331 fadt_info_table
332 [i].length),
333 (u64) * ACPI_ADD_PTR(u32,
334 &acpi_gbl_FADT,
335 fadt_info_table
336 [i].
337 source));
338 }
339 }
341 /*
342 * Calculate separate GAS structs for the PM1 Enable registers.
343 * These addresses do not appear (directly) in the FADT, so it is
344 * useful to calculate them once, here.
345 *
346 * The PM event blocks are split into two register blocks, first is the
347 * PM Status Register block, followed immediately by the PM Enable Register
348 * block. Each is of length (pm1_event_length/2)
349 */
350 pm1_register_length = (u8) ACPI_DIV_2(acpi_gbl_FADT.pm1_event_length);
352 /* The PM1A register block is required */
354 acpi_tb_init_generic_address(&acpi_gbl_xpm1a_enable,
355 pm1_register_length,
356 (acpi_gbl_FADT.xpm1a_event_block.address +
357 pm1_register_length));
358 /* Don't forget to copy space_id of the GAS */
359 acpi_gbl_xpm1a_enable.space_id =
360 acpi_gbl_FADT.xpm1a_event_block.space_id;
362 /* The PM1B register block is optional, ignore if not present */
364 if (acpi_gbl_FADT.xpm1b_event_block.address) {
365 acpi_tb_init_generic_address(&acpi_gbl_xpm1b_enable,
366 pm1_register_length,
367 (acpi_gbl_FADT.xpm1b_event_block.
368 address + pm1_register_length));
369 /* Don't forget to copy space_id of the GAS */
370 acpi_gbl_xpm1b_enable.space_id =
371 acpi_gbl_FADT.xpm1a_event_block.space_id;
373 }
374 }
376 /******************************************************************************
377 *
378 * FUNCTION: acpi_tb_validate_fadt
379 *
380 * PARAMETERS: Table - Pointer to the FADT to be validated
381 *
382 * RETURN: None
383 *
384 * DESCRIPTION: Validate various important fields within the FADT. If a problem
385 * is found, issue a message, but no status is returned.
386 * Used by both the table manager and the disassembler.
387 *
388 * Possible additional checks:
389 * (acpi_gbl_FADT.pm1_event_length >= 4)
390 * (acpi_gbl_FADT.pm1_control_length >= 2)
391 * (acpi_gbl_FADT.pm_timer_length >= 4)
392 * Gpe block lengths must be multiple of 2
393 *
394 ******************************************************************************/
396 static void __init acpi_tb_validate_fadt(void)
397 {
398 u32 *address32;
399 struct acpi_generic_address *address64;
400 u8 length;
401 acpi_native_uint i;
403 /* Examine all of the 64-bit extended address fields (X fields) */
405 for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
407 /* Generate pointers to the 32-bit and 64-bit addresses and get the length */
409 address64 =
410 ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT,
411 fadt_info_table[i].target);
412 address32 =
413 ACPI_ADD_PTR(u32, &acpi_gbl_FADT,
414 fadt_info_table[i].source);
415 length =
416 *ACPI_ADD_PTR(u8, &acpi_gbl_FADT,
417 fadt_info_table[i].length);
419 if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) {
420 /*
421 * Field is required (Pm1a_event, Pm1a_control, pm_timer).
422 * Both the address and length must be non-zero.
423 */
424 if (!address64->address || !length) {
425 ACPI_ERROR((AE_INFO,
426 "Required field \"%s\" has zero address and/or length: %8.8X%8.8X/%X",
427 fadt_info_table[i].name,
428 ACPI_FORMAT_UINT64(address64->
429 address),
430 length));
431 }
432 } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) {
433 /*
434 * Field is optional (PM2Control, GPE0, GPE1) AND has its own
435 * length field. If present, both the address and length must be valid.
436 */
437 if ((address64->address && !length)
438 || (!address64->address && length)) {
439 ACPI_WARNING((AE_INFO,
440 "Optional field \"%s\" has zero address or length: %8.8X%8.8X/%X",
441 fadt_info_table[i].name,
442 ACPI_FORMAT_UINT64(address64->
443 address),
444 length));
445 }
446 }
448 /* If both 32- and 64-bit addresses are valid (non-zero), they must match */
450 if (address64->address && *address32 &&
451 (address64->address != (u64) * address32)) {
452 ACPI_ERROR((AE_INFO,
453 "32/64X address mismatch in \"%s\": [%8.8X] [%8.8X%8.8X], using 64X",
454 fadt_info_table[i].name, *address32,
455 ACPI_FORMAT_UINT64(address64->address)));
456 }
457 }
458 }