drivers/acpi/acpica/rsutils.c

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