Merge branch 'idle-release' of git://git.kernel.org/pub/scm/linux/kernel/git/lenb...
[pandora-kernel.git] / drivers / acpi / acpica / nsrepair.c
1 /******************************************************************************
2  *
3  * Module Name: nsrepair - Repair for objects returned by predefined methods
4  *
5  *****************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2011, 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 #include "acinterp.h"
48 #include "acpredef.h"
49
50 #define _COMPONENT          ACPI_NAMESPACE
51 ACPI_MODULE_NAME("nsrepair")
52
53 /*******************************************************************************
54  *
55  * This module attempts to repair or convert objects returned by the
56  * predefined methods to an object type that is expected, as per the ACPI
57  * specification. The need for this code is dictated by the many machines that
58  * return incorrect types for the standard predefined methods. Performing these
59  * conversions here, in one place, eliminates the need for individual ACPI
60  * device drivers to do the same. Note: Most of these conversions are different
61  * than the internal object conversion routines used for implicit object
62  * conversion.
63  *
64  * The following conversions can be performed as necessary:
65  *
66  * Integer -> String
67  * Integer -> Buffer
68  * String  -> Integer
69  * String  -> Buffer
70  * Buffer  -> Integer
71  * Buffer  -> String
72  * Buffer  -> Package of Integers
73  * Package -> Package of one Package
74  *
75  * Additional possible repairs:
76  *
77  * Optional/unnecessary NULL package elements removed
78  * Required package elements that are NULL replaced by Integer/String/Buffer
79  * Incorrect standalone package wrapped with required outer package
80  *
81  ******************************************************************************/
82 /* Local prototypes */
83 static acpi_status
84 acpi_ns_convert_to_integer(union acpi_operand_object *original_object,
85                            union acpi_operand_object **return_object);
86
87 static acpi_status
88 acpi_ns_convert_to_string(union acpi_operand_object *original_object,
89                           union acpi_operand_object **return_object);
90
91 static acpi_status
92 acpi_ns_convert_to_buffer(union acpi_operand_object *original_object,
93                           union acpi_operand_object **return_object);
94
95 static acpi_status
96 acpi_ns_convert_to_package(union acpi_operand_object *original_object,
97                            union acpi_operand_object **return_object);
98
99 /*******************************************************************************
100  *
101  * FUNCTION:    acpi_ns_repair_object
102  *
103  * PARAMETERS:  Data                - Pointer to validation data structure
104  *              expected_btypes     - Object types expected
105  *              package_index       - Index of object within parent package (if
106  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
107  *                                    otherwise)
108  *              return_object_ptr   - Pointer to the object returned from the
109  *                                    evaluation of a method or object
110  *
111  * RETURN:      Status. AE_OK if repair was successful.
112  *
113  * DESCRIPTION: Attempt to repair/convert a return object of a type that was
114  *              not expected.
115  *
116  ******************************************************************************/
117
118 acpi_status
119 acpi_ns_repair_object(struct acpi_predefined_data *data,
120                       u32 expected_btypes,
121                       u32 package_index,
122                       union acpi_operand_object **return_object_ptr)
123 {
124         union acpi_operand_object *return_object = *return_object_ptr;
125         union acpi_operand_object *new_object;
126         acpi_status status;
127
128         ACPI_FUNCTION_NAME(ns_repair_object);
129
130         /*
131          * At this point, we know that the type of the returned object was not
132          * one of the expected types for this predefined name. Attempt to
133          * repair the object by converting it to one of the expected object
134          * types for this predefined name.
135          */
136         if (expected_btypes & ACPI_RTYPE_INTEGER) {
137                 status = acpi_ns_convert_to_integer(return_object, &new_object);
138                 if (ACPI_SUCCESS(status)) {
139                         goto object_repaired;
140                 }
141         }
142         if (expected_btypes & ACPI_RTYPE_STRING) {
143                 status = acpi_ns_convert_to_string(return_object, &new_object);
144                 if (ACPI_SUCCESS(status)) {
145                         goto object_repaired;
146                 }
147         }
148         if (expected_btypes & ACPI_RTYPE_BUFFER) {
149                 status = acpi_ns_convert_to_buffer(return_object, &new_object);
150                 if (ACPI_SUCCESS(status)) {
151                         goto object_repaired;
152                 }
153         }
154         if (expected_btypes & ACPI_RTYPE_PACKAGE) {
155                 status = acpi_ns_convert_to_package(return_object, &new_object);
156                 if (ACPI_SUCCESS(status)) {
157                         goto object_repaired;
158                 }
159         }
160
161         /* We cannot repair this object */
162
163         return (AE_AML_OPERAND_TYPE);
164
165       object_repaired:
166
167         /* Object was successfully repaired */
168
169         /*
170          * If the original object is a package element, we need to:
171          * 1. Set the reference count of the new object to match the
172          *    reference count of the old object.
173          * 2. Decrement the reference count of the original object.
174          */
175         if (package_index != ACPI_NOT_PACKAGE_ELEMENT) {
176                 new_object->common.reference_count =
177                     return_object->common.reference_count;
178
179                 if (return_object->common.reference_count > 1) {
180                         return_object->common.reference_count--;
181                 }
182
183                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
184                                   "%s: Converted %s to expected %s at index %u\n",
185                                   data->pathname,
186                                   acpi_ut_get_object_type_name(return_object),
187                                   acpi_ut_get_object_type_name(new_object),
188                                   package_index));
189         } else {
190                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
191                                   "%s: Converted %s to expected %s\n",
192                                   data->pathname,
193                                   acpi_ut_get_object_type_name(return_object),
194                                   acpi_ut_get_object_type_name(new_object)));
195         }
196
197         /* Delete old object, install the new return object */
198
199         acpi_ut_remove_reference(return_object);
200         *return_object_ptr = new_object;
201         data->flags |= ACPI_OBJECT_REPAIRED;
202         return (AE_OK);
203 }
204
205 /*******************************************************************************
206  *
207  * FUNCTION:    acpi_ns_convert_to_integer
208  *
209  * PARAMETERS:  original_object     - Object to be converted
210  *              return_object       - Where the new converted object is returned
211  *
212  * RETURN:      Status. AE_OK if conversion was successful.
213  *
214  * DESCRIPTION: Attempt to convert a String/Buffer object to an Integer.
215  *
216  ******************************************************************************/
217
218 static acpi_status
219 acpi_ns_convert_to_integer(union acpi_operand_object *original_object,
220                            union acpi_operand_object **return_object)
221 {
222         union acpi_operand_object *new_object;
223         acpi_status status;
224         u64 value = 0;
225         u32 i;
226
227         switch (original_object->common.type) {
228         case ACPI_TYPE_STRING:
229
230                 /* String-to-Integer conversion */
231
232                 status = acpi_ut_strtoul64(original_object->string.pointer,
233                                            ACPI_ANY_BASE, &value);
234                 if (ACPI_FAILURE(status)) {
235                         return (status);
236                 }
237                 break;
238
239         case ACPI_TYPE_BUFFER:
240
241                 /* Buffer-to-Integer conversion. Max buffer size is 64 bits. */
242
243                 if (original_object->buffer.length > 8) {
244                         return (AE_AML_OPERAND_TYPE);
245                 }
246
247                 /* Extract each buffer byte to create the integer */
248
249                 for (i = 0; i < original_object->buffer.length; i++) {
250                         value |=
251                             ((u64) original_object->buffer.
252                              pointer[i] << (i * 8));
253                 }
254                 break;
255
256         default:
257                 return (AE_AML_OPERAND_TYPE);
258         }
259
260         new_object = acpi_ut_create_integer_object(value);
261         if (!new_object) {
262                 return (AE_NO_MEMORY);
263         }
264
265         *return_object = new_object;
266         return (AE_OK);
267 }
268
269 /*******************************************************************************
270  *
271  * FUNCTION:    acpi_ns_convert_to_string
272  *
273  * PARAMETERS:  original_object     - Object to be converted
274  *              return_object       - Where the new converted object is returned
275  *
276  * RETURN:      Status. AE_OK if conversion was successful.
277  *
278  * DESCRIPTION: Attempt to convert a Integer/Buffer object to a String.
279  *
280  ******************************************************************************/
281
282 static acpi_status
283 acpi_ns_convert_to_string(union acpi_operand_object *original_object,
284                           union acpi_operand_object **return_object)
285 {
286         union acpi_operand_object *new_object;
287         acpi_size length;
288         acpi_status status;
289
290         switch (original_object->common.type) {
291         case ACPI_TYPE_INTEGER:
292                 /*
293                  * Integer-to-String conversion. Commonly, convert
294                  * an integer of value 0 to a NULL string. The last element of
295                  * _BIF and _BIX packages occasionally need this fix.
296                  */
297                 if (original_object->integer.value == 0) {
298
299                         /* Allocate a new NULL string object */
300
301                         new_object = acpi_ut_create_string_object(0);
302                         if (!new_object) {
303                                 return (AE_NO_MEMORY);
304                         }
305                 } else {
306                         status =
307                             acpi_ex_convert_to_string(original_object,
308                                                       &new_object,
309                                                       ACPI_IMPLICIT_CONVERT_HEX);
310                         if (ACPI_FAILURE(status)) {
311                                 return (status);
312                         }
313                 }
314                 break;
315
316         case ACPI_TYPE_BUFFER:
317                 /*
318                  * Buffer-to-String conversion. Use a to_string
319                  * conversion, no transform performed on the buffer data. The best
320                  * example of this is the _BIF method, where the string data from
321                  * the battery is often (incorrectly) returned as buffer object(s).
322                  */
323                 length = 0;
324                 while ((length < original_object->buffer.length) &&
325                        (original_object->buffer.pointer[length])) {
326                         length++;
327                 }
328
329                 /* Allocate a new string object */
330
331                 new_object = acpi_ut_create_string_object(length);
332                 if (!new_object) {
333                         return (AE_NO_MEMORY);
334                 }
335
336                 /*
337                  * Copy the raw buffer data with no transform. String is already NULL
338                  * terminated at Length+1.
339                  */
340                 ACPI_MEMCPY(new_object->string.pointer,
341                             original_object->buffer.pointer, length);
342                 break;
343
344         default:
345                 return (AE_AML_OPERAND_TYPE);
346         }
347
348         *return_object = new_object;
349         return (AE_OK);
350 }
351
352 /*******************************************************************************
353  *
354  * FUNCTION:    acpi_ns_convert_to_buffer
355  *
356  * PARAMETERS:  original_object     - Object to be converted
357  *              return_object       - Where the new converted object is returned
358  *
359  * RETURN:      Status. AE_OK if conversion was successful.
360  *
361  * DESCRIPTION: Attempt to convert a Integer/String/Package object to a Buffer.
362  *
363  ******************************************************************************/
364
365 static acpi_status
366 acpi_ns_convert_to_buffer(union acpi_operand_object *original_object,
367                           union acpi_operand_object **return_object)
368 {
369         union acpi_operand_object *new_object;
370         acpi_status status;
371         union acpi_operand_object **elements;
372         u32 *dword_buffer;
373         u32 count;
374         u32 i;
375
376         switch (original_object->common.type) {
377         case ACPI_TYPE_INTEGER:
378                 /*
379                  * Integer-to-Buffer conversion.
380                  * Convert the Integer to a packed-byte buffer. _MAT and other
381                  * objects need this sometimes, if a read has been performed on a
382                  * Field object that is less than or equal to the global integer
383                  * size (32 or 64 bits).
384                  */
385                 status =
386                     acpi_ex_convert_to_buffer(original_object, &new_object);
387                 if (ACPI_FAILURE(status)) {
388                         return (status);
389                 }
390                 break;
391
392         case ACPI_TYPE_STRING:
393
394                 /* String-to-Buffer conversion. Simple data copy */
395
396                 new_object =
397                     acpi_ut_create_buffer_object(original_object->string.
398                                                  length);
399                 if (!new_object) {
400                         return (AE_NO_MEMORY);
401                 }
402
403                 ACPI_MEMCPY(new_object->buffer.pointer,
404                             original_object->string.pointer,
405                             original_object->string.length);
406                 break;
407
408         case ACPI_TYPE_PACKAGE:
409                 /*
410                  * This case is often seen for predefined names that must return a
411                  * Buffer object with multiple DWORD integers within. For example,
412                  * _FDE and _GTM. The Package can be converted to a Buffer.
413                  */
414
415                 /* All elements of the Package must be integers */
416
417                 elements = original_object->package.elements;
418                 count = original_object->package.count;
419
420                 for (i = 0; i < count; i++) {
421                         if ((!*elements) ||
422                             ((*elements)->common.type != ACPI_TYPE_INTEGER)) {
423                                 return (AE_AML_OPERAND_TYPE);
424                         }
425                         elements++;
426                 }
427
428                 /* Create the new buffer object to replace the Package */
429
430                 new_object = acpi_ut_create_buffer_object(ACPI_MUL_4(count));
431                 if (!new_object) {
432                         return (AE_NO_MEMORY);
433                 }
434
435                 /* Copy the package elements (integers) to the buffer as DWORDs */
436
437                 elements = original_object->package.elements;
438                 dword_buffer = ACPI_CAST_PTR(u32, new_object->buffer.pointer);
439
440                 for (i = 0; i < count; i++) {
441                         *dword_buffer = (u32) (*elements)->integer.value;
442                         dword_buffer++;
443                         elements++;
444                 }
445                 break;
446
447         default:
448                 return (AE_AML_OPERAND_TYPE);
449         }
450
451         *return_object = new_object;
452         return (AE_OK);
453 }
454
455 /*******************************************************************************
456  *
457  * FUNCTION:    acpi_ns_convert_to_package
458  *
459  * PARAMETERS:  original_object     - Object to be converted
460  *              return_object       - Where the new converted object is returned
461  *
462  * RETURN:      Status. AE_OK if conversion was successful.
463  *
464  * DESCRIPTION: Attempt to convert a Buffer object to a Package. Each byte of
465  *              the buffer is converted to a single integer package element.
466  *
467  ******************************************************************************/
468
469 static acpi_status
470 acpi_ns_convert_to_package(union acpi_operand_object *original_object,
471                            union acpi_operand_object **return_object)
472 {
473         union acpi_operand_object *new_object;
474         union acpi_operand_object **elements;
475         u32 length;
476         u8 *buffer;
477
478         switch (original_object->common.type) {
479         case ACPI_TYPE_BUFFER:
480
481                 /* Buffer-to-Package conversion */
482
483                 length = original_object->buffer.length;
484                 new_object = acpi_ut_create_package_object(length);
485                 if (!new_object) {
486                         return (AE_NO_MEMORY);
487                 }
488
489                 /* Convert each buffer byte to an integer package element */
490
491                 elements = new_object->package.elements;
492                 buffer = original_object->buffer.pointer;
493
494                 while (length--) {
495                         *elements =
496                             acpi_ut_create_integer_object((u64) *buffer);
497                         if (!*elements) {
498                                 acpi_ut_remove_reference(new_object);
499                                 return (AE_NO_MEMORY);
500                         }
501                         elements++;
502                         buffer++;
503                 }
504                 break;
505
506         default:
507                 return (AE_AML_OPERAND_TYPE);
508         }
509
510         *return_object = new_object;
511         return (AE_OK);
512 }
513
514 /*******************************************************************************
515  *
516  * FUNCTION:    acpi_ns_repair_null_element
517  *
518  * PARAMETERS:  Data                - Pointer to validation data structure
519  *              expected_btypes     - Object types expected
520  *              package_index       - Index of object within parent package (if
521  *                                    applicable - ACPI_NOT_PACKAGE_ELEMENT
522  *                                    otherwise)
523  *              return_object_ptr   - Pointer to the object returned from the
524  *                                    evaluation of a method or object
525  *
526  * RETURN:      Status. AE_OK if repair was successful.
527  *
528  * DESCRIPTION: Attempt to repair a NULL element of a returned Package object.
529  *
530  ******************************************************************************/
531
532 acpi_status
533 acpi_ns_repair_null_element(struct acpi_predefined_data *data,
534                             u32 expected_btypes,
535                             u32 package_index,
536                             union acpi_operand_object **return_object_ptr)
537 {
538         union acpi_operand_object *return_object = *return_object_ptr;
539         union acpi_operand_object *new_object;
540
541         ACPI_FUNCTION_NAME(ns_repair_null_element);
542
543         /* No repair needed if return object is non-NULL */
544
545         if (return_object) {
546                 return (AE_OK);
547         }
548
549         /*
550          * Attempt to repair a NULL element of a Package object. This applies to
551          * predefined names that return a fixed-length package and each element
552          * is required. It does not apply to variable-length packages where NULL
553          * elements are allowed, especially at the end of the package.
554          */
555         if (expected_btypes & ACPI_RTYPE_INTEGER) {
556
557                 /* Need an Integer - create a zero-value integer */
558
559                 new_object = acpi_ut_create_integer_object((u64)0);
560         } else if (expected_btypes & ACPI_RTYPE_STRING) {
561
562                 /* Need a String - create a NULL string */
563
564                 new_object = acpi_ut_create_string_object(0);
565         } else if (expected_btypes & ACPI_RTYPE_BUFFER) {
566
567                 /* Need a Buffer - create a zero-length buffer */
568
569                 new_object = acpi_ut_create_buffer_object(0);
570         } else {
571                 /* Error for all other expected types */
572
573                 return (AE_AML_OPERAND_TYPE);
574         }
575
576         if (!new_object) {
577                 return (AE_NO_MEMORY);
578         }
579
580         /* Set the reference count according to the parent Package object */
581
582         new_object->common.reference_count =
583             data->parent_package->common.reference_count;
584
585         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
586                           "%s: Converted NULL package element to expected %s at index %u\n",
587                           data->pathname,
588                           acpi_ut_get_object_type_name(new_object),
589                           package_index));
590
591         *return_object_ptr = new_object;
592         data->flags |= ACPI_OBJECT_REPAIRED;
593         return (AE_OK);
594 }
595
596 /******************************************************************************
597  *
598  * FUNCTION:    acpi_ns_remove_null_elements
599  *
600  * PARAMETERS:  Data                - Pointer to validation data structure
601  *              package_type        - An acpi_return_package_types value
602  *              obj_desc            - A Package object
603  *
604  * RETURN:      None.
605  *
606  * DESCRIPTION: Remove all NULL package elements from packages that contain
607  *              a variable number of sub-packages. For these types of
608  *              packages, NULL elements can be safely removed.
609  *
610  *****************************************************************************/
611
612 void
613 acpi_ns_remove_null_elements(struct acpi_predefined_data *data,
614                              u8 package_type,
615                              union acpi_operand_object *obj_desc)
616 {
617         union acpi_operand_object **source;
618         union acpi_operand_object **dest;
619         u32 count;
620         u32 new_count;
621         u32 i;
622
623         ACPI_FUNCTION_NAME(ns_remove_null_elements);
624
625         /*
626          * PTYPE1 packages contain no subpackages.
627          * PTYPE2 packages contain a variable number of sub-packages. We can
628          * safely remove all NULL elements from the PTYPE2 packages.
629          */
630         switch (package_type) {
631         case ACPI_PTYPE1_FIXED:
632         case ACPI_PTYPE1_VAR:
633         case ACPI_PTYPE1_OPTION:
634                 return;
635
636         case ACPI_PTYPE2:
637         case ACPI_PTYPE2_COUNT:
638         case ACPI_PTYPE2_PKG_COUNT:
639         case ACPI_PTYPE2_FIXED:
640         case ACPI_PTYPE2_MIN:
641         case ACPI_PTYPE2_REV_FIXED:
642                 break;
643
644         default:
645                 return;
646         }
647
648         count = obj_desc->package.count;
649         new_count = count;
650
651         source = obj_desc->package.elements;
652         dest = source;
653
654         /* Examine all elements of the package object, remove nulls */
655
656         for (i = 0; i < count; i++) {
657                 if (!*source) {
658                         new_count--;
659                 } else {
660                         *dest = *source;
661                         dest++;
662                 }
663                 source++;
664         }
665
666         /* Update parent package if any null elements were removed */
667
668         if (new_count < count) {
669                 ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
670                                   "%s: Found and removed %u NULL elements\n",
671                                   data->pathname, (count - new_count)));
672
673                 /* NULL terminate list and update the package count */
674
675                 *dest = NULL;
676                 obj_desc->package.count = new_count;
677         }
678 }
679
680 /*******************************************************************************
681  *
682  * FUNCTION:    acpi_ns_repair_package_list
683  *
684  * PARAMETERS:  Data                - Pointer to validation data structure
685  *              obj_desc_ptr        - Pointer to the object to repair. The new
686  *                                    package object is returned here,
687  *                                    overwriting the old object.
688  *
689  * RETURN:      Status, new object in *obj_desc_ptr
690  *
691  * DESCRIPTION: Repair a common problem with objects that are defined to return
692  *              a variable-length Package of Packages. If the variable-length
693  *              is one, some BIOS code mistakenly simply declares a single
694  *              Package instead of a Package with one sub-Package. This
695  *              function attempts to repair this error by wrapping a Package
696  *              object around the original Package, creating the correct
697  *              Package with one sub-Package.
698  *
699  *              Names that can be repaired in this manner include:
700  *              _ALR, _CSD, _HPX, _MLS, _PRT, _PSS, _TRT, TSS
701  *
702  ******************************************************************************/
703
704 acpi_status
705 acpi_ns_repair_package_list(struct acpi_predefined_data *data,
706                             union acpi_operand_object **obj_desc_ptr)
707 {
708         union acpi_operand_object *pkg_obj_desc;
709
710         ACPI_FUNCTION_NAME(ns_repair_package_list);
711
712         /*
713          * Create the new outer package and populate it. The new package will
714          * have a single element, the lone subpackage.
715          */
716         pkg_obj_desc = acpi_ut_create_package_object(1);
717         if (!pkg_obj_desc) {
718                 return (AE_NO_MEMORY);
719         }
720
721         pkg_obj_desc->package.elements[0] = *obj_desc_ptr;
722
723         /* Return the new object in the object pointer */
724
725         *obj_desc_ptr = pkg_obj_desc;
726         data->flags |= ACPI_OBJECT_REPAIRED;
727
728         ACPI_DEBUG_PRINT((ACPI_DB_REPAIR,
729                           "%s: Repaired incorrectly formed Package\n",
730                           data->pathname));
731
732         return (AE_OK);
733 }