drivers/acpi/acpica/dsfield.c

   1 /******************************************************************************
   2  *
   3  * Module Name: dsfield - Dispatcher field routines
   4  *
   5  *****************************************************************************/
   6
   7 /*
   8  * Copyright (C) 2000 - 2012, 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 "amlcode.h"
  47 #include "acdispat.h"
  48 #include "acinterp.h"
  49 #include "acnamesp.h"
  50 #include "acparser.h"
  51
  52 #define _COMPONENT          ACPI_DISPATCHER
  53 ACPI_MODULE_NAME("dsfield")
  54
  55 /* Local prototypes */
  56 static acpi_status
  57 acpi_ds_get_field_names(struct acpi_create_field_info *info,
  58                         struct acpi_walk_state *walk_state,
  59                         union acpi_parse_object *arg);
  60
  61 /*******************************************************************************
  62  *
  63  * FUNCTION:    acpi_ds_create_buffer_field
  64  *
  65  * PARAMETERS:  Op                  - Current parse op (create_xXField)
  66  *              walk_state          - Current state
  67  *
  68  * RETURN:      Status
  69  *
  70  * DESCRIPTION: Execute the create_field operators:
  71  *              create_bit_field_op,
  72  *              create_byte_field_op,
  73  *              create_word_field_op,
  74  *              create_dword_field_op,
  75  *              create_qword_field_op,
  76  *              create_field_op     (all of which define a field in a buffer)
  77  *
  78  ******************************************************************************/
  79
  80 acpi_status
  81 acpi_ds_create_buffer_field(union acpi_parse_object *op,
  82                             struct acpi_walk_state *walk_state)
  83 {
  84         union acpi_parse_object *arg;
  85         struct acpi_namespace_node *node;
  86         acpi_status status;
  87         union acpi_operand_object *obj_desc;
  88         union acpi_operand_object *second_desc = NULL;
  89         u32 flags;
  90
  91         ACPI_FUNCTION_TRACE(ds_create_buffer_field);
  92
  93         /*
  94          * Get the name_string argument (name of the new buffer_field)
  95          */
  96         if (op->common.aml_opcode == AML_CREATE_FIELD_OP) {
  97
  98                 /* For create_field, name is the 4th argument */
  99
 100                 arg = acpi_ps_get_arg(op, 3);
 101         } else {
 102                 /* For all other create_xXXField operators, name is the 3rd argument */
 103
 104                 arg = acpi_ps_get_arg(op, 2);
 105         }
 106
 107         if (!arg) {
 108                 return_ACPI_STATUS(AE_AML_NO_OPERAND);
 109         }
 110
 111         if (walk_state->deferred_node) {
 112                 node = walk_state->deferred_node;
 113                 status = AE_OK;
 114         } else {
 115                 /* Execute flag should always be set when this function is entered */
 116
 117                 if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
 118                         return_ACPI_STATUS(AE_AML_INTERNAL);
 119                 }
 120
 121                 /* Creating new namespace node, should not already exist */
 122
 123                 flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 124                     ACPI_NS_ERROR_IF_FOUND;
 125
 126                 /*
 127                  * Mark node temporary if we are executing a normal control
 128                  * method. (Don't mark if this is a module-level code method)
 129                  */
 130                 if (walk_state->method_node &&
 131                     !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
 132                         flags |= ACPI_NS_TEMPORARY;
 133                 }
 134
 135                 /* Enter the name_string into the namespace */
 136
 137                 status =
 138                     acpi_ns_lookup(walk_state->scope_info,
 139                                    arg->common.value.string, ACPI_TYPE_ANY,
 140                                    ACPI_IMODE_LOAD_PASS1, flags, walk_state,
 141                                    &node);
 142                 if (ACPI_FAILURE(status)) {
 143                         ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
 144                         return_ACPI_STATUS(status);
 145                 }
 146         }
 147
 148         /*
 149          * We could put the returned object (Node) on the object stack for later,
 150          * but for now, we will put it in the "op" object that the parser uses,
 151          * so we can get it again at the end of this scope.
 152          */
 153         op->common.node = node;
 154
 155         /*
 156          * If there is no object attached to the node, this node was just created
 157          * and we need to create the field object. Otherwise, this was a lookup
 158          * of an existing node and we don't want to create the field object again.
 159          */
 160         obj_desc = acpi_ns_get_attached_object(node);
 161         if (obj_desc) {
 162                 return_ACPI_STATUS(AE_OK);
 163         }
 164
 165         /*
 166          * The Field definition is not fully parsed at this time.
 167          * (We must save the address of the AML for the buffer and index operands)
 168          */
 169
 170         /* Create the buffer field object */
 171
 172         obj_desc = acpi_ut_create_internal_object(ACPI_TYPE_BUFFER_FIELD);
 173         if (!obj_desc) {
 174                 status = AE_NO_MEMORY;
 175                 goto cleanup;
 176         }
 177
 178         /*
 179          * Remember location in AML stream of the field unit opcode and operands --
 180          * since the buffer and index operands must be evaluated.
 181          */
 182         second_desc = obj_desc->common.next_object;
 183         second_desc->extra.aml_start = op->named.data;
 184         second_desc->extra.aml_length = op->named.length;
 185         obj_desc->buffer_field.node = node;
 186
 187         /* Attach constructed field descriptors to parent node */
 188
 189         status = acpi_ns_attach_object(node, obj_desc, ACPI_TYPE_BUFFER_FIELD);
 190         if (ACPI_FAILURE(status)) {
 191                 goto cleanup;
 192         }
 193
 194       cleanup:
 195
 196         /* Remove local reference to the object */
 197
 198         acpi_ut_remove_reference(obj_desc);
 199         return_ACPI_STATUS(status);
 200 }
 201
 202 /*******************************************************************************
 203  *
 204  * FUNCTION:    acpi_ds_get_field_names
 205  *
 206  * PARAMETERS:  Info            - create_field info structure
 207  *  `           walk_state      - Current method state
 208  *              Arg             - First parser arg for the field name list
 209  *
 210  * RETURN:      Status
 211  *
 212  * DESCRIPTION: Process all named fields in a field declaration.  Names are
 213  *              entered into the namespace.
 214  *
 215  ******************************************************************************/
 216
 217 static acpi_status
 218 acpi_ds_get_field_names(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         u64 position;
 224         union acpi_parse_object *child;
 225
 226         ACPI_FUNCTION_TRACE_PTR(ds_get_field_names, info);
 227
 228         /* First field starts at bit zero */
 229
 230         info->field_bit_position = 0;
 231
 232         /* Process all elements in the field list (of parse nodes) */
 233
 234         while (arg) {
 235                 /*
 236                  * Four types of field elements are handled:
 237                  * 1) Name - Enters a new named field into the namespace
 238                  * 2) Offset - specifies a bit offset
 239                  * 3) access_as - changes the access mode/attributes
 240                  * 4) Connection - Associate a resource template with the field
 241                  */
 242                 switch (arg->common.aml_opcode) {
 243                 case AML_INT_RESERVEDFIELD_OP:
 244
 245                         position = (u64) info->field_bit_position
 246                             + (u64) arg->common.value.size;
 247
 248                         if (position > ACPI_UINT32_MAX) {
 249                                 ACPI_ERROR((AE_INFO,
 250                                             "Bit offset within field too large (> 0xFFFFFFFF)"));
 251                                 return_ACPI_STATUS(AE_SUPPORT);
 252                         }
 253
 254                         info->field_bit_position = (u32) position;
 255                         break;
 256
 257                 case AML_INT_ACCESSFIELD_OP:
 258                 case AML_INT_EXTACCESSFIELD_OP:
 259                         /*
 260                          * Get new access_type, access_attribute, and access_length fields
 261                          * -- to be used for all field units that follow, until the
 262                          * end-of-field or another access_as keyword is encountered.
 263                          * NOTE. These three bytes are encoded in the integer value
 264                          * of the parseop for convenience.
 265                          *
 266                          * In field_flags, preserve the flag bits other than the
 267                          * ACCESS_TYPE bits.
 268                          */
 269
 270                         /* access_type (byte_acc, word_acc, etc.) */
 271
 272                         info->field_flags = (u8)
 273                             ((info->
 274                               field_flags & ~(AML_FIELD_ACCESS_TYPE_MASK)) |
 275                              ((u8)((u32)(arg->common.value.integer & 0x07))));
 276
 277                         /* access_attribute (attrib_quick, attrib_byte, etc.) */
 278
 279                         info->attribute =
 280                             (u8)((arg->common.value.integer >> 8) & 0xFF);
 281
 282                         /* access_length (for serial/buffer protocols) */
 283
 284                         info->access_length =
 285                             (u8)((arg->common.value.integer >> 16) & 0xFF);
 286                         break;
 287
 288                 case AML_INT_CONNECTION_OP:
 289                         /*
 290                          * Clear any previous connection. New connection is used for all
 291                          * fields that follow, similar to access_as
 292                          */
 293                         info->resource_buffer = NULL;
 294                         info->connection_node = NULL;
 295
 296                         /*
 297                          * A Connection() is either an actual resource descriptor (buffer)
 298                          * or a named reference to a resource template
 299                          */
 300                         child = arg->common.value.arg;
 301                         if (child->common.aml_opcode == AML_INT_BYTELIST_OP) {
 302                                 info->resource_buffer = child->named.data;
 303                                 info->resource_length =
 304                                     (u16)child->named.value.integer;
 305                         } else {
 306                                 /* Lookup the Connection() namepath, it should already exist */
 307
 308                                 status = acpi_ns_lookup(walk_state->scope_info,
 309                                                         child->common.value.
 310                                                         name, ACPI_TYPE_ANY,
 311                                                         ACPI_IMODE_EXECUTE,
 312                                                         ACPI_NS_DONT_OPEN_SCOPE,
 313                                                         walk_state,
 314                                                         &info->connection_node);
 315                                 if (ACPI_FAILURE(status)) {
 316                                         ACPI_ERROR_NAMESPACE(child->common.
 317                                                              value.name,
 318                                                              status);
 319                                         return_ACPI_STATUS(status);
 320                                 }
 321                         }
 322                         break;
 323
 324                 case AML_INT_NAMEDFIELD_OP:
 325
 326                         /* Lookup the name, it should already exist */
 327
 328                         status = acpi_ns_lookup(walk_state->scope_info,
 329                                                 (char *)&arg->named.name,
 330                                                 info->field_type,
 331                                                 ACPI_IMODE_EXECUTE,
 332                                                 ACPI_NS_DONT_OPEN_SCOPE,
 333                                                 walk_state, &info->field_node);
 334                         if (ACPI_FAILURE(status)) {
 335                                 ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
 336                                                      status);
 337                                 return_ACPI_STATUS(status);
 338                         } else {
 339                                 arg->common.node = info->field_node;
 340                                 info->field_bit_length = arg->common.value.size;
 341
 342                                 /*
 343                                  * If there is no object attached to the node, this node was
 344                                  * just created and we need to create the field object.
 345                                  * Otherwise, this was a lookup of an existing node and we
 346                                  * don't want to create the field object again.
 347                                  */
 348                                 if (!acpi_ns_get_attached_object
 349                                     (info->field_node)) {
 350                                         status = acpi_ex_prep_field_value(info);
 351                                         if (ACPI_FAILURE(status)) {
 352                                                 return_ACPI_STATUS(status);
 353                                         }
 354                                 }
 355                         }
 356
 357                         /* Keep track of bit position for the next field */
 358
 359                         position = (u64) info->field_bit_position
 360                             + (u64) arg->common.value.size;
 361
 362                         if (position > ACPI_UINT32_MAX) {
 363                                 ACPI_ERROR((AE_INFO,
 364                                             "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)",
 365                                             ACPI_CAST_PTR(char,
 366                                                           &info->field_node->
 367                                                           name)));
 368                                 return_ACPI_STATUS(AE_SUPPORT);
 369                         }
 370
 371                         info->field_bit_position += info->field_bit_length;
 372                         break;
 373
 374                 default:
 375
 376                         ACPI_ERROR((AE_INFO,
 377                                     "Invalid opcode in field list: 0x%X",
 378                                     arg->common.aml_opcode));
 379                         return_ACPI_STATUS(AE_AML_BAD_OPCODE);
 380                 }
 381
 382                 arg = arg->common.next;
 383         }
 384
 385         return_ACPI_STATUS(AE_OK);
 386 }
 387
 388 /*******************************************************************************
 389  *
 390  * FUNCTION:    acpi_ds_create_field
 391  *
 392  * PARAMETERS:  Op              - Op containing the Field definition and args
 393  *              region_node     - Object for the containing Operation Region
 394  *  `           walk_state      - Current method state
 395  *
 396  * RETURN:      Status
 397  *
 398  * DESCRIPTION: Create a new field in the specified operation region
 399  *
 400  ******************************************************************************/
 401
 402 acpi_status
 403 acpi_ds_create_field(union acpi_parse_object *op,
 404                      struct acpi_namespace_node *region_node,
 405                      struct acpi_walk_state *walk_state)
 406 {
 407         acpi_status status;
 408         union acpi_parse_object *arg;
 409         struct acpi_create_field_info info;
 410
 411         ACPI_FUNCTION_TRACE_PTR(ds_create_field, op);
 412
 413         /* First arg is the name of the parent op_region (must already exist) */
 414
 415         arg = op->common.value.arg;
 416         if (!region_node) {
 417                 status =
 418                     acpi_ns_lookup(walk_state->scope_info,
 419                                    arg->common.value.name, ACPI_TYPE_REGION,
 420                                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 421                                    walk_state, &region_node);
 422                 if (ACPI_FAILURE(status)) {
 423                         ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
 424                         return_ACPI_STATUS(status);
 425                 }
 426         }
 427
 428         ACPI_MEMSET(&info, 0, sizeof(struct acpi_create_field_info));
 429
 430         /* Second arg is the field flags */
 431
 432         arg = arg->common.next;
 433         info.field_flags = (u8) arg->common.value.integer;
 434         info.attribute = 0;
 435
 436         /* Each remaining arg is a Named Field */
 437
 438         info.field_type = ACPI_TYPE_LOCAL_REGION_FIELD;
 439         info.region_node = region_node;
 440
 441         status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
 442         return_ACPI_STATUS(status);
 443 }
 444
 445 /*******************************************************************************
 446  *
 447  * FUNCTION:    acpi_ds_init_field_objects
 448  *
 449  * PARAMETERS:  Op              - Op containing the Field definition and args
 450  *  `           walk_state      - Current method state
 451  *
 452  * RETURN:      Status
 453  *
 454  * DESCRIPTION: For each "Field Unit" name in the argument list that is
 455  *              part of the field declaration, enter the name into the
 456  *              namespace.
 457  *
 458  ******************************************************************************/
 459
 460 acpi_status
 461 acpi_ds_init_field_objects(union acpi_parse_object *op,
 462                            struct acpi_walk_state *walk_state)
 463 {
 464         acpi_status status;
 465         union acpi_parse_object *arg = NULL;
 466         struct acpi_namespace_node *node;
 467         u8 type = 0;
 468         u32 flags;
 469
 470         ACPI_FUNCTION_TRACE_PTR(ds_init_field_objects, op);
 471
 472         /* Execute flag should always be set when this function is entered */
 473
 474         if (!(walk_state->parse_flags & ACPI_PARSE_EXECUTE)) {
 475                 if (walk_state->parse_flags & ACPI_PARSE_DEFERRED_OP) {
 476
 477                         /* bank_field Op is deferred, just return OK */
 478
 479                         return_ACPI_STATUS(AE_OK);
 480                 }
 481
 482                 return_ACPI_STATUS(AE_AML_INTERNAL);
 483         }
 484
 485         /*
 486          * Get the field_list argument for this opcode. This is the start of the
 487          * list of field elements.
 488          */
 489         switch (walk_state->opcode) {
 490         case AML_FIELD_OP:
 491                 arg = acpi_ps_get_arg(op, 2);
 492                 type = ACPI_TYPE_LOCAL_REGION_FIELD;
 493                 break;
 494
 495         case AML_BANK_FIELD_OP:
 496                 arg = acpi_ps_get_arg(op, 4);
 497                 type = ACPI_TYPE_LOCAL_BANK_FIELD;
 498                 break;
 499
 500         case AML_INDEX_FIELD_OP:
 501                 arg = acpi_ps_get_arg(op, 3);
 502                 type = ACPI_TYPE_LOCAL_INDEX_FIELD;
 503                 break;
 504
 505         default:
 506                 return_ACPI_STATUS(AE_BAD_PARAMETER);
 507         }
 508
 509         /* Creating new namespace node(s), should not already exist */
 510
 511         flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE |
 512             ACPI_NS_ERROR_IF_FOUND;
 513
 514         /*
 515          * Mark node(s) temporary if we are executing a normal control
 516          * method. (Don't mark if this is a module-level code method)
 517          */
 518         if (walk_state->method_node &&
 519             !(walk_state->parse_flags & ACPI_PARSE_MODULE_LEVEL)) {
 520                 flags |= ACPI_NS_TEMPORARY;
 521         }
 522
 523         /*
 524          * Walk the list of entries in the field_list
 525          * Note: field_list can be of zero length. In this case, Arg will be NULL.
 526          */
 527         while (arg) {
 528                 /*
 529                  * Ignore OFFSET/ACCESSAS/CONNECTION terms here; we are only interested
 530                  * in the field names in order to enter them into the namespace.
 531                  */
 532                 if (arg->common.aml_opcode == AML_INT_NAMEDFIELD_OP) {
 533                         status = acpi_ns_lookup(walk_state->scope_info,
 534                                                 (char *)&arg->named.name, type,
 535                                                 ACPI_IMODE_LOAD_PASS1, flags,
 536                                                 walk_state, &node);
 537                         if (ACPI_FAILURE(status)) {
 538                                 ACPI_ERROR_NAMESPACE((char *)&arg->named.name,
 539                                                      status);
 540                                 if (status != AE_ALREADY_EXISTS) {
 541                                         return_ACPI_STATUS(status);
 542                                 }
 543
 544                                 /* Name already exists, just ignore this error */
 545
 546                                 status = AE_OK;
 547                         }
 548
 549                         arg->common.node = node;
 550                 }
 551
 552                 /* Get the next field element in the list */
 553
 554                 arg = arg->common.next;
 555         }
 556
 557         return_ACPI_STATUS(AE_OK);
 558 }
 559
 560 /*******************************************************************************
 561  *
 562  * FUNCTION:    acpi_ds_create_bank_field
 563  *
 564  * PARAMETERS:  Op              - Op containing the Field definition and args
 565  *              region_node     - Object for the containing Operation Region
 566  *              walk_state      - Current method state
 567  *
 568  * RETURN:      Status
 569  *
 570  * DESCRIPTION: Create a new bank field in the specified operation region
 571  *
 572  ******************************************************************************/
 573
 574 acpi_status
 575 acpi_ds_create_bank_field(union acpi_parse_object *op,
 576                           struct acpi_namespace_node *region_node,
 577                           struct acpi_walk_state *walk_state)
 578 {
 579         acpi_status status;
 580         union acpi_parse_object *arg;
 581         struct acpi_create_field_info info;
 582
 583         ACPI_FUNCTION_TRACE_PTR(ds_create_bank_field, op);
 584
 585         /* First arg is the name of the parent op_region (must already exist) */
 586
 587         arg = op->common.value.arg;
 588         if (!region_node) {
 589                 status =
 590                     acpi_ns_lookup(walk_state->scope_info,
 591                                    arg->common.value.name, ACPI_TYPE_REGION,
 592                                    ACPI_IMODE_EXECUTE, ACPI_NS_SEARCH_PARENT,
 593                                    walk_state, &region_node);
 594                 if (ACPI_FAILURE(status)) {
 595                         ACPI_ERROR_NAMESPACE(arg->common.value.name, status);
 596                         return_ACPI_STATUS(status);
 597                 }
 598         }
 599
 600         /* Second arg is the Bank Register (Field) (must already exist) */
 601
 602         arg = arg->common.next;
 603         status =
 604             acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
 605                            ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 606                            ACPI_NS_SEARCH_PARENT, walk_state,
 607                            &info.register_node);
 608         if (ACPI_FAILURE(status)) {
 609                 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
 610                 return_ACPI_STATUS(status);
 611         }
 612
 613         /*
 614          * Third arg is the bank_value
 615          * This arg is a term_arg, not a constant
 616          * It will be evaluated later, by acpi_ds_eval_bank_field_operands
 617          */
 618         arg = arg->common.next;
 619
 620         /* Fourth arg is the field flags */
 621
 622         arg = arg->common.next;
 623         info.field_flags = (u8) arg->common.value.integer;
 624
 625         /* Each remaining arg is a Named Field */
 626
 627         info.field_type = ACPI_TYPE_LOCAL_BANK_FIELD;
 628         info.region_node = region_node;
 629
 630         /*
 631          * Use Info.data_register_node to store bank_field Op
 632          * It's safe because data_register_node will never be used when create bank field
 633          * We store aml_start and aml_length in the bank_field Op for late evaluation
 634          * Used in acpi_ex_prep_field_value(Info)
 635          *
 636          * TBD: Or, should we add a field in struct acpi_create_field_info, like "void *ParentOp"?
 637          */
 638         info.data_register_node = (struct acpi_namespace_node *)op;
 639
 640         status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
 641         return_ACPI_STATUS(status);
 642 }
 643
 644 /*******************************************************************************
 645  *
 646  * FUNCTION:    acpi_ds_create_index_field
 647  *
 648  * PARAMETERS:  Op              - Op containing the Field definition and args
 649  *              region_node     - Object for the containing Operation Region
 650  *  `           walk_state      - Current method state
 651  *
 652  * RETURN:      Status
 653  *
 654  * DESCRIPTION: Create a new index field in the specified operation region
 655  *
 656  ******************************************************************************/
 657
 658 acpi_status
 659 acpi_ds_create_index_field(union acpi_parse_object *op,
 660                            struct acpi_namespace_node *region_node,
 661                            struct acpi_walk_state *walk_state)
 662 {
 663         acpi_status status;
 664         union acpi_parse_object *arg;
 665         struct acpi_create_field_info info;
 666
 667         ACPI_FUNCTION_TRACE_PTR(ds_create_index_field, op);
 668
 669         /* First arg is the name of the Index register (must already exist) */
 670
 671         arg = op->common.value.arg;
 672         status =
 673             acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
 674                            ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 675                            ACPI_NS_SEARCH_PARENT, walk_state,
 676                            &info.register_node);
 677         if (ACPI_FAILURE(status)) {
 678                 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
 679                 return_ACPI_STATUS(status);
 680         }
 681
 682         /* Second arg is the data register (must already exist) */
 683
 684         arg = arg->common.next;
 685         status =
 686             acpi_ns_lookup(walk_state->scope_info, arg->common.value.string,
 687                            ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE,
 688                            ACPI_NS_SEARCH_PARENT, walk_state,
 689                            &info.data_register_node);
 690         if (ACPI_FAILURE(status)) {
 691                 ACPI_ERROR_NAMESPACE(arg->common.value.string, status);
 692                 return_ACPI_STATUS(status);
 693         }
 694
 695         /* Next arg is the field flags */
 696
 697         arg = arg->common.next;
 698         info.field_flags = (u8) arg->common.value.integer;
 699
 700         /* Each remaining arg is a Named Field */
 701
 702         info.field_type = ACPI_TYPE_LOCAL_INDEX_FIELD;
 703         info.region_node = region_node;
 704
 705         status = acpi_ds_get_field_names(&info, walk_state, arg->common.next);
 706         return_ACPI_STATUS(status);
 707 }