git.oblomov.eu Git - linux-2.6/blob - drivers/acpi/utilities/utmisc.c

   1 /*******************************************************************************
   2  *
   3  * Module Name: utmisc - common utility procedures
   4  *
   5  ******************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2006, R. Byron Moore
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44 #include <acpi/acpi.h>
  45 #include <acpi/acnamesp.h>
  46
  47 #define _COMPONENT          ACPI_UTILITIES
  48 ACPI_MODULE_NAME("utmisc")
  49
  50 /*******************************************************************************
  51  *
  52  * FUNCTION:    acpi_ut_allocate_owner_id
  53  *
  54  * PARAMETERS:  owner_id        - Where the new owner ID is returned
  55  *
  56  * RETURN:      Status
  57  *
  58  * DESCRIPTION: Allocate a table or method owner ID. The owner ID is used to
  59  *              track objects created by the table or method, to be deleted
  60  *              when the method exits or the table is unloaded.
  61  *
  62  ******************************************************************************/
  63 acpi_status acpi_ut_allocate_owner_id(acpi_owner_id * owner_id)
  64 {
  65         acpi_native_uint i;
  66         acpi_native_uint j;
  67         acpi_native_uint k;
  68         acpi_status status;
  69
  70         ACPI_FUNCTION_TRACE("ut_allocate_owner_id");
  71
  72         /* Guard against multiple allocations of ID to the same location */
  73
  74         if (*owner_id) {
  75                 ACPI_ERROR((AE_INFO, "Owner ID [%2.2X] already exists",
  76                             *owner_id));
  77                 return_ACPI_STATUS(AE_ALREADY_EXISTS);
  78         }
  79
  80         /* Mutex for the global ID mask */
  81
  82         status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
  83         if (ACPI_FAILURE(status)) {
  84                 return_ACPI_STATUS(status);
  85         }
  86
  87         /*
  88          * Find a free owner ID, cycle through all possible IDs on repeated
  89          * allocations. (ACPI_NUM_OWNERID_MASKS + 1) because first index may have
  90          * to be scanned twice.
  91          */
  92         for (i = 0, j = acpi_gbl_last_owner_id_index;
  93              i < (ACPI_NUM_OWNERID_MASKS + 1); i++, j++) {
  94                 if (j >= ACPI_NUM_OWNERID_MASKS) {
  95                         j = 0;  /* Wraparound to start of mask array */
  96                 }
  97
  98                 for (k = acpi_gbl_next_owner_id_offset; k < 32; k++) {
  99                         if (acpi_gbl_owner_id_mask[j] == ACPI_UINT32_MAX) {
 100                                 /* There are no free IDs in this mask */
 101
 102                                 break;
 103                         }
 104
 105                         if (!(acpi_gbl_owner_id_mask[j] & (1 << k))) {
 106                                 /*
 107                                  * Found a free ID. The actual ID is the bit index plus one,
 108                                  * making zero an invalid Owner ID. Save this as the last ID
 109                                  * allocated and update the global ID mask.
 110                                  */
 111                                 acpi_gbl_owner_id_mask[j] |= (1 << k);
 112
 113                                 acpi_gbl_last_owner_id_index = (u8) j;
 114                                 acpi_gbl_next_owner_id_offset = (u8) (k + 1);
 115
 116                                 /*
 117                                  * Construct encoded ID from the index and bit position
 118                                  *
 119                                  * Note: Last [j].k (bit 255) is never used and is marked
 120                                  * permanently allocated (prevents +1 overflow)
 121                                  */
 122                                 *owner_id =
 123                                     (acpi_owner_id) ((k + 1) + ACPI_MUL_32(j));
 124
 125                                 ACPI_DEBUG_PRINT((ACPI_DB_VALUES,
 126                                                   "Allocated owner_id: %2.2X\n",
 127                                                   (unsigned int)*owner_id));
 128                                 goto exit;
 129                         }
 130                 }
 131
 132                 acpi_gbl_next_owner_id_offset = 0;
 133         }
 134
 135         /*
 136          * All owner_ids have been allocated. This typically should
 137          * not happen since the IDs are reused after deallocation. The IDs are
 138          * allocated upon table load (one per table) and method execution, and
 139          * they are released when a table is unloaded or a method completes
 140          * execution.
 141          *
 142          * If this error happens, there may be very deep nesting of invoked control
 143          * methods, or there may be a bug where the IDs are not released.
 144          */
 145         status = AE_OWNER_ID_LIMIT;
 146         ACPI_ERROR((AE_INFO,
 147                     "Could not allocate new owner_id (255 max), AE_OWNER_ID_LIMIT"));
 148
 149       exit:
 150         (void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
 151         return_ACPI_STATUS(status);
 152 }
 153
 154 /*******************************************************************************
 155  *
 156  * FUNCTION:    acpi_ut_release_owner_id
 157  *
 158  * PARAMETERS:  owner_id_ptr        - Pointer to a previously allocated owner_iD
 159  *
 160  * RETURN:      None. No error is returned because we are either exiting a
 161  *              control method or unloading a table. Either way, we would
 162  *              ignore any error anyway.
 163  *
 164  * DESCRIPTION: Release a table or method owner ID.  Valid IDs are 1 - 255
 165  *
 166  ******************************************************************************/
 167
 168 void acpi_ut_release_owner_id(acpi_owner_id * owner_id_ptr)
 169 {
 170         acpi_owner_id owner_id = *owner_id_ptr;
 171         acpi_status status;
 172         acpi_native_uint index;
 173         u32 bit;
 174
 175         ACPI_FUNCTION_TRACE_U32("ut_release_owner_id", owner_id);
 176
 177         /* Always clear the input owner_id (zero is an invalid ID) */
 178
 179         *owner_id_ptr = 0;
 180
 181         /* Zero is not a valid owner_iD */
 182
 183         if (owner_id == 0) {
 184                 ACPI_ERROR((AE_INFO, "Invalid owner_id: %2.2X", owner_id));
 185                 return_VOID;
 186         }
 187
 188         /* Mutex for the global ID mask */
 189
 190         status = acpi_ut_acquire_mutex(ACPI_MTX_CACHES);
 191         if (ACPI_FAILURE(status)) {
 192                 return_VOID;
 193         }
 194
 195         /* Normalize the ID to zero */
 196
 197         owner_id--;
 198
 199         /* Decode ID to index/offset pair */
 200
 201         index = ACPI_DIV_32(owner_id);
 202         bit = 1 << ACPI_MOD_32(owner_id);
 203
 204         /* Free the owner ID only if it is valid */
 205
 206         if (acpi_gbl_owner_id_mask[index] & bit) {
 207                 acpi_gbl_owner_id_mask[index] ^= bit;
 208         } else {
 209                 ACPI_ERROR((AE_INFO,
 210                             "Release of non-allocated owner_id: %2.2X",
 211                             owner_id + 1));
 212         }
 213
 214         (void)acpi_ut_release_mutex(ACPI_MTX_CACHES);
 215         return_VOID;
 216 }
 217
 218 /*******************************************************************************
 219  *
 220  * FUNCTION:    acpi_ut_strupr (strupr)
 221  *
 222  * PARAMETERS:  src_string      - The source string to convert
 223  *
 224  * RETURN:      None
 225  *
 226  * DESCRIPTION: Convert string to uppercase
 227  *
 228  * NOTE: This is not a POSIX function, so it appears here, not in utclib.c
 229  *
 230  ******************************************************************************/
 231
 232 void acpi_ut_strupr(char *src_string)
 233 {
 234         char *string;
 235
 236         ACPI_FUNCTION_ENTRY();
 237
 238         if (!src_string) {
 239                 return;
 240         }
 241
 242         /* Walk entire string, uppercasing the letters */
 243
 244         for (string = src_string; *string; string++) {
 245                 *string = (char)ACPI_TOUPPER(*string);
 246         }
 247
 248         return;
 249 }
 250
 251 /*******************************************************************************
 252  *
 253  * FUNCTION:    acpi_ut_print_string
 254  *
 255  * PARAMETERS:  String          - Null terminated ASCII string
 256  *              max_length      - Maximum output length
 257  *
 258  * RETURN:      None
 259  *
 260  * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
 261  *              sequences.
 262  *
 263  ******************************************************************************/
 264
 265 void acpi_ut_print_string(char *string, u8 max_length)
 266 {
 267         u32 i;
 268
 269         if (!string) {
 270                 acpi_os_printf("<\"NULL STRING PTR\">");
 271                 return;
 272         }
 273
 274         acpi_os_printf("\"");
 275         for (i = 0; string[i] && (i < max_length); i++) {
 276                 /* Escape sequences */
 277
 278                 switch (string[i]) {
 279                 case 0x07:
 280                         acpi_os_printf("\\a");  /* BELL */
 281                         break;
 282
 283                 case 0x08:
 284                         acpi_os_printf("\\b");  /* BACKSPACE */
 285                         break;
 286
 287                 case 0x0C:
 288                         acpi_os_printf("\\f");  /* FORMFEED */
 289                         break;
 290
 291                 case 0x0A:
 292                         acpi_os_printf("\\n");  /* LINEFEED */
 293                         break;
 294
 295                 case 0x0D:
 296                         acpi_os_printf("\\r");  /* CARRIAGE RETURN */
 297                         break;
 298
 299                 case 0x09:
 300                         acpi_os_printf("\\t");  /* HORIZONTAL TAB */
 301                         break;
 302
 303                 case 0x0B:
 304                         acpi_os_printf("\\v");  /* VERTICAL TAB */
 305                         break;
 306
 307                 case '\'':      /* Single Quote */
 308                 case '\"':      /* Double Quote */
 309                 case '\\':      /* Backslash */
 310                         acpi_os_printf("\\%c", (int)string[i]);
 311                         break;
 312
 313                 default:
 314
 315                         /* Check for printable character or hex escape */
 316
 317                         if (ACPI_IS_PRINT(string[i])) {
 318                                 /* This is a normal character */
 319
 320                                 acpi_os_printf("%c", (int)string[i]);
 321                         } else {
 322                                 /* All others will be Hex escapes */
 323
 324                                 acpi_os_printf("\\x%2.2X", (s32) string[i]);
 325                         }
 326                         break;
 327                 }
 328         }
 329         acpi_os_printf("\"");
 330
 331         if (i == max_length && string[i]) {
 332                 acpi_os_printf("...");
 333         }
 334 }
 335
 336 /*******************************************************************************
 337  *
 338  * FUNCTION:    acpi_ut_dword_byte_swap
 339  *
 340  * PARAMETERS:  Value           - Value to be converted
 341  *
 342  * RETURN:      u32 integer with bytes swapped
 343  *
 344  * DESCRIPTION: Convert a 32-bit value to big-endian (swap the bytes)
 345  *
 346  ******************************************************************************/
 347
 348 u32 acpi_ut_dword_byte_swap(u32 value)
 349 {
 350         union {
 351                 u32 value;
 352                 u8 bytes[4];
 353         } out;
 354         union {
 355                 u32 value;
 356                 u8 bytes[4];
 357         } in;
 358
 359         ACPI_FUNCTION_ENTRY();
 360
 361         in.value = value;
 362
 363         out.bytes[0] = in.bytes[3];
 364         out.bytes[1] = in.bytes[2];
 365         out.bytes[2] = in.bytes[1];
 366         out.bytes[3] = in.bytes[0];
 367
 368         return (out.value);
 369 }
 370
 371 /*******************************************************************************
 372  *
 373  * FUNCTION:    acpi_ut_set_integer_width
 374  *
 375  * PARAMETERS:  Revision            From DSDT header
 376  *
 377  * RETURN:      None
 378  *
 379  * DESCRIPTION: Set the global integer bit width based upon the revision
 380  *              of the DSDT.  For Revision 1 and 0, Integers are 32 bits.
 381  *              For Revision 2 and above, Integers are 64 bits.  Yes, this
 382  *              makes a difference.
 383  *
 384  ******************************************************************************/
 385
 386 void acpi_ut_set_integer_width(u8 revision)
 387 {
 388
 389         if (revision <= 1) {
 390                 acpi_gbl_integer_bit_width = 32;
 391                 acpi_gbl_integer_nybble_width = 8;
 392                 acpi_gbl_integer_byte_width = 4;
 393         } else {
 394                 acpi_gbl_integer_bit_width = 64;
 395                 acpi_gbl_integer_nybble_width = 16;
 396                 acpi_gbl_integer_byte_width = 8;
 397         }
 398 }
 399
 400 #ifdef ACPI_DEBUG_OUTPUT
 401 /*******************************************************************************
 402  *
 403  * FUNCTION:    acpi_ut_display_init_pathname
 404  *
 405  * PARAMETERS:  Type                - Object type of the node
 406  *              obj_handle          - Handle whose pathname will be displayed
 407  *              Path                - Additional path string to be appended.
 408  *                                      (NULL if no extra path)
 409  *
 410  * RETURN:      acpi_status
 411  *
 412  * DESCRIPTION: Display full pathname of an object, DEBUG ONLY
 413  *
 414  ******************************************************************************/
 415
 416 void
 417 acpi_ut_display_init_pathname(u8 type,
 418                               struct acpi_namespace_node *obj_handle,
 419                               char *path)
 420 {
 421         acpi_status status;
 422         struct acpi_buffer buffer;
 423
 424         ACPI_FUNCTION_ENTRY();
 425
 426         /* Only print the path if the appropriate debug level is enabled */
 427
 428         if (!(acpi_dbg_level & ACPI_LV_INIT_NAMES)) {
 429                 return;
 430         }
 431
 432         /* Get the full pathname to the node */
 433
 434         buffer.length = ACPI_ALLOCATE_LOCAL_BUFFER;
 435         status = acpi_ns_handle_to_pathname(obj_handle, &buffer);
 436         if (ACPI_FAILURE(status)) {
 437                 return;
 438         }
 439
 440         /* Print what we're doing */
 441
 442         switch (type) {
 443         case ACPI_TYPE_METHOD:
 444                 acpi_os_printf("Executing  ");
 445                 break;
 446
 447         default:
 448                 acpi_os_printf("Initializing ");
 449                 break;
 450         }
 451
 452         /* Print the object type and pathname */
 453
 454         acpi_os_printf("%-12s %s",
 455                        acpi_ut_get_type_name(type), (char *)buffer.pointer);
 456
 457         /* Extra path is used to append names like _STA, _INI, etc. */
 458
 459         if (path) {
 460                 acpi_os_printf(".%s", path);
 461         }
 462         acpi_os_printf("\n");
 463
 464         ACPI_MEM_FREE(buffer.pointer);
 465 }
 466 #endif
 467
 468 /*******************************************************************************
 469  *
 470  * FUNCTION:    acpi_ut_valid_acpi_name
 471  *
 472  * PARAMETERS:  Name            - The name to be examined
 473  *
 474  * RETURN:      TRUE if the name is valid, FALSE otherwise
 475  *
 476  * DESCRIPTION: Check for a valid ACPI name.  Each character must be one of:
 477  *              1) Upper case alpha
 478  *              2) numeric
 479  *              3) underscore
 480  *
 481  ******************************************************************************/
 482
 483 u8 acpi_ut_valid_acpi_name(u32 name)
 484 {
 485         char *name_ptr = (char *)&name;
 486         char character;
 487         acpi_native_uint i;
 488
 489         ACPI_FUNCTION_ENTRY();
 490
 491         for (i = 0; i < ACPI_NAME_SIZE; i++) {
 492                 character = *name_ptr;
 493                 name_ptr++;
 494
 495                 if (!((character == '_') ||
 496                       (character >= 'A' && character <= 'Z') ||
 497                       (character >= '0' && character <= '9'))) {
 498                         return (FALSE);
 499                 }
 500         }
 501
 502         return (TRUE);
 503 }
 504
 505 /*******************************************************************************
 506  *
 507  * FUNCTION:    acpi_ut_valid_acpi_character
 508  *
 509  * PARAMETERS:  Character           - The character to be examined
 510  *
 511  * RETURN:      1 if Character may appear in a name, else 0
 512  *
 513  * DESCRIPTION: Check for a printable character
 514  *
 515  ******************************************************************************/
 516
 517 u8 acpi_ut_valid_acpi_character(char character)
 518 {
 519
 520         ACPI_FUNCTION_ENTRY();
 521
 522         return ((u8) ((character == '_') ||
 523                       (character >= 'A' && character <= 'Z') ||
 524                       (character >= '0' && character <= '9')));
 525 }
 526
 527 /*******************************************************************************
 528  *
 529  * FUNCTION:    acpi_ut_strtoul64
 530  *
 531  * PARAMETERS:  String          - Null terminated string
 532  *              Base            - Radix of the string: 10, 16, or ACPI_ANY_BASE
 533  *              ret_integer     - Where the converted integer is returned
 534  *
 535  * RETURN:      Status and Converted value
 536  *
 537  * DESCRIPTION: Convert a string into an unsigned value.
 538  *              NOTE: Does not support Octal strings, not needed.
 539  *
 540  ******************************************************************************/
 541
 542 acpi_status
 543 acpi_ut_strtoul64(char *string, u32 base, acpi_integer * ret_integer)
 544 {
 545         u32 this_digit = 0;
 546         acpi_integer return_value = 0;
 547         acpi_integer quotient;
 548
 549         ACPI_FUNCTION_TRACE("ut_stroul64");
 550
 551         if ((!string) || !(*string)) {
 552                 goto error_exit;
 553         }
 554
 555         switch (base) {
 556         case ACPI_ANY_BASE:
 557         case 10:
 558         case 16:
 559                 break;
 560
 561         default:
 562                 /* Invalid Base */
 563                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 564         }
 565
 566         /* Skip over any white space in the buffer */
 567
 568         while (ACPI_IS_SPACE(*string) || *string == '\t') {
 569                 string++;
 570         }
 571
 572         /*
 573          * If the input parameter Base is zero, then we need to
 574          * determine if it is decimal or hexadecimal:
 575          */
 576         if (base == 0) {
 577                 if ((*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
 578                         base = 16;
 579                         string += 2;
 580                 } else {
 581                         base = 10;
 582                 }
 583         }
 584
 585         /*
 586          * For hexadecimal base, skip over the leading
 587          * 0 or 0x, if they are present.
 588          */
 589         if ((base == 16) &&
 590             (*string == '0') && (ACPI_TOLOWER(*(string + 1)) == 'x')) {
 591                 string += 2;
 592         }
 593
 594         /* Any string left? */
 595
 596         if (!(*string)) {
 597                 goto error_exit;
 598         }
 599
 600         /* Main loop: convert the string to a 64-bit integer */
 601
 602         while (*string) {
 603                 if (ACPI_IS_DIGIT(*string)) {
 604                         /* Convert ASCII 0-9 to Decimal value */
 605
 606                         this_digit = ((u8) * string) - '0';
 607                 } else {
 608                         if (base == 10) {
 609                                 /* Digit is out of range */
 610
 611                                 goto error_exit;
 612                         }
 613
 614                         this_digit = (u8) ACPI_TOUPPER(*string);
 615                         if (ACPI_IS_XDIGIT((char)this_digit)) {
 616                                 /* Convert ASCII Hex char to value */
 617
 618                                 this_digit = this_digit - 'A' + 10;
 619                         } else {
 620                                 /*
 621                                  * We allow non-hex chars, just stop now, same as end-of-string.
 622                                  * See ACPI spec, string-to-integer conversion.
 623                                  */
 624                                 break;
 625                         }
 626                 }
 627
 628                 /* Divide the digit into the correct position */
 629
 630                 (void)
 631                     acpi_ut_short_divide((ACPI_INTEGER_MAX -
 632                                           (acpi_integer) this_digit), base,
 633                                          &quotient, NULL);
 634                 if (return_value > quotient) {
 635                         goto error_exit;
 636                 }
 637
 638                 return_value *= base;
 639                 return_value += this_digit;
 640                 string++;
 641         }
 642
 643         /* All done, normal exit */
 644
 645         *ret_integer = return_value;
 646         return_ACPI_STATUS(AE_OK);
 647
 648       error_exit:
 649         /* Base was set/validated above */
 650
 651         if (base == 10) {
 652                 return_ACPI_STATUS(AE_BAD_DECIMAL_CONSTANT);
 653         } else {
 654                 return_ACPI_STATUS(AE_BAD_HEX_CONSTANT);
 655         }
 656 }
 657
 658 /*******************************************************************************
 659  *
 660  * FUNCTION:    acpi_ut_create_update_state_and_push
 661  *
 662  * PARAMETERS:  Object          - Object to be added to the new state
 663  *              Action          - Increment/Decrement
 664  *              state_list      - List the state will be added to
 665  *
 666  * RETURN:      Status
 667  *
 668  * DESCRIPTION: Create a new state and push it
 669  *
 670  ******************************************************************************/
 671
 672 acpi_status
 673 acpi_ut_create_update_state_and_push(union acpi_operand_object *object,
 674                                      u16 action,
 675                                      union acpi_generic_state **state_list)
 676 {
 677         union acpi_generic_state *state;
 678
 679         ACPI_FUNCTION_ENTRY();
 680
 681         /* Ignore null objects; these are expected */
 682
 683         if (!object) {
 684                 return (AE_OK);
 685         }
 686
 687         state = acpi_ut_create_update_state(object, action);
 688         if (!state) {
 689                 return (AE_NO_MEMORY);
 690         }
 691
 692         acpi_ut_push_generic_state(state_list, state);
 693         return (AE_OK);
 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(union acpi_operand_object * source_object,
 713                           void *target_object,
 714                           acpi_pkg_callback walk_callback, void *context)
 715 {
 716         acpi_status status = AE_OK;
 717         union acpi_generic_state *state_list = NULL;
 718         union acpi_generic_state *state;
 719         u32 this_index;
 720         union acpi_operand_object *this_source_obj;
 721
 722         ACPI_FUNCTION_TRACE("ut_walk_package_tree");
 723
 724         state = acpi_ut_create_pkg_state(source_object, target_object, 0);
 725         if (!state) {
 726                 return_ACPI_STATUS(AE_NO_MEMORY);
 727         }
 728
 729         while (state) {
 730                 /* Get one element of the package */
 731
 732                 this_index = state->pkg.index;
 733                 this_source_obj = (union acpi_operand_object *)
 734                     state->pkg.source_object->package.elements[this_index];
 735
 736                 /*
 737                  * Check for:
 738                  * 1) An uninitialized package element.  It is completely
 739                  *    legal to declare a package and leave it uninitialized
 740                  * 2) Not an internal object - can be a namespace node instead
 741                  * 3) Any type other than a package.  Packages are handled in else
 742                  *    case below.
 743                  */
 744                 if ((!this_source_obj) ||
 745                     (ACPI_GET_DESCRIPTOR_TYPE(this_source_obj) !=
 746                      ACPI_DESC_TYPE_OPERAND)
 747                     || (ACPI_GET_OBJECT_TYPE(this_source_obj) !=
 748                         ACPI_TYPE_PACKAGE)) {
 749                         status =
 750                             walk_callback(ACPI_COPY_TYPE_SIMPLE,
 751                                           this_source_obj, state, context);
 752                         if (ACPI_FAILURE(status)) {
 753                                 return_ACPI_STATUS(status);
 754                         }
 755
 756                         state->pkg.index++;
 757                         while (state->pkg.index >=
 758                                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                 } else {
 787                         /* This is a subobject of type package */
 788
 789                         status =
 790                             walk_callback(ACPI_COPY_TYPE_PACKAGE,
 791                                           this_source_obj, 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.
 803                                                          this_target_obj, 0);
 804                         if (!state) {
 805                                 return_ACPI_STATUS(AE_NO_MEMORY);
 806                         }
 807                 }
 808         }
 809
 810         /* We should never get here */
 811
 812         return_ACPI_STATUS(AE_AML_INTERNAL);
 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 acpi_ut_generate_checksum(u8 * buffer, u32 length)
 829 {
 830         u32 i;
 831         signed char sum = 0;
 832
 833         for (i = 0; i < length; i++) {
 834                 sum = (signed char)(sum + buffer[i]);
 835         }
 836
 837         return ((u8) (0 - sum));
 838 }
 839
 840 /*******************************************************************************
 841  *
 842  * FUNCTION:    acpi_ut_error, acpi_ut_warning, acpi_ut_info
 843  *
 844  * PARAMETERS:  module_name         - Caller's module name (for error output)
 845  *              line_number         - Caller's line number (for error output)
 846  *              Format              - Printf format string + additional args
 847  *
 848  * RETURN:      None
 849  *
 850  * DESCRIPTION: Print message with module/line/version info
 851  *
 852  ******************************************************************************/
 853
 854 void ACPI_INTERNAL_VAR_XFACE
 855 acpi_ut_error(char *module_name, u32 line_number, char *format, ...)
 856 {
 857         va_list args;
 858
 859         acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number);
 860
 861         va_start(args, format);
 862         acpi_os_vprintf(format, args);
 863         acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
 864 }
 865
 866 void ACPI_INTERNAL_VAR_XFACE
 867 acpi_ut_exception(char *module_name,
 868                   u32 line_number, acpi_status status, char *format, ...)
 869 {
 870         va_list args;
 871
 872         acpi_os_printf("ACPI Exception (%s-%04d): %s, ", module_name,
 873                        line_number, acpi_format_exception(status));
 874
 875         va_start(args, format);
 876         acpi_os_vprintf(format, args);
 877         acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
 878 }
 879
 880 void ACPI_INTERNAL_VAR_XFACE
 881 acpi_ut_warning(char *module_name, u32 line_number, char *format, ...)
 882 {
 883         va_list args;
 884
 885         acpi_os_printf("ACPI Warning (%s-%04d): ", module_name, line_number);
 886
 887         va_start(args, format);
 888         acpi_os_vprintf(format, args);
 889         acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
 890 }
 891
 892 void ACPI_INTERNAL_VAR_XFACE
 893 acpi_ut_info(char *module_name, u32 line_number, char *format, ...)
 894 {
 895         va_list args;
 896
 897         acpi_os_printf("ACPI (%s-%04d): ", module_name, line_number);
 898
 899         va_start(args, format);
 900         acpi_os_vprintf(format, args);
 901         acpi_os_printf(" [%X]\n", ACPI_CA_VERSION);
 902 }
 903
 904 /*******************************************************************************
 905  *
 906  * FUNCTION:    acpi_ut_report_error, Warning, Info
 907  *
 908  * PARAMETERS:  module_name         - Caller's module name (for error output)
 909  *              line_number         - Caller's line number (for error output)
 910  *
 911  * RETURN:      None
 912  *
 913  * DESCRIPTION: Print error message
 914  *
 915  * Note: Legacy only, should be removed when no longer used by drivers.
 916  *
 917  ******************************************************************************/
 918
 919 void acpi_ut_report_error(char *module_name, u32 line_number)
 920 {
 921
 922         acpi_os_printf("ACPI Error (%s-%04d): ", module_name, line_number);
 923 }
 924
 925 void acpi_ut_report_warning(char *module_name, u32 line_number)
 926 {
 927
 928         acpi_os_printf("ACPI Warning (%s-%04d): ", module_name, line_number);
 929 }
 930
 931 void acpi_ut_report_info(char *module_name, u32 line_number)
 932 {
 933
 934         acpi_os_printf("ACPI (%s-%04d): ", module_name, line_number);
 935 }