OpenCores
URL https://opencores.org/ocsvn/test_project/test_project/trunk

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [acpi/] [tables/] [tbfadt.c] - Blame information for rev 67

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 62 marcus.erl
/******************************************************************************
2
 *
3
 * Module Name: tbfadt   - FADT table utilities
4
 *
5
 *****************************************************************************/
6
 
7
/*
8
 * Copyright (C) 2000 - 2007, R. Byron Moore
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
 */
43
 
44
#include <acpi/acpi.h>
45
#include <acpi/actables.h>
46
 
47
#define _COMPONENT          ACPI_TABLES
48
ACPI_MODULE_NAME("tbfadt")
49
 
50
/* Local prototypes */
51
static void inline
52
acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
53
                             u8 bit_width, u64 address);
54
 
55
static void acpi_tb_convert_fadt(void);
56
 
57
static void acpi_tb_validate_fadt(void);
58
 
59
/* Table for conversion of FADT to common internal format and FADT validation */
60
 
61
typedef struct acpi_fadt_info {
62
        char *name;
63
        u8 target;
64
        u8 source;
65
        u8 length;
66
        u8 type;
67
 
68
} acpi_fadt_info;
69
 
70
#define ACPI_FADT_REQUIRED          1
71
#define ACPI_FADT_SEPARATE_LENGTH   2
72
 
73
static struct acpi_fadt_info fadt_info_table[] = {
74
        {"Pm1aEventBlock", ACPI_FADT_OFFSET(xpm1a_event_block),
75
         ACPI_FADT_OFFSET(pm1a_event_block),
76
         ACPI_FADT_OFFSET(pm1_event_length), ACPI_FADT_REQUIRED},
77
 
78
        {"Pm1bEventBlock", ACPI_FADT_OFFSET(xpm1b_event_block),
79
         ACPI_FADT_OFFSET(pm1b_event_block),
80
         ACPI_FADT_OFFSET(pm1_event_length), 0},
81
 
82
        {"Pm1aControlBlock", ACPI_FADT_OFFSET(xpm1a_control_block),
83
         ACPI_FADT_OFFSET(pm1a_control_block),
84
         ACPI_FADT_OFFSET(pm1_control_length), ACPI_FADT_REQUIRED},
85
 
86
        {"Pm1bControlBlock", ACPI_FADT_OFFSET(xpm1b_control_block),
87
         ACPI_FADT_OFFSET(pm1b_control_block),
88
         ACPI_FADT_OFFSET(pm1_control_length), 0},
89
 
90
        {"Pm2ControlBlock", ACPI_FADT_OFFSET(xpm2_control_block),
91
         ACPI_FADT_OFFSET(pm2_control_block),
92
         ACPI_FADT_OFFSET(pm2_control_length), ACPI_FADT_SEPARATE_LENGTH},
93
 
94
        {"PmTimerBlock", ACPI_FADT_OFFSET(xpm_timer_block),
95
         ACPI_FADT_OFFSET(pm_timer_block),
96
         ACPI_FADT_OFFSET(pm_timer_length), ACPI_FADT_REQUIRED},
97
 
98
        {"Gpe0Block", ACPI_FADT_OFFSET(xgpe0_block),
99
         ACPI_FADT_OFFSET(gpe0_block),
100
         ACPI_FADT_OFFSET(gpe0_block_length), ACPI_FADT_SEPARATE_LENGTH},
101
 
102
        {"Gpe1Block", ACPI_FADT_OFFSET(xgpe1_block),
103
         ACPI_FADT_OFFSET(gpe1_block),
104
         ACPI_FADT_OFFSET(gpe1_block_length), ACPI_FADT_SEPARATE_LENGTH}
105
};
106
 
107
#define ACPI_FADT_INFO_ENTRIES        (sizeof (fadt_info_table) / sizeof (struct acpi_fadt_info))
108
 
109
/*******************************************************************************
110
 *
111
 * FUNCTION:    acpi_tb_init_generic_address
112
 *
113
 * PARAMETERS:  generic_address     - GAS struct to be initialized
114
 *              bit_width           - Width of this register
115
 *              Address             - Address of the register
116
 *
117
 * RETURN:      None
118
 *
119
 * DESCRIPTION: Initialize a Generic Address Structure (GAS)
120
 *              See the ACPI specification for a full description and
121
 *              definition of this structure.
122
 *
123
 ******************************************************************************/
124
 
125
static void inline
126
acpi_tb_init_generic_address(struct acpi_generic_address *generic_address,
127
                             u8 bit_width, u64 address)
