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 }