Merge branch 'for-linus' of master.kernel.org:/pub/scm/linux/kernel/git/roland/infiniband
[linux-2.6] / drivers / acpi / resources / rsutils.c
1 /*******************************************************************************
2  *
3  * Module Name: rsutils - Utilities for the resource manager
4  *
5  ******************************************************************************/
6
7 /*
8  * Copyright (C) 2000 - 2006, R. Byron Moore
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 <acpi/acnamesp.h>
46 #include <acpi/acresrc.h>
47
48 #define _COMPONENT          ACPI_RESOURCES
49 ACPI_MODULE_NAME("rsutils")
50
51 /*******************************************************************************
52  *
53  * FUNCTION:    acpi_rs_decode_bitmask
54  *
55  * PARAMETERS:  Mask            - Bitmask to decode
56  *              List            - Where the converted list is returned
57  *
58  * RETURN:      Count of bits set (length of list)
59  *
60  * DESCRIPTION: Convert a bit mask into a list of values
61  *
62  ******************************************************************************/
63 u8 acpi_rs_decode_bitmask(u16 mask, u8 * list)
64 {
65         acpi_native_uint i;
66         u8 bit_count;
67
68         ACPI_FUNCTION_ENTRY();
69
70         /* Decode the mask bits */
71
72         for (i = 0, bit_count = 0; mask; i++) {
73                 if (mask & 0x0001) {
74                         list[bit_count] = (u8) i;
75                         bit_count++;
76                 }
77
78                 mask >>= 1;
79         }
80
81         return (bit_count);
82 }
83
84 /*******************************************************************************
85  *
86  * FUNCTION:    acpi_rs_encode_bitmask
87  *
88  * PARAMETERS:  List            - List of values to encode
89  *              Count           - Length of list
90  *
91  * RETURN:      Encoded bitmask
92  *
93  * DESCRIPTION: Convert a list of values to an encoded bitmask
94  *
95  ******************************************************************************/
96
97 u16 acpi_rs_encode_bitmask(u8 * list, u8 count)
98 {
99         acpi_native_uint i;
100         u16 mask;
101
102         ACPI_FUNCTION_ENTRY();
103
104         /* Encode the list into a single bitmask */
105
106         for (i = 0, mask = 0; i < count; i++) {
107                 mask |= (0x0001 << list[i]);
108         }
109
110         return (mask);
111 }
112
113 /*******************************************************************************
114  *
115  * FUNCTION:    acpi_rs_move_data
116  *
117  * PARAMETERS:  Destination         - Pointer to the destination descriptor
118  *              Source              - Pointer to the source descriptor
119  *              item_count          - How many items to move
120  *              move_type           - Byte width
121  *
122  * RETURN:      None
123  *
124  * DESCRIPTION: Move multiple data items from one descriptor to another. Handles
125  *              alignment issues and endian issues if necessary, as configured
126  *              via the ACPI_MOVE_* macros. (This is why a memcpy is not used)
127  *
128  ******************************************************************************/
129
130 void
131 acpi_rs_move_data(void *destination, void *source, u16 item_count, u8 move_type)
132 {
133         acpi_native_uint i;
134
135         ACPI_FUNCTION_ENTRY();
136
137         /* One move per item */
138
139         for (i = 0; i < item_count; i++) {
140                 switch (move_type) {
141                         /*
142                          * For the 8-bit case, we can perform the move all at once
143                          * since there are no alignment or endian issues
144                          */
145                 case ACPI_RSC_MOVE8:
146                         ACPI_MEMCPY(destination, source, item_count);
147                         return;
148
149                         /*
150                          * 16-, 32-, and 64-bit cases must use the move macros that perform
151                          * endian conversion and/or accomodate hardware that cannot perform
152                          * misaligned memory transfers
153                          */
154                 case ACPI_RSC_MOVE16:
155                         ACPI_MOVE_16_TO_16(&ACPI_CAST_PTR(u16, destination)[i],
156                                            &ACPI_CAST_PTR(u16, source)[i]);
157                         break;
158
159                 case ACPI_RSC_MOVE32:
160                         ACPI_MOVE_32_TO_32(&ACPI_CAST_PTR(u32, destination)[i],
161                                            &ACPI_CAST_PTR(u32, source)[i]);
162                         break;
163
164                 case ACPI_RSC_MOVE64:
165                         ACPI_MOVE_64_TO_64(&ACPI_CAST_PTR(u64, destination)[i],
166                                            &ACPI_CAST_PTR(u64, source)[i]);
167                         break;
168
169                 default:
170                         return;
171                 }
172         }
173 }
174
175 /*******************************************************************************
176  *
177  * FUNCTION:    acpi_rs_set_resource_length
178  *
179  * PARAMETERS:  total_length        - Length of the AML descriptor, including
180  *                                    the header and length fields.
181  *              Aml                 - Pointer to the raw AML descriptor
182  *
183  * RETURN:      None
184  *
185  * DESCRIPTION: Set the resource_length field of an AML
186  *              resource descriptor, both Large and Small descriptors are
187  *              supported automatically. Note: Descriptor Type field must
188  *              be valid.
189  *
190  ******************************************************************************/
191
192 void
193 acpi_rs_set_resource_length(acpi_rsdesc_size total_length,
194                             union aml_resource *aml)
195 {
196         acpi_rs_length resource_length;
197
198         ACPI_FUNCTION_ENTRY();
199
200         /* Length is the total descriptor length minus the header length */
201
202         resource_length = (acpi_rs_length)
203             (total_length - acpi_ut_get_resource_header_length(aml));
204
205         /* Length is stored differently for large and small descriptors */
206
207         if (aml->small_header.descriptor_type & ACPI_RESOURCE_NAME_LARGE) {
208
209                 /* Large descriptor -- bytes 1-2 contain the 16-bit length */
210
211                 ACPI_MOVE_16_TO_16(&aml->large_header.resource_length,
212                                    &resource_length);
213         } else {
214                 /* Small descriptor -- bits 2:0 of byte 0 contain the length */
215
216                 aml->small_header.descriptor_type = (u8)
217
218                     /* Clear any existing length, preserving descriptor type bits */
219                     ((aml->small_header.
220                       descriptor_type & ~ACPI_RESOURCE_NAME_SMALL_LENGTH_MASK)
221
222                      | resource_length);
223         }
224 }
225
226 /*******************************************************************************
227  *
228  * FUNCTION:    acpi_rs_set_resource_header
229  *
230  * PARAMETERS:  descriptor_type     - Byte to be inserted as the type
231  *              total_length        - Length of the AML descriptor, including
232  *                                    the header and length fields.
233  *              Aml                 - Pointer to the raw AML descriptor
234  *
235  * RETURN:      None
236  *
237  * DESCRIPTION: Set the descriptor_type and resource_length fields of an AML
238  *              resource descriptor, both Large and Small descriptors are
239  *              supported automatically
240  *
241  ******************************************************************************/
242
243 void
244 acpi_rs_set_resource_header(u8 descriptor_type,
245                             acpi_rsdesc_size total_length,
246                             union aml_resource *aml)
247 {
248         ACPI_FUNCTION_ENTRY();
249
250         /* Set the Resource Type */
251
252         aml->small_header.descriptor_type = descriptor_type;
253
254         /* Set the Resource Length */
255
256         acpi_rs_set_resource_length(total_length, aml);
257 }
258
259 /*******************************************************************************
260  *
261  * FUNCTION:    acpi_rs_strcpy
262  *
263  * PARAMETERS:  Destination         - Pointer to the destination string
264  *              Source              - Pointer to the source string
265  *
266  * RETURN:      String length, including NULL terminator
267  *
268  * DESCRIPTION: Local string copy that returns the string length, saving a
269  *              strcpy followed by a strlen.
270  *
271  ******************************************************************************/
272
273 static u16 acpi_rs_strcpy(char *destination, char *source)
274 {
275         u16 i;
276
277         ACPI_FUNCTION_ENTRY();
278
279         for (i = 0; source[i]; i++) {
280                 destination[i] = source[i];
281         }
282
283         destination[i] = 0;
284
285         /* Return string length including the NULL terminator */
286
287         return ((u16) (i + 1));
288 }
289
290 /*******************************************************************************
291  *
292  * FUNCTION:    acpi_rs_get_resource_source
293  *
294  * PARAMETERS:  resource_length     - Length field of the descriptor
295  *              minimum_length      - Minimum length of the descriptor (minus
296  *                                    any optional fields)
297  *              resource_source     - Where the resource_source is returned
298  *              Aml                 - Pointer to the raw AML descriptor
299  *              string_ptr          - (optional) where to store the actual
300  *                                    resource_source string
301  *
302  * RETURN:      Length of the string plus NULL terminator, rounded up to native
303  *              word boundary
304  *
305  * DESCRIPTION: Copy the optional resource_source data from a raw AML descriptor
306  *              to an internal resource descriptor
307  *
308  ******************************************************************************/
309
310 acpi_rs_length
311 acpi_rs_get_resource_source(acpi_rs_length resource_length,
312                             acpi_rs_length minimum_length,
313                             struct acpi_resource_source * resource_source,
314                             union aml_resource * aml, char *string_ptr)
315 {
316         acpi_rsdesc_size total_length;
317         u8 *aml_resource_source;
318
319         ACPI_FUNCTION_ENTRY();
320
321         total_length =
322             resource_length + sizeof(struct aml_resource_large_header);
323         aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length);
324
325         /*
326          * resource_source is present if the length of the descriptor is longer than
327          * the minimum length.
328          *
329          * Note: Some resource descriptors will have an additional null, so
330          * we add 1 to the minimum length.
331          */
332         if (total_length > (acpi_rsdesc_size) (minimum_length + 1)) {
333
334                 /* Get the resource_source_index */
335
336                 resource_source->index = aml_resource_source[0];
337
338                 resource_source->string_ptr = string_ptr;
339                 if (!string_ptr) {
340                         /*
341                          * String destination pointer is not specified; Set the String
342                          * pointer to the end of the current resource_source structure.
343                          */
344                         resource_source->string_ptr =
345                             ACPI_ADD_PTR(char, resource_source,
346                                          sizeof(struct acpi_resource_source));
347                 }
348
349                 /*
350                  * In order for the Resource length to be a multiple of the native
351                  * word, calculate the length of the string (+1 for NULL terminator)
352                  * and expand to the next word multiple.
353                  *
354                  * Zero the entire area of the buffer.
355                  */
356                 total_length =
357                     (u32)
358                     ACPI_STRLEN(ACPI_CAST_PTR(char, &aml_resource_source[1])) +
359                     1;
360                 total_length = (u32) ACPI_ROUND_UP_TO_NATIVE_WORD(total_length);
361
362                 ACPI_MEMSET(resource_source->string_ptr, 0, total_length);
363
364                 /* Copy the resource_source string to the destination */
365
366                 resource_source->string_length =
367                     acpi_rs_strcpy(resource_source->string_ptr,
368                                    ACPI_CAST_PTR(char,
369                                                  &aml_resource_source[1]));
370
371                 return ((acpi_rs_length) total_length);
372         }
373
374         /* resource_source is not present */
375
376         resource_source->index = 0;
377         resource_source->string_length = 0;
378         resource_source->string_ptr = NULL;
379         return (0);
380 }
381
382 /*******************************************************************************
383  *
384  * FUNCTION:    acpi_rs_set_resource_source
385  *
386  * PARAMETERS:  Aml                 - Pointer to the raw AML descriptor
387  *              minimum_length      - Minimum length of the descriptor (minus
388  *                                    any optional fields)
389  *              resource_source     - Internal resource_source
390
391  *
392  * RETURN:      Total length of the AML descriptor
393  *
394  * DESCRIPTION: Convert an optional resource_source from internal format to a
395  *              raw AML resource descriptor
396  *
397  ******************************************************************************/
398
399 acpi_rsdesc_size
400 acpi_rs_set_resource_source(union aml_resource * aml,
401                             acpi_rs_length minimum_length,
402                             struct acpi_resource_source * resource_source)
403 {
404         u8 *aml_resource_source;
405         acpi_rsdesc_size descriptor_length;
406
407         ACPI_FUNCTION_ENTRY();
408
409         descriptor_length = minimum_length;
410
411         /* Non-zero string length indicates presence of a resource_source */
412
413         if (resource_source->string_length) {
414
415                 /* Point to the end of the AML descriptor */
416
417                 aml_resource_source = ACPI_ADD_PTR(u8, aml, minimum_length);
418
419                 /* Copy the resource_source_index */
420
421                 aml_resource_source[0] = (u8) resource_source->index;
422
423                 /* Copy the resource_source string */
424
425                 ACPI_STRCPY(ACPI_CAST_PTR(char, &aml_resource_source[1]),
426                             resource_source->string_ptr);
427
428                 /*
429                  * Add the length of the string (+ 1 for null terminator) to the
430                  * final descriptor length
431                  */
432                 descriptor_length +=
433                     ((acpi_rsdesc_size) resource_source->string_length + 1);
434         }
435
436         /* Return the new total length of the AML descriptor */
437
438         return (descriptor_length);
439 }
440
441 /*******************************************************************************
442  *
443  * FUNCTION:    acpi_rs_get_prt_method_data
444  *
445  * PARAMETERS:  Node            - Device node
446  *              ret_buffer      - Pointer to a buffer structure for the
447  *                                results
448  *
449  * RETURN:      Status
450  *
451  * DESCRIPTION: This function is called to get the _PRT value of an object
452  *              contained in an object specified by the handle passed in
453  *
454  *              If the function fails an appropriate status will be returned
455  *              and the contents of the callers buffer is undefined.
456  *
457  ******************************************************************************/
458
459 acpi_status
460 acpi_rs_get_prt_method_data(struct acpi_namespace_node * node,
461                             struct acpi_buffer * ret_buffer)
462 {
463         union acpi_operand_object *obj_desc;
464         acpi_status status;
465
466         ACPI_FUNCTION_TRACE(rs_get_prt_method_data);
467
468         /* Parameters guaranteed valid by caller */
469
470         /* Execute the method, no parameters */
471
472         status = acpi_ut_evaluate_object(node, METHOD_NAME__PRT,
473                                          ACPI_BTYPE_PACKAGE, &obj_desc);
474         if (ACPI_FAILURE(status)) {
475                 return_ACPI_STATUS(status);
476         }
477
478         /*
479          * Create a resource linked list from the byte stream buffer that comes
480          * back from the _CRS method execution.
481          */
482         status = acpi_rs_create_pci_routing_table(obj_desc, ret_buffer);
483
484         /* On exit, we must delete the object returned by evaluate_object */
485
486         acpi_ut_remove_reference(obj_desc);
487         return_ACPI_STATUS(status);
488 }
489
490 /*******************************************************************************
491  *
492  * FUNCTION:    acpi_rs_get_crs_method_data
493  *
494  * PARAMETERS:  Node            - Device node
495  *              ret_buffer      - Pointer to a buffer structure for the
496  *                                results
497  *
498  * RETURN:      Status
499  *
500  * DESCRIPTION: This function is called to get the _CRS value of an object
501  *              contained in an object specified by the handle passed in
502  *
503  *              If the function fails an appropriate status will be returned
504  *              and the contents of the callers buffer is undefined.
505  *
506  ******************************************************************************/
507
508 acpi_status
509 acpi_rs_get_crs_method_data(struct acpi_namespace_node *node,
510                             struct acpi_buffer *ret_buffer)
511 {
512         union acpi_operand_object *obj_desc;
513         acpi_status status;
514
515         ACPI_FUNCTION_TRACE(rs_get_crs_method_data);
516
517         /* Parameters guaranteed valid by caller */
518
519         /* Execute the method, no parameters */
520
521         status = acpi_ut_evaluate_object(node, METHOD_NAME__CRS,
522                                          ACPI_BTYPE_BUFFER, &obj_desc);
523         if (ACPI_FAILURE(status)) {
524                 return_ACPI_STATUS(status);
525         }
526
527         /*
528          * Make the call to create a resource linked list from the
529          * byte stream buffer that comes back from the _CRS method
530          * execution.
531          */
532         status = acpi_rs_create_resource_list(obj_desc, ret_buffer);
533
534         /* On exit, we must delete the object returned by evaluate_object */
535
536         acpi_ut_remove_reference(obj_desc);
537         return_ACPI_STATUS(status);
538 }
539
540 /*******************************************************************************
541  *
542  * FUNCTION:    acpi_rs_get_prs_method_data
543  *
544  * PARAMETERS:  Node            - Device node
545  *              ret_buffer      - Pointer to a buffer structure for the
546  *                                results
547  *
548  * RETURN:      Status
549  *
550  * DESCRIPTION: This function is called to get the _PRS value of an object
551  *              contained in an object specified by the handle passed in
552  *
553  *              If the function fails an appropriate status will be returned
554  *              and the contents of the callers buffer is undefined.
555  *
556  ******************************************************************************/
557
558 #ifdef ACPI_FUTURE_USAGE
559 acpi_status
560 acpi_rs_get_prs_method_data(struct acpi_namespace_node *node,
561                             struct acpi_buffer *ret_buffer)
562 {
563         union acpi_operand_object *obj_desc;
564         acpi_status status;
565
566         ACPI_FUNCTION_TRACE(rs_get_prs_method_data);
567
568         /* Parameters guaranteed valid by caller */
569
570         /* Execute the method, no parameters */
571
572         status = acpi_ut_evaluate_object(node, METHOD_NAME__PRS,
573                                          ACPI_BTYPE_BUFFER, &obj_desc);
574         if (ACPI_FAILURE(status)) {
575                 return_ACPI_STATUS(status);
576         }
577
578         /*
579          * Make the call to create a resource linked list from the
580          * byte stream buffer that comes back from the _CRS method
581          * execution.
582          */
583         status = acpi_rs_create_resource_list(obj_desc, ret_buffer);
584
585         /* On exit, we must delete the object returned by evaluate_object */
586
587         acpi_ut_remove_reference(obj_desc);
588         return_ACPI_STATUS(status);
589 }
590 #endif                          /*  ACPI_FUTURE_USAGE  */
591
592 /*******************************************************************************
593  *
594  * FUNCTION:    acpi_rs_get_method_data
595  *
596  * PARAMETERS:  Handle          - Handle to the containing object
597  *              Path            - Path to method, relative to Handle
598  *              ret_buffer      - Pointer to a buffer structure for the
599  *                                results
600  *
601  * RETURN:      Status
602  *
603  * DESCRIPTION: This function is called to get the _CRS or _PRS value of an
604  *              object contained in an object specified by the handle passed in
605  *
606  *              If the function fails an appropriate status will be returned
607  *              and the contents of the callers buffer is undefined.
608  *
609  ******************************************************************************/
610
611 acpi_status
612 acpi_rs_get_method_data(acpi_handle handle,
613                         char *path, struct acpi_buffer *ret_buffer)
614 {
615         union acpi_operand_object *obj_desc;
616         acpi_status status;
617
618         ACPI_FUNCTION_TRACE(rs_get_method_data);
619
620         /* Parameters guaranteed valid by caller */
621
622         /* Execute the method, no parameters */
623
624         status =
625             acpi_ut_evaluate_object(handle, path, ACPI_BTYPE_BUFFER, &obj_desc);
626         if (ACPI_FAILURE(status)) {
627                 return_ACPI_STATUS(status);
628         }
629
630         /*
631          * Make the call to create a resource linked list from the
632          * byte stream buffer that comes back from the method
633          * execution.
634          */
635         status = acpi_rs_create_resource_list(obj_desc, ret_buffer);
636
637         /* On exit, we must delete the object returned by evaluate_object */
638
639         acpi_ut_remove_reference(obj_desc);
640         return_ACPI_STATUS(status);
641 }
642
643 /*******************************************************************************
644  *
645  * FUNCTION:    acpi_rs_set_srs_method_data
646  *
647  * PARAMETERS:  Node            - Device node
648  *              in_buffer       - Pointer to a buffer structure of the
649  *                                parameter
650  *
651  * RETURN:      Status
652  *
653  * DESCRIPTION: This function is called to set the _SRS of an object contained
654  *              in an object specified by the handle passed in
655  *
656  *              If the function fails an appropriate status will be returned
657  *              and the contents of the callers buffer is undefined.
658  *
659  * Note: Parameters guaranteed valid by caller
660  *
661  ******************************************************************************/
662
663 acpi_status
664 acpi_rs_set_srs_method_data(struct acpi_namespace_node *node,
665                             struct acpi_buffer *in_buffer)
666 {
667         struct acpi_evaluate_info *info;
668         union acpi_operand_object *args[2];
669         acpi_status status;
670         struct acpi_buffer buffer;
671
672         ACPI_FUNCTION_TRACE(rs_set_srs_method_data);
673
674         /* Allocate and initialize the evaluation information block */
675
676         info = ACPI_ALLOCATE_ZEROED(sizeof(struct acpi_evaluate_info));
677         if (!info) {
678                 return_ACPI_STATUS(AE_NO_MEMORY);
679         }
680
681         info->prefix_node = node;
682         info->pathname = METHOD_NAME__SRS;
683         info->parameters = args;
684         info->parameter_type = ACPI_PARAM_ARGS;
685         info->flags = ACPI_IGNORE_RETURN_VALUE;
686
687         /*
688          * The in_buffer parameter will point to a linked list of
689          * resource parameters. It needs to be formatted into a
690          * byte stream to be sent in as an input parameter to _SRS
691          *
692          * Convert the linked list into a byte stream
693          */
694         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
695         status = acpi_rs_create_aml_resources(in_buffer->pointer, &buffer);
696         if (ACPI_FAILURE(status)) {
697                 goto cleanup;
698         }
699
700         /* Create and initialize the method parameter object */
701
702         args[0] = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
703         if (!args[0]) {
704                 /*
705                  * Must free the buffer allocated above (otherwise it is freed
706                  * later)
707                  */
708                 ACPI_FREE(buffer.pointer);
709                 status = AE_NO_MEMORY;
710                 goto cleanup;
711         }
712
713         args[0]->buffer.length = (u32) buffer.length;
714         args[0]->buffer.pointer = buffer.pointer;
715         args[0]->common.flags = AOPOBJ_DATA_VALID;
716         args[1] = NULL;
717
718         /* Execute the method, no return value is expected */
719
720         status = acpi_ns_evaluate(info);
721
722         /* Clean up and return the status from acpi_ns_evaluate */
723
724         acpi_ut_remove_reference(args[0]);
725
726       cleanup:
727         ACPI_FREE(info);
728         return_ACPI_STATUS(status);
729 }