128
{
129
 
130
        /*
131
         * The 64-bit Address field is non-aligned in the byte packed
132
         * GAS struct.
133
         */
134
        ACPI_MOVE_64_TO_64(&generic_address->address, &address);
135
 
136
        /* All other fields are byte-wide */
137
 
138
        generic_address->space_id = ACPI_ADR_SPACE_SYSTEM_IO;
139
        generic_address->bit_width = bit_width;
140
        generic_address->bit_offset = 0;
141
        generic_address->access_width = 0;
142
}
143
 
144
/*******************************************************************************
145
 *
146
 * FUNCTION:    acpi_tb_parse_fadt
147
 *
148
 * PARAMETERS:  table_index         - Index for the FADT
149
 *              Flags               - Flags
150
 *
151
 * RETURN:      None
152
 *
153
 * DESCRIPTION: Initialize the FADT, DSDT and FACS tables
154
 *              (FADT contains the addresses of the DSDT and FACS)
155
 *
156
 ******************************************************************************/
157
 
158
void acpi_tb_parse_fadt(acpi_native_uint table_index, u8 flags)
159
{
160
        u32 length;
161
        struct acpi_table_header *table;
162
 
163
        /*
164
         * The FADT has multiple versions with different lengths,
165
         * and it contains pointers to both the DSDT and FACS tables.
166
         *
167
         * Get a local copy of the FADT and convert it to a common format
168
         * Map entire FADT, assumed to be smaller than one page.
169
         */
170
        length = acpi_gbl_root_table_list.tables[table_index].length;
171
 
172
        table =
173
            acpi_os_map_memory(acpi_gbl_root_table_list.tables[table_index].
174
                               address, length);
175
        if (!table) {
176
                return;
177
        }
178
 
179
        /*
180
         * Validate the FADT checksum before we copy the table. Ignore
181
         * checksum error as we want to try to get the DSDT and FACS.
182
         */
183
        (void)acpi_tb_verify_checksum(table, length);
184
 
185
        /* Obtain a local copy of the FADT in common ACPI 2.0+ format */
186
 
187
        acpi_tb_create_local_fadt(table, length);
188
 
189
        /* All done with the real FADT, unmap it */
190
 
191
        acpi_os_unmap_memory(table, length);
192
 
193
        /* Obtain the DSDT and FACS tables via their addresses within the FADT */
194
 
195
        acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xdsdt,
196
                              flags, ACPI_SIG_DSDT, ACPI_TABLE_INDEX_DSDT);
197
 
198
        acpi_tb_install_table((acpi_physical_address) acpi_gbl_FADT.Xfacs,
199
                              flags, ACPI_SIG_FACS, ACPI_TABLE_INDEX_FACS);
200
}
201
 
202
/*******************************************************************************
203
 *
204
 * FUNCTION:    acpi_tb_create_local_fadt
205
 *
206
 * PARAMETERS:  Table               - Pointer to BIOS FADT
207
 *              Length              - Length of the table
208
 *
209
 * RETURN:      None
210
 *
211
 * DESCRIPTION: Get a local copy of the FADT and convert it to a common format.
212
 *              Performs validation on some important FADT fields.
213
 *
214
 * NOTE:        We create a local copy of the FADT regardless of the version.
215
 *
216
 ******************************************************************************/
217
 
218
void acpi_tb_create_local_fadt(struct acpi_table_header *table, u32 length)
219
{
220
 
221
        /*
222
         * Check if the FADT is larger than the largest table that we expect
223
         * (the ACPI 2.0/3.0 version). If so, truncate the table, and issue
224
         * a warning.
225
         */
226
        if (length > sizeof(struct acpi_table_fadt)) {
227
                ACPI_WARNING((AE_INFO,
228
                              "FADT (revision %u) is longer than ACPI 2.0 version, truncating length 0x%X to 0x%zX",
229
                              table->revision, (unsigned)length,
230
                              sizeof(struct acpi_table_fadt)));
231
        }
232
 
233
        /* Clear the entire local FADT */
234
 
235
        ACPI_MEMSET(&acpi_gbl_FADT, 0, sizeof(struct acpi_table_fadt));
236
 
237
        /* Copy the original FADT, up to sizeof (struct acpi_table_fadt) */
238
 
239
        ACPI_MEMCPY(&acpi_gbl_FADT, table,
240
                    ACPI_MIN(length, sizeof(struct acpi_table_fadt)));
241
 
242
        /*
243
         * 1) Convert the local copy of the FADT to the common internal format
244
         * 2) Validate some of the important values within the FADT
245
         */
246
        acpi_tb_convert_fadt();
247
        acpi_tb_validate_fadt();
248
}
249
 
