drivers/acpi/utilities/utmisc.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utmisc - common utility procedures
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, 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
  45 #include <acpi/acpi.h>
  46 #include <acpi/acnamesp.h>
  47
  48
  49 #define _COMPONENT          ACPI_UTILITIES
  50          ACPI_MODULE_NAME    ("utmisc")
  51
  52
  53 /*******************************************************************************
  54  *
  55  * FUNCTION:    acpi_ut_allocate_owner_id
  56  *
  57  * PARAMETERS:  owner_id        - Where the new owner ID is returned
  58  *
  59  * RETURN:      Status
  60  *
  61  * DESCRIPTION: Allocate a table or method owner ID. The owner ID is used to
  62  *              track objects created by the table or method, to be deleted
  63  *              when the method exits or the table is unloaded.
  64  *
  65  ******************************************************************************/
  66
  67 acpi_status
  68 acpi_ut_allocate_owner_id (
  69         acpi_owner_id                   *owner_id)
  70 {
  71         acpi_native_uint                i;
  72         acpi_status                     status;
  73
  74
  75         ACPI_FUNCTION_TRACE ("ut_allocate_owner_id");
  76
  77
  78         /* Mutex for the global ID mask */
  79
  80         status = acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
  81         if (ACPI_FAILURE (status)) {
  82                 return_ACPI_STATUS (status);
  83         }
  84
  85         /* Find a free owner ID */
  86
  87         for (i = 0; i < 32; i++) {
  88                 if (!(acpi_gbl_owner_id_mask & (1 << i))) {
  89                         acpi_gbl_owner_id_mask |= (1 << i);
  90                         *owner_id = (acpi_owner_id) (i + 1);
  91                         goto exit;
  92                 }
  93         }
  94
  95         /*
  96          * If we are here, all owner_ids have been allocated. This probably should
  97          * not happen since the IDs are reused after deallocation. The IDs are
  98          * allocated upon table load (one per table) and method execution, and
  99          * they are released when a table is unloaded or a method completes
 100          * execution.
 101          */
 102         *owner_id = 0;
 103         status = AE_OWNER_ID_LIMIT;
 104         ACPI_REPORT_ERROR ((
 105                 "Could not allocate new owner_id (32 max), AE_OWNER_ID_LIMIT\n"));
 106
 107 exit:
 108         (void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
 109         return_ACPI_STATUS (status);
 110 }
 111
 112
 113 /*******************************************************************************
 114  *
 115  * FUNCTION:    acpi_ut_release_owner_id
 116  *
 117  * PARAMETERS:  owner_id_ptr        - Pointer to a previously allocated owner_iD
 118  *
 119  * RETURN:      None. No error is returned because we are either exiting a
 120  *              control method or unloading a table. Either way, we would
 121  *              ignore any error anyway.
 122  *
 123  * DESCRIPTION: Release a table or method owner ID.  Valid IDs are 1 - 32
 124  *
 125  ******************************************************************************/
 126
 127 void
 128 acpi_ut_release_owner_id (
 129         acpi_owner_id                   *owner_id_ptr)
 130 {
 131         acpi_owner_id                   owner_id = *owner_id_ptr;
 132         acpi_status                     status;
 133
 134
 135         ACPI_FUNCTION_TRACE ("ut_release_owner_id");
 136
 137
 138         /* Always clear the input owner_id (zero is an invalid ID) */
 139
 140         *owner_id_ptr = 0;
 141
 142         /* Zero is not a valid owner_iD */
 143
 144         if ((owner_id == 0) || (owner_id > 32)) {
 145                 ACPI_REPORT_ERROR (("Invalid owner_id: %2.2X\n", owner_id));
 146                 return_VOID;
 147         }
 148
 149         /* Mutex for the global ID mask */
 150
 151         status = acpi_ut_acquire_mutex (ACPI_MTX_CACHES);
 152         if (ACPI_FAILURE (status)) {
 153                 return_VOID;
 154         }
 155
 156         owner_id--; /* Normalize to zero */
 157
 158         /* Free the owner ID only if it is valid */
 159
 160         if (acpi_gbl_owner_id_mask & (1 << owner_id)) {
 161                 acpi_gbl_owner_id_mask ^= (1 << owner_id);
 162         }
 163
 164         (void) acpi_ut_release_mutex (ACPI_MTX_CACHES);
 165         return_VOID;
 166 }
 167
 168
 169 /*******************************************************************************
 170  *
 171  * FUNCTION:    acpi_ut_strupr (strupr)
 172  *
 173  * PARAMETERS:  src_string      - The source string to convert
 174  *
 175  * RETURN:      None
 176  *
 177  * DESCRIPTION: Convert string to uppercase
 178  *
 179  * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
 180  *
 181  ******************************************************************************/
 182
 183 void
 184 acpi_ut_strupr (
 185         char                            *src_string)
 186 {
 187         char                            *string;
 188
 189
 190         ACPI_FUNCTION_ENTRY ();
 191
 192
 193         if (!src_string) {
 194                 return;
 195         }
 196
 197         /* Walk entire string, uppercasing the letters */
 198
 199         for (string = src_string; *string; string++) {
 200                 *string = (char) ACPI_TOUPPER (*string);
 201         }
 202
 203         return;
 204 }
 205
 206
 207 /*******************************************************************************
 208  *
 209  * FUNCTION:    acpi_ut_print_string
 210  *
 211  * PARAMETERS:  String          - Null terminated ASCII string
 212  *              max_length      - Maximum output length
 213  *
 214  * RETURN:      None
 215  *
 216  * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
 217  *              sequences.
 218  *
 219  ******************************************************************************/
 220
 221 void
 222 acpi_ut_print_string (
 223         char                            *string,
 224         u8                              max_length)
 225 {
 226         u32                             i;
 227
 228
 229         if (!string) {
 230                 acpi_os_printf ("<\"NULL STRING PTR\">");
 231                 return;
 232         }
 233
 234         acpi_os_printf ("\"");
 235         for (i = 0; string[i] && (i < max_length); i++) {
 236                 /* Escape sequences */
 237
 238                 switch (string[i]) {
 239                 case 0x07:
 240                         acpi_os_printf ("\\a");      /* BELL */
 241                         break;
 242
 243                 case 0x08:
 244                         acpi_os_printf ("\\b");     /* BACKSPACE */
 245                         break;
 246
 247                 case 0x0C:
 248                         acpi_os_printf ("\\f");     /* FORMFEED */
 249                         break;
 250
 251                 case 0x0A:
 252                         acpi_os_printf ("\\n");     /* LINEFEED */
 253                         break;
 254
 255                 case 0x0D:
 256                         acpi_os_printf ("\\r");     /* CARRIAGE RETURN*/
 257                         break;
 258
 259                 case 0x09:
 260                         acpi_os_printf ("\\t");     /* HORIZONTAL TAB */
 261                         break;
 262
 263                 case 0x0B:
 264                         acpi_os_printf ("\\v");     /* VERTICAL TAB */
 265                         break;
 266
 267                 case '\'':                      /* Single Quote */
 268                 case '\"':                      /* Double Quote */
 269                 case '\\':                      /* Backslash */
 270                         acpi_os_printf ("\\%c", (int) string[i]);
 271                         break;
 272
 273                 default:
 274
 275                         /* Check for printable character or hex escape */
 276
 277                         if (ACPI_IS_PRINT (string[i]))
 278                         {
 279                                 /* This is a normal character */
 280
 281                                 acpi_os_printf ("%c", (int) string[i]);
 282                         }
 283                         else
 284                         {
 285                                 /* All others will be Hex escapes */
 286
 287                                 acpi_os_printf ("\\x%2.2X", (s32) string[i]);
 288                         }
 289                         break;
 290                 }
 291         }
 292         acpi_os_printf ("\"");
 293
 294         if (i == max_length && string[i]) {
 295                 acpi_os_printf ("...");
 296         }
 297 }
 298
 299
 300 /*******************************************************************************
 301  *
 302  * FUNCTION:    acpi_ut_dword_byte_swap
 303  *
 304  * PARAMETERS:  Value           - Value to be converted
 305  *
 306  * RETURN:      u32 integer with bytes swapped
 307  *
 308  * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes)
 309  *
 310  ******************************************************************************/
 311
 312 u32
 313 acpi_ut_dword_byte_swap (
 314         u32                             value)
 315 {
 316         union {
 317                 u32                         value;
 318                 u8                          bytes[4];
 319         } out;
 320         union {
 321                 u32                         value;
 322                 u8                          bytes[4];
 323         } in;
 324
 325
 326         ACPI_FUNCTION_ENTRY ();
 327
 328
 329         in.value = value;
 330
 331         out.bytes[0] = in.bytes[3];
 332         out.bytes[1] = in.bytes[2];
 333         out.bytes[2] = in.bytes[1];
 334         out.bytes[3] = in.bytes[0];
 335
 336         return (out.value);
 337 }
 338
 339
 340 /*******************************************************************************
 341  *
 342  * FUNCTION:    acpi_ut_set_integer_width
 343  *
 344  * PARAMETERS:  Revision            From DSDT header
 345  *
 346  * RETURN:      None
 347  *
 348  * DESCRIPTION: Set the global integer bit width based upon the revision
 349  *              of the DSDT.  For Revision 1 and 0, Integers are 32 bits.
 350  *              For Revision 2 and above, Integers are 64 bits.  Yes, this
 351  *              makes a difference.
 352  *
 353  ******************************************************************************/
 354
 355 void
 356 acpi_ut_set_integer_width (
 357         u8                              revision)
 358 {
 359
 360         if (revision <= 1) {
 361                 acpi_gbl_integer_bit_width = 32;
 362                 acpi_gbl_integer_nybble_width = 8;
 363                 acpi_gbl_integer_byte_width = 4;
 364         }
 365         else {
 366                 acpi_gbl_integer_bit_width = 64;
 367                 acpi_gbl_integer_nybble_width = 16;
 368                 acpi_gbl_integer_byte_width = 8;
 369         }
 370 }
 371
 372
 373 #ifdef ACPI_DEBUG_OUTPUT
 374 /*******************************************************************************
 375  *
 376  * FUNCTION:    acpi_ut_display_init_pathname
 377  *
 378  * PARAMETERS:  Type                - Object type of the node
 379  *              obj_handle          - Handle whose pathname will be displayed
 380  *              Path                - Additional path string to be appended.
 381  *                                      (NULL if no extra path)
 382  *
 383  * RETURN:      acpi_status
 384  *
 385  * DESCRIPTION: Display full pathname of an object, DEBUG ONLY
 386  *
 387  ******************************************************************************/
 388
 389 void
 390 acpi_ut_display_init_pathname (
 391         u8                              type,
 392         struct acpi_namespace_node      *obj_handle,
 393         char                            *path)
 394 {
 395         acpi_status                     status;
 396         struct acpi_buffer              buffer;
 397
 398
 399         ACPI_FUNCTION_ENTRY ();
 400
 401
 402         /* Only print the path if the appropriate debug level is enabled */
 403
 404         if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
 405                 return;
 406         }
 407
 408         /* Get the full pathname to the node */
 409
 410         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
 411         status = acpi_ns_handle_to_pathname (obj_handle, &buffer);
 412         if (ACPI_FAILURE (status)) {
 413                 return;
 414         }
 415
 416         /* Print what we're doing */
 417
 418         switch (type) {
 419         case ACPI_TYPE_METHOD:
 420                 acpi_os_printf ("Executing  ");
 421                 break;
 422
 423         default:
 424                 acpi_os_printf ("Initializing ");
 425                 break;
 426         }
 427
 428         /* Print the object type and pathname */
 429
 430         acpi_os_printf ("%-12s %s",
 431                 acpi_ut_get_type_name (type), (char *) buffer.pointer);
 432
 433         /* Extra path is used to append names like _STA, _INI, etc. */
 434
 435         if (path) {
 436                 acpi_os_printf (".%s", path);
 437         }
 438         acpi_os_printf ("\n");
 439
 440         ACPI_MEM_FREE (buffer.pointer);
 441 }
 442 #endif
 443
 444
 445 /*******************************************************************************
 446  *
 447  * FUNCTION:    acpi_ut_valid_acpi_name
 448  *
 449  * PARAMETERS:  Name            - The name to be examined
 450  *
 451  * RETURN:      TRUE if the name is valid, FALSE otherwise
 452  *
 453  * DESCRIPTION: Check for a valid ACPI name.  Each character must be one of:
 454  *              1) Upper case alpha
 455  *              2) numeric
 456  *              3) underscore
 457  *
 458  ******************************************************************************/
 459
 460 u8
 461 acpi_ut_valid_acpi_name (
 462         u32                             name)
 463 {
 464         char                            *name_ptr = (char *) &name;
 465         char                            character;
 466         acpi_native_uint                i;
 467
 468
 469         ACPI_FUNCTION_ENTRY ();
 470
 471
 472         for (i = 0; i < ACPI_NAME_SIZE; i++) {
 473                 character = *name_ptr;
 474                 name_ptr++;
 475
 476                 if (!((character == '_') ||
 477                           (character >= 'A' && character <= 'Z') ||
 478                           (character >= '0' && character <= '9'))) {
 479                         return (FALSE);
 480                 }
 481         }
 482
 483         return (TRUE);
 484 }
 485
 486
 487 /*******************************************************************************
 488  *
 489  * FUNCTION:    acpi_ut_valid_acpi_character
 490  *
 491  * PARAMETERS:  Character           - The character to be examined
 492  *
 493  * RETURN:      1 if Character may appear in a name, else 0
 494  *
 495  * DESCRIPTION: Check for a printable character
 496  *
 497  ******************************************************************************/
 498
 499 u8
 500 acpi_ut_valid_acpi_character (
 501         char                            character)
 502 {
 503
 504         ACPI_FUNCTION_ENTRY ();
 505
 506         return ((u8)   ((character == '_') ||
 507                            (character >= 'A' && character <= 'Z') ||
 508                            (character >= '0' && character <= '9')));
 509 }
 510
 511
 512 /*******************************************************************************
 513  *
 514  * FUNCTION:    acpi_ut_strtoul64
 515  *
 516  * PARAMETERS:  String          - Null terminated string
 517  *              Base            - Radix of the string: 10, 16, or ACPI_ANY_BASE
 518  *              ret_integer     - Where the converted integer is returned
 519  *
 520  * RETURN:      Status and Converted value
 521  *
 522  * DESCRIPTION: Convert a string into an unsigned value.
 523  *              NOTE: Does not support Octal strings, not needed.
 524  *
 525  ******************************************************************************/
 526
 527 acpi_status
 528 acpi_ut_strtoul64 (
 529         char                            *string,
 530         u32                             base,
 531         acpi_integer                    *ret_integer)
 532 {
 533         u32                             this_digit = 0;
 534         acpi_integer                    return_value = 0;
 535         acpi_integer                    quotient;
 536
 537
 538         ACPI_FUNCTION_TRACE ("ut_stroul64");
 539
 540
 541         if ((!string) || !(*string)) {
 542                 goto error_exit;
 543         }
 544
 545         switch (base) {
 546         case ACPI_ANY_BASE:
 547         case 10:
 548         case 16:
 549                 break;
 550
 551         default:
 552                 /* Invalid Base */
 553                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 554         }
 555
 556         /* Skip over any white space in the buffer */
 557
 558         while (ACPI_IS_SPACE (*string) || *string == '\t') {
 559                 string++;
 560         }
 561
 562         /*
 563          * If the input parameter Base is zero, then we need to
 564          * determine if it is decimal or hexadecimal:
 565          */
 566         if (base == 0) {
 567                 if ((*string == '0') &&
 568                         (ACPI_TOLOWER (*(string + 1)) == 'x')) {
 569                         base = 16;
 570                         string += 2;
 571                 }
 572                 else {
 573                         base = 10;
 574                 }
 575         }
 576
 577         /*
 578          * For hexadecimal base, skip over the leading
 579          * 0 or 0x, if they are present.
 580          */
 581         if ((base == 16) &&
 582                 (*string == '0') &&
 583                 (ACPI_TOLOWER (*(string + 1)) == 'x')) {
 584                 string += 2;
 585         }
 586
 587         /* Any string left? */
 588
 589         if (!(*string)) {
 590                 goto error_exit;
 591         }
 592
 593         /* Main loop: convert the string to a 64-bit integer */
 594
 595         while (*string) {
 596                 if (ACPI_IS_DIGIT (*string)) {
 597                         /* Convert ASCII 0-9 to Decimal value */
 598
 599                         this_digit = ((u8) *string) - '0';
 600                 }
 601                 else {
 602                         if (base == 10) {
 603                                 /* Digit is out of range */
 604
 605                                 goto error_exit;
 606                         }
 607
 608                         this_digit = (u8) ACPI_TOUPPER (*string);
 609                         if (ACPI_IS_XDIGIT ((char) this_digit)) {
 610                                 /* Convert ASCII Hex char to value */
 611
 612                                 this_digit = this_digit - 'A' + 10;
 613                         }
 614                         else {
 615                                 /*
 616                                  * We allow non-hex chars, just stop now, same as end-of-string.
 617                                  * See ACPI spec, string-to-integer conversion.
 618                                  */
 619                                 break;
 620                         }
 621                 }
 622
 623                 /* Divide the digit into the correct position */
 624
 625                 (void) acpi_ut_short_divide ((ACPI_INTEGER_MAX - (acpi_integer) this_digit),
 626                                  base, &quotient, NULL);
 627                 if (return_value > quotient) {
 628                         goto error_exit;
 629                 }
 630
 631                 return_value *= base;
 632                 return_value += this_digit;
 633                 string++;
 634         }
 635
 636         /* All done, normal exit */
 637
 638         *ret_integer = return_value;
 639         return_ACPI_STATUS (AE_OK);
 640
 641
 642 error_exit:
 643         /* Base was set/validated above */
 644
 645         if (base == 10) {
 646                 return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
 647         }
 648         else {
 649                 return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
 650         }
 651 }
 652
 653
 654 /*******************************************************************************
 655  *
 656  * FUNCTION:    acpi_ut_create_update_state_and_push
 657  *
 658  * PARAMETERS:  Object          - Object to be added to the new state
 659  *              Action          - Increment/Decrement
 660  *              state_list      - List the state will be added to
 661  *
 662  * RETURN:      Status
 663  *
 664  * DESCRIPTION: Create a new state and push it
 665  *
 666  ******************************************************************************/
 667
 668 acpi_status
 669 acpi_ut_create_update_state_and_push (
 670         union acpi_operand_object       *object,
 671         u16                             action,
 672         union acpi_generic_state        **state_list)
 673 {
 674         union acpi_generic_state         *state;
 675
 676
 677         ACPI_FUNCTION_ENTRY ();
 678
 679
 680         /* Ignore null objects; these are expected */
 681
 682         if (!object) {
 683                 return (AE_OK);
 684         }
 685
 686         state = acpi_ut_create_update_state (object, action);
 687         if (!state) {
 688                 return (AE_NO_MEMORY);
 689         }
 690
 691         acpi_ut_push_generic_state (state_list, state);
 692         return (AE_OK);
 693 }
 694
 695
 696 /*******************************************************************************
 697  *
 698  * FUNCTION:    acpi_ut_walk_package_tree
 699  *
 700  * PARAMETERS:  source_object       - The package to walk
 701  *              target_object       - Target object (if package is being copied)
 702  *              walk_callback       - Called once for each package element
 703  *              Context             - Passed to the callback function
 704  *
 705  * RETURN:      Status
 706  *
 707  * DESCRIPTION: Walk through a package
 708  *
 709  ******************************************************************************/
 710
 711 acpi_status
 712 acpi_ut_walk_package_tree (
 713         union acpi_operand_object       *source_object,
 714         void                            *target_object,
 715         acpi_pkg_callback               walk_callback,
 716         void                            *context)
 717 {
 718         acpi_status                     status = AE_OK;
 719         union acpi_generic_state        *state_list = NULL;
 720         union acpi_generic_state        *state;
 721         u32                             this_index;
 722         union acpi_operand_object       *this_source_obj;
 723
 724
 725         ACPI_FUNCTION_TRACE ("ut_walk_package_tree");
 726
 727
 728         state = acpi_ut_create_pkg_state (source_object, target_object, 0);
 729         if (!state) {
 730                 return_ACPI_STATUS (AE_NO_MEMORY);
 731         }
 732
 733         while (state) {
 734                 /* Get one element of the package */
 735
 736                 this_index    = state->pkg.index;
 737                 this_source_obj = (union acpi_operand_object *)
 738                                   state->pkg.source_object->package.elements[this_index];
 739
 740                 /*
 741                  * Check for:
 742                  * 1) An uninitialized package element.  It is completely
 743                  *    legal to declare a package and leave it uninitialized
 744                  * 2) Not an internal object - can be a namespace node instead
 745                  * 3) Any type other than a package.  Packages are handled in else
 746                  *    case below.
 747                  */
 748                 if ((!this_source_obj) ||
 749                         (ACPI_GET_DESCRIPTOR_TYPE (this_source_obj) != ACPI_DESC_TYPE_OPERAND) ||
 750                         (ACPI_GET_OBJECT_TYPE (this_source_obj) != ACPI_TYPE_PACKAGE)) {
 751                         status = walk_callback (ACPI_COPY_TYPE_SIMPLE, this_source_obj,
 752                                          state, context);
 753                         if (ACPI_FAILURE (status)) {
 754                                 return_ACPI_STATUS (status);
 755                         }
 756
 757                         state->pkg.index++;
 758                         while (state->pkg.index >= state->pkg.source_object->package.count) {
 759                                 /*
 760                                  * We've handled all of the objects at this level,  This means
 761                                  * that we have just completed a package.  That package may
 762                                  * have contained one or more packages itself.
 763                                  *
 764                                  * Delete this state and pop the previous state (package).
 765                                  */
 766                                 acpi_ut_delete_generic_state (state);
 767                                 state = acpi_ut_pop_generic_state (&state_list);
 768
 769                                 /* Finished when there are no more states */
 770
 771                                 if (!state) {
 772                                         /*
 773                                          * We have handled all of the objects in the top level
 774                                          * package just add the length of the package objects
 775                                          * and exit
 776                                          */
 777                                         return_ACPI_STATUS (AE_OK);
 778                                 }
 779
 780                                 /*
 781                                  * Go back up a level and move the index past the just
 782                                  * completed package object.
 783                                  */
 784                                 state->pkg.index++;
 785                         }
 786                 }
 787                 else {
 788                         /* This is a subobject of type package */
 789
 790                         status = walk_callback (ACPI_COPY_TYPE_PACKAGE, this_source_obj,
 791                                           state, context);
 792                         if (ACPI_FAILURE (status)) {
 793                                 return_ACPI_STATUS (status);
 794                         }
 795
 796                         /*
 797                          * Push the current state and create a new one
 798                          * The callback above returned a new target package object.
 799                          */
 800                         acpi_ut_push_generic_state (&state_list, state);
 801                         state = acpi_ut_create_pkg_state (this_source_obj,
 802                                            state->pkg.this_target_obj, 0);
 803                         if (!state) {
 804                                 return_ACPI_STATUS (AE_NO_MEMORY);
 805                         }
 806                 }
 807         }
 808
 809         /* We should never get here */
 810
 811         return_ACPI_STATUS (AE_AML_INTERNAL);
 812 }
 813
 814
 815 /*******************************************************************************
 816  *
 817  * FUNCTION:    acpi_ut_generate_checksum
 818  *
 819  * PARAMETERS:  Buffer          - Buffer to be scanned
 820  *              Length          - number of bytes to examine
 821  *
 822  * RETURN:      The generated checksum
 823  *
 824  * DESCRIPTION: Generate a checksum on a raw buffer
 825  *
 826  ******************************************************************************/
 827
 828 u8
 829 acpi_ut_generate_checksum (
 830         u8                              *buffer,
 831         u32                             length)
 832 {
 833         u32                             i;
 834         signed char                     sum = 0;
 835
 836
 837         for (i = 0; i < length; i++) {
 838                 sum = (signed char) (sum + buffer[i]);
 839         }
 840
 841         return ((u8) (0 - sum));
 842 }
 843
 844
 845 /*******************************************************************************
 846  *
 847  * FUNCTION:    acpi_ut_get_resource_end_tag
 848  *
 849  * PARAMETERS:  obj_desc        - The resource template buffer object
 850  *
 851  * RETURN:      Pointer to the end tag
 852  *
 853  * DESCRIPTION: Find the END_TAG resource descriptor in a resource template
 854  *
 855  ******************************************************************************/
 856
 857
 858 u8 *
 859 acpi_ut_get_resource_end_tag (
 860         union acpi_operand_object       *obj_desc)
 861 {
 862         u8                              buffer_byte;
 863         u8                              *buffer;
 864         u8                              *end_buffer;
 865
 866
 867         buffer    = obj_desc->buffer.pointer;
 868         end_buffer = buffer + obj_desc->buffer.length;
 869
 870         while (buffer < end_buffer) {
 871                 buffer_byte = *buffer;
 872                 if (buffer_byte & ACPI_RDESC_TYPE_MASK) {
 873                         /* Large Descriptor - Length is next 2 bytes */
 874
 875                         buffer += ((*(buffer+1) | (*(buffer+2) << 8)) + 3);
 876                 }
 877                 else {
 878                         /* Small Descriptor.  End Tag will be found here */
 879
 880                         if ((buffer_byte & ACPI_RDESC_SMALL_MASK) == ACPI_RDESC_TYPE_END_TAG) {
 881                                 /* Found the end tag descriptor, all done. */
 882
 883                                 return (buffer);
 884                         }
 885
 886                         /* Length is in the header */
 887
 888                         buffer += ((buffer_byte & 0x07) + 1);
 889                 }
 890         }
 891
 892         /* End tag not found */
 893
 894         return (NULL);
 895 }
 896
 897
 898 /*******************************************************************************
 899  *
 900  * FUNCTION:    acpi_ut_report_error
 901  *
 902  * PARAMETERS:  module_name         - Caller's module name (for error output)
 903  *              line_number         - Caller's line number (for error output)
 904  *              component_id        - Caller's component ID (for error output)
 905  *
 906  * RETURN:      None
 907  *
 908  * DESCRIPTION: Print error message
 909  *
 910  ******************************************************************************/
 911
 912 void
 913 acpi_ut_report_error (
 914         char                            *module_name,
 915         u32                             line_number,
 916         u32                             component_id)
 917 {
 918
 919         acpi_os_printf ("%8s-%04d: *** Error: ", module_name, line_number);
 920 }
 921
 922
 923 /*******************************************************************************
 924  *
 925  * FUNCTION:    acpi_ut_report_warning
 926  *
 927  * PARAMETERS:  module_name         - Caller's module name (for error output)
 928  *              line_number         - Caller's line number (for error output)
 929  *              component_id        - Caller's component ID (for error output)
 930  *
 931  * RETURN:      None
 932  *
 933  * DESCRIPTION: Print warning message
 934  *
 935  ******************************************************************************/
 936
 937 void
 938 acpi_ut_report_warning (
 939         char                            *module_name,
 940         u32                             line_number,
 941         u32                             component_id)
 942 {
 943
 944         acpi_os_printf ("%8s-%04d: *** Warning: ", module_name, line_number);
 945 }
 946
 947
 948 /*******************************************************************************
 949  *
 950  * FUNCTION:    acpi_ut_report_info
 951  *
 952  * PARAMETERS:  module_name         - Caller's module name (for error output)
 953  *              line_number         - Caller's line number (for error output)
 954  *              component_id        - Caller's component ID (for error output)
 955  *
 956  * RETURN:      None
 957  *
 958  * DESCRIPTION: Print information message
 959  *
 960  ******************************************************************************/
 961
 962 void
 963 acpi_ut_report_info (
 964         char                            *module_name,
 965         u32                             line_number,
 966         u32                             component_id)
 967 {
 968
 969         acpi_os_printf ("%8s-%04d: *** Info: ", module_name, line_number);
 970 }
 971
 972