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

Subversion Repositories test_project

[/] [test_project/] [trunk/] [linux_sd_driver/] [drivers/] [acpi/] [tables/] [tbxfroot.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: tbxfroot - Find the root ACPI table (RSDT)
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("tbxfroot")
49
 
50
/* Local prototypes */
51
static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length);
52
 
53
static acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp);
54
 
55
/*******************************************************************************
56
 *
57
 * FUNCTION:    acpi_tb_validate_rsdp
58
 *
59
 * PARAMETERS:  Rsdp                - Pointer to unvalidated RSDP
60
 *
61
 * RETURN:      Status
62
 *
63
 * DESCRIPTION: Validate the RSDP (ptr)
64
 *
65
 ******************************************************************************/
66
 
67
static acpi_status acpi_tb_validate_rsdp(struct acpi_table_rsdp *rsdp)
68
{
69
        ACPI_FUNCTION_ENTRY();
70
 
71
        /*
72
         * The signature and checksum must both be correct
73
         *
74
         * Note: Sometimes there exists more than one RSDP in memory; the valid
75
         * RSDP has a valid checksum, all others have an invalid checksum.
76
         */
77
        if (ACPI_STRNCMP((char *)rsdp, ACPI_SIG_RSDP, sizeof(ACPI_SIG_RSDP) - 1)
78
            != 0) {
79
 
80
                /* Nope, BAD Signature */
81
 
82
                return (AE_BAD_SIGNATURE);
83
        }
84
 
85
        /* Check the standard checksum */
86
 
87
        if (acpi_tb_checksum((u8 *) rsdp, ACPI_RSDP_CHECKSUM_LENGTH) != 0) {
88
                return (AE_BAD_CHECKSUM);
89
        }
90
 
91
        /* Check extended checksum if table version >= 2 */
92
 
93
        if ((rsdp->revision >= 2) &&
94
            (acpi_tb_checksum((u8 *) rsdp, ACPI_RSDP_XCHECKSUM_LENGTH) != 0)) {
95
                return (AE_BAD_CHECKSUM);
96
        }
97
 
98
        return (AE_OK);
99
}
100
 
101
/*******************************************************************************
102
 *
103
 * FUNCTION:    acpi_tb_find_rsdp
104
 *
105
 * PARAMETERS:  table_address           - Where the table pointer is returned
106
 *
107
 * RETURN:      Status, RSDP physical address
108
 *
109
 * DESCRIPTION: Search lower 1_mbyte of memory for the root system descriptor
110
 *              pointer structure.  If it is found, set *RSDP to point to it.
111
 *
112
 * NOTE1:       The RSDP must be either in the first 1_k of the Extended
113
 *              BIOS Data Area or between E0000 and FFFFF (From ACPI Spec.)
114
 *              Only a 32-bit physical address is necessary.
115
 *
116
 * NOTE2:       This function is always available, regardless of the
117
 *              initialization state of the rest of ACPI.
118
 *
119
 ******************************************************************************/
120
 
