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 }