250
/*******************************************************************************
251
 *
252
 * FUNCTION:    acpi_tb_convert_fadt
253
 *
254
 * PARAMETERS:  None, uses acpi_gbl_FADT
255
 *
256
 * RETURN:      None
257
 *
258
 * DESCRIPTION: Converts all versions of the FADT to a common internal format.
259
 *              Expand all 32-bit addresses to 64-bit.
260
 *
261
 * NOTE:        acpi_gbl_FADT must be of size (struct acpi_table_fadt),
262
 *              and must contain a copy of the actual FADT.
263
 *
264
 * ACPICA will use the "X" fields of the FADT for all addresses.
265
 *
266
 * "X" fields are optional extensions to the original V1.0 fields. Even if
267
 * they are present in the structure, they can be optionally not used by
268
 * setting them to zero. Therefore, we must selectively expand V1.0 fields
269
 * if the corresponding X field is zero.
270
 *
271
 * For ACPI 1.0 FADTs, all address fields are expanded to the corresponding
272
 * "X" fields.
273
 *
274
 * For ACPI 2.0 FADTs, any "X" fields that are NULL are filled in by
275
 * expanding the corresponding ACPI 1.0 field.
276
 *
277
 ******************************************************************************/
278
 
279
static void acpi_tb_convert_fadt(void)
280
{
281
        u8 pm1_register_length;
282
        struct acpi_generic_address *target;
283
        acpi_native_uint i;
284
 
285
        /* Update the local FADT table header length */
286
 
287
        acpi_gbl_FADT.header.length = sizeof(struct acpi_table_fadt);
288
 
289
        /* Expand the 32-bit FACS and DSDT addresses to 64-bit as necessary */
290
 
291
        if (!acpi_gbl_FADT.Xfacs) {
292
                acpi_gbl_FADT.Xfacs = (u64) acpi_gbl_FADT.facs;
293
        }
294
 
295
        if (!acpi_gbl_FADT.Xdsdt) {
296
                acpi_gbl_FADT.Xdsdt = (u64) acpi_gbl_FADT.dsdt;
297
        }
298
 
299
        /*
300
         * For ACPI 1.0 FADTs (revision 1 or 2), ensure that reserved fields which
301
         * should be zero are indeed zero. This will workaround BIOSs that
302
         * inadvertently place values in these fields.
303
         *
304
         * The ACPI 1.0 reserved fields that will be zeroed are the bytes located at
305
         * offset 45, 55, 95, and the word located at offset 109, 110.
306
         */
307
        if (acpi_gbl_FADT.header.revision < 3) {
308
                acpi_gbl_FADT.preferred_profile = 0;
309
                acpi_gbl_FADT.pstate_control = 0;
310
                acpi_gbl_FADT.cst_control = 0;
311
                acpi_gbl_FADT.boot_flags = 0;
312
        }
313
 
314
        /*
315
         * Expand the ACPI 1.0 32-bit V1.0 addresses to the ACPI 2.0 64-bit "X"
316
         * generic address structures as necessary.
317
         */
318
        for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
319
                target =
320
                    ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT,
321
                                 fadt_info_table[i].target);
322
 
323
                /* Expand only if the X target is null */
324
 
325
                if (!target->address) {
326
                        acpi_tb_init_generic_address(target,
327
                                                     *ACPI_ADD_PTR(u8,
328
                                                                   &acpi_gbl_FADT,
329
                                                                   fadt_info_table
330
                                                                   [i].length),
331
                                                     (u64) * ACPI_ADD_PTR(u32,
332
                                                                          &acpi_gbl_FADT,
333
                                                                          fadt_info_table
334
                                                                          [i].
335
                                                                          source));
336
                }
337
        }
338
 
339
        /*
340
         * Calculate separate GAS structs for the PM1 Enable registers.
341
         * These addresses do not appear (directly) in the FADT, so it is
342
         * useful to calculate them once, here.
343
         *
344
         * The PM event blocks are split into two register blocks, first is the
345
         * PM Status Register block, followed immediately by the PM Enable Register
346
         * block. Each is of length (pm1_event_length/2)
347
         */
348
        pm1_register_length = (u8) ACPI_DIV_2(acpi_gbl_FADT.pm1_event_length);
349
 
350
        /* The PM1A register block is required */
351
 
352
        acpi_tb_init_generic_address(&acpi_gbl_xpm1a_enable,
353
                                     pm1_register_length,
354
                                     (acpi_gbl_FADT.xpm1a_event_block.address +
355
                                      pm1_register_length));
