linux/drivers/acpi/acpica/utobject.c
<<
>>
Prefs
   1/******************************************************************************
   2 *
   3 * Module Name: utobject - ACPI object create/delete/size/cache routines
   4 *
   5 *****************************************************************************/
   6
   7/*
   8 * Copyright (C) 2000 - 2013, 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
  48#define _COMPONENT          ACPI_UTILITIES
  49ACPI_MODULE_NAME("utobject")
  50
  51/* Local prototypes */
  52static acpi_status
  53acpi_ut_get_simple_object_size(union acpi_operand_object *obj,
  54                               acpi_size * obj_length);
  55
  56static acpi_status
  57acpi_ut_get_package_object_size(union acpi_operand_object *obj,
  58                                acpi_size * obj_length);
  59
  60static acpi_status
  61acpi_ut_get_element_length(u8 object_type,
  62                           union acpi_operand_object *source_object,
  63                           union acpi_generic_state *state, void *context);
  64
  65/*******************************************************************************
  66 *
  67 * FUNCTION:    acpi_ut_create_internal_object_dbg
  68 *
  69 * PARAMETERS:  module_name         - Source file name of caller
  70 *              line_number         - Line number of caller
  71 *              component_id        - Component type of caller
  72 *              type                - ACPI Type of the new object
  73 *
  74 * RETURN:      A new internal object, null on failure
  75 *
  76 * DESCRIPTION: Create and initialize a new internal object.
  77 *
  78 * NOTE:        We always allocate the worst-case object descriptor because
  79 *              these objects are cached, and we want them to be
  80 *              one-size-satisifies-any-request. This in itself may not be
  81 *              the most memory efficient, but the efficiency of the object
  82 *              cache should more than make up for this!
  83 *
  84 ******************************************************************************/
  85
  86union acpi_operand_object *acpi_ut_create_internal_object_dbg(const char
  87                                                              *module_name,
  88                                                              u32 line_number,
  89                                                              u32 component_id,
  90                                                              acpi_object_type
  91                                                              type)
  92{
  93        union acpi_operand_object *object;
  94        union acpi_operand_object *second_object;
  95
  96        ACPI_FUNCTION_TRACE_STR(ut_create_internal_object_dbg,
  97                                acpi_ut_get_type_name(type));
  98
  99        /* Allocate the raw object descriptor */
 100
 101        object =
 102            acpi_ut_allocate_object_desc_dbg(module_name, line_number,
 103                                             component_id);
 104        if (!object) {
 105                return_PTR(NULL);
 106        }
 107
 108        switch (type) {
 109        case ACPI_TYPE_REGION:
 110        case ACPI_TYPE_BUFFER_FIELD:
 111        case ACPI_TYPE_LOCAL_BANK_FIELD:
 112
 113                /* These types require a secondary object */
 114
 115                second_object = acpi_ut_allocate_object_desc_dbg(module_name,
 116                                                                 line_number,
 117                                                                 component_id);
 118                if (!second_object) {
 119                        acpi_ut_delete_object_desc(object);
 120                        return_PTR(NULL);
 121                }
 122
 123                second_object->common.type = ACPI_TYPE_LOCAL_EXTRA;
 124                second_object->common.reference_count = 1;
 125
 126                /* Link the second object to the first */
 127
 128                object->common.next_object = second_object;
 129                break;
 130
 131        default:
 132                /* All others have no secondary object */
 133                break;
 134        }
 135
 136        /* Save the object type in the object descriptor */
 137
 138        object->common.type = (u8) type;
 139
 140        /* Init the reference count */
 141
 142        object->common.reference_count = 1;
 143
 144        /* Any per-type initialization should go here */
 145
 146        return_PTR(object);
 147}
 148
 149/*******************************************************************************
 150 *
 151 * FUNCTION:    acpi_ut_create_package_object
 152 *
 153 * PARAMETERS:  count               - Number of package elements
 154 *
 155 * RETURN:      Pointer to a new Package object, null on failure
 156 *
 157 * DESCRIPTION: Create a fully initialized package object
 158 *
 159 ******************************************************************************/
 160
 161union acpi_operand_object *acpi_ut_create_package_object(u32 count)
 162{
 163        union acpi_operand_object *package_desc;
 164        union acpi_operand_object **package_elements;
 165
 166        ACPI_FUNCTION_TRACE_U32(ut_create_package_object, count);
 167
 168        /* Create a new Package object */
 169
 170        package_desc = acpi_ut_create_internal_object(ACPI_TYPE_PACKAGE);
 171        if (!package_desc) {
 172                return_PTR(NULL);
 173        }
 174
 175        /*
 176         * Create the element array. Count+1 allows the array to be null
 177         * terminated.
 178         */
 179        package_elements = ACPI_ALLOCATE_ZEROED(((acpi_size) count +
 180                                                 1) * sizeof(void *));
 181        if (!package_elements) {
 182                acpi_ut_remove_reference(package_desc);
 183                return_PTR(NULL);
 184        }
 185
 186        package_desc->package.count = count;
 187        package_desc->package.elements = package_elements;
 188        return_PTR(package_desc);
 189}
 190
 191/*******************************************************************************
 192 *
 193 * FUNCTION:    acpi_ut_create_integer_object
 194 *
 195 * PARAMETERS:  initial_value       - Initial value for the integer
 196 *
 197 * RETURN:      Pointer to a new Integer object, null on failure
 198 *
 199 * DESCRIPTION: Create an initialized integer object
 200 *
 201 ******************************************************************************/
 202
 203union acpi_operand_object *acpi_ut_create_integer_object(u64 initial_value)
 204{
 205        union acpi_operand_object *integer_desc;
 206
 207        ACPI_FUNCTION_TRACE(ut_create_integer_object);
 208
 209        /* Create and initialize a new integer object */
 210
 211        integer_desc = acpi_ut_create_internal_object(ACPI_TYPE_INTEGER);
 212        if (!integer_desc) {
 213                return_PTR(NULL);
 214        }
 215
 216        integer_desc->integer.value = initial_value;
 217        return_PTR(integer_desc);
 218}
 219
 220/*******************************************************************************
 221 *
 222 * FUNCTION:    acpi_ut_create_buffer_object
 223 *
 224 * PARAMETERS:  buffer_size            - Size of buffer to be created
 225 *
 226 * RETURN:      Pointer to a new Buffer object, null on failure
 227 *
 228 * DESCRIPTION: Create a fully initialized buffer object
 229 *
 230 ******************************************************************************/
 231
 232union acpi_operand_object *acpi_ut_create_buffer_object(acpi_size buffer_size)
 233{
 234        union acpi_operand_object *buffer_desc;
 235        u8 *buffer = NULL;
 236
 237        ACPI_FUNCTION_TRACE_U32(ut_create_buffer_object, buffer_size);
 238
 239        /* Create a new Buffer object */
 240
 241        buffer_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER);
 242        if (!buffer_desc) {
 243                return_PTR(NULL);
 244        }
 245
 246        /* Create an actual buffer only if size > 0 */
 247
 248        if (buffer_size > 0) {
 249
 250                /* Allocate the actual buffer */
 251
 252                buffer = ACPI_ALLOCATE_ZEROED(buffer_size);
 253                if (!buffer) {
 254                        ACPI_ERROR((AE_INFO, "Could not allocate size %u",
 255                                    (u32) buffer_size));
 256                        acpi_ut_remove_reference(buffer_desc);
 257                        return_PTR(NULL);
 258                }
 259        }
 260
 261        /* Complete buffer object initialization */
 262
 263        buffer_desc->buffer.flags |= AOPOBJ_DATA_VALID;
 264        buffer_desc->buffer.pointer = buffer;
 265        buffer_desc->buffer.length = (u32) buffer_size;
 266
 267        /* Return the new buffer descriptor */
 268
 269        return_PTR(buffer_desc);
 270}
 271
 272/*******************************************************************************
 273 *
 274 * FUNCTION:    acpi_ut_create_string_object
 275 *
 276 * PARAMETERS:  string_size         - Size of string to be created. Does not
 277 *                                    include NULL terminator, this is added
 278 *                                    automatically.
 279 *
 280 * RETURN:      Pointer to a new String object
 281 *
 282 * DESCRIPTION: Create a fully initialized string object
 283 *
 284 ******************************************************************************/
 285
 286union acpi_operand_object *acpi_ut_create_string_object(acpi_size string_size)
 287{
 288        union acpi_operand_object *string_desc;
 289        char *string;
 290
 291        ACPI_FUNCTION_TRACE_U32(ut_create_string_object, string_size);
 292
 293        /* Create a new String object */
 294
 295        string_desc = acpi_ut_create_internal_object(ACPI_TYPE_STRING);
 296        if (!string_desc) {
 297                return_PTR(NULL);
 298        }
 299
 300        /*
 301         * Allocate the actual string buffer -- (Size + 1) for NULL terminator.
 302         * NOTE: Zero-length strings are NULL terminated
 303         */
 304        string = ACPI_ALLOCATE_ZEROED(string_size + 1);
 305        if (!string) {
 306                ACPI_ERROR((AE_INFO, "Could not allocate size %u",
 307                            (u32) string_size));
 308                acpi_ut_remove_reference(string_desc);
 309                return_PTR(NULL);
 310        }
 311
 312        /* Complete string object initialization */
 313
 314        string_desc->string.pointer = string;
 315        string_desc->string.length = (u32) string_size;
 316
 317        /* Return the new string descriptor */
 318
 319        return_PTR(string_desc);
 320}
 321
 322/*******************************************************************************
 323 *
 324 * FUNCTION:    acpi_ut_valid_internal_object
 325 *
 326 * PARAMETERS:  object              - Object to be validated
 327 *
 328 * RETURN:      TRUE if object is valid, FALSE otherwise
 329 *
 330 * DESCRIPTION: Validate a pointer to be of type union acpi_operand_object
 331 *
 332 ******************************************************************************/
 333
 334u8 acpi_ut_valid_internal_object(void *object)
 335{
 336
 337        ACPI_FUNCTION_NAME(ut_valid_internal_object);
 338
 339        /* Check for a null pointer */
 340
 341        if (!object) {
 342                ACPI_DEBUG_PRINT((ACPI_DB_EXEC, "**** Null Object Ptr\n"));
 343                return (FALSE);
 344        }
 345
 346        /* Check the descriptor type field */
 347
 348        switch (ACPI_GET_DESCRIPTOR_TYPE(object)) {
 349        case ACPI_DESC_TYPE_OPERAND:
 350
 351                /* The object appears to be a valid union acpi_operand_object */
 352
 353                return (TRUE);
 354
 355        default:
 356                ACPI_DEBUG_PRINT((ACPI_DB_EXEC,
 357                                  "%p is not not an ACPI operand obj [%s]\n",
 358                                  object, acpi_ut_get_descriptor_name(object)));
 359                break;
 360        }
 361
 362        return (FALSE);
 363}
 364
 365/*******************************************************************************
 366 *
 367 * FUNCTION:    acpi_ut_allocate_object_desc_dbg
 368 *
 369 * PARAMETERS:  module_name         - Caller's module name (for error output)
 370 *              line_number         - Caller's line number (for error output)
 371 *              component_id        - Caller's component ID (for error output)
 372 *
 373 * RETURN:      Pointer to newly allocated object descriptor. Null on error
 374 *
 375 * DESCRIPTION: Allocate a new object descriptor. Gracefully handle
 376 *              error conditions.
 377 *
 378 ******************************************************************************/
 379
 380void *acpi_ut_allocate_object_desc_dbg(const char *module_name,
 381                                       u32 line_number, u32 component_id)
 382{
 383        union acpi_operand_object *object;
 384
 385        ACPI_FUNCTION_TRACE(ut_allocate_object_desc_dbg);
 386
 387        object = acpi_os_acquire_object(acpi_gbl_operand_cache);
 388        if (!object) {
 389                ACPI_ERROR((module_name, line_number,
 390                            "Could not allocate an object descriptor"));
 391
 392                return_PTR(NULL);
 393        }
 394
 395        /* Mark the descriptor type */
 396
 397        memset(object, 0, sizeof(union acpi_operand_object));
 398        ACPI_SET_DESCRIPTOR_TYPE(object, ACPI_DESC_TYPE_OPERAND);
 399
 400        ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, "%p Size %X\n",
 401                          object, (u32) sizeof(union acpi_operand_object)));
 402
 403        return_PTR(object);
 404}
 405
 406/*******************************************************************************
 407 *
 408 * FUNCTION:    acpi_ut_delete_object_desc
 409 *
 410 * PARAMETERS:  object          - An Acpi internal object to be deleted
 411 *
 412 * RETURN:      None.
 413 *
 414 * DESCRIPTION: Free an ACPI object descriptor or add it to the object cache
 415 *
 416 ******************************************************************************/
 417
 418void acpi_ut_delete_object_desc(union acpi_operand_object *object)
 419{
 420        ACPI_FUNCTION_TRACE_PTR(ut_delete_object_desc, object);
 421
 422        /* Object must be of type union acpi_operand_object */
 423
 424        if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) {
 425                ACPI_ERROR((AE_INFO,
 426                            "%p is not an ACPI Operand object [%s]", object,
 427                            acpi_ut_get_descriptor_name(object)));
 428                return_VOID;
 429        }
 430
 431        (void)acpi_os_release_object(acpi_gbl_operand_cache, object);
 432        return_VOID;
 433}
 434
 435/*******************************************************************************
 436 *
 437 * FUNCTION:    acpi_ut_get_simple_object_size
 438 *
 439 * PARAMETERS:  internal_object    - An ACPI operand object
 440 *              obj_length         - Where the length is returned
 441 *
 442 * RETURN:      Status
 443 *
 444 * DESCRIPTION: This function is called to determine the space required to
 445 *              contain a simple object for return to an external user.
 446 *
 447 *              The length includes the object structure plus any additional
 448 *              needed space.
 449 *
 450 ******************************************************************************/
 451
 452static acpi_status
 453acpi_ut_get_simple_object_size(union acpi_operand_object *internal_object,
 454                               acpi_size * obj_length)
 455{
 456        acpi_size length;
 457        acpi_size size;
 458        acpi_status status = AE_OK;
 459
 460        ACPI_FUNCTION_TRACE_PTR(ut_get_simple_object_size, internal_object);
 461
 462        /*
 463         * Handle a null object (Could be a uninitialized package
 464         * element -- which is legal)
 465         */
 466        if (!internal_object) {
 467                *obj_length = sizeof(union acpi_object);
 468                return_ACPI_STATUS(AE_OK);
 469        }
 470
 471        /* Start with the length of the Acpi object */
 472
 473        length = sizeof(union acpi_object);
 474
 475        if (ACPI_GET_DESCRIPTOR_TYPE(internal_object) == ACPI_DESC_TYPE_NAMED) {
 476
 477                /* Object is a named object (reference), just return the length */
 478
 479                *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
 480                return_ACPI_STATUS(status);
 481        }
 482
 483        /*
 484         * The final length depends on the object type
 485         * Strings and Buffers are packed right up against the parent object and
 486         * must be accessed bytewise or there may be alignment problems on
 487         * certain processors
 488         */
 489        switch (internal_object->common.type) {
 490        case ACPI_TYPE_STRING:
 491
 492                length += (acpi_size) internal_object->string.length + 1;
 493                break;
 494
 495        case ACPI_TYPE_BUFFER:
 496
 497                length += (acpi_size) internal_object->buffer.length;
 498                break;
 499
 500        case ACPI_TYPE_INTEGER:
 501        case ACPI_TYPE_PROCESSOR:
 502        case ACPI_TYPE_POWER:
 503
 504                /* No extra data for these types */
 505
 506                break;
 507
 508        case ACPI_TYPE_LOCAL_REFERENCE:
 509
 510                switch (internal_object->reference.class) {
 511                case ACPI_REFCLASS_NAME:
 512
 513                        /*
 514                         * Get the actual length of the full pathname to this object.
 515                         * The reference will be converted to the pathname to the object
 516                         */
 517                        size =
 518                            acpi_ns_get_pathname_length(internal_object->
 519                                                        reference.node);
 520                        if (!size) {
 521                                return_ACPI_STATUS(AE_BAD_PARAMETER);
 522                        }
 523
 524                        length += ACPI_ROUND_UP_TO_NATIVE_WORD(size);
 525                        break;
 526
 527                default:
 528
 529                        /*
 530                         * No other reference opcodes are supported.
 531                         * Notably, Locals and Args are not supported, but this may be
 532                         * required eventually.
 533                         */
 534                        ACPI_ERROR((AE_INFO,
 535                                    "Cannot convert to external object - "
 536                                    "unsupported Reference Class [%s] 0x%X in object %p",
 537                                    acpi_ut_get_reference_name(internal_object),
 538                                    internal_object->reference.class,
 539                                    internal_object));
 540                        status = AE_TYPE;
 541                        break;
 542                }
 543                break;
 544
 545        default:
 546
 547                ACPI_ERROR((AE_INFO, "Cannot convert to external object - "
 548                            "unsupported type [%s] 0x%X in object %p",
 549                            acpi_ut_get_object_type_name(internal_object),
 550                            internal_object->common.type, internal_object));
 551                status = AE_TYPE;
 552                break;
 553        }
 554
 555        /*
 556         * Account for the space required by the object rounded up to the next
 557         * multiple of the machine word size. This keeps each object aligned
 558         * on a machine word boundary. (preventing alignment faults on some
 559         * machines.)
 560         */
 561        *obj_length = ACPI_ROUND_UP_TO_NATIVE_WORD(length);
 562        return_ACPI_STATUS(status);
 563}
 564
 565/*******************************************************************************
 566 *
 567 * FUNCTION:    acpi_ut_get_element_length
 568 *
 569 * PARAMETERS:  acpi_pkg_callback
 570 *
 571 * RETURN:      Status
 572 *
 573 * DESCRIPTION: Get the length of one package element.
 574 *
 575 ******************************************************************************/
 576
 577static acpi_status
 578acpi_ut_get_element_length(u8 object_type,
 579                           union acpi_operand_object *source_object,
 580                           union acpi_generic_state *state, void *context)
 581{
 582        acpi_status status = AE_OK;
 583        struct acpi_pkg_info *info = (struct acpi_pkg_info *)context;
 584        acpi_size object_space;
 585
 586        switch (object_type) {
 587        case ACPI_COPY_TYPE_SIMPLE:
 588
 589                /*
 590                 * Simple object - just get the size (Null object/entry is handled
 591                 * here also) and sum it into the running package length
 592                 */
 593                status =
 594                    acpi_ut_get_simple_object_size(source_object,
 595                                                   &object_space);
 596                if (ACPI_FAILURE(status)) {
 597                        return (status);
 598                }
 599
 600                info->length += object_space;
 601                break;
 602
 603        case ACPI_COPY_TYPE_PACKAGE:
 604
 605                /* Package object - nothing much to do here, let the walk handle it */
 606
 607                info->num_packages++;
 608                state->pkg.this_target_obj = NULL;
 609                break;
 610
 611        default:
 612
 613                /* No other types allowed */
 614
 615                return (AE_BAD_PARAMETER);
 616        }
 617
 618        return (status);
 619}
 620
 621/*******************************************************************************
 622 *
 623 * FUNCTION:    acpi_ut_get_package_object_size
 624 *
 625 * PARAMETERS:  internal_object     - An ACPI internal object
 626 *              obj_length          - Where the length is returned
 627 *
 628 * RETURN:      Status
 629 *
 630 * DESCRIPTION: This function is called to determine the space required to
 631 *              contain a package object for return to an external user.
 632 *
 633 *              This is moderately complex since a package contains other
 634 *              objects including packages.
 635 *
 636 ******************************************************************************/
 637
 638static acpi_status
 639acpi_ut_get_package_object_size(union acpi_operand_object *internal_object,
 640                                acpi_size * obj_length)
 641{
 642        acpi_status status;
 643        struct acpi_pkg_info info;
 644
 645        ACPI_FUNCTION_TRACE_PTR(ut_get_package_object_size, internal_object);
 646
 647        info.length = 0;
 648        info.object_space = 0;
 649        info.num_packages = 1;
 650
 651        status = acpi_ut_walk_package_tree(internal_object, NULL,
 652                                           acpi_ut_get_element_length, &info);
 653        if (ACPI_FAILURE(status)) {
 654                return_ACPI_STATUS(status);
 655        }
 656
 657        /*
 658         * We have handled all of the objects in all levels of the package.
 659         * just add the length of the package objects themselves.
 660         * Round up to the next machine word.
 661         */
 662        info.length += ACPI_ROUND_UP_TO_NATIVE_WORD(sizeof(union acpi_object)) *
 663            (acpi_size) info.num_packages;
 664
 665        /* Return the total package length */
 666
 667        *obj_length = info.length;
 668        return_ACPI_STATUS(status);
 669}
 670
 671/*******************************************************************************
 672 *
 673 * FUNCTION:    acpi_ut_get_object_size
 674 *
 675 * PARAMETERS:  internal_object     - An ACPI internal object
 676 *              obj_length          - Where the length will be returned
 677 *
 678 * RETURN:      Status
 679 *
 680 * DESCRIPTION: This function is called to determine the space required to
 681 *              contain an object for return to an API user.
 682 *
 683 ******************************************************************************/
 684
 685acpi_status
 686acpi_ut_get_object_size(union acpi_operand_object *internal_object,
 687                        acpi_size * obj_length)
 688{
 689        acpi_status status;
 690
 691        ACPI_FUNCTION_ENTRY();
 692
 693        if ((ACPI_GET_DESCRIPTOR_TYPE(internal_object) ==
 694             ACPI_DESC_TYPE_OPERAND)
 695            && (internal_object->common.type == ACPI_TYPE_PACKAGE)) {
 696                status =
 697                    acpi_ut_get_package_object_size(internal_object,
 698                                                    obj_length);
 699        } else {
 700                status =
 701                    acpi_ut_get_simple_object_size(internal_object, obj_length);
 702        }
 703
 704        return (status);
 705}
 706