1 /******************************************************************************
2 *
3 * Module Name: nspredef - Validation of ACPI predefined methods and objects
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2013, 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 ACPI_CREATE_PREDEFINED_TABLE
45
46 #include "acpi.h"
47 #include "accommon.h"
48 #include "acnamesp.h"
49 #include "acpredef.h"
50
51
52 #define _COMPONENT ACPI_NAMESPACE
53 ACPI_MODULE_NAME ("nspredef")
54
55
56 /*******************************************************************************
57 *
58 * This module validates predefined ACPI objects that appear in the namespace,
59 * at the time they are evaluated (via AcpiEvaluateObject). The purpose of this
60 * validation is to detect problems with BIOS-exposed predefined ACPI objects
61 * before the results are returned to the ACPI-related drivers.
62 *
63 * There are several areas that are validated:
64 *
65 * 1) The number of input arguments as defined by the method/object in the
66 * ASL is validated against the ACPI specification.
67 * 2) The type of the return object (if any) is validated against the ACPI
68 * specification.
69 * 3) For returned package objects, the count of package elements is
70 * validated, as well as the type of each package element. Nested
71 * packages are supported.
72 *
73 * For any problems found, a warning message is issued.
74 *
75 ******************************************************************************/
76
77
78 /* Local prototypes */
79
80 static ACPI_STATUS
81 AcpiNsCheckReference (
82 ACPI_EVALUATE_INFO *Info,
83 ACPI_OPERAND_OBJECT *ReturnObject);
84
85 static UINT32
86 AcpiNsGetBitmappedType (
87 ACPI_OPERAND_OBJECT *ReturnObject);
88
89
90 /*******************************************************************************
91 *
92 * FUNCTION: AcpiNsCheckReturnValue
93 *
94 * PARAMETERS: Node - Namespace node for the method/object
95 * Info - Method execution information block
96 * UserParamCount - Number of parameters actually passed
97 * ReturnStatus - Status from the object evaluation
98 * ReturnObjectPtr - Pointer to the object returned from the
99 * evaluation of a method or object
100 *
101 * RETURN: Status
102 *
103 * DESCRIPTION: Check the value returned from a predefined name.
104 *
105 ******************************************************************************/
106
107 ACPI_STATUS
108 AcpiNsCheckReturnValue (
109 ACPI_NAMESPACE_NODE *Node,
110 ACPI_EVALUATE_INFO *Info,
111 UINT32 UserParamCount,
112 ACPI_STATUS ReturnStatus,
113 ACPI_OPERAND_OBJECT **ReturnObjectPtr)
114 {
115 ACPI_STATUS Status;
116 const ACPI_PREDEFINED_INFO *Predefined;
117
118
119 /* If not a predefined name, we cannot validate the return object */
120
121 Predefined = Info->Predefined;
122 if (!Predefined)
123 {
124 return (AE_OK);
125 }
126
127 /*
128 * If the method failed or did not actually return an object, we cannot
129 * validate the return object
130 */
131 if ((ReturnStatus != AE_OK) &&
132 (ReturnStatus != AE_CTRL_RETURN_VALUE))
133 {
134 return (AE_OK);
135 }
136
137 /*
138 * Return value validation and possible repair.
139 *
140 * 1) Don't perform return value validation/repair if this feature
141 * has been disabled via a global option.
142 *
143 * 2) We have a return value, but if one wasn't expected, just exit,
144 * this is not a problem. For example, if the "Implicit Return"
145 * feature is enabled, methods will always return a value.
146 *
147 * 3) If the return value can be of any type, then we cannot perform
148 * any validation, just exit.
149 */
150 if (AcpiGbl_DisableAutoRepair ||
151 (!Predefined->Info.ExpectedBtypes) ||
152 (Predefined->Info.ExpectedBtypes == ACPI_RTYPE_ALL))
153 {
154 return (AE_OK);
155 }
156
157 /*
158 * Check that the type of the main return object is what is expected
159 * for this predefined name
160 */
161 Status = AcpiNsCheckObjectType (Info, ReturnObjectPtr,
162 Predefined->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT);
163 if (ACPI_FAILURE (Status))
164 {
165 goto Exit;
166 }
167
168 /*
169 *
170 * 4) If there is no return value and it is optional, just return
171 * AE_OK (_WAK).
172 */
173 if (!(*ReturnObjectPtr))
174 {
175 goto Exit;
176 }
177
178 /*
179 * For returned Package objects, check the type of all sub-objects.
180 * Note: Package may have been newly created by call above.
181 */
182 if ((*ReturnObjectPtr)->Common.Type == ACPI_TYPE_PACKAGE)
183 {
184 Info->ParentPackage = *ReturnObjectPtr;
185 Status = AcpiNsCheckPackage (Info, ReturnObjectPtr);
186 if (ACPI_FAILURE (Status))
187 {
188 /* We might be able to fix some errors */
189
190 if ((Status != AE_AML_OPERAND_TYPE) &&
191 (Status != AE_AML_OPERAND_VALUE))
192 {
193 goto Exit;
194 }
195 }
196 }
197
198 /*
199 * The return object was OK, or it was successfully repaired above.
200 * Now make some additional checks such as verifying that package
201 * objects are sorted correctly (if required) or buffer objects have
202 * the correct data width (bytes vs. dwords). These repairs are
203 * performed on a per-name basis, i.e., the code is specific to
204 * particular predefined names.
205 */
206 Status = AcpiNsComplexRepairs (Info, Node, Status, ReturnObjectPtr);
207
208 Exit:
209 /*
210 * If the object validation failed or if we successfully repaired one
211 * or more objects, mark the parent node to suppress further warning
212 * messages during the next evaluation of the same method/object.
213 */
214 if (ACPI_FAILURE (Status) ||
215 (Info->ReturnFlags & ACPI_OBJECT_REPAIRED))
216 {
217 Node->Flags |= ANOBJ_EVALUATED;
218 }
219
220 return (Status);
221 }
222
223
224 /*******************************************************************************
225 *
226 * FUNCTION: AcpiNsCheckObjectType
227 *
228 * PARAMETERS: Info - Method execution information block
229 * ReturnObjectPtr - Pointer to the object returned from the
230 * evaluation of a method or object
231 * ExpectedBtypes - Bitmap of expected return type(s)
232 * PackageIndex - Index of object within parent package (if
233 * applicable - ACPI_NOT_PACKAGE_ELEMENT
234 * otherwise)
235 *
236 * RETURN: Status
237 *
238 * DESCRIPTION: Check the type of the return object against the expected object
239 * type(s). Use of Btype allows multiple expected object types.
240 *
241 ******************************************************************************/
242
243 ACPI_STATUS
244 AcpiNsCheckObjectType (
245 ACPI_EVALUATE_INFO *Info,
246 ACPI_OPERAND_OBJECT **ReturnObjectPtr,
247 UINT32 ExpectedBtypes,
248 UINT32 PackageIndex)
249 {
250 ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr;
251 ACPI_STATUS Status = AE_OK;
252 char TypeBuffer[48]; /* Room for 5 types */
253
254
255 /* A Namespace node should not get here, but make sure */
256
257 if (ReturnObject &&
258 ACPI_GET_DESCRIPTOR_TYPE (ReturnObject) == ACPI_DESC_TYPE_NAMED)
259 {
260 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
261 "Invalid return type - Found a Namespace node [%4.4s] type %s",
262 ReturnObject->Node.Name.Ascii,
263 AcpiUtGetTypeName (ReturnObject->Node.Type)));
264 return (AE_AML_OPERAND_TYPE);
265 }
266
267 /*
268 * Convert the object type (ACPI_TYPE_xxx) to a bitmapped object type.
269 * The bitmapped type allows multiple possible return types.
270 *
271 * Note, the cases below must handle all of the possible types returned
272 * from all of the predefined names (including elements of returned
273 * packages)
274 */
275 Info->ReturnBtype = AcpiNsGetBitmappedType (ReturnObject);
276 if (Info->ReturnBtype == ACPI_RTYPE_ANY)
277 {
278 /* Not one of the supported objects, must be incorrect */
279 goto TypeErrorExit;
280 }
281
282 /* For reference objects, check that the reference type is correct */
283
284 if ((Info->ReturnBtype & ExpectedBtypes) == ACPI_RTYPE_REFERENCE)
285 {
286 Status = AcpiNsCheckReference (Info, ReturnObject);
287 return (Status);
288 }
289
290 /* Attempt simple repair of the returned object if necessary */
291
292 Status = AcpiNsSimpleRepair (Info, ExpectedBtypes,
293 PackageIndex, ReturnObjectPtr);
294 if (ACPI_SUCCESS (Status))
295 {
296 return (AE_OK); /* Successful repair */
297 }
298
299
300 TypeErrorExit:
301
302 /* Create a string with all expected types for this predefined object */
303
304 AcpiUtGetExpectedReturnTypes (TypeBuffer, ExpectedBtypes);
305
306 if (!ReturnObject)
307 {
308 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
309 "Expected return object of type %s",
310 TypeBuffer));
311 }
312 else if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT)
313 {
314 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
315 "Return type mismatch - found %s, expected %s",
316 AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));
317 }
318 else
319 {
320 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
321 "Return Package type mismatch at index %u - "
322 "found %s, expected %s", PackageIndex,
323 AcpiUtGetObjectTypeName (ReturnObject), TypeBuffer));
324 }
325
326 return (AE_AML_OPERAND_TYPE);
327 }
328
329
330 /*******************************************************************************
331 *
332 * FUNCTION: AcpiNsCheckReference
333 *
334 * PARAMETERS: Info - Method execution information block
335 * ReturnObject - Object returned from the evaluation of a
336 * method or object
337 *
338 * RETURN: Status
339 *
340 * DESCRIPTION: Check a returned reference object for the correct reference
341 * type. The only reference type that can be returned from a
342 * predefined method is a named reference. All others are invalid.
343 *
344 ******************************************************************************/
345
346 static ACPI_STATUS
347 AcpiNsCheckReference (
348 ACPI_EVALUATE_INFO *Info,
349 ACPI_OPERAND_OBJECT *ReturnObject)
350 {
351
352 /*
353 * Check the reference object for the correct reference type (opcode).
354 * The only type of reference that can be converted to an ACPI_OBJECT is
355 * a reference to a named object (reference class: NAME)
356 */
357 if (ReturnObject->Reference.Class == ACPI_REFCLASS_NAME)
358 {
359 return (AE_OK);
360 }
361
362 ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, Info->NodeFlags,
363 "Return type mismatch - unexpected reference object type [%s] %2.2X",
364 AcpiUtGetReferenceName (ReturnObject),
365 ReturnObject->Reference.Class));
366
367 return (AE_AML_OPERAND_TYPE);
368 }
369
370
371 /*******************************************************************************
372 *
373 * FUNCTION: AcpiNsGetBitmappedType
374 *
375 * PARAMETERS: ReturnObject - Object returned from method/obj evaluation
376 *
377 * RETURN: Object return type. ACPI_RTYPE_ANY indicates that the object
378 * type is not supported. ACPI_RTYPE_NONE indicates that no
379 * object was returned (ReturnObject is NULL).
380 *
381 * DESCRIPTION: Convert object type into a bitmapped object return type.
382 *
383 ******************************************************************************/
384
385 static UINT32
386 AcpiNsGetBitmappedType (
387 ACPI_OPERAND_OBJECT *ReturnObject)
388 {
389 UINT32 ReturnBtype;
390
391
392 if (!ReturnObject)
393 {
394 return (ACPI_RTYPE_NONE);
395 }
396
397 /* Map ACPI_OBJECT_TYPE to internal bitmapped type */
398
399 switch (ReturnObject->Common.Type)
400 {
401 case ACPI_TYPE_INTEGER:
402
403 ReturnBtype = ACPI_RTYPE_INTEGER;
404 break;
405
406 case ACPI_TYPE_BUFFER:
407
408 ReturnBtype = ACPI_RTYPE_BUFFER;
409 break;
410
411 case ACPI_TYPE_STRING:
412
413 ReturnBtype = ACPI_RTYPE_STRING;
414 break;
415
416 case ACPI_TYPE_PACKAGE:
417
418 ReturnBtype = ACPI_RTYPE_PACKAGE;
419 break;
420
421 case ACPI_TYPE_LOCAL_REFERENCE:
422
423 ReturnBtype = ACPI_RTYPE_REFERENCE;
424 break;
425
426 default:
427
428 /* Not one of the supported objects, must be incorrect */
429
430 ReturnBtype = ACPI_RTYPE_ANY;
431 break;
432 }
433
434 return (ReturnBtype);
435 }