121
acpi_status acpi_find_root_pointer(acpi_native_uint * table_address)
122
{
123
        u8 *table_ptr;
124
        u8 *mem_rover;
125
        u32 physical_address;
126
 
127
        ACPI_FUNCTION_TRACE(acpi_find_root_pointer);
128
 
129
        /* 1a) Get the location of the Extended BIOS Data Area (EBDA) */
130
 
131
        table_ptr = acpi_os_map_memory((acpi_physical_address)
132
                                       ACPI_EBDA_PTR_LOCATION,
133
                                       ACPI_EBDA_PTR_LENGTH);
134
        if (!table_ptr) {
135
                ACPI_ERROR((AE_INFO,
136
                            "Could not map memory at %8.8X for length %X",
137
                            ACPI_EBDA_PTR_LOCATION, ACPI_EBDA_PTR_LENGTH));
138
 
139
                return_ACPI_STATUS(AE_NO_MEMORY);
140
        }
141
 
142
        ACPI_MOVE_16_TO_32(&physical_address, table_ptr);
143
 
144
        /* Convert segment part to physical address */
145
 
146
        physical_address <<= 4;
147
        acpi_os_unmap_memory(table_ptr, ACPI_EBDA_PTR_LENGTH);
148
 
149
        /* EBDA present? */
150
 
151
        if (physical_address > 0x400) {
152
                /*
153
                 * 1b) Search EBDA paragraphs (EBDA is required to be a
154
                 *     minimum of 1_k length)
155
                 */
156
                table_ptr = acpi_os_map_memory((acpi_native_uint)
157
                                               physical_address,
158
                                               ACPI_EBDA_WINDOW_SIZE);
159
                if (!table_ptr) {
160
                        ACPI_ERROR((AE_INFO,
161
                                    "Could not map memory at %8.8X for length %X",
162
                                    physical_address, ACPI_EBDA_WINDOW_SIZE));
163
 
164
                        return_ACPI_STATUS(AE_NO_MEMORY);
165
                }
166
 
167
                mem_rover =
168
                    acpi_tb_scan_memory_for_rsdp(table_ptr,
169
                                                 ACPI_EBDA_WINDOW_SIZE);
170
                acpi_os_unmap_memory(table_ptr, ACPI_EBDA_WINDOW_SIZE);
171
 
172
                if (mem_rover) {
173
 
174
                        /* Return the physical address */
175
 
176
                        physical_address +=
177
                            (u32) ACPI_PTR_DIFF(mem_rover, table_ptr);
178
 
179
                        *table_address = physical_address;
180
                        return_ACPI_STATUS(AE_OK);
181
                }
182
        }
183
 
184
        /*
185
         * 2) Search upper memory: 16-byte boundaries in E0000h-FFFFFh
186
         */
187
        table_ptr = acpi_os_map_memory((acpi_physical_address)
188
                                       ACPI_HI_RSDP_WINDOW_BASE,
189
                                       ACPI_HI_RSDP_WINDOW_SIZE);
190
 
191
        if (!table_ptr) {
192
                ACPI_ERROR((AE_INFO,
193
                            "Could not map memory at %8.8X for length %X",
194
                            ACPI_HI_RSDP_WINDOW_BASE,
195
                            ACPI_HI_RSDP_WINDOW_SIZE));
196
 
197
                return_ACPI_STATUS(AE_NO_MEMORY);
198
        }
199
 
200
        mem_rover =
201
            acpi_tb_scan_memory_for_rsdp(table_ptr, ACPI_HI_RSDP_WINDOW_SIZE);
202
        acpi_os_unmap_memory(table_ptr, ACPI_HI_RSDP_WINDOW_SIZE);
203
 
204
        if (mem_rover) {
205
 
206
                /* Return the physical address */
207
 
208
                physical_address = (u32)
209
                    (ACPI_HI_RSDP_WINDOW_BASE +
210
                     ACPI_PTR_DIFF(mem_rover, table_ptr));
211
 
212
                *table_address = physical_address;
213
                return_ACPI_STATUS(AE_OK);
214
        }
215
 
216
        /* A valid RSDP was not found */
217
 
218
        ACPI_ERROR((AE_INFO, "A valid RSDP was not found"));
219
        return_ACPI_STATUS(AE_NOT_FOUND);
220
}
221
 
222
ACPI_EXPORT_SYMBOL(acpi_find_root_pointer)
223
 
224
/*******************************************************************************
225
 *
226
 * FUNCTION:    acpi_tb_scan_memory_for_rsdp
227
 *
228
 * PARAMETERS:  start_address       - Starting pointer for search
229
 *              Length              - Maximum length to search
230
 *
231
 * RETURN:      Pointer to the RSDP if found, otherwise NULL.
232
 *
233
 * DESCRIPTION: Search a block of memory for the RSDP signature
234
 *
235
 ******************************************************************************/
236
static u8 *acpi_tb_scan_memory_for_rsdp(u8 * start_address, u32 length)
237
{
238
        acpi_status status;
239
        u8 *mem_rover;
240
        u8 *end_address;
241
 
242
        ACPI_FUNCTION_TRACE(tb_scan_memory_for_rsdp);
243
 
244
        end_address = start_address + length;
245
 
246
        /* Search from given start address for the requested length */
247
 
248
        for (mem_rover = start_address; mem_rover < end_address;
249
             mem_rover += ACPI_RSDP_SCAN_STEP) {
250
 
251
                /* The RSDP signature and checksum must both be correct */
252
 
253
                status =
254
                    acpi_tb_validate_rsdp(ACPI_CAST_PTR
255
                                          (struct acpi_table_rsdp, mem_rover));
256
                if (ACPI_SUCCESS(status)) {
257
 
258
                        /* Sig and checksum valid, we have found a real RSDP */
259
 
260
                        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
261
                                          "RSDP located at physical address %p\n",
262
                                          mem_rover));
263
                        return_PTR(mem_rover);
264
                }
265
 
266
                /* No sig match or bad checksum, keep searching */
267
        }
268
 
269
        /* Searched entire block, no RSDP was found */
270
 
271
        ACPI_DEBUG_PRINT((ACPI_DB_INFO,
272
                          "Searched entire block from %p, valid RSDP was not found\n",
273
                          start_address));
274
        return_PTR(NULL);
275
}

powered by: WebSVN 2.1.0

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