1 /****************************************************************************** 2 * 3 * Module Name: dsfield - Dispatcher field routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, 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 #define __DSFIELD_C__ 45 46 #include <contrib/dev/acpica/include/acpi.h> 47 #include <contrib/dev/acpica/include/accommon.h> 48 #include <contrib/dev/acpica/include/amlcode.h> 49 #include <contrib/dev/acpica/include/acdispat.h> 50 #include <contrib/dev/acpica/include/acinterp.h> 51 #include <contrib/dev/acpica/include/acnamesp.h> 52 #include <contrib/dev/acpica/include/acparser.h> 53 54 55 #define _COMPONENT ACPI_DISPATCHER 56 ACPI_MODULE_NAME ("dsfield") 57 58 /* Local prototypes */ 59 60 #ifdef ACPI_ASL_COMPILER 61 #include <contrib/dev/acpica/include/acdisasm.h> 62 63 static ACPI_STATUS 64 AcpiDsCreateExternalRegion ( 65 ACPI_STATUS LookupStatus, 66 ACPI_PARSE_OBJECT *Op, 67 char *Path, 68 ACPI_WALK_STATE *WalkState, 69 ACPI_NAMESPACE_NODE **Node); 70 #endif 71 72 static ACPI_STATUS 73 AcpiDsGetFieldNames ( 74 ACPI_CREATE_FIELD_INFO *Info, 75 ACPI_WALK_STATE *WalkState, 76 ACPI_PARSE_OBJECT *Arg); 77 78 79 #ifdef ACPI_ASL_COMPILER 80 /******************************************************************************* 81 * 82 * FUNCTION: AcpiDsCreateExternalRegion (iASL Disassembler only) 83 * 84 * PARAMETERS: LookupStatus - Status from NsLookup operation 85 * Op - Op containing the Field definition and args 86 * Path - Pathname of the region 87 * ` WalkState - Current method state 88 * Node - Where the new region node is returned 89 * 90 * RETURN: Status 91 * 92 * DESCRIPTION: Add region to the external list if NOT_FOUND. Create a new 93 * region node/object. 94 * 95 ******************************************************************************/ 96 97 static ACPI_STATUS 98 AcpiDsCreateExternalRegion ( 99 ACPI_STATUS LookupStatus, 100 ACPI_PARSE_OBJECT *Op, 101 char *Path, 102 ACPI_WALK_STATE *WalkState, 103 ACPI_NAMESPACE_NODE **Node) 104 { 105 ACPI_STATUS Status; 106 ACPI_OPERAND_OBJECT *ObjDesc; 107 108 109 if (LookupStatus != AE_NOT_FOUND) 110 { 111 return (LookupStatus); 112 } 113 114 /* 115 * Table disassembly: 116 * OperationRegion not found. Generate an External for it, and 117 * insert the name into the namespace. 118 */ 119 AcpiDmAddOpToExternalList (Op, Path, ACPI_TYPE_REGION, 0, 0); 120 Status = AcpiNsLookup (WalkState->ScopeInfo, Path, ACPI_TYPE_REGION, 121 ACPI_IMODE_LOAD_PASS1, ACPI_NS_SEARCH_PARENT, WalkState, Node); 122 if (ACPI_FAILURE (Status)) 123 { 124 return (Status); 125 } 126 127 /* Must create and install a region object for the new node */ 128 129 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_REGION); 130 if (!ObjDesc) 131 { 132 return (AE_NO_MEMORY); 133 } 134 135 ObjDesc->Region.Node = *Node; 136 Status = AcpiNsAttachObject (*Node, ObjDesc, ACPI_TYPE_REGION); 137 return (Status); 138 } 139 #endif 140 141 142 /******************************************************************************* 143 * 144 * FUNCTION: AcpiDsCreateBufferField 145 * 146 * PARAMETERS: Op - Current parse op (CreateXXField) 147 * WalkState - Current state 148 * 149 * RETURN: Status 150 * 151 * DESCRIPTION: Execute the CreateField operators: 152 * CreateBitFieldOp, 153 * CreateByteFieldOp, 154 * CreateWordFieldOp, 155 * CreateDwordFieldOp, 156 * CreateQwordFieldOp, 157 * CreateFieldOp (all of which define a field in a buffer) 158 * 159 ******************************************************************************/ 160 161 ACPI_STATUS 162 AcpiDsCreateBufferField ( 163 ACPI_PARSE_OBJECT *Op, 164 ACPI_WALK_STATE *WalkState) 165 { 166 ACPI_PARSE_OBJECT *Arg; 167 ACPI_NAMESPACE_NODE *Node; 168 ACPI_STATUS Status; 169 ACPI_OPERAND_OBJECT *ObjDesc; 170 ACPI_OPERAND_OBJECT *SecondDesc = NULL; 171 UINT32 Flags; 172 173 174 ACPI_FUNCTION_TRACE (DsCreateBufferField); 175 176 177 /* 178 * Get the NameString argument (name of the new BufferField) 179 */ 180 if (Op->Common.AmlOpcode == AML_CREATE_FIELD_OP) 181 { 182 /* For CreateField, name is the 4th argument */ 183 184 Arg = AcpiPsGetArg (Op, 3); 185 } 186 else 187 { 188 /* For all other CreateXXXField operators, name is the 3rd argument */ 189 190 Arg = AcpiPsGetArg (Op, 2); 191 } 192 193 if (!Arg) 194 { 195 return_ACPI_STATUS (AE_AML_NO_OPERAND); 196 } 197 198 if (WalkState->DeferredNode) 199 { 200 Node = WalkState->DeferredNode; 201 Status = AE_OK; 202 } 203 else 204 { 205 /* Execute flag should always be set when this function is entered */ 206 207 if (!(WalkState->ParseFlags & ACPI_PARSE_EXECUTE)) 208 { 209 return_ACPI_STATUS (AE_AML_INTERNAL); 210 } 211 212 /* Creating new namespace node, should not already exist */ 213 214 Flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | 215 ACPI_NS_ERROR_IF_FOUND; 216 217 /* 218 * Mark node temporary if we are executing a normal control 219 * method. (Don't mark if this is a module-level code method) 220 */ 221 if (WalkState->MethodNode && 222 !(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) 223 { 224 Flags |= ACPI_NS_TEMPORARY; 225 } 226 227 /* Enter the NameString into the namespace */ 228 229 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, 230 ACPI_TYPE_ANY, ACPI_IMODE_LOAD_PASS1, 231 Flags, WalkState, &Node); 232 if (ACPI_FAILURE (Status)) 233 { 234 ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status); 235 return_ACPI_STATUS (Status); 236 } 237 } 238 239 /* 240 * We could put the returned object (Node) on the object stack for later, 241 * but for now, we will put it in the "op" object that the parser uses, 242 * so we can get it again at the end of this scope. 243 */ 244 Op->Common.Node = Node; 245 246 /* 247 * If there is no object attached to the node, this node was just created 248 * and we need to create the field object. Otherwise, this was a lookup 249 * of an existing node and we don't want to create the field object again. 250 */ 251 ObjDesc = AcpiNsGetAttachedObject (Node); 252 if (ObjDesc) 253 { 254 return_ACPI_STATUS (AE_OK); 255 } 256 257 /* 258 * The Field definition is not fully parsed at this time. 259 * (We must save the address of the AML for the buffer and index operands) 260 */ 261 262 /* Create the buffer field object */ 263 264 ObjDesc = AcpiUtCreateInternalObject (ACPI_TYPE_BUFFER_FIELD); 265 if (!ObjDesc) 266 { 267 Status = AE_NO_MEMORY; 268 goto Cleanup; 269 } 270 271 /* 272 * Remember location in AML stream of the field unit opcode and operands -- 273 * since the buffer and index operands must be evaluated. 274 */ 275 SecondDesc = ObjDesc->Common.NextObject; 276 SecondDesc->Extra.AmlStart = Op->Named.Data; 277 SecondDesc->Extra.AmlLength = Op->Named.Length; 278 ObjDesc->BufferField.Node = Node; 279 280 /* Attach constructed field descriptors to parent node */ 281 282 Status = AcpiNsAttachObject (Node, ObjDesc, ACPI_TYPE_BUFFER_FIELD); 283 if (ACPI_FAILURE (Status)) 284 { 285 goto Cleanup; 286 } 287 288 289 Cleanup: 290 291 /* Remove local reference to the object */ 292 293 AcpiUtRemoveReference (ObjDesc); 294 return_ACPI_STATUS (Status); 295 } 296 297 298 /******************************************************************************* 299 * 300 * FUNCTION: AcpiDsGetFieldNames 301 * 302 * PARAMETERS: Info - CreateField info structure 303 * ` WalkState - Current method state 304 * Arg - First parser arg for the field name list 305 * 306 * RETURN: Status 307 * 308 * DESCRIPTION: Process all named fields in a field declaration. Names are 309 * entered into the namespace. 310 * 311 ******************************************************************************/ 312 313 static ACPI_STATUS 314 AcpiDsGetFieldNames ( 315 ACPI_CREATE_FIELD_INFO *Info, 316 ACPI_WALK_STATE *WalkState, 317 ACPI_PARSE_OBJECT *Arg) 318 { 319 ACPI_STATUS Status; 320 UINT64 Position; 321 ACPI_PARSE_OBJECT *Child; 322 323 324 ACPI_FUNCTION_TRACE_PTR (DsGetFieldNames, Info); 325 326 327 /* First field starts at bit zero */ 328 329 Info->FieldBitPosition = 0; 330 331 /* Process all elements in the field list (of parse nodes) */ 332 333 while (Arg) 334 { 335 /* 336 * Four types of field elements are handled: 337 * 1) Name - Enters a new named field into the namespace 338 * 2) Offset - specifies a bit offset 339 * 3) AccessAs - changes the access mode/attributes 340 * 4) Connection - Associate a resource template with the field 341 */ 342 switch (Arg->Common.AmlOpcode) 343 { 344 case AML_INT_RESERVEDFIELD_OP: 345 346 Position = (UINT64) Info->FieldBitPosition 347 + (UINT64) Arg->Common.Value.Size; 348 349 if (Position > ACPI_UINT32_MAX) 350 { 351 ACPI_ERROR ((AE_INFO, 352 "Bit offset within field too large (> 0xFFFFFFFF)")); 353 return_ACPI_STATUS (AE_SUPPORT); 354 } 355 356 Info->FieldBitPosition = (UINT32) Position; 357 break; 358 359 case AML_INT_ACCESSFIELD_OP: 360 case AML_INT_EXTACCESSFIELD_OP: 361 /* 362 * Get new AccessType, AccessAttribute, and AccessLength fields 363 * -- to be used for all field units that follow, until the 364 * end-of-field or another AccessAs keyword is encountered. 365 * NOTE. These three bytes are encoded in the integer value 366 * of the parseop for convenience. 367 * 368 * In FieldFlags, preserve the flag bits other than the 369 * ACCESS_TYPE bits. 370 */ 371 372 /* AccessType (ByteAcc, WordAcc, etc.) */ 373 374 Info->FieldFlags = (UINT8) 375 ((Info->FieldFlags & ~(AML_FIELD_ACCESS_TYPE_MASK)) | 376 ((UINT8) ((UINT32) (Arg->Common.Value.Integer & 0x07)))); 377 378 /* AccessAttribute (AttribQuick, AttribByte, etc.) */ 379 380 Info->Attribute = (UINT8) ((Arg->Common.Value.Integer >> 8) & 0xFF); 381 382 /* AccessLength (for serial/buffer protocols) */ 383 384 Info->AccessLength = (UINT8) ((Arg->Common.Value.Integer >> 16) & 0xFF); 385 break; 386 387 case AML_INT_CONNECTION_OP: 388 /* 389 * Clear any previous connection. New connection is used for all 390 * fields that follow, similar to AccessAs 391 */ 392 Info->ResourceBuffer = NULL; 393 Info->ConnectionNode = NULL; 394 Info->PinNumberIndex = 0; 395 396 /* 397 * A Connection() is either an actual resource descriptor (buffer) 398 * or a named reference to a resource template 399 */ 400 Child = Arg->Common.Value.Arg; 401 if (Child->Common.AmlOpcode == AML_INT_BYTELIST_OP) 402 { 403 Info->ResourceBuffer = Child->Named.Data; 404 Info->ResourceLength = (UINT16) Child->Named.Value.Integer; 405 } 406 else 407 { 408 /* Lookup the Connection() namepath, it should already exist */ 409 410 Status = AcpiNsLookup (WalkState->ScopeInfo, 411 Child->Common.Value.Name, ACPI_TYPE_ANY, 412 ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE, 413 WalkState, &Info->ConnectionNode); 414 if (ACPI_FAILURE (Status)) 415 { 416 ACPI_ERROR_NAMESPACE (Child->Common.Value.Name, Status); 417 return_ACPI_STATUS (Status); 418 } 419 } 420 break; 421 422 case AML_INT_NAMEDFIELD_OP: 423 424 /* Lookup the name, it should already exist */ 425 426 Status = AcpiNsLookup (WalkState->ScopeInfo, 427 (char *) &Arg->Named.Name, Info->FieldType, 428 ACPI_IMODE_EXECUTE, ACPI_NS_DONT_OPEN_SCOPE, 429 WalkState, &Info->FieldNode); 430 if (ACPI_FAILURE (Status)) 431 { 432 ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status); 433 return_ACPI_STATUS (Status); 434 } 435 else 436 { 437 Arg->Common.Node = Info->FieldNode; 438 Info->FieldBitLength = Arg->Common.Value.Size; 439 440 /* 441 * If there is no object attached to the node, this node was 442 * just created and we need to create the field object. 443 * Otherwise, this was a lookup of an existing node and we 444 * don't want to create the field object again. 445 */ 446 if (!AcpiNsGetAttachedObject (Info->FieldNode)) 447 { 448 Status = AcpiExPrepFieldValue (Info); 449 if (ACPI_FAILURE (Status)) 450 { 451 return_ACPI_STATUS (Status); 452 } 453 } 454 } 455 456 /* Keep track of bit position for the next field */ 457 458 Position = (UINT64) Info->FieldBitPosition 459 + (UINT64) Arg->Common.Value.Size; 460 461 if (Position > ACPI_UINT32_MAX) 462 { 463 ACPI_ERROR ((AE_INFO, 464 "Field [%4.4s] bit offset too large (> 0xFFFFFFFF)", 465 ACPI_CAST_PTR (char, &Info->FieldNode->Name))); 466 return_ACPI_STATUS (AE_SUPPORT); 467 } 468 469 Info->FieldBitPosition += Info->FieldBitLength; 470 Info->PinNumberIndex++; /* Index relative to previous Connection() */ 471 break; 472 473 default: 474 475 ACPI_ERROR ((AE_INFO, 476 "Invalid opcode in field list: 0x%X", Arg->Common.AmlOpcode)); 477 return_ACPI_STATUS (AE_AML_BAD_OPCODE); 478 } 479 480 Arg = Arg->Common.Next; 481 } 482 483 return_ACPI_STATUS (AE_OK); 484 } 485 486 487 /******************************************************************************* 488 * 489 * FUNCTION: AcpiDsCreateField 490 * 491 * PARAMETERS: Op - Op containing the Field definition and args 492 * RegionNode - Object for the containing Operation Region 493 * ` WalkState - Current method state 494 * 495 * RETURN: Status 496 * 497 * DESCRIPTION: Create a new field in the specified operation region 498 * 499 ******************************************************************************/ 500 501 ACPI_STATUS 502 AcpiDsCreateField ( 503 ACPI_PARSE_OBJECT *Op, 504 ACPI_NAMESPACE_NODE *RegionNode, 505 ACPI_WALK_STATE *WalkState) 506 { 507 ACPI_STATUS Status; 508 ACPI_PARSE_OBJECT *Arg; 509 ACPI_CREATE_FIELD_INFO Info; 510 511 512 ACPI_FUNCTION_TRACE_PTR (DsCreateField, Op); 513 514 515 /* First arg is the name of the parent OpRegion (must already exist) */ 516 517 Arg = Op->Common.Value.Arg; 518 519 if (!RegionNode) 520 { 521 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.Name, 522 ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE, 523 ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode); 524 #ifdef ACPI_ASL_COMPILER 525 Status = AcpiDsCreateExternalRegion (Status, Arg, 526 Arg->Common.Value.Name, WalkState, &RegionNode); 527 #endif 528 if (ACPI_FAILURE (Status)) 529 { 530 ACPI_ERROR_NAMESPACE (Arg->Common.Value.Name, Status); 531 return_ACPI_STATUS (Status); 532 } 533 } 534 535 ACPI_MEMSET (&Info, 0, sizeof (ACPI_CREATE_FIELD_INFO)); 536 537 /* Second arg is the field flags */ 538 539 Arg = Arg->Common.Next; 540 Info.FieldFlags = (UINT8) Arg->Common.Value.Integer; 541 Info.Attribute = 0; 542 543 /* Each remaining arg is a Named Field */ 544 545 Info.FieldType = ACPI_TYPE_LOCAL_REGION_FIELD; 546 Info.RegionNode = RegionNode; 547 548 Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next); 549 return_ACPI_STATUS (Status); 550 } 551 552 553 /******************************************************************************* 554 * 555 * FUNCTION: AcpiDsInitFieldObjects 556 * 557 * PARAMETERS: Op - Op containing the Field definition and args 558 * ` WalkState - Current method state 559 * 560 * RETURN: Status 561 * 562 * DESCRIPTION: For each "Field Unit" name in the argument list that is 563 * part of the field declaration, enter the name into the 564 * namespace. 565 * 566 ******************************************************************************/ 567 568 ACPI_STATUS 569 AcpiDsInitFieldObjects ( 570 ACPI_PARSE_OBJECT *Op, 571 ACPI_WALK_STATE *WalkState) 572 { 573 ACPI_STATUS Status; 574 ACPI_PARSE_OBJECT *Arg = NULL; 575 ACPI_NAMESPACE_NODE *Node; 576 UINT8 Type = 0; 577 UINT32 Flags; 578 579 580 ACPI_FUNCTION_TRACE_PTR (DsInitFieldObjects, Op); 581 582 583 /* Execute flag should always be set when this function is entered */ 584 585 if (!(WalkState->ParseFlags & ACPI_PARSE_EXECUTE)) 586 { 587 if (WalkState->ParseFlags & ACPI_PARSE_DEFERRED_OP) 588 { 589 /* BankField Op is deferred, just return OK */ 590 591 return_ACPI_STATUS (AE_OK); 592 } 593 594 return_ACPI_STATUS (AE_AML_INTERNAL); 595 } 596 597 /* 598 * Get the FieldList argument for this opcode. This is the start of the 599 * list of field elements. 600 */ 601 switch (WalkState->Opcode) 602 { 603 case AML_FIELD_OP: 604 605 Arg = AcpiPsGetArg (Op, 2); 606 Type = ACPI_TYPE_LOCAL_REGION_FIELD; 607 break; 608 609 case AML_BANK_FIELD_OP: 610 611 Arg = AcpiPsGetArg (Op, 4); 612 Type = ACPI_TYPE_LOCAL_BANK_FIELD; 613 break; 614 615 case AML_INDEX_FIELD_OP: 616 617 Arg = AcpiPsGetArg (Op, 3); 618 Type = ACPI_TYPE_LOCAL_INDEX_FIELD; 619 break; 620 621 default: 622 623 return_ACPI_STATUS (AE_BAD_PARAMETER); 624 } 625 626 /* Creating new namespace node(s), should not already exist */ 627 628 Flags = ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE | 629 ACPI_NS_ERROR_IF_FOUND; 630 631 /* 632 * Mark node(s) temporary if we are executing a normal control 633 * method. (Don't mark if this is a module-level code method) 634 */ 635 if (WalkState->MethodNode && 636 !(WalkState->ParseFlags & ACPI_PARSE_MODULE_LEVEL)) 637 { 638 Flags |= ACPI_NS_TEMPORARY; 639 } 640 641 /* 642 * Walk the list of entries in the FieldList 643 * Note: FieldList can be of zero length. In this case, Arg will be NULL. 644 */ 645 while (Arg) 646 { 647 /* 648 * Ignore OFFSET/ACCESSAS/CONNECTION terms here; we are only interested 649 * in the field names in order to enter them into the namespace. 650 */ 651 if (Arg->Common.AmlOpcode == AML_INT_NAMEDFIELD_OP) 652 { 653 Status = AcpiNsLookup (WalkState->ScopeInfo, 654 (char *) &Arg->Named.Name, Type, ACPI_IMODE_LOAD_PASS1, 655 Flags, WalkState, &Node); 656 if (ACPI_FAILURE (Status)) 657 { 658 ACPI_ERROR_NAMESPACE ((char *) &Arg->Named.Name, Status); 659 if (Status != AE_ALREADY_EXISTS) 660 { 661 return_ACPI_STATUS (Status); 662 } 663 664 /* Name already exists, just ignore this error */ 665 666 Status = AE_OK; 667 } 668 669 Arg->Common.Node = Node; 670 } 671 672 /* Get the next field element in the list */ 673 674 Arg = Arg->Common.Next; 675 } 676 677 return_ACPI_STATUS (AE_OK); 678 } 679 680 681 /******************************************************************************* 682 * 683 * FUNCTION: AcpiDsCreateBankField 684 * 685 * PARAMETERS: Op - Op containing the Field definition and args 686 * RegionNode - Object for the containing Operation Region 687 * WalkState - Current method state 688 * 689 * RETURN: Status 690 * 691 * DESCRIPTION: Create a new bank field in the specified operation region 692 * 693 ******************************************************************************/ 694 695 ACPI_STATUS 696 AcpiDsCreateBankField ( 697 ACPI_PARSE_OBJECT *Op, 698 ACPI_NAMESPACE_NODE *RegionNode, 699 ACPI_WALK_STATE *WalkState) 700 { 701 ACPI_STATUS Status; 702 ACPI_PARSE_OBJECT *Arg; 703 ACPI_CREATE_FIELD_INFO Info; 704 705 706 ACPI_FUNCTION_TRACE_PTR (DsCreateBankField, Op); 707 708 709 /* First arg is the name of the parent OpRegion (must already exist) */ 710 711 Arg = Op->Common.Value.Arg; 712 if (!RegionNode) 713 { 714 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.Name, 715 ACPI_TYPE_REGION, ACPI_IMODE_EXECUTE, 716 ACPI_NS_SEARCH_PARENT, WalkState, &RegionNode); 717 #ifdef ACPI_ASL_COMPILER 718 Status = AcpiDsCreateExternalRegion (Status, Arg, 719 Arg->Common.Value.Name, WalkState, &RegionNode); 720 #endif 721 if (ACPI_FAILURE (Status)) 722 { 723 ACPI_ERROR_NAMESPACE (Arg->Common.Value.Name, Status); 724 return_ACPI_STATUS (Status); 725 } 726 } 727 728 /* Second arg is the Bank Register (Field) (must already exist) */ 729 730 Arg = Arg->Common.Next; 731 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, 732 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE, 733 ACPI_NS_SEARCH_PARENT, WalkState, &Info.RegisterNode); 734 if (ACPI_FAILURE (Status)) 735 { 736 ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status); 737 return_ACPI_STATUS (Status); 738 } 739 740 /* 741 * Third arg is the BankValue 742 * This arg is a TermArg, not a constant 743 * It will be evaluated later, by AcpiDsEvalBankFieldOperands 744 */ 745 Arg = Arg->Common.Next; 746 747 /* Fourth arg is the field flags */ 748 749 Arg = Arg->Common.Next; 750 Info.FieldFlags = (UINT8) Arg->Common.Value.Integer; 751 752 /* Each remaining arg is a Named Field */ 753 754 Info.FieldType = ACPI_TYPE_LOCAL_BANK_FIELD; 755 Info.RegionNode = RegionNode; 756 757 /* 758 * Use Info.DataRegisterNode to store BankField Op 759 * It's safe because DataRegisterNode will never be used when create bank field 760 * We store AmlStart and AmlLength in the BankField Op for late evaluation 761 * Used in AcpiExPrepFieldValue(Info) 762 * 763 * TBD: Or, should we add a field in ACPI_CREATE_FIELD_INFO, like "void *ParentOp"? 764 */ 765 Info.DataRegisterNode = (ACPI_NAMESPACE_NODE*) Op; 766 767 Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next); 768 return_ACPI_STATUS (Status); 769 } 770 771 772 /******************************************************************************* 773 * 774 * FUNCTION: AcpiDsCreateIndexField 775 * 776 * PARAMETERS: Op - Op containing the Field definition and args 777 * RegionNode - Object for the containing Operation Region 778 * ` WalkState - Current method state 779 * 780 * RETURN: Status 781 * 782 * DESCRIPTION: Create a new index field in the specified operation region 783 * 784 ******************************************************************************/ 785 786 ACPI_STATUS 787 AcpiDsCreateIndexField ( 788 ACPI_PARSE_OBJECT *Op, 789 ACPI_NAMESPACE_NODE *RegionNode, 790 ACPI_WALK_STATE *WalkState) 791 { 792 ACPI_STATUS Status; 793 ACPI_PARSE_OBJECT *Arg; 794 ACPI_CREATE_FIELD_INFO Info; 795 796 797 ACPI_FUNCTION_TRACE_PTR (DsCreateIndexField, Op); 798 799 800 /* First arg is the name of the Index register (must already exist) */ 801 802 Arg = Op->Common.Value.Arg; 803 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, 804 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE, 805 ACPI_NS_SEARCH_PARENT, WalkState, &Info.RegisterNode); 806 if (ACPI_FAILURE (Status)) 807 { 808 ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status); 809 return_ACPI_STATUS (Status); 810 } 811 812 /* Second arg is the data register (must already exist) */ 813 814 Arg = Arg->Common.Next; 815 Status = AcpiNsLookup (WalkState->ScopeInfo, Arg->Common.Value.String, 816 ACPI_TYPE_ANY, ACPI_IMODE_EXECUTE, 817 ACPI_NS_SEARCH_PARENT, WalkState, &Info.DataRegisterNode); 818 if (ACPI_FAILURE (Status)) 819 { 820 ACPI_ERROR_NAMESPACE (Arg->Common.Value.String, Status); 821 return_ACPI_STATUS (Status); 822 } 823 824 /* Next arg is the field flags */ 825 826 Arg = Arg->Common.Next; 827 Info.FieldFlags = (UINT8) Arg->Common.Value.Integer; 828 829 /* Each remaining arg is a Named Field */ 830 831 Info.FieldType = ACPI_TYPE_LOCAL_INDEX_FIELD; 832 Info.RegionNode = RegionNode; 833 834 Status = AcpiDsGetFieldNames (&Info, WalkState, Arg->Common.Next); 835 return_ACPI_STATUS (Status); 836 } 837