Print this page
update to acpica-unix2-20140114
acpica-unix2-20130823
PANKOVs restructure

Split Close
Expand all
Collapse all
          --- old/usr/src/uts/intel/io/acpica/executer/exoparg1.c
          +++ new/usr/src/common/acpica/components/executer/exoparg1.c
   1      -
   2    1  /******************************************************************************
   3    2   *
   4    3   * Module Name: exoparg1 - AML execution - opcodes with 1 argument
   5    4   *
   6    5   *****************************************************************************/
   7    6  
   8    7  /*
   9      - * Copyright (C) 2000 - 2011, Intel Corp.
        8 + * Copyright (C) 2000 - 2014, Intel Corp.
  10    9   * All rights reserved.
  11   10   *
  12   11   * Redistribution and use in source and binary forms, with or without
  13   12   * modification, are permitted provided that the following conditions
  14   13   * are met:
  15   14   * 1. Redistributions of source code must retain the above copyright
  16   15   *    notice, this list of conditions, and the following disclaimer,
  17   16   *    without modification.
  18   17   * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  19   18   *    substantially similar to the "NO WARRANTY" disclaimer below
↓ open down ↓ 154 lines elided ↑ open up ↑
 174  173  
 175  174      /* Examine the AML opcode */
 176  175  
 177  176      switch (WalkState->Opcode)
 178  177      {
 179  178      case AML_RELEASE_OP:    /*  Release (MutexObject) */
 180  179  
 181  180          Status = AcpiExReleaseMutex (Operand[0], WalkState);
 182  181          break;
 183  182  
 184      -
 185  183      case AML_RESET_OP:      /*  Reset (EventObject) */
 186  184  
 187  185          Status = AcpiExSystemResetEvent (Operand[0]);
 188  186          break;
 189  187  
 190      -
 191  188      case AML_SIGNAL_OP:     /*  Signal (EventObject) */
 192  189  
 193  190          Status = AcpiExSystemSignalEvent (Operand[0]);
 194  191          break;
 195  192  
 196      -
 197  193      case AML_SLEEP_OP:      /*  Sleep (MsecTime) */
 198  194  
 199  195          Status = AcpiExSystemDoSleep (Operand[0]->Integer.Value);
 200  196          break;
 201  197  
 202      -
 203  198      case AML_STALL_OP:      /*  Stall (UsecTime) */
 204  199  
 205  200          Status = AcpiExSystemDoStall ((UINT32) Operand[0]->Integer.Value);
 206  201          break;
 207  202  
 208      -
 209  203      case AML_UNLOAD_OP:     /*  Unload (Handle) */
 210  204  
 211  205          Status = AcpiExUnloadTable (Operand[0]);
 212  206          break;
 213  207  
 214      -
 215  208      default:                /*  Unknown opcode  */
 216  209  
 217  210          ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 218  211              WalkState->Opcode));
 219  212          Status = AE_AML_BAD_OPCODE;
 220  213          break;
 221  214      }
 222  215  
 223  216      return_ACPI_STATUS (Status);
 224  217  }
