Merge tag 'v4.0-rc2' into x86/asm, to refresh the tree
[firefly-linux-kernel-4.4.55.git] / drivers / acpi / acpica / tbxface.c
1 /******************************************************************************
2  *
3  * Module Name: tbxface - ACPI table-oriented external interfaces
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2015, 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  */
43
44 #define EXPORT_ACPI_INTERFACES
45
46 #include <acpi/acpi.h>
47 #include "accommon.h"
48 #include "actables.h"
49
50 #define _COMPONENT          ACPI_TABLES
51 ACPI_MODULE_NAME("tbxface")
52
53 /*******************************************************************************
54  *
55  * FUNCTION:    acpi_allocate_root_table
56  *
57  * PARAMETERS:  initial_table_count - Size of initial_table_array, in number of
58  *                                    struct acpi_table_desc structures
59  *
60  * RETURN:      Status
61  *
62  * DESCRIPTION: Allocate a root table array. Used by iASL compiler and
63  *              acpi_initialize_tables.
64  *
65  ******************************************************************************/
66 acpi_status acpi_allocate_root_table(u32 initial_table_count)
67 {
68
69         acpi_gbl_root_table_list.max_table_count = initial_table_count;
70         acpi_gbl_root_table_list.flags = ACPI_ROOT_ALLOW_RESIZE;
71
72         return (acpi_tb_resize_root_table_list());
73 }
74
75 /*******************************************************************************
76  *
77  * FUNCTION:    acpi_initialize_tables
78  *
79  * PARAMETERS:  initial_table_array - Pointer to an array of pre-allocated
80  *                                    struct acpi_table_desc structures. If NULL, the
81  *                                    array is dynamically allocated.
82  *              initial_table_count - Size of initial_table_array, in number of
83  *                                    struct acpi_table_desc structures
84  *              allow_resize        - Flag to tell Table Manager if resize of
85  *                                    pre-allocated array is allowed. Ignored
86  *                                    if initial_table_array is NULL.
87  *
88  * RETURN:      Status
89  *
90  * DESCRIPTION: Initialize the table manager, get the RSDP and RSDT/XSDT.
91  *
92  * NOTE:        Allows static allocation of the initial table array in order
93  *              to avoid the use of dynamic memory in confined environments
94  *              such as the kernel boot sequence where it may not be available.
95  *
96  *              If the host OS memory managers are initialized, use NULL for
97  *              initial_table_array, and the table will be dynamically allocated.
98  *
99  ******************************************************************************/
100
101 acpi_status __init
102 acpi_initialize_tables(struct acpi_table_desc * initial_table_array,
103                        u32 initial_table_count, u8 allow_resize)
104 {
105         acpi_physical_address rsdp_address;
106         acpi_status status;
107
108         ACPI_FUNCTION_TRACE(acpi_initialize_tables);
109
110         /*
111          * Setup the Root Table Array and allocate the table array
112          * if requested
113          */
114         if (!initial_table_array) {
115                 status = acpi_allocate_root_table(initial_table_count);
116                 if (ACPI_FAILURE(status)) {
117                         return_ACPI_STATUS(status);
118                 }
119         } else {
120                 /* Root Table Array has been statically allocated by the host */
121
122                 ACPI_MEMSET(initial_table_array, 0,
123                             (acpi_size) initial_table_count *
124                             sizeof(struct acpi_table_desc));
125
126                 acpi_gbl_root_table_list.tables = initial_table_array;
127                 acpi_gbl_root_table_list.max_table_count = initial_table_count;
128                 acpi_gbl_root_table_list.flags = ACPI_ROOT_ORIGIN_UNKNOWN;
129                 if (allow_resize) {
130                         acpi_gbl_root_table_list.flags |=
131                             ACPI_ROOT_ALLOW_RESIZE;
132                 }
133         }
134
135         /* Get the address of the RSDP */
136
137         rsdp_address = acpi_os_get_root_pointer();
138         if (!rsdp_address) {
139                 return_ACPI_STATUS(AE_NOT_FOUND);
140         }
141
142         /*
143          * Get the root table (RSDT or XSDT) and extract all entries to the local
144          * Root Table Array. This array contains the information of the RSDT/XSDT
145          * in a common, more useable format.
146          */
147         status = acpi_tb_parse_root_table(rsdp_address);
148         return_ACPI_STATUS(status);
149 }
150
151 ACPI_EXPORT_SYMBOL_INIT(acpi_initialize_tables)
152
153 /*******************************************************************************
154  *
155  * FUNCTION:    acpi_reallocate_root_table
156  *
157  * PARAMETERS:  None
158  *
159  * RETURN:      Status
160  *
161  * DESCRIPTION: Reallocate Root Table List into dynamic memory. Copies the
162  *              root list from the previously provided scratch area. Should
163  *              be called once dynamic memory allocation is available in the
164  *              kernel.
165  *
166  ******************************************************************************/
167 acpi_status __init acpi_reallocate_root_table(void)
168 {
169         acpi_status status;
170
171         ACPI_FUNCTION_TRACE(acpi_reallocate_root_table);
172
173         /*
174          * Only reallocate the root table if the host provided a static buffer
175          * for the table array in the call to acpi_initialize_tables.
176          */
177         if (acpi_gbl_root_table_list.flags & ACPI_ROOT_ORIGIN_ALLOCATED) {
178                 return_ACPI_STATUS(AE_SUPPORT);
179         }
180
181         acpi_gbl_root_table_list.flags |= ACPI_ROOT_ALLOW_RESIZE;
182
183         status = acpi_tb_resize_root_table_list();
184         return_ACPI_STATUS(status);
185 }
186
187 ACPI_EXPORT_SYMBOL_INIT(acpi_reallocate_root_table)
188
189 /*******************************************************************************
190  *
191  * FUNCTION:    acpi_get_table_header
192  *
193  * PARAMETERS:  signature           - ACPI signature of needed table
194  *              instance            - Which instance (for SSDTs)
195  *              out_table_header    - The pointer to the table header to fill
196  *
197  * RETURN:      Status and pointer to mapped table header
198  *
199  * DESCRIPTION: Finds an ACPI table header.
200  *
201  * NOTE:        Caller is responsible in unmapping the header with
202  *              acpi_os_unmap_memory
203  *
204  ******************************************************************************/
205 acpi_status
206 acpi_get_table_header(char *signature,
207                       u32 instance, struct acpi_table_header *out_table_header)
208 {
209         u32 i;
210         u32 j;
211         struct acpi_table_header *header;
212
213         /* Parameter validation */
214
215         if (!signature || !out_table_header) {
216                 return (AE_BAD_PARAMETER);
217         }
218
219         /* Walk the root table list */
220
221         for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
222              i++) {
223                 if (!ACPI_COMPARE_NAME
224                     (&(acpi_gbl_root_table_list.tables[i].signature),
225                      signature)) {
226                         continue;
227                 }
228
229                 if (++j < instance) {
230                         continue;
231                 }
232
233                 if (!acpi_gbl_root_table_list.tables[i].pointer) {
234                         if ((acpi_gbl_root_table_list.tables[i].flags &
235                              ACPI_TABLE_ORIGIN_MASK) ==
236                             ACPI_TABLE_ORIGIN_INTERNAL_PHYSICAL) {
237                                 header =
238                                     acpi_os_map_memory(acpi_gbl_root_table_list.
239                                                        tables[i].address,
240                                                        sizeof(struct
241                                                               acpi_table_header));
242                                 if (!header) {
243                                         return (AE_NO_MEMORY);
244                                 }
245                                 ACPI_MEMCPY(out_table_header, header,
246                                             sizeof(struct acpi_table_header));
247                                 acpi_os_unmap_memory(header,
248                                                      sizeof(struct
249                                                             acpi_table_header));
250                         } else {
251                                 return (AE_NOT_FOUND);
252                         }
253                 } else {
254                         ACPI_MEMCPY(out_table_header,
255                                     acpi_gbl_root_table_list.tables[i].pointer,
256                                     sizeof(struct acpi_table_header));
257                 }
258                 return (AE_OK);
259         }
260
261         return (AE_NOT_FOUND);
262 }
263
264 ACPI_EXPORT_SYMBOL(acpi_get_table_header)
265
266 /*******************************************************************************
267  *
268  * FUNCTION:    acpi_get_table_with_size
269  *
270  * PARAMETERS:  signature           - ACPI signature of needed table
271  *              instance            - Which instance (for SSDTs)
272  *              out_table           - Where the pointer to the table is returned
273  *
274  * RETURN:      Status and pointer to the requested table
275  *
276  * DESCRIPTION: Finds and verifies an ACPI table. Table must be in the
277  *              RSDT/XSDT.
278  *
279  ******************************************************************************/
280 acpi_status
281 acpi_get_table_with_size(char *signature,
282                u32 instance, struct acpi_table_header **out_table,
283                acpi_size *tbl_size)
284 {
285         u32 i;
286         u32 j;
287         acpi_status status;
288
289         /* Parameter validation */
290
291         if (!signature || !out_table) {
292                 return (AE_BAD_PARAMETER);
293         }
294
295         /* Walk the root table list */
296
297         for (i = 0, j = 0; i < acpi_gbl_root_table_list.current_table_count;
298              i++) {
299                 if (!ACPI_COMPARE_NAME
300                     (&(acpi_gbl_root_table_list.tables[i].signature),
301                      signature)) {
302                         continue;
303                 }
304
305                 if (++j < instance) {
306                         continue;
307                 }
308
309                 status =
310                     acpi_tb_validate_table(&acpi_gbl_root_table_list.tables[i]);
311                 if (ACPI_SUCCESS(status)) {
312                         *out_table = acpi_gbl_root_table_list.tables[i].pointer;
313                         *tbl_size = acpi_gbl_root_table_list.tables[i].length;
314                 }
315
316                 if (!acpi_gbl_permanent_mmap) {
317                         acpi_gbl_root_table_list.tables[i].pointer = NULL;
318                 }
319
320                 return (status);
321         }
322
323         return (AE_NOT_FOUND);
324 }
325
326 ACPI_EXPORT_SYMBOL(acpi_get_table_with_size)
327
328 acpi_status
329 acpi_get_table(char *signature,
330                u32 instance, struct acpi_table_header **out_table)
331 {
332         acpi_size tbl_size;
333
334         return acpi_get_table_with_size(signature,
335                        instance, out_table, &tbl_size);
336 }
337
338 ACPI_EXPORT_SYMBOL(acpi_get_table)
339
340 /*******************************************************************************
341  *
342  * FUNCTION:    acpi_get_table_by_index
343  *
344  * PARAMETERS:  table_index         - Table index
345  *              table               - Where the pointer to the table is returned
346  *
347  * RETURN:      Status and pointer to the requested table
348  *
349  * DESCRIPTION: Obtain a table by an index into the global table list. Used
350  *              internally also.
351  *
352  ******************************************************************************/
353 acpi_status
354 acpi_get_table_by_index(u32 table_index, struct acpi_table_header ** table)
355 {
356         acpi_status status;
357
358         ACPI_FUNCTION_TRACE(acpi_get_table_by_index);
359
360         /* Parameter validation */
361
362         if (!table) {
363                 return_ACPI_STATUS(AE_BAD_PARAMETER);
364         }
365
366         (void)acpi_ut_acquire_mutex(ACPI_MTX_TABLES);
367
368         /* Validate index */
369
370         if (table_index >= acpi_gbl_root_table_list.current_table_count) {
371                 (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
372                 return_ACPI_STATUS(AE_BAD_PARAMETER);
373         }
374
375         if (!acpi_gbl_root_table_list.tables[table_index].pointer) {
376
377                 /* Table is not mapped, map it */
378
379                 status =
380                     acpi_tb_validate_table(&acpi_gbl_root_table_list.
381                                            tables[table_index]);
382                 if (ACPI_FAILURE(status)) {
383                         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
384                         return_ACPI_STATUS(status);
385                 }
386         }
387
388         *table = acpi_gbl_root_table_list.tables[table_index].pointer;
389         (void)acpi_ut_release_mutex(ACPI_MTX_TABLES);
390         return_ACPI_STATUS(AE_OK);
391 }
392
393 ACPI_EXPORT_SYMBOL(acpi_get_table_by_index)
394
395 /*******************************************************************************
396  *
397  * FUNCTION:    acpi_install_table_handler
398  *
399  * PARAMETERS:  handler         - Table event handler
400  *              context         - Value passed to the handler on each event
401  *
402  * RETURN:      Status
403  *
404  * DESCRIPTION: Install a global table event handler.
405  *
406  ******************************************************************************/
407 acpi_status
408 acpi_install_table_handler(acpi_table_handler handler, void *context)
409 {
410         acpi_status status;
411
412         ACPI_FUNCTION_TRACE(acpi_install_table_handler);
413
414         if (!handler) {
415                 return_ACPI_STATUS(AE_BAD_PARAMETER);
416         }
417
418         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
419         if (ACPI_FAILURE(status)) {
420                 return_ACPI_STATUS(status);
421         }
422
423         /* Don't allow more than one handler */
424
425         if (acpi_gbl_table_handler) {
426                 status = AE_ALREADY_EXISTS;
427                 goto cleanup;
428         }
429
430         /* Install the handler */
431
432         acpi_gbl_table_handler = handler;
433         acpi_gbl_table_handler_context = context;
434
435 cleanup:
436         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
437         return_ACPI_STATUS(status);
438 }
439
440 ACPI_EXPORT_SYMBOL(acpi_install_table_handler)
441
442 /*******************************************************************************
443  *
444  * FUNCTION:    acpi_remove_table_handler
445  *
446  * PARAMETERS:  handler         - Table event handler that was installed
447  *                                previously.
448  *
449  * RETURN:      Status
450  *
451  * DESCRIPTION: Remove a table event handler
452  *
453  ******************************************************************************/
454 acpi_status acpi_remove_table_handler(acpi_table_handler handler)
455 {
456         acpi_status status;
457
458         ACPI_FUNCTION_TRACE(acpi_remove_table_handler);
459
460         status = acpi_ut_acquire_mutex(ACPI_MTX_EVENTS);
461         if (ACPI_FAILURE(status)) {
462                 return_ACPI_STATUS(status);
463         }
464
465         /* Make sure that the installed handler is the same */
466
467         if (!handler || handler != acpi_gbl_table_handler) {
468                 status = AE_BAD_PARAMETER;
469                 goto cleanup;
470         }
471
472         /* Remove the handler */
473
474         acpi_gbl_table_handler = NULL;
475
476 cleanup:
477         (void)acpi_ut_release_mutex(ACPI_MTX_EVENTS);
478         return_ACPI_STATUS(status);
479 }
480
481 ACPI_EXPORT_SYMBOL(acpi_remove_table_handler)