drivers/acpi/dispatcher/dsfield.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsfield - Dispatcher field routines
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2005, R. Byron Moore
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #include <acpi/acpi.h>
  46 #include <acpi/amlcode.h>
  47 #include <acpi/acdispat.h>
  48 #include <acpi/acinterp.h>
  49 #include <acpi/acnamesp.h>
  50 #include <acpi/acparser.h>
  51
  52
  53 #define _COMPONENT          ACPI_DISPATCHER
  54          ACPI_MODULE_NAME    ("dsfield")
  55
  56 /* Local prototypes */
  57
  58 static acpi_status
  59 acpi_ds_get_field_names (
  60         struct acpi_create_field_info   *info,
  61         struct acpi_walk_state          *walk_state,
  62         union acpi_parse_object         *arg);
  63
  64
  65 /*******************************************************************************
  66  *
  67  * FUNCTION:    acpi_ds_create_buffer_field
  68  *
  69  * PARAMETERS:  Op                  - Current parse op (create_xXField)
  70  *              walk_state          - Current state
  71  *
  72  * RETURN:      Status
  73  *
  74  * DESCRIPTION: Execute the create_field operators:
  75  *              create_bit_field_op,
  76  *              create_byte_field_op,
  77  *              create_word_field_op,
  78  *              create_dword_field_op,
  79  *              create_qword_field_op,
  80  *              create_field_op     (all of which define a field in a buffer)
  81  *
  82  ******************************************************************************/
  83
  84 acpi_status
  85 acpi_ds_create_buffer_field (
  86         union acpi_parse_object         *op,
  87         struct acpi_walk_state          *walk_state)
  88 {
  89         union acpi_parse_object         *arg;
  90         struct acpi_namespace_node      *node;
  91         acpi_status                     status;
  92         union acpi_operand_object       *obj_desc;
  93         union acpi_operand_object       *second_desc = NULL;
  94         u32                             flags;
  95
  96
  97         ACPI_FUNCTION_TRACE ("ds_create_buffer_field");
  98
  99
 100         /* Get the name_string argument */
 101
 102         if (op->common.aml_opcode == AML_CREATE_FIELD_OP) {
 103                 arg = acpi_ps_get_arg (op, 3);
 104         }
 105         else {
 106                 /* Create Bit/Byte/Word/Dword field */
 107
 108                 arg = acpi_ps_get_arg (op, 2);
 109         }
 110
 111         if (!arg) {
 112                 return_ACPI_STATUS (AE_AML_NO_OPERAND);
 113         }
 114
 115         if (walk_state->deferred_node) {
 116                 node = walk_state->deferred_node;
 117                 status = AE_OK;
 118         }
 119         else {
 120                 /*
 121                  * During the load phase, we want to enter the name of the field into
 122                  * the namespace.  During the execute phase (when we evaluate the size
 123                  * operand), we want to lookup the name
 124                  */
 125                 if (walk_state->parse_flags & ACPI_PARSE_EXECUTE) {
 126                         flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE;
 127                 }
 128                 else {
 129                         flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 130                                         ACPI_NS_ERROR_IF_FOUND;
 131                 }
 132
 133                 /*
 134                  * Enter the name_string into the namespace
 135                  */
 136                 status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.string,
 137                                  ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS1,
 138                                  flags, walk_state, &(node));
 139                 if (ACPI_FAILURE (status)) {
 140                         ACPI_REPORT_NSERROR (arg->common.value.string, status);
 141                         return_ACPI_STATUS (status);
 142                 }
 143         }
 144
 145         /* We could put the returned object (Node) on the object stack for later,
 146          * but for now, we will put it in the "op" object that the parser uses,
 147          * so we can get it again at the end of this scope
 148          */
 149         op->common.node = node;
 150
 151         /*
 152          * If there is no object attached to the node, this node was just created
 153          * and we need to create the field object.  Otherwise, this was a lookup
 154          * of an existing node and we don't want to create the field object again.
 155          */
 156         obj_desc = acpi_ns_get_attached_object (node);
 157         if (obj_desc) {
 158                 return_ACPI_STATUS (AE_OK);
 159         }
 160
 161         /*
 162          * The Field definition is not fully parsed at this time.
 163          * (We must save the address of the AML for the buffer and index operands)
 164          */
 165
 166         /* Create the buffer field object */
 167
 168         obj_desc = acpi_ut_create_internal_object (ACPI_TYPE_BUFFER_FIELD);
 169         if (!obj_desc) {
 170                 status = AE_NO_MEMORY;
 171                 goto cleanup;
 172         }
 173
 174         /*
 175          * Remember location in AML stream of the field unit
 176          * opcode and operands -- since the buffer and index
 177          * operands must be evaluated.
 178          */
 179         second_desc                 = obj_desc->common.next_object;
 180         second_desc->extra.aml_start = op->named.data;
 181         second_desc->extra.aml_length = op->named.length;
 182         obj_desc->buffer_field.node = node;
 183
 184         /* Attach constructed field descriptors to parent node */
 185
 186         status = acpi_ns_attach_object (node, obj_desc, ACPI_TYPE_BUFFER_FIELD);
 187         if (ACPI_FAILURE (status)) {
 188                 goto cleanup;
 189         }
 190
 191
 192 cleanup:
 193
 194         /* Remove local reference to the object */
 195
 196         acpi_ut_remove_reference (obj_desc);
 197         return_ACPI_STATUS (status);
 198 }
 199
 200
 201 /*******************************************************************************
 202  *
 203  * FUNCTION:    acpi_ds_get_field_names
 204  *
 205  * PARAMETERS:  Info            - create_field info structure
 206  *  `           walk_state      - Current method state
 207  *              Arg             - First parser arg for the field name list
 208  *
 209  * RETURN:      Status
 210  *
 211  * DESCRIPTION: Process all named fields in a field declaration.  Names are
 212  *              entered into the namespace.
 213  *
 214  ******************************************************************************/
 215
 216 static acpi_status
 217 acpi_ds_get_field_names (
 218         struct acpi_create_field_info   *info,
 219         struct acpi_walk_state          *walk_state,
 220         union acpi_parse_object         *arg)
 221 {
 222         acpi_status                     status;
 223         acpi_integer                    position;
 224
 225
 226         ACPI_FUNCTION_TRACE_PTR ("ds_get_field_names", info);
 227
 228
 229         /* First field starts at bit zero */
 230
 231         info->field_bit_position = 0;
 232
 233         /* Process all elements in the field list (of parse nodes) */
 234
 235         while (arg) {
 236                 /*
 237                  * Three types of field elements are handled:
 238                  * 1) Offset - specifies a bit offset
 239                  * 2) access_as - changes the access mode
 240                  * 3) Name - Enters a new named field into the namespace
 241                  */
 242                 switch (arg->common.aml_opcode) {
 243                 case AML_INT_RESERVEDFIELD_OP:
 244
 245                         position = (acpi_integer) info->field_bit_position
 246                                          + (acpi_integer) arg->common.value.size;
 247
 248                         if (position > ACPI_UINT32_MAX) {
 249                                 ACPI_REPORT_ERROR ((
 250                                         "Bit offset within field too large (> 0xFFFFFFFF)\n"));
 251                                 return_ACPI_STATUS (AE_SUPPORT);
 252                         }
 253
 254                         info->field_bit_position = (u32) position;
 255                         break;
 256
 257
 258                 case AML_INT_ACCESSFIELD_OP:
 259
 260                         /*
 261                          * Get a new access_type and access_attribute -- to be used for all
 262                          * field units that follow, until field end or another access_as
 263                          * keyword.
 264                          *
 265                          * In field_flags, preserve the flag bits other than the
 266                          * ACCESS_TYPE bits
 267                          */
 268                         info->field_flags = (u8)
 269                                 ((info->field_flags & ~(AML_FIELD_ACCESS_TYPE_MASK)) |
 270                                 ((u8) ((u32) arg->common.value.integer >> 8)));
 271
 272                         info->attribute = (u8) (arg->common.value.integer);
 273                         break;
 274
 275
 276                 case AML_INT_NAMEDFIELD_OP:
 277
 278                         /* Lookup the name */
 279
 280                         status = acpi_ns_lookup (walk_state->scope_info,
 281                                           (char *) &arg->named.name,
 282                                           info->field_type, ACPI_IMODE_EXECUTE,
 283                                           ACPI_NS_DONT_OPEN_SCOPE,
 284                                           walk_state, &info->field_node);
 285                         if (ACPI_FAILURE (status)) {
 286                                 ACPI_REPORT_NSERROR ((char *) &arg->named.name, status);
 287                                 if (status != AE_ALREADY_EXISTS) {
 288                                         return_ACPI_STATUS (status);
 289                                 }
 290
 291                                 /* Already exists, ignore error */
 292                         }
 293                         else {
 294                                 arg->common.node = info->field_node;
 295                                 info->field_bit_length = arg->common.value.size;
 296
 297                                 /* Create and initialize an object for the new Field Node */
 298
 299                                 status = acpi_ex_prep_field_value (info);
 300                                 if (ACPI_FAILURE (status)) {
 301                                         return_ACPI_STATUS (status);
 302                                 }
 303                         }
 304
 305                         /* Keep track of bit position for the next field */
 306
 307                         position = (acpi_integer) info->field_bit_position
 308                                          + (acpi_integer) arg->common.value.size;
 309
 310                         if (position > ACPI_UINT32_MAX) {
 311                                 ACPI_REPORT_ERROR ((
 312                                         "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)\n",
 313                                         (char *) &info->field_node->name));
 314                                 return_ACPI_STATUS (AE_SUPPORT);
 315                         }
 316
 317                         info->field_bit_position += info->field_bit_length;
 318                         break;
 319
 320
 321                 default:
 322
 323                         ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
 324                                 "Invalid opcode in field list: %X\n",
 325                                 arg->common.aml_opcode));
 326                         return_ACPI_STATUS (AE_AML_BAD_OPCODE);
 327                 }
 328
 329                 arg = arg->common.next;
 330         }
 331
 332         return_ACPI_STATUS (AE_OK);
 333 }
 334
 335
 336 /*******************************************************************************
 337  *
 338  * FUNCTION:    acpi_ds_create_field
 339  *
 340  * PARAMETERS:  Op              - Op containing the Field definition and args
 341  *              region_node     - Object for the containing Operation Region
 342  *  `           walk_state      - Current method state
 343  *
 344  * RETURN:      Status
 345  *
 346  * DESCRIPTION: Create a new field in the specified operation region
 347  *
 348  ******************************************************************************/
 349
 350 acpi_status
 351 acpi_ds_create_field (
 352         union acpi_parse_object         *op,
 353         struct acpi_namespace_node      *region_node,
 354         struct acpi_walk_state          *walk_state)
 355 {
 356         acpi_status                     status;
 357         union acpi_parse_object         *arg;
 358         struct acpi_create_field_info   info;
 359
 360
 361         ACPI_FUNCTION_TRACE_PTR ("ds_create_field", op);
 362
 363
 364         /* First arg is the name of the parent op_region (must already exist) */
 365
 366         arg = op->common.value.arg;
 367         if (!region_node) {
 368                 status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.name,
 369                                   ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE,
 370                                   ACPI_NS_SEARCH_PARENT, walk_state, &region_node);
 371                 if (ACPI_FAILURE (status)) {
 372                         ACPI_REPORT_NSERROR (arg->common.value.name, status);
 373                         return_ACPI_STATUS (status);
 374                 }
 375         }
 376
 377         /* Second arg is the field flags */
 378
 379         arg = arg->common.next;
 380         info.field_flags = (u8) arg->common.value.integer;
 381         info.attribute = 0;
 382
 383         /* Each remaining arg is a Named Field */
 384
 385         info.field_type = ACPI_TYPE_LOCAL_REGION_FIELD;
 386         info.region_node = region_node;
 387
 388         status = acpi_ds_get_field_names (&info, walk_state, arg->common.next);
 389
 390         return_ACPI_STATUS (status);
 391 }
 392
 393
 394 /*******************************************************************************
 395  *
 396  * FUNCTION:    acpi_ds_init_field_objects
 397  *
 398  * PARAMETERS:  Op              - Op containing the Field definition and args
 399  *  `           walk_state      - Current method state
 400  *
 401  * RETURN:      Status
 402  *
 403  * DESCRIPTION: For each "Field Unit" name in the argument list that is
 404  *              part of the field declaration, enter the name into the
 405  *              namespace.
 406  *
 407  ******************************************************************************/
 408
 409 acpi_status
 410 acpi_ds_init_field_objects (
 411         union acpi_parse_object         *op,
 412         struct acpi_walk_state          *walk_state)
 413 {
 414         acpi_status                     status;
 415         union acpi_parse_object         *arg = NULL;
 416         struct acpi_namespace_node      *node;
 417         u8                              type = 0;
 418
 419
 420         ACPI_FUNCTION_TRACE_PTR ("ds_init_field_objects", op);
 421
 422
 423         switch (walk_state->opcode) {
 424         case AML_FIELD_OP:
 425                 arg = acpi_ps_get_arg (op, 2);
 426                 type = ACPI_TYPE_LOCAL_REGION_FIELD;
 427                 break;
 428
 429         case AML_BANK_FIELD_OP:
 430                 arg = acpi_ps_get_arg (op, 4);
 431                 type = ACPI_TYPE_LOCAL_BANK_FIELD;
 432                 break;
 433
 434         case AML_INDEX_FIELD_OP:
 435                 arg = acpi_ps_get_arg (op, 3);
 436                 type = ACPI_TYPE_LOCAL_INDEX_FIELD;
 437                 break;
 438
 439         default:
 440                 return_ACPI_STATUS (AE_BAD_PARAMETER);
 441         }
 442
 443         /*
 444          * Walk the list of entries in the field_list
 445          */
 446         while (arg) {
 447                 /* Ignore OFFSET and ACCESSAS terms here */
 448
 449                 if (arg->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
 450                         status = acpi_ns_lookup (walk_state->scope_info,
 451                                           (char *) &arg->named.name,
 452                                           type, ACPI_IMODE_LOAD_PASS1,
 453                                           ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 454                                           ACPI_NS_ERROR_IF_FOUND,
 455                                           walk_state, &node);
 456                         if (ACPI_FAILURE (status)) {
 457                                 ACPI_REPORT_NSERROR ((char *) &arg->named.name, status);
 458                                 if (status != AE_ALREADY_EXISTS) {
 459                                         return_ACPI_STATUS (status);
 460                                 }
 461
 462                                 /* Name already exists, just ignore this error */
 463
 464                                 status = AE_OK;
 465                         }
 466
 467                         arg->common.node = node;
 468                 }
 469
 470                 /* Move to next field in the list */
 471
 472                 arg = arg->common.next;
 473         }
 474
 475         return_ACPI_STATUS (AE_OK);
 476 }
 477
 478
 479 /*******************************************************************************
 480  *
 481  * FUNCTION:    acpi_ds_create_bank_field
 482  *
 483  * PARAMETERS:  Op              - Op containing the Field definition and args
 484  *              region_node     - Object for the containing Operation Region
 485  *  `           walk_state      - Current method state
 486  *
 487  * RETURN:      Status
 488  *
 489  * DESCRIPTION: Create a new bank field in the specified operation region
 490  *
 491  ******************************************************************************/
 492
 493 acpi_status
 494 acpi_ds_create_bank_field (
 495         union acpi_parse_object         *op,
 496         struct acpi_namespace_node      *region_node,
 497         struct acpi_walk_state          *walk_state)
 498 {
 499         acpi_status                     status;
 500         union acpi_parse_object         *arg;
 501         struct acpi_create_field_info   info;
 502
 503
 504         ACPI_FUNCTION_TRACE_PTR ("ds_create_bank_field", op);
 505
 506
 507         /* First arg is the name of the parent op_region (must already exist) */
 508
 509         arg = op->common.value.arg;
 510         if (!region_node) {
 511                 status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.name,
 512                                   ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE,
 513                                   ACPI_NS_SEARCH_PARENT, walk_state, &region_node);
 514                 if (ACPI_FAILURE (status)) {
 515                         ACPI_REPORT_NSERROR (arg->common.value.name, status);
 516                         return_ACPI_STATUS (status);
 517                 }
 518         }
 519
 520         /* Second arg is the Bank Register (Field) (must already exist) */
 521
 522         arg = arg->common.next;
 523         status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.string,
 524                           ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 525                           ACPI_NS_SEARCH_PARENT, walk_state, &info.register_node);
 526         if (ACPI_FAILURE (status)) {
 527                 ACPI_REPORT_NSERROR (arg->common.value.string, status);
 528                 return_ACPI_STATUS (status);
 529         }
 530
 531         /* Third arg is the bank_value */
 532
 533         arg = arg->common.next;
 534         info.bank_value = (u32) arg->common.value.integer;
 535
 536         /* Fourth arg is the field flags */
 537
 538         arg = arg->common.next;
 539         info.field_flags = (u8) arg->common.value.integer;
 540
 541         /* Each remaining arg is a Named Field */
 542
 543         info.field_type = ACPI_TYPE_LOCAL_BANK_FIELD;
 544         info.region_node = region_node;
 545
 546         status = acpi_ds_get_field_names (&info, walk_state, arg->common.next);
 547
 548         return_ACPI_STATUS (status);
 549 }
 550
 551
 552 /*******************************************************************************
 553  *
 554  * FUNCTION:    acpi_ds_create_index_field
 555  *
 556  * PARAMETERS:  Op              - Op containing the Field definition and args
 557  *              region_node     - Object for the containing Operation Region
 558  *  `           walk_state      - Current method state
 559  *
 560  * RETURN:      Status
 561  *
 562  * DESCRIPTION: Create a new index field in the specified operation region
 563  *
 564  ******************************************************************************/
 565
 566 acpi_status
 567 acpi_ds_create_index_field (
 568         union acpi_parse_object         *op,
 569         struct acpi_namespace_node      *region_node,
 570         struct acpi_walk_state          *walk_state)
 571 {
 572         acpi_status                     status;
 573         union acpi_parse_object         *arg;
 574         struct acpi_create_field_info   info;
 575
 576
 577         ACPI_FUNCTION_TRACE_PTR ("ds_create_index_field", op);
 578
 579
 580         /* First arg is the name of the Index register (must already exist) */
 581
 582         arg = op->common.value.arg;
 583         status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.string,
 584                           ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 585                           ACPI_NS_SEARCH_PARENT, walk_state, &info.register_node);
 586         if (ACPI_FAILURE (status)) {
 587                 ACPI_REPORT_NSERROR (arg->common.value.string, status);
 588                 return_ACPI_STATUS (status);
 589         }
 590
 591         /* Second arg is the data register (must already exist) */
 592
 593         arg = arg->common.next;
 594         status = acpi_ns_lookup (walk_state->scope_info, arg->common.value.string,
 595                           ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 596                           ACPI_NS_SEARCH_PARENT, walk_state, &info.data_register_node);
 597         if (ACPI_FAILURE (status)) {
 598                 ACPI_REPORT_NSERROR (arg->common.value.string, status);
 599                 return_ACPI_STATUS (status);
 600         }
 601
 602         /* Next arg is the field flags */
 603
 604         arg = arg->common.next;
 605         info.field_flags = (u8) arg->common.value.integer;
 606
 607         /* Each remaining arg is a Named Field */
 608
 609         info.field_type = ACPI_TYPE_LOCAL_INDEX_FIELD;
 610         info.region_node = region_node;
 611
 612         status = acpi_ds_get_field_names (&info, walk_state, arg->common.next);
 613
 614         return_ACPI_STATUS (status);
 615 }
 616
 617