ACPICA: Update all ACPICA copyrights and signons to 2010
[linux-2.6.git] / drivers / acpi / acpica / uteval.c
1 /******************************************************************************
2  *
3  * Module Name: uteval - Object evaluation
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2010, 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 #include <acpi/acpi.h>
45 #include "accommon.h"
46 #include "acnamesp.h"
47
48 #define _COMPONENT          ACPI_UTILITIES
49 ACPI_MODULE_NAME("uteval")
50
51 /*
52  * Strings supported by the _OSI predefined (internal) method.
53  *
54  * March 2009: Removed "Linux" as this host no longer wants to respond true
55  * for this string. Basically, the only safe OS strings are windows-related
56  * and in many or most cases represent the only test path within the
57  * BIOS-provided ASL code.
58  *
59  * The second element of each entry is used to track the newest version of
60  * Windows that the BIOS has requested.
61  */
62 static struct acpi_interface_info acpi_interfaces_supported[] = {
63         /* Operating System Vendor Strings */
64
65         {"Windows 2000", ACPI_OSI_WIN_2000},    /* Windows 2000 */
66         {"Windows 2001", ACPI_OSI_WIN_XP},      /* Windows XP */
67         {"Windows 2001 SP1", ACPI_OSI_WIN_XP_SP1},      /* Windows XP SP1 */
68         {"Windows 2001.1", ACPI_OSI_WINSRV_2003},       /* Windows Server 2003 */
69         {"Windows 2001 SP2", ACPI_OSI_WIN_XP_SP2},      /* Windows XP SP2 */
70         {"Windows 2001.1 SP1", ACPI_OSI_WINSRV_2003_SP1},       /* Windows Server 2003 SP1 - Added 03/2006 */
71         {"Windows 2006", ACPI_OSI_WIN_VISTA},   /* Windows Vista - Added 03/2006 */
72         {"Windows 2006.1", ACPI_OSI_WINSRV_2008},       /* Windows Server 2008 - Added 09/2009 */
73         {"Windows 2006 SP1", ACPI_OSI_WIN_VISTA_SP1},   /* Windows Vista SP1 - Added 09/2009 */
74         {"Windows 2009", ACPI_OSI_WIN_7},       /* Windows 7 and Server 2008 R2 - Added 09/2009 */
75
76         /* Feature Group Strings */
77
78         {"Extended Address Space Descriptor", 0}
79
80         /*
81          * All "optional" feature group strings (features that are implemented
82          * by the host) should be implemented in the host version of
83          * acpi_os_validate_interface and should not be added here.
84          */
85 };
86
87 /*******************************************************************************
88  *
89  * FUNCTION:    acpi_ut_osi_implementation
90  *
91  * PARAMETERS:  walk_state          - Current walk state
92  *
93  * RETURN:      Status
94  *
95  * DESCRIPTION: Implementation of the _OSI predefined control method
96  *
97  ******************************************************************************/
98
99 acpi_status acpi_ut_osi_implementation(struct acpi_walk_state *walk_state)
100 {
101         acpi_status status;
102         union acpi_operand_object *string_desc;
103         union acpi_operand_object *return_desc;
104         u32 return_value;
105         u32 i;
106
107         ACPI_FUNCTION_TRACE(ut_osi_implementation);
108
109         /* Validate the string input argument */
110
111         string_desc = walk_state->arguments[0].object;
112         if (!string_desc || (string_desc->common.type != ACPI_TYPE_STRING)) {
113                 return_ACPI_STATUS(AE_TYPE);
114         }
115
116         /* Create a return object */
117
118         return_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
119         if (!return_desc) {
120                 return_ACPI_STATUS(AE_NO_MEMORY);
121         }
122
123         /* Default return value is 0, NOT SUPPORTED */
124
125         return_value = 0;
126
127         /* Compare input string to static table of supported interfaces */
128
129         for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_interfaces_supported); i++) {
130                 if (!ACPI_STRCMP(string_desc->string.pointer,
131                                  acpi_interfaces_supported[i].name)) {
132                         /*
133                          * The interface is supported.
134                          * Update the osi_data if necessary. We keep track of the latest
135                          * version of Windows that has been requested by the BIOS.
136                          */
137                         if (acpi_interfaces_supported[i].value >
138                             acpi_gbl_osi_data) {
139                                 acpi_gbl_osi_data =
140                                     acpi_interfaces_supported[i].value;
141                         }
142
143                         return_value = ACPI_UINT32_MAX;
144                         goto exit;
145                 }
146         }
147
148         /*
149          * Did not match the string in the static table, call the host OSL to
150          * check for a match with one of the optional strings (such as
151          * "Module Device", "3.0 Thermal Model", etc.)
152          */
153         status = acpi_os_validate_interface(string_desc->string.pointer);
154         if (ACPI_SUCCESS(status)) {
155
156                 /* The interface is supported */
157
158                 return_value = ACPI_UINT32_MAX;
159         }
160
161 exit:
162         ACPI_DEBUG_PRINT_RAW ((ACPI_DB_INFO,
163                 "ACPI: BIOS _OSI(%s) is %ssupported\n",
164                 string_desc->string.pointer, return_value == 0 ? "not " : ""));
165
166         /* Complete the return value */
167
168         return_desc->integer.value = return_value;
169         walk_state->return_desc = return_desc;
170         return_ACPI_STATUS (AE_OK);
171 }
172
173 /*******************************************************************************
174  *
175  * FUNCTION:    acpi_osi_invalidate
176  *
177  * PARAMETERS:  interface_string
178  *
179  * RETURN:      Status
180  *
181  * DESCRIPTION: invalidate string in pre-defiend _OSI string list
182  *
183  ******************************************************************************/
184
185 acpi_status acpi_osi_invalidate(char *interface)
186 {
187         int i;
188
189         for (i = 0; i < ACPI_ARRAY_LENGTH(acpi_interfaces_supported); i++) {
190                 if (!ACPI_STRCMP(interface, acpi_interfaces_supported[i].name)) {
191                         *acpi_interfaces_supported[i].name = '\0';
192                         return AE_OK;
193                 }
194         }
195         return AE_NOT_FOUND;
196 }
197
198 /*******************************************************************************
199  *
200  * FUNCTION:    acpi_ut_evaluate_object
201  *
202  * PARAMETERS:  prefix_node         - Starting node
203  *              Path                - Path to object from starting node
204  *              expected_return_types - Bitmap of allowed return types
205  *              return_desc         - Where a return value is stored
206  *
207  * RETURN:      Status
208  *
209  * DESCRIPTION: Evaluates a namespace object and verifies the type of the
210  *              return object. Common code that simplifies accessing objects
211  *              that have required return objects of fixed types.
212  *
213  *              NOTE: Internal function, no parameter validation
214  *
215  ******************************************************************************/
216
217 acpi_status
218 acpi_ut_evaluate_object(struct acpi_namespace_node *prefix_node,
219                         char *path,
220                         u32 expected_return_btypes,
221                         union acpi_operand_object **return_desc)
222 {
223         struct acpi_evaluate_info *info;
224         acpi_status status;
225         u32 return_btype;
226
227         ACPI_FUNCTION_TRACE(ut_evaluate_object);
228
229         /* Allocate the evaluation information block */
230
231         info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
232         if (!info) {
233                 return_ACPI_STATUS(AE_NO_MEMORY);
234         }
235
236         info->prefix_node = prefix_node;
237         info->pathname = path;
238
239         /* Evaluate the object/method */
240
241         status = acpi_ns_evaluate(info);
242         if (ACPI_FAILURE(status)) {
243                 if (status == AE_NOT_FOUND) {
244                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
245                                           "[%4.4s.%s] was not found\n",
246                                           acpi_ut_get_node_name(prefix_node),
247                                           path));
248                 } else {
249                         ACPI_ERROR_METHOD("Method execution failed",
250                                           prefix_node, path, status);
251                 }
252
253                 goto cleanup;
254         }
255
256         /* Did we get a return object? */
257
258         if (!info->return_object) {
259                 if (expected_return_btypes) {
260                         ACPI_ERROR_METHOD("No object was returned from",
261                                           prefix_node, path, AE_NOT_EXIST);
262
263                         status = AE_NOT_EXIST;
264                 }
265
266                 goto cleanup;
267         }
268
269         /* Map the return object type to the bitmapped type */
270
271         switch ((info->return_object)->common.type) {
272         case ACPI_TYPE_INTEGER:
273                 return_btype = ACPI_BTYPE_INTEGER;
274                 break;
275
276         case ACPI_TYPE_BUFFER:
277                 return_btype = ACPI_BTYPE_BUFFER;
278                 break;
279
280         case ACPI_TYPE_STRING:
281                 return_btype = ACPI_BTYPE_STRING;
282                 break;
283
284         case ACPI_TYPE_PACKAGE:
285                 return_btype = ACPI_BTYPE_PACKAGE;
286                 break;
287
288         default:
289                 return_btype = 0;
290                 break;
291         }
292
293         if ((acpi_gbl_enable_interpreter_slack) && (!expected_return_btypes)) {
294                 /*
295                  * We received a return object, but one was not expected. This can
296                  * happen frequently if the "implicit return" feature is enabled.
297                  * Just delete the return object and return AE_OK.
298                  */
299                 acpi_ut_remove_reference(info->return_object);
300                 goto cleanup;
301         }
302
303         /* Is the return object one of the expected types? */
304
305         if (!(expected_return_btypes & return_btype)) {
306                 ACPI_ERROR_METHOD("Return object type is incorrect",
307                                   prefix_node, path, AE_TYPE);
308
309                 ACPI_ERROR((AE_INFO,
310                             "Type returned from %s was incorrect: %s, expected Btypes: %X",
311                             path,
312                             acpi_ut_get_object_type_name(info->return_object),
313                             expected_return_btypes));
314
315                 /* On error exit, we must delete the return object */
316
317                 acpi_ut_remove_reference(info->return_object);
318                 status = AE_TYPE;
319                 goto cleanup;
320         }
321
322         /* Object type is OK, return it */
323
324         *return_desc = info->return_object;
325
326       cleanup:
327         ACPI_FREE(info);
328         return_ACPI_STATUS(status);
329 }
330
331 /*******************************************************************************
332  *
333  * FUNCTION:    acpi_ut_evaluate_numeric_object
334  *
335  * PARAMETERS:  object_name         - Object name to be evaluated
336  *              device_node         - Node for the device
337  *              Value               - Where the value is returned
338  *
339  * RETURN:      Status
340  *
341  * DESCRIPTION: Evaluates a numeric namespace object for a selected device
342  *              and stores result in *Value.
343  *
344  *              NOTE: Internal function, no parameter validation
345  *
346  ******************************************************************************/
347
348 acpi_status
349 acpi_ut_evaluate_numeric_object(char *object_name,
350                                 struct acpi_namespace_node *device_node,
351                                 acpi_integer *value)
352 {
353         union acpi_operand_object *obj_desc;
354         acpi_status status;
355
356         ACPI_FUNCTION_TRACE(ut_evaluate_numeric_object);
357
358         status = acpi_ut_evaluate_object(device_node, object_name,
359                                          ACPI_BTYPE_INTEGER, &obj_desc);
360         if (ACPI_FAILURE(status)) {
361                 return_ACPI_STATUS(status);
362         }
363
364         /* Get the returned Integer */
365
366         *value = obj_desc->integer.value;
367
368         /* On exit, we must delete the return object */
369
370         acpi_ut_remove_reference(obj_desc);
371         return_ACPI_STATUS(status);
372 }
373
374 /*******************************************************************************
375  *
376  * FUNCTION:    acpi_ut_execute_STA
377  *
378  * PARAMETERS:  device_node         - Node for the device
379  *              Flags               - Where the status flags are returned
380  *
381  * RETURN:      Status
382  *
383  * DESCRIPTION: Executes _STA for selected device and stores results in
384  *              *Flags.
385  *
386  *              NOTE: Internal function, no parameter validation
387  *
388  ******************************************************************************/
389
390 acpi_status
391 acpi_ut_execute_STA(struct acpi_namespace_node *device_node, u32 * flags)
392 {
393         union acpi_operand_object *obj_desc;
394         acpi_status status;
395
396         ACPI_FUNCTION_TRACE(ut_execute_STA);
397
398         status = acpi_ut_evaluate_object(device_node, METHOD_NAME__STA,
399                                          ACPI_BTYPE_INTEGER, &obj_desc);
400         if (ACPI_FAILURE(status)) {
401                 if (AE_NOT_FOUND == status) {
402                         ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
403                                           "_STA on %4.4s was not found, assuming device is present\n",
404                                           acpi_ut_get_node_name(device_node)));
405
406                         *flags = ACPI_UINT32_MAX;
407                         status = AE_OK;
408                 }
409
410                 return_ACPI_STATUS(status);
411         }
412
413         /* Extract the status flags */
414
415         *flags = (u32) obj_desc->integer.value;
416
417         /* On exit, we must delete the return object */
418
419         acpi_ut_remove_reference(obj_desc);
420         return_ACPI_STATUS(status);
421 }
422
423 /*******************************************************************************
424  *
425  * FUNCTION:    acpi_ut_execute_power_methods
426  *
427  * PARAMETERS:  device_node         - Node for the device
428  *              method_names        - Array of power method names
429  *              method_count        - Number of methods to execute
430  *              out_values          - Where the power method values are returned
431  *
432  * RETURN:      Status, out_values
433  *
434  * DESCRIPTION: Executes the specified power methods for the device and returns
435  *              the result(s).
436  *
437  *              NOTE: Internal function, no parameter validation
438  *
439 ******************************************************************************/
440
441 acpi_status
442 acpi_ut_execute_power_methods(struct acpi_namespace_node *device_node,
443                               const char **method_names,
444                               u8 method_count, u8 *out_values)
445 {
446         union acpi_operand_object *obj_desc;
447         acpi_status status;
448         acpi_status final_status = AE_NOT_FOUND;
449         u32 i;
450
451         ACPI_FUNCTION_TRACE(ut_execute_power_methods);
452
453         for (i = 0; i < method_count; i++) {
454                 /*
455                  * Execute the power method (_sx_d or _sx_w). The only allowable
456                  * return type is an Integer.
457                  */
458                 status = acpi_ut_evaluate_object(device_node,
459                                                  ACPI_CAST_PTR(char,
460                                                                method_names[i]),
461                                                  ACPI_BTYPE_INTEGER, &obj_desc);
462                 if (ACPI_SUCCESS(status)) {
463                         out_values[i] = (u8)obj_desc->integer.value;
464
465                         /* Delete the return object */
466
467                         acpi_ut_remove_reference(obj_desc);
468                         final_status = AE_OK;   /* At least one value is valid */
469                         continue;
470                 }
471
472                 out_values[i] = ACPI_UINT8_MAX;
473                 if (status == AE_NOT_FOUND) {
474                         continue;       /* Ignore if not found */
475                 }
476
477                 ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
478                                   "Failed %s on Device %4.4s, %s\n",
479                                   ACPI_CAST_PTR(char, method_names[i]),
480                                   acpi_ut_get_node_name(device_node),
481                                   acpi_format_exception(status)));
482         }
483
484         return_ACPI_STATUS(final_status);
485 }