356
        /* Don't forget to copy space_id of the GAS */
357
        acpi_gbl_xpm1a_enable.space_id =
358
            acpi_gbl_FADT.xpm1a_event_block.space_id;
359
 
360
        /* The PM1B register block is optional, ignore if not present */
361
 
362
        if (acpi_gbl_FADT.xpm1b_event_block.address) {
363
                acpi_tb_init_generic_address(&acpi_gbl_xpm1b_enable,
364
                                             pm1_register_length,
365
                                             (acpi_gbl_FADT.xpm1b_event_block.
366
                                              address + pm1_register_length));
367
                /* Don't forget to copy space_id of the GAS */
368
                acpi_gbl_xpm1b_enable.space_id =
369
                    acpi_gbl_FADT.xpm1a_event_block.space_id;
370
 
371
        }
372
}
373
 
374
/******************************************************************************
375
 *
376
 * FUNCTION:    acpi_tb_validate_fadt
377
 *
378
 * PARAMETERS:  Table           - Pointer to the FADT to be validated
379
 *
380
 * RETURN:      None
381
 *
382
 * DESCRIPTION: Validate various important fields within the FADT. If a problem
383
 *              is found, issue a message, but no status is returned.
384
 *              Used by both the table manager and the disassembler.
385
 *
386
 * Possible additional checks:
387
 * (acpi_gbl_FADT.pm1_event_length >= 4)
388
 * (acpi_gbl_FADT.pm1_control_length >= 2)
389
 * (acpi_gbl_FADT.pm_timer_length >= 4)
390
 * Gpe block lengths must be multiple of 2
391
 *
392
 ******************************************************************************/
393
 
394
static void acpi_tb_validate_fadt(void)
395
{
396
        u32 *address32;
397
        struct acpi_generic_address *address64;
398
        u8 length;
399
        acpi_native_uint i;
400
 
401
        /* Examine all of the 64-bit extended address fields (X fields) */
402
 
403
        for (i = 0; i < ACPI_FADT_INFO_ENTRIES; i++) {
404
 
405
                /* Generate pointers to the 32-bit and 64-bit addresses and get the length */
406
 
407
                address64 =
408
                    ACPI_ADD_PTR(struct acpi_generic_address, &acpi_gbl_FADT,
409
                                 fadt_info_table[i].target);
410
                address32 =
411
                    ACPI_ADD_PTR(u32, &acpi_gbl_FADT,
412
                                 fadt_info_table[i].source);
413
                length =
414
                    *ACPI_ADD_PTR(u8, &acpi_gbl_FADT,
415
                                  fadt_info_table[i].length);
416
 
417
                if (fadt_info_table[i].type & ACPI_FADT_REQUIRED) {
418
                        /*
419
                         * Field is required (Pm1a_event, Pm1a_control, pm_timer).
420
                         * Both the address and length must be non-zero.
421
                         */
422
                        if (!address64->address || !length) {
423
                                ACPI_ERROR((AE_INFO,
424
                                            "Required field \"%s\" has zero address and/or length: %8.8X%8.8X/%X",
425
                                            fadt_info_table[i].name,
426
                                            ACPI_FORMAT_UINT64(address64->
427
                                                               address),
428
                                            length));
429
                        }
430
                } else if (fadt_info_table[i].type & ACPI_FADT_SEPARATE_LENGTH) {
431
                        /*
432
                         * Field is optional (PM2Control, GPE0, GPE1) AND has its own
433
                         * length field. If present, both the address and length must be valid.
434
                         */
435
                        if ((address64->address && !length)
436
                            || (!address64->address && length)) {
437
                                ACPI_WARNING((AE_INFO,
438
                                              "Optional field \"%s\" has zero address or length: %8.8X%8.8X/%X",
439
                                              fadt_info_table[i].name,
440
                                              ACPI_FORMAT_UINT64(address64->
441
                                                                 address),
442
                                              length));
443
                        }
444
                }
445
 
446
                /* If both 32- and 64-bit addresses are valid (non-zero), they must match */
447
 
448
                if (address64->address && *address32 &&
449
                    (address64->address != (u64) * address32)) {
450
                        ACPI_ERROR((AE_INFO,
451
                                    "32/64X address mismatch in \"%s\": [%8.8X] [%8.8X%8.8X], using 64X",
452
                                    fadt_info_table[i].name, *address32,
453
                                    ACPI_FORMAT_UINT64(address64->address)));
454
                }
455
        }
456
}

powered by: WebSVN 2.1.0

© copyright 1999-2025 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.