drivers/acpi/interpreter/amresnte.c

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: amresnte - AML Interpreter object resolution
   5  *              $Revision: 25 $
   6  *
   7  *****************************************************************************/
   8
   9 /*
  10  *  Copyright (C) 2000 R. Byron Moore
  11  *
  12  *  This program is free software; you can redistribute it and/or modify
  13  *  it under the terms of the GNU General Public License as published by
  14  *  the Free Software Foundation; either version 2 of the License, or
  15  *  (at your option) any later version.
  16  *
  17  *  This program is distributed in the hope that it will be useful,
  18  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  *  GNU General Public License for more details.
  21  *
  22  *  You should have received a copy of the GNU General Public License
  23  *  along with this program; if not, write to the Free Software
  24  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  25  */
  26
  27
  28 #include "acpi.h"
  29 #include "amlcode.h"
  30 #include "acparser.h"
  31 #include "acdispat.h"
  32 #include "acinterp.h"
  33 #include "acnamesp.h"
  34 #include "actables.h"
  35 #include "acevents.h"
  36
  37
  38 #define _COMPONENT          INTERPRETER
  39          MODULE_NAME         ("amresnte")
  40
  41
  42 /*******************************************************************************
  43  *
  44  * FUNCTION:    Acpi_aml_resolve_node_to_value
  45  *
  46  * PARAMETERS:  Stack_ptr       - Pointer to a location on a stack that contains
  47  *                                a pointer to an Node
  48  *
  49  * RETURN:      Status
  50  *
  51  * DESCRIPTION: Resolve a ACPI_NAMESPACE_NODE (Node,
  52  *              A.K.A. a "direct name pointer")
  53  *
  54  * Note: for some of the data types, the pointer attached to the Node
  55  * can be either a pointer to an actual internal object or a pointer into the
  56  * AML stream itself.  These types are currently:
  57  *
  58  *      ACPI_TYPE_NUMBER
  59  *      ACPI_TYPE_STRING
  60  *      ACPI_TYPE_BUFFER
  61  *      ACPI_TYPE_MUTEX
  62  *      ACPI_TYPE_PACKAGE
  63  *
  64  ******************************************************************************/
  65
  66 ACPI_STATUS
  67 acpi_aml_resolve_node_to_value (
  68         ACPI_NAMESPACE_NODE     **stack_ptr,
  69         ACPI_WALK_STATE         *walk_state)
  70
  71 {
  72         ACPI_STATUS             status = AE_OK;
  73         ACPI_OPERAND_OBJECT     *val_desc = NULL;
  74         ACPI_OPERAND_OBJECT     *obj_desc = NULL;
  75         ACPI_NAMESPACE_NODE     *node;
  76         u8                      *aml_pointer = NULL;
  77         OBJECT_TYPE_INTERNAL    entry_type;
  78         u8                      locked;
  79         u8                      attached_aml_pointer = FALSE;
  80         u8                      aml_opcode = 0;
  81         ACPI_INTEGER            temp_val;
  82         OBJECT_TYPE_INTERNAL    object_type;
  83
  84
  85         node = *stack_ptr;
  86
  87
  88         /*
  89          * The stack pointer is a "Direct name ptr", and points to a
  90          * a ACPI_NAMESPACE_NODE (Node).  Get the pointer that is attached to
  91          * the Node.
  92          */
  93
  94         val_desc    = acpi_ns_get_attached_object ((ACPI_HANDLE) node);
  95         entry_type  = acpi_ns_get_type ((ACPI_HANDLE) node);
  96
  97         /*
  98          * The Val_desc attached to the Node can be either:
  99          * 1) An internal ACPI object
 100          * 2) A pointer into the AML stream (into one of the ACPI system tables)
 101          */
 102
 103         if (acpi_tb_system_table_pointer (val_desc)) {
 104                 attached_aml_pointer = TRUE;
 105                 aml_opcode = *((u8 *) val_desc);
 106                 aml_pointer = ((u8 *) val_desc) + 1;
 107
 108         }
 109
 110
 111         /*
 112          * Several Entry_types do not require further processing, so
 113          *  we will return immediately
 114          */
 115         /* Devices rarely have an attached object, return the Node
 116          *  and Method locals and arguments have a pseudo-Node
 117          */
 118         if (entry_type == ACPI_TYPE_DEVICE ||
 119                 (node->flags & (ANOBJ_METHOD_ARG | ANOBJ_METHOD_LOCAL)))
 120         {
 121                 return (AE_OK);
 122         }
 123
 124         if (!val_desc) {
 125                 return (AE_AML_NO_OPERAND);
 126         }
 127
 128         /*
 129          * Action is based on the type of the Node, which indicates the type
 130          * of the attached object or pointer
 131          */
 132         switch (entry_type)
 133         {
 134
 135         case ACPI_TYPE_PACKAGE:
 136
 137                 if (attached_aml_pointer) {
 138                         /*
 139                          * This means that the package initialization is not parsed
 140                          * -- should not happen
 141                          */
 142                         return (AE_NOT_IMPLEMENTED);
 143                 }
 144
 145                 /* Val_desc is an internal object in all cases by the time we get here */
 146
 147                 if (ACPI_TYPE_PACKAGE != val_desc->common.type) {
 148                         return (AE_AML_OPERAND_TYPE);
 149                 }
 150
 151                 /* Return an additional reference to the object */
 152
 153                 obj_desc = val_desc;
 154                 acpi_cm_add_reference (obj_desc);
 155                 break;
 156
 157
 158         case ACPI_TYPE_BUFFER:
 159
 160                 if (attached_aml_pointer) {
 161                         /*
 162                          * This means that the buffer initialization is not parsed
 163                          * -- should not happen
 164                          */
 165                         return (AE_NOT_IMPLEMENTED);
 166                 }
 167
 168                 /* Val_desc is an internal object in all cases by the time we get here */
 169
 170                 if (ACPI_TYPE_BUFFER != val_desc->common.type) {
 171                         return (AE_AML_OPERAND_TYPE);
 172                 }
 173
 174                 /* Return an additional reference to the object */
 175
 176                 obj_desc = val_desc;
 177                 acpi_cm_add_reference (obj_desc);
 178                 break;
 179
 180
 181         case ACPI_TYPE_STRING:
 182
 183                 if (attached_aml_pointer) {
 184                         /* Allocate a new string object */
 185
 186                         obj_desc = acpi_cm_create_internal_object (ACPI_TYPE_STRING);
 187                         if (!obj_desc) {
 188                                 return (AE_NO_MEMORY);
 189                         }
 190
 191                         /* Init the internal object */
 192
 193                         obj_desc->string.pointer = (NATIVE_CHAR *) aml_pointer;
 194                         obj_desc->string.length = STRLEN (obj_desc->string.pointer);
 195                 }
 196
 197                 else {
 198                         if (ACPI_TYPE_STRING != val_desc->common.type) {
 199                                 return (AE_AML_OPERAND_TYPE);
 200                         }
 201
 202                         /* Return an additional reference to the object */
 203
 204                         obj_desc = val_desc;
 205                         acpi_cm_add_reference (obj_desc);
 206                 }
 207
 208                 break;
 209
 210
 211         case ACPI_TYPE_NUMBER:
 212
 213                 /*
 214                  * The Node has an attached internal object, make sure that it's a
 215                  * number
 216                  */
 217
 218                 if (ACPI_TYPE_NUMBER != val_desc->common.type) {
 219                         return (AE_AML_OPERAND_TYPE);
 220                 }
 221
 222                 /* Return an additional reference to the object */
 223
 224                 obj_desc = val_desc;
 225                 acpi_cm_add_reference (obj_desc);
 226                 break;
 227
 228
 229         case INTERNAL_TYPE_DEF_FIELD:
 230
 231                 /*
 232                  * TBD: [Investigate] Is this the correct solution?
 233                  *
 234                  * This section was extended to convert to generic buffer if
 235                  *  the return length is greater than 32 bits, but still allows
 236                  *  for returning a type Number for smaller values because the
 237                  *  caller can then apply arithmetic operators on those fields.
 238                  *
 239                  * XXX - Implementation limitation: Fields are implemented as type
 240                  * XXX - Number, but they really are supposed to be type Buffer.
 241                  * XXX - The two are interchangeable only for lengths <= 32 bits.
 242                  */
 243                 if(val_desc->field.length > 32) {
 244                         object_type = ACPI_TYPE_BUFFER;
 245                 }
 246                 else {
 247                         object_type = ACPI_TYPE_NUMBER;
 248                 }
 249
 250                 /*
 251                  * Create the destination buffer object and the buffer space.
 252                  */
 253                 obj_desc = acpi_cm_create_internal_object (object_type);
 254                 if (!obj_desc) {
 255                         return (AE_NO_MEMORY);
 256                 }
 257
 258                 /*
 259                  * Fill in the object specific details
 260                  */
 261                 if (ACPI_TYPE_BUFFER == object_type) {
 262                         obj_desc->buffer.pointer = acpi_cm_callocate (val_desc->field.length);
 263                         if (!obj_desc->buffer.pointer) {
 264                                 acpi_cm_remove_reference(obj_desc);
 265                                 return (AE_NO_MEMORY);
 266                         }
 267
 268                         obj_desc->buffer.length = val_desc->field.length;
 269
 270                         status = acpi_aml_access_named_field (ACPI_READ, (ACPI_HANDLE) node,
 271                                           obj_desc->buffer.pointer, obj_desc->buffer.length);
 272
 273                         if (ACPI_FAILURE (status)) {
 274                                 return (status);
 275                         }
 276                 }
 277                 else {
 278                         status = acpi_aml_access_named_field (ACPI_READ, (ACPI_HANDLE) node,
 279                                           &temp_val, sizeof (temp_val));
 280
 281                         if (ACPI_FAILURE (status)) {
 282                                 return (status);
 283                         }
 284
 285                         obj_desc->number.value = temp_val;
 286                 }
 287
 288
 289                 break;
 290
 291
 292         case INTERNAL_TYPE_BANK_FIELD:
 293
 294                 if (attached_aml_pointer) {
 295                         return (AE_AML_OPERAND_TYPE);
 296                 }
 297
 298                 if (INTERNAL_TYPE_BANK_FIELD != val_desc->common.type) {
 299                         return (AE_AML_OPERAND_TYPE);
 300                 }
 301
 302
 303                 /* Get the global lock if needed */
 304
 305                 obj_desc = (ACPI_OPERAND_OBJECT *) *stack_ptr;
 306                 locked = acpi_aml_acquire_global_lock (obj_desc->field_unit.lock_rule);
 307
 308                 /* Set Index value to select proper Data register */
 309                 /* perform the update */
 310
 311                 status = acpi_aml_access_named_field (ACPI_WRITE,
 312                                  val_desc->bank_field.bank_select, &val_desc->bank_field.value,
 313                                  sizeof (val_desc->bank_field.value));
 314
 315                 acpi_aml_release_global_lock (locked);
 316
 317
 318                 if (ACPI_FAILURE (status)) {
 319                         return (status);
 320                 }
 321
 322                 /* Read Data value */
 323
 324                 status = acpi_aml_access_named_field (ACPI_READ,
 325                                  (ACPI_HANDLE) val_desc->bank_field.container,
 326                                  &temp_val, sizeof (temp_val));
 327                 if (ACPI_FAILURE (status)) {
 328                         return (status);
 329                 }
 330
 331                 /* Create an object for the result */
 332
 333                 obj_desc = acpi_cm_create_internal_object (ACPI_TYPE_NUMBER);
 334                 if (!obj_desc) {
 335                         return (AE_NO_MEMORY);
 336                 }
 337
 338                 obj_desc->number.value = temp_val;
 339                 break;
 340
 341
 342         case INTERNAL_TYPE_INDEX_FIELD:
 343
 344                 if (attached_aml_pointer) {
 345                         return (AE_AML_OPERAND_TYPE);
 346                 }
 347
 348                 if (INTERNAL_TYPE_INDEX_FIELD != val_desc->common.type) {
 349                         return (AE_AML_OPERAND_TYPE);
 350                 }
 351
 352
 353                 /* Set Index value to select proper Data register */
 354                 /* Get the global lock if needed */
 355
 356                 obj_desc = (ACPI_OPERAND_OBJECT *) *stack_ptr;
 357                 locked = acpi_aml_acquire_global_lock (obj_desc->field_unit.lock_rule);
 358
 359                 /* Perform the update */
 360
 361                 status = acpi_aml_access_named_field (ACPI_WRITE,
 362                                   val_desc->index_field.index, &val_desc->index_field.value,
 363                                   sizeof (val_desc->index_field.value));
 364
 365                 acpi_aml_release_global_lock (locked);
 366
 367                 if (ACPI_FAILURE (status)) {
 368                         return (status);
 369                 }
 370
 371                 /* Read Data value */
 372
 373                 status = acpi_aml_access_named_field (ACPI_READ, val_desc->index_field.data,
 374                                   &temp_val, sizeof (temp_val));
 375                 if (ACPI_FAILURE (status)) {
 376                         return (status);
 377                 }
 378
 379                 /* Create an object for the result */
 380
 381                 obj_desc = acpi_cm_create_internal_object (ACPI_TYPE_NUMBER);
 382                 if (!obj_desc) {
 383                         return (AE_NO_MEMORY);
 384                 }
 385
 386                 obj_desc->number.value = temp_val;
 387                 break;
 388
 389
 390         case ACPI_TYPE_FIELD_UNIT:
 391
 392                 if (attached_aml_pointer) {
 393                         return (AE_AML_OPERAND_TYPE);
 394                 }
 395
 396                 if (val_desc->common.type != (u8) entry_type) {
 397                         return (AE_AML_OPERAND_TYPE);
 398                         break;
 399                 }
 400
 401                 /* Create object for result */
 402
 403                 obj_desc = acpi_cm_create_internal_object (ACPI_TYPE_ANY);
 404                 if (!obj_desc) {
 405                         return (AE_NO_MEMORY);
 406                 }
 407
 408                 status = acpi_aml_get_field_unit_value (val_desc, obj_desc);
 409                 if (ACPI_FAILURE (status)) {
 410                         acpi_cm_remove_reference (obj_desc);
 411                         return (status);
 412                 }
 413
 414                 break;
 415
 416
 417         /*
 418          * For these objects, just return the object attached to the Node
 419          */
 420
 421         case ACPI_TYPE_MUTEX:
 422         case ACPI_TYPE_METHOD:
 423         case ACPI_TYPE_POWER:
 424         case ACPI_TYPE_PROCESSOR:
 425         case ACPI_TYPE_THERMAL:
 426         case ACPI_TYPE_EVENT:
 427         case ACPI_TYPE_REGION:
 428
 429
 430                 /* Return an additional reference to the object */
 431
 432                 obj_desc = val_desc;
 433                 acpi_cm_add_reference (obj_desc);
 434                 break;
 435
 436
 437         /* TYPE_Any is untyped, and thus there is no object associated with it */
 438
 439         case ACPI_TYPE_ANY:
 440
 441                 return (AE_AML_OPERAND_TYPE);  /* Cannot be AE_TYPE */
 442                 break;
 443
 444
 445         /*
 446          * The only named references allowed are named constants
 447          *
 448          * e.g.     Name (\OSFL, Ones)
 449          */
 450         case INTERNAL_TYPE_REFERENCE:
 451
 452                 switch (val_desc->reference.op_code)
 453                 {
 454
 455                 case AML_ZERO_OP:
 456
 457                         temp_val = 0;
 458                         break;
 459
 460
 461                 case AML_ONE_OP:
 462
 463                         temp_val = 1;
 464                         break;
 465
 466
 467                 case AML_ONES_OP:
 468
 469                         temp_val = ACPI_INTEGER_MAX;
 470                         break;
 471
 472
 473                 default:
 474
 475                         return (AE_AML_BAD_OPCODE);
 476                 }
 477
 478                 /* Create object for result */
 479
 480                 obj_desc = acpi_cm_create_internal_object (ACPI_TYPE_NUMBER);
 481                 if (!obj_desc) {
 482                         return (AE_NO_MEMORY);
 483                 }
 484
 485                 obj_desc->number.value = temp_val;
 486
 487                 /* Truncate value if we are executing from a 32-bit ACPI table */
 488
 489                 acpi_aml_truncate_for32bit_table (obj_desc, walk_state);
 490                 break;
 491
 492
 493         /* Default case is for unknown types */
 494
 495         default:
 496
 497                 return (AE_AML_OPERAND_TYPE);
 498
 499         } /* switch (Entry_type) */
 500
 501
 502         /* Put the object descriptor on the stack */
 503
 504         *stack_ptr = (void *) obj_desc;
 505
 506         return (status);
 507 }
 508
 509