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