↓ open down ↓ 99 lines elided ↑ open up ↑
 324  317              goto Cleanup;
 325  318          }
 326  319  
 327  320          switch (WalkState->Opcode)
 328  321          {
 329  322          case AML_BIT_NOT_OP:            /* Not (Operand, Result)  */
 330  323  
 331  324              ReturnDesc->Integer.Value = ~Operand[0]->Integer.Value;
 332  325              break;
 333  326  
 334      -
 335  327          case AML_FIND_SET_LEFT_BIT_OP:  /* FindSetLeftBit (Operand, Result) */
 336  328  
 337  329              ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
 338  330  
 339  331              /*
 340  332               * Acpi specification describes Integer type as a little
 341  333               * endian unsigned value, so this boundary condition is valid.
 342  334               */
 343  335              for (Temp32 = 0; ReturnDesc->Integer.Value &&
 344  336                               Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
 345  337              {
 346  338                  ReturnDesc->Integer.Value >>= 1;
 347  339              }
 348  340  
 349  341              ReturnDesc->Integer.Value = Temp32;
 350  342              break;
 351  343  
 352      -
 353  344          case AML_FIND_SET_RIGHT_BIT_OP: /* FindSetRightBit (Operand, Result) */
 354  345  
 355  346              ReturnDesc->Integer.Value = Operand[0]->Integer.Value;
 356  347  
 357  348              /*
 358  349               * The Acpi specification describes Integer type as a little
 359  350               * endian unsigned value, so this boundary condition is valid.
 360  351               */
 361  352              for (Temp32 = 0; ReturnDesc->Integer.Value &&
 362  353                               Temp32 < ACPI_INTEGER_BIT_SIZE; ++Temp32)
 363  354              {
 364  355                  ReturnDesc->Integer.Value <<= 1;
 365  356              }
 366  357  
 367  358              /* Since the bit position is one-based, subtract from 33 (65) */
 368  359  
 369  360              ReturnDesc->Integer.Value =
 370  361                  Temp32 == 0 ? 0 : (ACPI_INTEGER_BIT_SIZE + 1) - Temp32;
 371  362              break;
 372  363  
 373      -
 374  364          case AML_FROM_BCD_OP:           /* FromBcd (BCDValue, Result)  */
 375      -
 376  365              /*
 377  366               * The 64-bit ACPI integer can hold 16 4-bit BCD characters
 378  367               * (if table is 32-bit, integer can hold 8 BCD characters)
 379  368               * Convert each 4-bit BCD value
 380  369               */
 381  370              PowerOfTen = 1;
 382  371              ReturnDesc->Integer.Value = 0;
 383  372              Digit = Operand[0]->Integer.Value;
 384  373  
 385  374              /* Convert each BCD digit (each is one nybble wide) */
↓ open down ↓ 24 lines elided ↑ open up ↑
 410  399                  /* Shift to next BCD digit */
 411  400  
 412  401                  Digit >>= 4;
 413  402  
 414  403                  /* Next power of 10 */
 415  404  
 416  405                  PowerOfTen *= 10;
 417  406              }
 418  407              break;
 419  408  
 420      -
 421  409          case AML_TO_BCD_OP:             /* ToBcd (Operand, Result)  */
 422  410  
 423  411              ReturnDesc->Integer.Value = 0;
 424  412              Digit = Operand[0]->Integer.Value;
 425  413  
 426  414              /* Each BCD digit is one nybble wide */
 427  415  
 428  416              for (i = 0; (i < AcpiGbl_IntegerNybbleWidth) && (Digit > 0); i++)
 429  417              {
 430  418                  (void) AcpiUtShortDivide (Digit, 10, &Digit, &Temp32);
↓ open down ↓ 11 lines elided ↑ open up ↑
 442  430              if (Digit > 0)
 443  431              {
 444  432                  ACPI_ERROR ((AE_INFO,
 445  433                      "Integer too large to convert to BCD: 0x%8.8X%8.8X",
 446  434                      ACPI_FORMAT_UINT64 (Operand[0]->Integer.Value)));
 447  435                  Status = AE_AML_NUMERIC_OVERFLOW;
 448  436                  goto Cleanup;
 449  437              }
 450  438              break;
 451  439  
 452      -
 453  440          case AML_COND_REF_OF_OP:        /* CondRefOf (SourceObject, Result)  */
 454      -
 455  441              /*
 456  442               * This op is a little strange because the internal return value is
 457  443               * different than the return value stored in the result descriptor
 458  444               * (There are really two return values)
 459  445               */
 460  446              if ((ACPI_NAMESPACE_NODE *) Operand[0] == AcpiGbl_RootNode)
 461  447              {
 462  448                  /*
 463  449                   * This means that the object does not exist in the namespace,
 464  450                   * return FALSE
↓ open down ↓ 14 lines elided ↑ open up ↑
 479  465              Status = AcpiExStore (ReturnDesc2, Operand[1], WalkState);
 480  466              AcpiUtRemoveReference (ReturnDesc2);
 481  467  
 482  468              /* The object exists in the namespace, return TRUE */
 483  469  
 484  470              ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
 485  471              goto Cleanup;
 486  472  
 487  473  
 488  474          default:
      475 +
 489  476              /* No other opcodes get here */
      477 +
 490  478              break;
 491  479          }
 492  480          break;
 493  481  
 494      -
 495  482      case AML_STORE_OP:              /* Store (Source, Target) */
 496      -
 497  483          /*
 498  484           * A store operand is typically a number, string, buffer or lvalue
 499  485           * Be careful about deleting the source object,
 500  486           * since the object itself may have been stored.
 501  487           */
 502  488          Status = AcpiExStore (Operand[0], Operand[1], WalkState);
 503  489          if (ACPI_FAILURE (Status))
 504  490          {
 505  491              return_ACPI_STATUS (Status);
 506  492          }
↓ open down ↓ 6 lines elided ↑ open up ↑
 513  499               * Normally, we would remove a reference on the Operand[0]
 514  500               * parameter; But since it is being used as the internal return
 515  501               * object (meaning we would normally increment it), the two
 516  502               * cancel out, and we simply don't do anything.
 517  503               */
 518  504              WalkState->ResultObj = Operand[0];
 519  505              WalkState->Operands[0] = NULL;  /* Prevent deletion */
 520  506          }
 521  507          return_ACPI_STATUS (Status);
 522  508  
 523      -
 524  509      /*
 525  510       * ACPI 2.0 Opcodes
 526  511       */
 527  512      case AML_COPY_OP:               /* Copy (Source, Target) */
 528  513  
 529  514          Status = AcpiUtCopyIobjectToIobject (Operand[0], &ReturnDesc,
 530  515                      WalkState);
 531  516          break;
 532  517  
 533      -
 534  518      case AML_TO_DECSTRING_OP:       /* ToDecimalString (Data, Result) */
 535  519  
 536  520          Status = AcpiExConvertToString (Operand[0], &ReturnDesc,
 537  521                      ACPI_EXPLICIT_CONVERT_DECIMAL);
 538  522          if (ReturnDesc == Operand[0])
 539  523          {
 540  524              /* No conversion performed, add ref to handle return value */
 541  525              AcpiUtAddReference (ReturnDesc);
 542  526          }
 543  527          break;
 544  528  
 545      -
 546  529      case AML_TO_HEXSTRING_OP:       /* ToHexString (Data, Result) */
 547  530  
 548  531          Status = AcpiExConvertToString (Operand[0], &ReturnDesc,
 549  532                      ACPI_EXPLICIT_CONVERT_HEX);
 550  533          if (ReturnDesc == Operand[0])
 551  534          {
 552  535              /* No conversion performed, add ref to handle return value */
 553  536              AcpiUtAddReference (ReturnDesc);
 554  537          }
 555  538          break;
 556  539  
 557      -
 558  540      case AML_TO_BUFFER_OP:          /* ToBuffer (Data, Result) */
 559  541  
 560  542          Status = AcpiExConvertToBuffer (Operand[0], &ReturnDesc);
 561  543          if (ReturnDesc == Operand[0])
 562  544          {
 563  545              /* No conversion performed, add ref to handle return value */
 564  546              AcpiUtAddReference (ReturnDesc);
 565  547          }
 566  548          break;
 567  549  
 568      -
 569  550      case AML_TO_INTEGER_OP:         /* ToInteger (Data, Result) */
 570  551  
 571  552          Status = AcpiExConvertToInteger (Operand[0], &ReturnDesc,
 572  553                      ACPI_ANY_BASE);
 573  554          if (ReturnDesc == Operand[0])
 574  555          {
 575  556              /* No conversion performed, add ref to handle return value */
 576  557              AcpiUtAddReference (ReturnDesc);
 577  558          }
 578  559          break;
 579  560  
 580      -
 581  561      case AML_SHIFT_LEFT_BIT_OP:     /* ShiftLeftBit (Source, BitNum)  */
 582  562      case AML_SHIFT_RIGHT_BIT_OP:    /* ShiftRightBit (Source, BitNum) */
 583  563  
 584  564          /* These are two obsolete opcodes */
 585  565  
 586  566          ACPI_ERROR ((AE_INFO,
 587  567              "%s is obsolete and not implemented",
 588  568              AcpiPsGetOpcodeName (WalkState->Opcode)));
 589  569          Status = AE_SUPPORT;
 590  570          goto Cleanup;
 591  571  
 592      -
 593  572      default:                        /* Unknown opcode */
 594  573  
 595  574          ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
 596  575              WalkState->Opcode));
 597  576          Status = AE_AML_BAD_OPCODE;
 598  577          goto Cleanup;
 599  578      }
 600  579  
 601  580      if (ACPI_SUCCESS (Status))
 602  581      {
↓ open down ↓ 58 lines elided ↑ open up ↑
 661  640      case AML_LNOT_OP:               /* LNot (Operand) */
 662  641  
 663  642          ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) 0);
 664  643          if (!ReturnDesc)
 665  644          {
 666  645              Status = AE_NO_MEMORY;
 667  646              goto Cleanup;
 668  647          }
 669  648  
 670  649          /*
 671      -         * Set result to ONES (TRUE) if Value == 0.  Note:
      650 +         * Set result to ONES (TRUE) if Value == 0. Note:
 672  651           * ReturnDesc->Integer.Value is initially == 0 (FALSE) from above.
 673  652           */
 674  653          if (!Operand[0]->Integer.Value)
 675  654          {
 676  655              ReturnDesc->Integer.Value = ACPI_UINT64_MAX;
 677  656          }
 678  657          break;
 679  658  
 680      -
 681  659      case AML_DECREMENT_OP:          /* Decrement (Operand)  */
 682  660      case AML_INCREMENT_OP:          /* Increment (Operand)  */
 683      -
 684  661          /*
 685      -         * Create a new integer.  Can't just get the base integer and
      662 +         * Create a new integer. Can't just get the base integer and
 686  663           * increment it because it may be an Arg or Field.
 687  664           */
 688  665          ReturnDesc = AcpiUtCreateInternalObject (ACPI_TYPE_INTEGER);
 689  666          if (!ReturnDesc)
 690  667          {
 691  668              Status = AE_NO_MEMORY;
 692  669              goto Cleanup;
 693  670          }
 694  671  
 695  672          /*
↓ open down ↓ 42 lines elided ↑ open up ↑
 738  715  
 739  716          AcpiUtRemoveReference (TempDesc);
 740  717  
 741  718          /*
 742  719           * Store the result back (indirectly) through the original
 743  720           * Reference object
 744  721           */
 745  722          Status = AcpiExStore (ReturnDesc, Operand[0], WalkState);
 746  723          break;
 747  724  
 748      -
 749  725      case AML_TYPE_OP:               /* ObjectType (SourceObject) */
 750      -
 751  726          /*
 752  727           * Note: The operand is not resolved at this point because we want to
 753      -         * get the associated object, not its value.  For example, we don't
      728 +         * get the associated object, not its value. For example, we don't
 754  729           * want to resolve a FieldUnit to its value, we want the actual
 755  730           * FieldUnit object.
 756  731           */
 757  732  
 758  733          /* Get the type of the base object */
 759  734  
 760  735          Status = AcpiExResolveMultiple (WalkState, Operand[0], &Type, NULL);
 761  736          if (ACPI_FAILURE (Status))
 762  737          {
 763  738              goto Cleanup;
↓ open down ↓ 2 lines elided ↑ open up ↑
 766  741          /* Allocate a descriptor to hold the type. */
 767  742  
 768  743          ReturnDesc = AcpiUtCreateIntegerObject ((UINT64) Type);
 769  744          if (!ReturnDesc)
 770  745          {
 771  746              Status = AE_NO_MEMORY;
 772  747              goto Cleanup;
 773  748          }
 774  749          break;
 775  750  
 776      -
 777  751      case AML_SIZE_OF_OP:            /* SizeOf (SourceObject)  */
 778      -
 779  752          /*
 780  753           * Note: The operand is not resolved at this point because we want to
 781  754           * get the associated object, not its value.
 782  755           */
 783  756  
 784  757          /* Get the base object */
 785  758  
 786  759          Status = AcpiExResolveMultiple (WalkState,
 787  760                      Operand[0], &Type, &TempDesc);
 788  761          if (ACPI_FAILURE (Status))
 789  762          {
 790  763              goto Cleanup;
 791  764          }
 792  765  
 793  766          /*
 794  767           * The type of the base object must be integer, buffer, string, or
 795      -         * package.  All others are not supported.
      768 +         * package. All others are not supported.
 796  769           *
 797  770           * NOTE: Integer is not specifically supported by the ACPI spec,
 798  771           * but is supported implicitly via implicit operand conversion.
 799  772           * rather than bother with conversion, we just use the byte width
 800  773           * global (4 or 8 bytes).
 801  774           */
 802  775          switch (Type)
 803  776          {
 804  777          case ACPI_TYPE_INTEGER:
      778 +
 805  779              Value = AcpiGbl_IntegerByteWidth;
 806  780              break;
 807  781  
 808  782          case ACPI_TYPE_STRING:
      783 +
 809  784              Value = TempDesc->String.Length;
 810  785              break;
 811  786  
 812  787          case ACPI_TYPE_BUFFER:
 813  788  
 814  789              /* Buffer arguments may not be evaluated at this point */
 815  790  
 816  791              Status = AcpiDsGetBufferArguments (TempDesc);
 817  792              Value = TempDesc->Buffer.Length;
 818  793              break;
 819  794  
 820  795          case ACPI_TYPE_PACKAGE:
 821  796  
 822  797              /* Package arguments may not be evaluated at this point */
 823  798  
 824  799              Status = AcpiDsGetPackageArguments (TempDesc);
 825  800              Value = TempDesc->Package.Count;
 826  801              break;
 827  802  
 828  803          default:
      804 +
 829  805              ACPI_ERROR ((AE_INFO,
 830  806                  "Operand must be Buffer/Integer/String/Package - found type %s",
 831  807                  AcpiUtGetTypeName (Type)));
 832  808              Status = AE_AML_OPERAND_TYPE;
 833  809              goto Cleanup;
 834  810          }
 835  811  
 836  812          if (ACPI_FAILURE (Status))
 837  813          {
 838  814              goto Cleanup;
↓ open down ↓ 87 lines elided ↑ open up ↑
 926  902                      break;
 927  903  
 928  904                  default:
 929  905  
 930  906                      /* Must be an Index op - handled below */
 931  907                      break;
 932  908                  }
 933  909                  break;
 934  910  
 935  911              case ACPI_TYPE_STRING:
      912 +
 936  913                  break;
 937  914  
 938  915              default:
      916 +
 939  917                  Status = AE_AML_OPERAND_TYPE;
 940  918                  goto Cleanup;
 941  919              }
 942  920          }
 943  921  
 944  922          if (ACPI_GET_DESCRIPTOR_TYPE (Operand[0]) != ACPI_DESC_TYPE_NAMED)
 945  923          {
 946  924              if ((Operand[0])->Common.Type == ACPI_TYPE_STRING)
 947  925              {
 948  926                  /*
↓ open down ↓ 38 lines elided ↑ open up ↑
 987  965          }
 988  966          else
 989  967          {
 990  968              /*
 991  969               * This must be a reference object produced by either the
 992  970               * Index() or RefOf() operator
 993  971               */
 994  972              switch (Operand[0]->Reference.Class)
 995  973              {
 996  974              case ACPI_REFCLASS_INDEX:
 997      -
 998  975                  /*
 999  976                   * The target type for the Index operator must be
1000  977                   * either a Buffer or a Package
1001  978                   */
1002  979                  switch (Operand[0]->Reference.TargetType)
1003  980                  {
1004  981                  case ACPI_TYPE_BUFFER_FIELD:
1005  982  
1006  983                      TempDesc = Operand[0]->Reference.Object;
1007  984  
↓ open down ↓ 11 lines elided ↑ open up ↑
1019  996                       */
1020  997                      ReturnDesc = AcpiUtCreateIntegerObject ((UINT64)
1021  998                          TempDesc->Buffer.Pointer[Operand[0]->Reference.Value]);
1022  999                      if (!ReturnDesc)
1023 1000                      {
1024 1001                          Status = AE_NO_MEMORY;
1025 1002                          goto Cleanup;
1026 1003                      }
1027 1004                      break;
1028 1005  
1029      -
1030 1006                  case ACPI_TYPE_PACKAGE:
1031      -
1032 1007                      /*
1033      -                     * Return the referenced element of the package.  We must
     1008 +                     * Return the referenced element of the package. We must
1034 1009                       * add another reference to the referenced object, however.
1035 1010                       */
1036 1011                      ReturnDesc = *(Operand[0]->Reference.Where);
1037      -                    if (ReturnDesc)
     1012 +                    if (!ReturnDesc)
1038 1013                      {
1039      -                        AcpiUtAddReference (ReturnDesc);
     1014 +                        /*
     1015 +                         * Element is NULL, do not allow the dereference.
     1016 +                         * This provides compatibility with other ACPI
     1017 +                         * implementations.
     1018 +                         */
     1019 +                        return_ACPI_STATUS (AE_AML_UNINITIALIZED_ELEMENT);
1040 1020                      }
     1021 +
     1022 +                    AcpiUtAddReference (ReturnDesc);
1041 1023                      break;
1042 1024  
1043      -
1044 1025                  default:
1045 1026  
1046 1027                      ACPI_ERROR ((AE_INFO,
1047 1028                          "Unknown Index TargetType 0x%X in reference object %p",
1048 1029                          Operand[0]->Reference.TargetType, Operand[0]));
1049 1030                      Status = AE_AML_OPERAND_TYPE;
1050 1031                      goto Cleanup;
1051 1032                  }
1052 1033                  break;
1053 1034  
1054      -
1055 1035              case ACPI_REFCLASS_REFOF:
1056 1036  
1057 1037                  ReturnDesc = Operand[0]->Reference.Object;
1058 1038  
1059 1039                  if (ACPI_GET_DESCRIPTOR_TYPE (ReturnDesc) ==
1060      -                        ACPI_DESC_TYPE_NAMED)
     1040 +                    ACPI_DESC_TYPE_NAMED)
1061 1041                  {
1062 1042                      ReturnDesc = AcpiNsGetAttachedObject (
1063      -                                    (ACPI_NAMESPACE_NODE *) ReturnDesc);
1064      -                }
     1043 +                        (ACPI_NAMESPACE_NODE *) ReturnDesc);
     1044 +                    if (!ReturnDesc)
     1045 +                    {
     1046 +                        break;
     1047 +                    }
1065 1048  
1066      -                /* Add another reference to the object! */
     1049 +                   /*
     1050 +                    * June 2013:
     1051 +                    * BufferFields/FieldUnits require additional resolution
     1052 +                    */
     1053 +                    switch (ReturnDesc->Common.Type)
     1054 +                    {
     1055 +                    case ACPI_TYPE_BUFFER_FIELD:
     1056 +                    case ACPI_TYPE_LOCAL_REGION_FIELD:
     1057 +                    case ACPI_TYPE_LOCAL_BANK_FIELD:
     1058 +                    case ACPI_TYPE_LOCAL_INDEX_FIELD:
1067 1059  
1068      -                AcpiUtAddReference (ReturnDesc);
1069      -                break;
     1060 +                        Status = AcpiExReadDataFromField (WalkState,
     1061 +                            ReturnDesc, &TempDesc);
     1062 +                        if (ACPI_FAILURE (Status))
     1063 +                        {
     1064 +                            goto Cleanup;
     1065 +                        }
1070 1066  
     1067 +                        ReturnDesc = TempDesc;
     1068 +                        break;
1071 1069  
     1070 +                    default:
     1071 +
     1072 +                        /* Add another reference to the object */
     1073 +
     1074 +                        AcpiUtAddReference (ReturnDesc);
     1075 +                        break;
     1076 +                    }
     1077 +                }
     1078 +                break;
     1079 +
1072 1080              default:
     1081 +
1073 1082                  ACPI_ERROR ((AE_INFO,
1074 1083                      "Unknown class in reference(%p) - 0x%2.2X",
1075 1084                      Operand[0], Operand[0]->Reference.Class));
1076 1085  
1077 1086                  Status = AE_TYPE;
1078 1087                  goto Cleanup;
1079 1088              }
1080 1089          }
1081 1090          break;
1082 1091  
1083      -
1084 1092      default:
1085 1093  
1086 1094          ACPI_ERROR ((AE_INFO, "Unknown AML opcode 0x%X",
1087 1095              WalkState->Opcode));
1088 1096          Status = AE_AML_BAD_OPCODE;
1089 1097          goto Cleanup;
1090 1098      }
1091 1099  
1092 1100  
1093 1101  Cleanup:
↓ open down ↓ 7 lines elided ↑ open up ↑
1101 1109  
1102 1110      /* Save return object on success */
1103 1111  
1104 1112      else
1105 1113      {
1106 1114          WalkState->ResultObj = ReturnDesc;
1107 1115      }
1108 1116  
1109 1117      return_ACPI_STATUS (Status);
1110 1118  }
1111      -
    
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX