1 | /****************************************************************************** |
2 | * |
3 | * Module Name: nsrepair - Repair for objects returned by predefined methods |
4 | * |
5 | *****************************************************************************/ |
6 | |
7 | /* |
8 | * Copyright (C) 2000 - 2016, 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.h" |
45 | #include "accommon.h" |
46 | #include "acnamesp.h" |
47 | #include "acinterp.h" |
48 | #include "acpredef.h" |
49 | #include "amlresrc.h" |
50 | |
51 | #define _COMPONENT ACPI_NAMESPACE |
52 | ACPI_MODULE_NAME ("nsrepair" ) |
53 | |
54 | |
55 | /******************************************************************************* |
56 | * |
57 | * This module attempts to repair or convert objects returned by the |
58 | * predefined methods to an object type that is expected, as per the ACPI |
59 | * specification. The need for this code is dictated by the many machines that |
60 | * return incorrect types for the standard predefined methods. Performing these |
61 | * conversions here, in one place, eliminates the need for individual ACPI |
62 | * device drivers to do the same. Note: Most of these conversions are different |
63 | * than the internal object conversion routines used for implicit object |
64 | * conversion. |
65 | * |
66 | * The following conversions can be performed as necessary: |
67 | * |
68 | * Integer -> String |
69 | * Integer -> Buffer |
70 | * String -> Integer |
71 | * String -> Buffer |
72 | * Buffer -> Integer |
73 | * Buffer -> String |
74 | * Buffer -> Package of Integers |
75 | * Package -> Package of one Package |
76 | * |
77 | * Additional conversions that are available: |
78 | * Convert a null return or zero return value to an EndTag descriptor |
79 | * Convert an ASCII string to a Unicode buffer |
80 | * |
81 | * An incorrect standalone object is wrapped with required outer package |
82 | * |
83 | * Additional possible repairs: |
84 | * Required package elements that are NULL replaced by Integer/String/Buffer |
85 | * |
86 | ******************************************************************************/ |
87 | |
88 | |
89 | /* Local prototypes */ |
90 | |
91 | static const ACPI_SIMPLE_REPAIR_INFO * |
92 | AcpiNsMatchSimpleRepair ( |
93 | ACPI_NAMESPACE_NODE *Node, |
94 | UINT32 ReturnBtype, |
95 | UINT32 PackageIndex); |
96 | |
97 | |
98 | /* |
99 | * Special but simple repairs for some names. |
100 | * |
101 | * 2nd argument: Unexpected types that can be repaired |
102 | */ |
103 | static const ACPI_SIMPLE_REPAIR_INFO AcpiObjectRepairInfo[] = |
104 | { |
105 | /* Resource descriptor conversions */ |
106 | |
107 | { "_CRS" , ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE, |
108 | ACPI_NOT_PACKAGE_ELEMENT, |
109 | AcpiNsConvertToResource }, |
110 | { "_DMA" , ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE, |
111 | ACPI_NOT_PACKAGE_ELEMENT, |
112 | AcpiNsConvertToResource }, |
113 | { "_PRS" , ACPI_RTYPE_INTEGER | ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER | ACPI_RTYPE_NONE, |
114 | ACPI_NOT_PACKAGE_ELEMENT, |
115 | AcpiNsConvertToResource }, |
116 | |
117 | /* Object reference conversions */ |
118 | |
119 | { "_DEP" , ACPI_RTYPE_STRING, ACPI_ALL_PACKAGE_ELEMENTS, |
120 | AcpiNsConvertToReference }, |
121 | |
122 | /* Unicode conversions */ |
123 | |
124 | { "_MLS" , ACPI_RTYPE_STRING, 1, |
125 | AcpiNsConvertToUnicode }, |
126 | { "_STR" , ACPI_RTYPE_STRING | ACPI_RTYPE_BUFFER, |
127 | ACPI_NOT_PACKAGE_ELEMENT, |
128 | AcpiNsConvertToUnicode }, |
129 | { {0,0,0,0}, 0, 0, NULL } /* Table terminator */ |
130 | }; |
131 | |
132 | |
133 | /******************************************************************************* |
134 | * |
135 | * FUNCTION: AcpiNsSimpleRepair |
136 | * |
137 | * PARAMETERS: Info - Method execution information block |
138 | * ExpectedBtypes - Object types expected |
139 | * PackageIndex - Index of object within parent package (if |
140 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
141 | * otherwise) |
142 | * ReturnObjectPtr - Pointer to the object returned from the |
143 | * evaluation of a method or object |
144 | * |
145 | * RETURN: Status. AE_OK if repair was successful. |
146 | * |
147 | * DESCRIPTION: Attempt to repair/convert a return object of a type that was |
148 | * not expected. |
149 | * |
150 | ******************************************************************************/ |
151 | |
152 | ACPI_STATUS |
153 | AcpiNsSimpleRepair ( |
154 | ACPI_EVALUATE_INFO *Info, |
155 | UINT32 ExpectedBtypes, |
156 | UINT32 PackageIndex, |
157 | ACPI_OPERAND_OBJECT **ReturnObjectPtr) |
158 | { |
159 | ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr; |
160 | ACPI_OPERAND_OBJECT *NewObject = NULL; |
161 | ACPI_STATUS Status; |
162 | const ACPI_SIMPLE_REPAIR_INFO *Predefined; |
163 | |
164 | |
165 | ACPI_FUNCTION_NAME (NsSimpleRepair); |
166 | |
167 | |
168 | /* |
169 | * Special repairs for certain names that are in the repair table. |
170 | * Check if this name is in the list of repairable names. |
171 | */ |
172 | Predefined = AcpiNsMatchSimpleRepair (Info->Node, |
173 | Info->ReturnBtype, PackageIndex); |
174 | if (Predefined) |
175 | { |
176 | if (!ReturnObject) |
177 | { |
178 | ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, |
179 | ACPI_WARN_ALWAYS, "Missing expected return value" )); |
180 | } |
181 | |
182 | Status = Predefined->ObjectConverter (Info->Node, ReturnObject, |
183 | &NewObject); |
184 | if (ACPI_FAILURE (Status)) |
185 | { |
186 | /* A fatal error occurred during a conversion */ |
187 | |
188 | ACPI_EXCEPTION ((AE_INFO, Status, |
189 | "During return object analysis" )); |
190 | return (Status); |
191 | } |
192 | if (NewObject) |
193 | { |
194 | goto ObjectRepaired; |
195 | } |
196 | } |
197 | |
198 | /* |
199 | * Do not perform simple object repair unless the return type is not |
200 | * expected. |
201 | */ |
202 | if (Info->ReturnBtype & ExpectedBtypes) |
203 | { |
204 | return (AE_OK); |
205 | } |
206 | |
207 | /* |
208 | * At this point, we know that the type of the returned object was not |
209 | * one of the expected types for this predefined name. Attempt to |
210 | * repair the object by converting it to one of the expected object |
211 | * types for this predefined name. |
212 | */ |
213 | |
214 | /* |
215 | * If there is no return value, check if we require a return value for |
216 | * this predefined name. Either one return value is expected, or none, |
217 | * for both methods and other objects. |
218 | * |
219 | * Try to fix if there was no return object. Warning if failed to fix. |
220 | */ |
221 | if (!ReturnObject) |
222 | { |
223 | if (ExpectedBtypes && (!(ExpectedBtypes & ACPI_RTYPE_NONE))) |
224 | { |
225 | if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT) |
226 | { |
227 | ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, |
228 | ACPI_WARN_ALWAYS, "Found unexpected NULL package element" )); |
229 | |
230 | Status = AcpiNsRepairNullElement (Info, ExpectedBtypes, |
231 | PackageIndex, ReturnObjectPtr); |
232 | if (ACPI_SUCCESS (Status)) |
233 | { |
234 | return (AE_OK); /* Repair was successful */ |
235 | } |
236 | } |
237 | else |
238 | { |
239 | ACPI_WARN_PREDEFINED ((AE_INFO, Info->FullPathname, |
240 | ACPI_WARN_ALWAYS, "Missing expected return value" )); |
241 | } |
242 | |
243 | return (AE_AML_NO_RETURN_VALUE); |
244 | } |
245 | } |
246 | |
247 | if (ExpectedBtypes & ACPI_RTYPE_INTEGER) |
248 | { |
249 | Status = AcpiNsConvertToInteger (ReturnObject, &NewObject); |
250 | if (ACPI_SUCCESS (Status)) |
251 | { |
252 | goto ObjectRepaired; |
253 | } |
254 | } |
255 | if (ExpectedBtypes & ACPI_RTYPE_STRING) |
256 | { |
257 | Status = AcpiNsConvertToString (ReturnObject, &NewObject); |
258 | if (ACPI_SUCCESS (Status)) |
259 | { |
260 | goto ObjectRepaired; |
261 | } |
262 | } |
263 | if (ExpectedBtypes & ACPI_RTYPE_BUFFER) |
264 | { |
265 | Status = AcpiNsConvertToBuffer (ReturnObject, &NewObject); |
266 | if (ACPI_SUCCESS (Status)) |
267 | { |
268 | goto ObjectRepaired; |
269 | } |
270 | } |
271 | if (ExpectedBtypes & ACPI_RTYPE_PACKAGE) |
272 | { |
273 | /* |
274 | * A package is expected. We will wrap the existing object with a |
275 | * new package object. It is often the case that if a variable-length |
276 | * package is required, but there is only a single object needed, the |
277 | * BIOS will return that object instead of wrapping it with a Package |
278 | * object. Note: after the wrapping, the package will be validated |
279 | * for correct contents (expected object type or types). |
280 | */ |
281 | Status = AcpiNsWrapWithPackage (Info, ReturnObject, &NewObject); |
282 | if (ACPI_SUCCESS (Status)) |
283 | { |
284 | /* |
285 | * The original object just had its reference count |
286 | * incremented for being inserted into the new package. |
287 | */ |
288 | *ReturnObjectPtr = NewObject; /* New Package object */ |
289 | Info->ReturnFlags |= ACPI_OBJECT_REPAIRED; |
290 | return (AE_OK); |
291 | } |
292 | } |
293 | |
294 | /* We cannot repair this object */ |
295 | |
296 | return (AE_AML_OPERAND_TYPE); |
297 | |
298 | |
299 | ObjectRepaired: |
300 | |
301 | /* Object was successfully repaired */ |
302 | |
303 | if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT) |
304 | { |
305 | /* |
306 | * The original object is a package element. We need to |
307 | * decrement the reference count of the original object, |
308 | * for removing it from the package. |
309 | * |
310 | * However, if the original object was just wrapped with a |
311 | * package object as part of the repair, we don't need to |
312 | * change the reference count. |
313 | */ |
314 | if (!(Info->ReturnFlags & ACPI_OBJECT_WRAPPED)) |
315 | { |
316 | NewObject->Common.ReferenceCount = |
317 | ReturnObject->Common.ReferenceCount; |
318 | |
319 | if (ReturnObject->Common.ReferenceCount > 1) |
320 | { |
321 | ReturnObject->Common.ReferenceCount--; |
322 | } |
323 | } |
324 | |
325 | ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR, |
326 | "%s: Converted %s to expected %s at Package index %u\n" , |
327 | Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject), |
328 | AcpiUtGetObjectTypeName (NewObject), PackageIndex)); |
329 | } |
330 | else |
331 | { |
332 | ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR, |
333 | "%s: Converted %s to expected %s\n" , |
334 | Info->FullPathname, AcpiUtGetObjectTypeName (ReturnObject), |
335 | AcpiUtGetObjectTypeName (NewObject))); |
336 | } |
337 | |
338 | /* Delete old object, install the new return object */ |
339 | |
340 | AcpiUtRemoveReference (ReturnObject); |
341 | *ReturnObjectPtr = NewObject; |
342 | Info->ReturnFlags |= ACPI_OBJECT_REPAIRED; |
343 | return (AE_OK); |
344 | } |
345 | |
346 | |
347 | /****************************************************************************** |
348 | * |
349 | * FUNCTION: AcpiNsMatchSimpleRepair |
350 | * |
351 | * PARAMETERS: Node - Namespace node for the method/object |
352 | * ReturnBtype - Object type that was returned |
353 | * PackageIndex - Index of object within parent package (if |
354 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
355 | * otherwise) |
356 | * |
357 | * RETURN: Pointer to entry in repair table. NULL indicates not found. |
358 | * |
359 | * DESCRIPTION: Check an object name against the repairable object list. |
360 | * |
361 | *****************************************************************************/ |
362 | |
363 | static const ACPI_SIMPLE_REPAIR_INFO * |
364 | AcpiNsMatchSimpleRepair ( |
365 | ACPI_NAMESPACE_NODE *Node, |
366 | UINT32 ReturnBtype, |
367 | UINT32 PackageIndex) |
368 | { |
369 | const ACPI_SIMPLE_REPAIR_INFO *ThisName; |
370 | |
371 | |
372 | /* Search info table for a repairable predefined method/object name */ |
373 | |
374 | ThisName = AcpiObjectRepairInfo; |
375 | while (ThisName->ObjectConverter) |
376 | { |
377 | if (ACPI_COMPARE_NAME (Node->Name.Ascii, ThisName->Name)) |
378 | { |
379 | /* Check if we can actually repair this name/type combination */ |
380 | |
381 | if ((ReturnBtype & ThisName->UnexpectedBtypes) && |
382 | (ThisName->PackageIndex == ACPI_ALL_PACKAGE_ELEMENTS || |
383 | PackageIndex == ThisName->PackageIndex)) |
384 | { |
385 | return (ThisName); |
386 | } |
387 | |
388 | return (NULL); |
389 | } |
390 | |
391 | ThisName++; |
392 | } |
393 | |
394 | return (NULL); /* Name was not found in the repair table */ |
395 | } |
396 | |
397 | |
398 | /******************************************************************************* |
399 | * |
400 | * FUNCTION: AcpiNsRepairNullElement |
401 | * |
402 | * PARAMETERS: Info - Method execution information block |
403 | * ExpectedBtypes - Object types expected |
404 | * PackageIndex - Index of object within parent package (if |
405 | * applicable - ACPI_NOT_PACKAGE_ELEMENT |
406 | * otherwise) |
407 | * ReturnObjectPtr - Pointer to the object returned from the |
408 | * evaluation of a method or object |
409 | * |
410 | * RETURN: Status. AE_OK if repair was successful. |
411 | * |
412 | * DESCRIPTION: Attempt to repair a NULL element of a returned Package object. |
413 | * |
414 | ******************************************************************************/ |
415 | |
416 | ACPI_STATUS |
417 | AcpiNsRepairNullElement ( |
418 | ACPI_EVALUATE_INFO *Info, |
419 | UINT32 ExpectedBtypes, |
420 | UINT32 PackageIndex, |
421 | ACPI_OPERAND_OBJECT **ReturnObjectPtr) |
422 | { |
423 | ACPI_OPERAND_OBJECT *ReturnObject = *ReturnObjectPtr; |
424 | ACPI_OPERAND_OBJECT *NewObject; |
425 | |
426 | |
427 | ACPI_FUNCTION_NAME (NsRepairNullElement); |
428 | |
429 | |
430 | /* No repair needed if return object is non-NULL */ |
431 | |
432 | if (ReturnObject) |
433 | { |
434 | return (AE_OK); |
435 | } |
436 | |
437 | /* |
438 | * Attempt to repair a NULL element of a Package object. This applies to |
439 | * predefined names that return a fixed-length package and each element |
440 | * is required. It does not apply to variable-length packages where NULL |
441 | * elements are allowed, especially at the end of the package. |
442 | */ |
443 | if (ExpectedBtypes & ACPI_RTYPE_INTEGER) |
444 | { |
445 | /* Need an Integer - create a zero-value integer */ |
446 | |
447 | NewObject = AcpiUtCreateIntegerObject ((UINT64) 0); |
448 | } |
449 | else if (ExpectedBtypes & ACPI_RTYPE_STRING) |
450 | { |
451 | /* Need a String - create a NULL string */ |
452 | |
453 | NewObject = AcpiUtCreateStringObject (0); |
454 | } |
455 | else if (ExpectedBtypes & ACPI_RTYPE_BUFFER) |
456 | { |
457 | /* Need a Buffer - create a zero-length buffer */ |
458 | |
459 | NewObject = AcpiUtCreateBufferObject (0); |
460 | } |
461 | else |
462 | { |
463 | /* Error for all other expected types */ |
464 | |
465 | return (AE_AML_OPERAND_TYPE); |
466 | } |
467 | |
468 | if (!NewObject) |
469 | { |
470 | return (AE_NO_MEMORY); |
471 | } |
472 | |
473 | /* Set the reference count according to the parent Package object */ |
474 | |
475 | NewObject->Common.ReferenceCount = |
476 | Info->ParentPackage->Common.ReferenceCount; |
477 | |
478 | ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR, |
479 | "%s: Converted NULL package element to expected %s at index %u\n" , |
480 | Info->FullPathname, AcpiUtGetObjectTypeName (NewObject), |
481 | PackageIndex)); |
482 | |
483 | *ReturnObjectPtr = NewObject; |
484 | Info->ReturnFlags |= ACPI_OBJECT_REPAIRED; |
485 | return (AE_OK); |
486 | } |
487 | |
488 | |
489 | /****************************************************************************** |
490 | * |
491 | * FUNCTION: AcpiNsRemoveNullElements |
492 | * |
493 | * PARAMETERS: Info - Method execution information block |
494 | * PackageType - An AcpiReturnPackageTypes value |
495 | * ObjDesc - A Package object |
496 | * |
497 | * RETURN: None. |
498 | * |
499 | * DESCRIPTION: Remove all NULL package elements from packages that contain |
500 | * a variable number of subpackages. For these types of |
501 | * packages, NULL elements can be safely removed. |
502 | * |
503 | *****************************************************************************/ |
504 | |
505 | void |
506 | AcpiNsRemoveNullElements ( |
507 | ACPI_EVALUATE_INFO *Info, |
508 | UINT8 PackageType, |
509 | ACPI_OPERAND_OBJECT *ObjDesc) |
510 | { |
511 | ACPI_OPERAND_OBJECT **Source; |
512 | ACPI_OPERAND_OBJECT **Dest; |
513 | UINT32 Count; |
514 | UINT32 NewCount; |
515 | UINT32 i; |
516 | |
517 | |
518 | ACPI_FUNCTION_NAME (NsRemoveNullElements); |
519 | |
520 | |
521 | /* |
522 | * We can safely remove all NULL elements from these package types: |
523 | * PTYPE1_VAR packages contain a variable number of simple data types. |
524 | * PTYPE2 packages contain a variable number of subpackages. |
525 | */ |
526 | switch (PackageType) |
527 | { |
528 | case ACPI_PTYPE1_VAR: |
529 | case ACPI_PTYPE2: |
530 | case ACPI_PTYPE2_COUNT: |
531 | case ACPI_PTYPE2_PKG_COUNT: |
532 | case ACPI_PTYPE2_FIXED: |
533 | case ACPI_PTYPE2_MIN: |
534 | case ACPI_PTYPE2_REV_FIXED: |
535 | case ACPI_PTYPE2_FIX_VAR: |
536 | break; |
537 | |
538 | default: |
539 | case ACPI_PTYPE2_VAR_VAR: |
540 | case ACPI_PTYPE1_FIXED: |
541 | case ACPI_PTYPE1_OPTION: |
542 | return; |
543 | } |
544 | |
545 | Count = ObjDesc->Package.Count; |
546 | NewCount = Count; |
547 | |
548 | Source = ObjDesc->Package.Elements; |
549 | Dest = Source; |
550 | |
551 | /* Examine all elements of the package object, remove nulls */ |
552 | |
553 | for (i = 0; i < Count; i++) |
554 | { |
555 | if (!*Source) |
556 | { |
557 | NewCount--; |
558 | } |
559 | else |
560 | { |
561 | *Dest = *Source; |
562 | Dest++; |
563 | } |
564 | |
565 | Source++; |
566 | } |
567 | |
568 | /* Update parent package if any null elements were removed */ |
569 | |
570 | if (NewCount < Count) |
571 | { |
572 | ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR, |
573 | "%s: Found and removed %u NULL elements\n" , |
574 | Info->FullPathname, (Count - NewCount))); |
575 | |
576 | /* NULL terminate list and update the package count */ |
577 | |
578 | *Dest = NULL; |
579 | ObjDesc->Package.Count = NewCount; |
580 | } |
581 | } |
582 | |
583 | |
584 | /******************************************************************************* |
585 | * |
586 | * FUNCTION: AcpiNsWrapWithPackage |
587 | * |
588 | * PARAMETERS: Info - Method execution information block |
589 | * OriginalObject - Pointer to the object to repair. |
590 | * ObjDescPtr - The new package object is returned here |
591 | * |
592 | * RETURN: Status, new object in *ObjDescPtr |
593 | * |
594 | * DESCRIPTION: Repair a common problem with objects that are defined to |
595 | * return a variable-length Package of sub-objects. If there is |
596 | * only one sub-object, some BIOS code mistakenly simply declares |
597 | * the single object instead of a Package with one sub-object. |
598 | * This function attempts to repair this error by wrapping a |
599 | * Package object around the original object, creating the |
600 | * correct and expected Package with one sub-object. |
601 | * |
602 | * Names that can be repaired in this manner include: |
603 | * _ALR, _CSD, _HPX, _MLS, _PLD, _PRT, _PSS, _TRT, _TSS, |
604 | * _BCL, _DOD, _FIX, _Sx |
605 | * |
606 | ******************************************************************************/ |
607 | |
608 | ACPI_STATUS |
609 | AcpiNsWrapWithPackage ( |
610 | ACPI_EVALUATE_INFO *Info, |
611 | ACPI_OPERAND_OBJECT *OriginalObject, |
612 | ACPI_OPERAND_OBJECT **ObjDescPtr) |
613 | { |
614 | ACPI_OPERAND_OBJECT *PkgObjDesc; |
615 | |
616 | |
617 | ACPI_FUNCTION_NAME (NsWrapWithPackage); |
618 | |
619 | |
620 | /* |
621 | * Create the new outer package and populate it. The new |
622 | * package will have a single element, the lone sub-object. |
623 | */ |
624 | PkgObjDesc = AcpiUtCreatePackageObject (1); |
625 | if (!PkgObjDesc) |
626 | { |
627 | return (AE_NO_MEMORY); |
628 | } |
629 | |
630 | PkgObjDesc->Package.Elements[0] = OriginalObject; |
631 | |
632 | ACPI_DEBUG_PRINT ((ACPI_DB_REPAIR, |
633 | "%s: Wrapped %s with expected Package object\n" , |
634 | Info->FullPathname, AcpiUtGetObjectTypeName (OriginalObject))); |
635 | |
636 | /* Return the new object in the object pointer */ |
637 | |
638 | *ObjDescPtr = PkgObjDesc; |
639 | Info->ReturnFlags |= ACPI_OBJECT_REPAIRED | ACPI_OBJECT_WRAPPED; |
640 | return (AE_OK); |
641 | } |
642 | |