aslpredef.c revision 249112
1204766Sjkim/****************************************************************************** 2204766Sjkim * 3204766Sjkim * Module Name: aslpredef - support for ACPI predefined names 4204766Sjkim * 5204766Sjkim *****************************************************************************/ 6204766Sjkim 7217365Sjkim/* 8245582Sjkim * Copyright (C) 2000 - 2013, Intel Corp. 9204766Sjkim * All rights reserved. 10204766Sjkim * 11217365Sjkim * Redistribution and use in source and binary forms, with or without 12217365Sjkim * modification, are permitted provided that the following conditions 13217365Sjkim * are met: 14217365Sjkim * 1. Redistributions of source code must retain the above copyright 15217365Sjkim * notice, this list of conditions, and the following disclaimer, 16217365Sjkim * without modification. 17217365Sjkim * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18217365Sjkim * substantially similar to the "NO WARRANTY" disclaimer below 19217365Sjkim * ("Disclaimer") and any redistribution must be conditioned upon 20217365Sjkim * including a substantially similar Disclaimer requirement for further 21217365Sjkim * binary redistribution. 22217365Sjkim * 3. Neither the names of the above-listed copyright holders nor the names 23217365Sjkim * of any contributors may be used to endorse or promote products derived 24217365Sjkim * from this software without specific prior written permission. 25204766Sjkim * 26217365Sjkim * Alternatively, this software may be distributed under the terms of the 27217365Sjkim * GNU General Public License ("GPL") version 2 as published by the Free 28217365Sjkim * Software Foundation. 29204766Sjkim * 30217365Sjkim * NO WARRANTY 31217365Sjkim * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32217365Sjkim * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33217365Sjkim * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34217365Sjkim * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35217365Sjkim * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36217365Sjkim * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37217365Sjkim * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38217365Sjkim * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39217365Sjkim * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40217365Sjkim * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41217365Sjkim * POSSIBILITY OF SUCH DAMAGES. 42217365Sjkim */ 43204766Sjkim 44204766Sjkim#define ACPI_CREATE_PREDEFINED_TABLE 45249112Sjkim#define ACPI_CREATE_RESOURCE_TABLE 46204766Sjkim 47204773Sjkim#include <contrib/dev/acpica/compiler/aslcompiler.h> 48204766Sjkim#include "aslcompiler.y.h" 49204773Sjkim#include <contrib/dev/acpica/include/acpredef.h> 50246849Sjkim#include <contrib/dev/acpica/include/acnamesp.h> 51204766Sjkim 52204766Sjkim 53204766Sjkim#define _COMPONENT ACPI_COMPILER 54204766Sjkim ACPI_MODULE_NAME ("aslpredef") 55204766Sjkim 56204766Sjkim 57204766Sjkim/* Local prototypes */ 58204766Sjkim 59218590Sjkimstatic void 60218590SjkimApCheckForUnexpectedReturnValue ( 61218590Sjkim ACPI_PARSE_OBJECT *Op, 62218590Sjkim ASL_METHOD_INFO *MethodInfo); 63218590Sjkim 64204766Sjkimstatic UINT32 65204766SjkimApCheckForSpecialName ( 66204766Sjkim ACPI_PARSE_OBJECT *Op, 67204766Sjkim char *Name); 68204766Sjkim 69204766Sjkim 70204766Sjkim/******************************************************************************* 71204766Sjkim * 72204766Sjkim * FUNCTION: ApCheckForPredefinedMethod 73204766Sjkim * 74204766Sjkim * PARAMETERS: Op - A parse node of type "METHOD". 75204766Sjkim * MethodInfo - Saved info about this method 76204766Sjkim * 77204766Sjkim * RETURN: None 78204766Sjkim * 79204766Sjkim * DESCRIPTION: If method is a predefined name, check that the number of 80204766Sjkim * arguments and the return type (returns a value or not) 81204766Sjkim * is correct. 82204766Sjkim * 83204766Sjkim ******************************************************************************/ 84204766Sjkim 85220663SjkimBOOLEAN 86204766SjkimApCheckForPredefinedMethod ( 87204766Sjkim ACPI_PARSE_OBJECT *Op, 88204766Sjkim ASL_METHOD_INFO *MethodInfo) 89204766Sjkim{ 90249112Sjkim UINT32 Index; 91249112Sjkim UINT32 RequiredArgCount; 92249112Sjkim const ACPI_PREDEFINED_INFO *ThisName; 93204766Sjkim 94204766Sjkim 95204766Sjkim /* Check for a match against the predefined name list */ 96204766Sjkim 97204766Sjkim Index = ApCheckForPredefinedName (Op, Op->Asl.NameSeg); 98204766Sjkim 99204766Sjkim switch (Index) 100204766Sjkim { 101204766Sjkim case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 102204766Sjkim case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 103204766Sjkim case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 104204766Sjkim 105204766Sjkim /* Just return, nothing to do */ 106220663Sjkim return (FALSE); 107204766Sjkim 108204766Sjkim 109207344Sjkim case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 110204766Sjkim 111204766Sjkim Gbl_ReservedMethods++; 112204766Sjkim 113207344Sjkim /* NumArguments must be zero for all _Lxx/_Exx/_Wxx/_Qxx methods */ 114204766Sjkim 115204766Sjkim if (MethodInfo->NumArguments != 0) 116204766Sjkim { 117209746Sjkim sprintf (MsgBuffer, "%s requires %u", Op->Asl.ExternalName, 0); 118204766Sjkim 119204766Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, 120204766Sjkim MsgBuffer); 121204766Sjkim } 122204766Sjkim break; 123204766Sjkim 124204766Sjkim 125204766Sjkim default: 126204766Sjkim /* 127204766Sjkim * Matched a predefined method name 128204766Sjkim * 129204766Sjkim * Validate the ASL-defined argument count. Allow two different legal 130204766Sjkim * arg counts. 131204766Sjkim */ 132204766Sjkim Gbl_ReservedMethods++; 133249112Sjkim ThisName = &AcpiGbl_PredefinedMethods[Index]; 134249112Sjkim RequiredArgCount = ThisName->Info.ArgumentList & METHOD_ARG_MASK; 135204766Sjkim 136249112Sjkim if (MethodInfo->NumArguments != RequiredArgCount) 137204766Sjkim { 138209746Sjkim sprintf (MsgBuffer, "%4.4s requires %u", 139249112Sjkim ThisName->Info.Name, RequiredArgCount); 140204766Sjkim 141249112Sjkim if ((MethodInfo->NumArguments > RequiredArgCount) && 142249112Sjkim !(ThisName->Info.ArgumentList & ARG_COUNT_IS_MINIMUM)) 143204766Sjkim { 144204766Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, 145204766Sjkim MsgBuffer); 146204766Sjkim } 147204766Sjkim else 148204766Sjkim { 149204766Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Op, 150204766Sjkim MsgBuffer); 151204766Sjkim } 152204766Sjkim } 153204766Sjkim 154204766Sjkim /* 155204766Sjkim * Check if method returns no value, but the predefined name is 156204766Sjkim * required to return a value 157204766Sjkim */ 158204766Sjkim if (MethodInfo->NumReturnNoValue && 159249112Sjkim ThisName->Info.ExpectedBtypes) 160204766Sjkim { 161249112Sjkim AcpiUtGetExpectedReturnTypes (StringBuffer, 162249112Sjkim ThisName->Info.ExpectedBtypes); 163204766Sjkim 164206117Sjkim sprintf (MsgBuffer, "%s required for %4.4s", 165249112Sjkim StringBuffer, ThisName->Info.Name); 166206117Sjkim 167204766Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op, 168204766Sjkim MsgBuffer); 169204766Sjkim } 170204766Sjkim break; 171204766Sjkim } 172220663Sjkim 173220663Sjkim return (TRUE); 174204766Sjkim} 175204766Sjkim 176204766Sjkim 177204766Sjkim/******************************************************************************* 178204766Sjkim * 179218590Sjkim * FUNCTION: ApCheckForUnexpectedReturnValue 180218590Sjkim * 181218590Sjkim * PARAMETERS: Op - A parse node of type "RETURN". 182218590Sjkim * MethodInfo - Saved info about this method 183218590Sjkim * 184218590Sjkim * RETURN: None 185218590Sjkim * 186218590Sjkim * DESCRIPTION: Check for an unexpected return value from a predefined method. 187218590Sjkim * Invoked for predefined methods that are defined to not return 188218590Sjkim * any value. If there is a return value, issue a remark, since 189218590Sjkim * the ASL writer may be confused as to the method definition 190218590Sjkim * and/or functionality. 191218590Sjkim * 192218590Sjkim * Note: We ignore all return values of "Zero", since this is what a standalone 193218590Sjkim * Return() statement will always generate -- so we ignore it here -- 194218590Sjkim * i.e., there is no difference between Return() and Return(Zero). 195218590Sjkim * Also, a null Return() will be disassembled to return(Zero) -- so, we 196218590Sjkim * don't want to generate extraneous remarks/warnings for a disassembled 197218590Sjkim * ASL file. 198218590Sjkim * 199218590Sjkim ******************************************************************************/ 200218590Sjkim 201218590Sjkimstatic void 202218590SjkimApCheckForUnexpectedReturnValue ( 203218590Sjkim ACPI_PARSE_OBJECT *Op, 204218590Sjkim ASL_METHOD_INFO *MethodInfo) 205218590Sjkim{ 206218590Sjkim ACPI_PARSE_OBJECT *ReturnValueOp; 207218590Sjkim 208218590Sjkim 209218590Sjkim /* Ignore Return() and Return(Zero) (they are the same) */ 210218590Sjkim 211218590Sjkim ReturnValueOp = Op->Asl.Child; 212218590Sjkim if (ReturnValueOp->Asl.ParseOpcode == PARSEOP_ZERO) 213218590Sjkim { 214218590Sjkim return; 215218590Sjkim } 216218590Sjkim 217218590Sjkim /* We have a valid return value, but the reserved name did not expect it */ 218218590Sjkim 219218590Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_NO_RETURN_VAL, 220218590Sjkim Op, MethodInfo->Op->Asl.ExternalName); 221218590Sjkim} 222218590Sjkim 223218590Sjkim 224218590Sjkim/******************************************************************************* 225218590Sjkim * 226206117Sjkim * FUNCTION: ApCheckPredefinedReturnValue 227206117Sjkim * 228206117Sjkim * PARAMETERS: Op - A parse node of type "RETURN". 229206117Sjkim * MethodInfo - Saved info about this method 230206117Sjkim * 231206117Sjkim * RETURN: None 232206117Sjkim * 233206117Sjkim * DESCRIPTION: If method is a predefined name, attempt to validate the return 234206117Sjkim * value. Only "static" types can be validated - a simple return 235206117Sjkim * of an integer/string/buffer/package or a named reference to 236206117Sjkim * a static object. Values such as a Localx or Argx or a control 237218590Sjkim * method invocation are not checked. Issue a warning if there is 238218590Sjkim * a valid return value, but the reserved method defines no 239218590Sjkim * return value. 240206117Sjkim * 241206117Sjkim ******************************************************************************/ 242206117Sjkim 243206117Sjkimvoid 244206117SjkimApCheckPredefinedReturnValue ( 245206117Sjkim ACPI_PARSE_OBJECT *Op, 246206117Sjkim ASL_METHOD_INFO *MethodInfo) 247206117Sjkim{ 248249112Sjkim UINT32 Index; 249249112Sjkim ACPI_PARSE_OBJECT *ReturnValueOp; 250249112Sjkim const ACPI_PREDEFINED_INFO *ThisName; 251206117Sjkim 252206117Sjkim 253206117Sjkim /* Check parent method for a match against the predefined name list */ 254206117Sjkim 255206117Sjkim Index = ApCheckForPredefinedName (MethodInfo->Op, 256206117Sjkim MethodInfo->Op->Asl.NameSeg); 257206117Sjkim 258206117Sjkim switch (Index) 259206117Sjkim { 260218590Sjkim case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 261218590Sjkim 262218590Sjkim /* No return value expected, warn if there is one */ 263218590Sjkim 264218590Sjkim ApCheckForUnexpectedReturnValue (Op, MethodInfo); 265218590Sjkim return; 266218590Sjkim 267206117Sjkim case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 268206117Sjkim case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 269206117Sjkim case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 270206117Sjkim 271206117Sjkim /* Just return, nothing to do */ 272206117Sjkim return; 273206117Sjkim 274207344Sjkim default: /* A standard predefined ACPI name */ 275206117Sjkim 276249112Sjkim ThisName = &AcpiGbl_PredefinedMethods[Index]; 277249112Sjkim if (!ThisName->Info.ExpectedBtypes) 278206117Sjkim { 279218590Sjkim /* No return value expected, warn if there is one */ 280218590Sjkim 281218590Sjkim ApCheckForUnexpectedReturnValue (Op, MethodInfo); 282206117Sjkim return; 283206117Sjkim } 284206117Sjkim 285206117Sjkim /* Get the object returned, it is the next argument */ 286206117Sjkim 287206117Sjkim ReturnValueOp = Op->Asl.Child; 288206117Sjkim switch (ReturnValueOp->Asl.ParseOpcode) 289206117Sjkim { 290206117Sjkim case PARSEOP_ZERO: 291206117Sjkim case PARSEOP_ONE: 292206117Sjkim case PARSEOP_ONES: 293206117Sjkim case PARSEOP_INTEGER: 294206117Sjkim case PARSEOP_STRING_LITERAL: 295206117Sjkim case PARSEOP_BUFFER: 296206117Sjkim case PARSEOP_PACKAGE: 297206117Sjkim 298206117Sjkim /* Static data return object - check against expected type */ 299206117Sjkim 300249112Sjkim ApCheckObjectType (ThisName->Info.Name, ReturnValueOp, 301249112Sjkim ThisName->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT); 302246849Sjkim 303246849Sjkim /* For packages, check the individual package elements */ 304246849Sjkim 305246849Sjkim if (ReturnValueOp->Asl.ParseOpcode == PARSEOP_PACKAGE) 306246849Sjkim { 307249112Sjkim ApCheckPackage (ReturnValueOp, ThisName); 308246849Sjkim } 309206117Sjkim break; 310206117Sjkim 311206117Sjkim default: 312206117Sjkim 313206117Sjkim /* 314206117Sjkim * All other ops are very difficult or impossible to typecheck at 315206117Sjkim * compile time. These include all Localx, Argx, and method 316206117Sjkim * invocations. Also, NAMESEG and NAMESTRING because the type of 317206117Sjkim * any named object can be changed at runtime (for example, 318206117Sjkim * CopyObject will change the type of the target object.) 319206117Sjkim */ 320206117Sjkim break; 321206117Sjkim } 322206117Sjkim } 323206117Sjkim} 324206117Sjkim 325206117Sjkim 326206117Sjkim/******************************************************************************* 327206117Sjkim * 328204766Sjkim * FUNCTION: ApCheckForPredefinedObject 329204766Sjkim * 330204766Sjkim * PARAMETERS: Op - A parse node 331204766Sjkim * Name - The ACPI name to be checked 332204766Sjkim * 333204766Sjkim * RETURN: None 334204766Sjkim * 335204766Sjkim * DESCRIPTION: Check for a predefined name for a static object (created via 336204766Sjkim * the ASL Name operator). If it is a predefined ACPI name, ensure 337204766Sjkim * that the name does not require any arguments (which would 338204766Sjkim * require a control method implemenation of the name), and that 339204766Sjkim * the type of the object is one of the expected types for the 340204766Sjkim * predefined name. 341204766Sjkim * 342204766Sjkim ******************************************************************************/ 343204766Sjkim 344204766Sjkimvoid 345204766SjkimApCheckForPredefinedObject ( 346204766Sjkim ACPI_PARSE_OBJECT *Op, 347204766Sjkim char *Name) 348204766Sjkim{ 349249112Sjkim UINT32 Index; 350249112Sjkim ACPI_PARSE_OBJECT *ObjectOp; 351249112Sjkim const ACPI_PREDEFINED_INFO *ThisName; 352204766Sjkim 353204766Sjkim 354204766Sjkim /* 355204766Sjkim * Check for a real predefined name -- not a resource descriptor name 356204766Sjkim * or a predefined scope name 357204766Sjkim */ 358204766Sjkim Index = ApCheckForPredefinedName (Op, Name); 359207344Sjkim 360207344Sjkim switch (Index) 361204766Sjkim { 362207344Sjkim case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 363207344Sjkim case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 364207344Sjkim case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 365207344Sjkim 366207344Sjkim /* Nothing to do */ 367204766Sjkim return; 368204766Sjkim 369207344Sjkim case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 370207344Sjkim 371204766Sjkim /* 372207344Sjkim * These names must be control methods, by definition in ACPI spec. 373207344Sjkim * Also because they are defined to return no value. None of them 374207344Sjkim * require any arguments. 375204766Sjkim */ 376204766Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 377207344Sjkim "with zero arguments"); 378207344Sjkim return; 379204766Sjkim 380246849Sjkim default: 381246849Sjkim break; 382246849Sjkim } 383204766Sjkim 384246849Sjkim /* A standard predefined ACPI name */ 385207344Sjkim 386246849Sjkim /* 387246849Sjkim * If this predefined name requires input arguments, then 388246849Sjkim * it must be implemented as a control method 389246849Sjkim */ 390249112Sjkim ThisName = &AcpiGbl_PredefinedMethods[Index]; 391249112Sjkim if ((ThisName->Info.ArgumentList & METHOD_ARG_MASK) > 0) 392246849Sjkim { 393246849Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 394246849Sjkim "with arguments"); 395246849Sjkim return; 396246849Sjkim } 397207344Sjkim 398246849Sjkim /* 399246849Sjkim * If no return value is expected from this predefined name, then 400246849Sjkim * it follows that it must be implemented as a control method 401246849Sjkim * (with zero args, because the args > 0 case was handled above) 402246849Sjkim * Examples are: _DIS, _INI, _IRC, _OFF, _ON, _PSx 403246849Sjkim */ 404249112Sjkim if (!ThisName->Info.ExpectedBtypes) 405246849Sjkim { 406246849Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 407246849Sjkim "with zero arguments"); 408207344Sjkim return; 409207344Sjkim } 410246849Sjkim 411246849Sjkim /* Typecheck the actual object, it is the next argument */ 412246849Sjkim 413246849Sjkim ObjectOp = Op->Asl.Child->Asl.Next; 414249112Sjkim ApCheckObjectType (ThisName->Info.Name, Op->Asl.Child->Asl.Next, 415249112Sjkim ThisName->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT); 416246849Sjkim 417246849Sjkim /* For packages, check the individual package elements */ 418246849Sjkim 419246849Sjkim if (ObjectOp->Asl.ParseOpcode == PARSEOP_PACKAGE) 420246849Sjkim { 421249112Sjkim ApCheckPackage (ObjectOp, ThisName); 422246849Sjkim } 423204766Sjkim} 424204766Sjkim 425204766Sjkim 426204766Sjkim/******************************************************************************* 427204766Sjkim * 428204766Sjkim * FUNCTION: ApCheckForPredefinedName 429204766Sjkim * 430204766Sjkim * PARAMETERS: Op - A parse node 431204766Sjkim * Name - NameSeg to check 432204766Sjkim * 433204766Sjkim * RETURN: None 434204766Sjkim * 435204766Sjkim * DESCRIPTION: Check a NameSeg against the reserved list. 436204766Sjkim * 437204766Sjkim ******************************************************************************/ 438204766Sjkim 439204766SjkimUINT32 440204766SjkimApCheckForPredefinedName ( 441204766Sjkim ACPI_PARSE_OBJECT *Op, 442204766Sjkim char *Name) 443204766Sjkim{ 444249112Sjkim UINT32 i; 445249112Sjkim const ACPI_PREDEFINED_INFO *ThisName; 446204766Sjkim 447204766Sjkim 448204766Sjkim if (Name[0] == 0) 449204766Sjkim { 450204766Sjkim AcpiOsPrintf ("Found a null name, external = %s\n", 451204766Sjkim Op->Asl.ExternalName); 452204766Sjkim } 453204766Sjkim 454204766Sjkim /* All reserved names are prefixed with a single underscore */ 455204766Sjkim 456204766Sjkim if (Name[0] != '_') 457204766Sjkim { 458204766Sjkim return (ACPI_NOT_RESERVED_NAME); 459204766Sjkim } 460204766Sjkim 461204766Sjkim /* Check for a standard predefined method name */ 462204766Sjkim 463249112Sjkim ThisName = AcpiGbl_PredefinedMethods; 464249112Sjkim for (i = 0; ThisName->Info.Name[0]; i++) 465204766Sjkim { 466249112Sjkim if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 467204766Sjkim { 468204766Sjkim /* Return index into predefined array */ 469204766Sjkim return (i); 470204766Sjkim } 471249112Sjkim 472249112Sjkim ThisName++; /* Does not account for extra package data, but is OK */ 473204766Sjkim } 474204766Sjkim 475204766Sjkim /* Check for resource names and predefined scope names */ 476204766Sjkim 477249112Sjkim ThisName = AcpiGbl_ResourceNames; 478249112Sjkim while (ThisName->Info.Name[0]) 479204766Sjkim { 480249112Sjkim if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 481204766Sjkim { 482204766Sjkim return (ACPI_PREDEFINED_NAME); 483204766Sjkim } 484249112Sjkim 485249112Sjkim ThisName++; 486204766Sjkim } 487204766Sjkim 488249112Sjkim ThisName = AcpiGbl_ScopeNames; 489249112Sjkim while (ThisName->Info.Name[0]) 490204766Sjkim { 491249112Sjkim if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 492204766Sjkim { 493204766Sjkim return (ACPI_PREDEFINED_NAME); 494204766Sjkim } 495249112Sjkim 496249112Sjkim ThisName++; 497204766Sjkim } 498204766Sjkim 499207344Sjkim /* Check for _Lxx/_Exx/_Wxx/_Qxx/_T_x. Warning if unknown predefined name */ 500204766Sjkim 501204766Sjkim return (ApCheckForSpecialName (Op, Name)); 502204766Sjkim} 503204766Sjkim 504204766Sjkim 505204766Sjkim/******************************************************************************* 506204766Sjkim * 507204766Sjkim * FUNCTION: ApCheckForSpecialName 508204766Sjkim * 509204766Sjkim * PARAMETERS: Op - A parse node 510204766Sjkim * Name - NameSeg to check 511204766Sjkim * 512204766Sjkim * RETURN: None 513204766Sjkim * 514206117Sjkim * DESCRIPTION: Check for the "special" predefined names - 515207344Sjkim * _Lxx, _Exx, _Qxx, _Wxx, and _T_x 516204766Sjkim * 517204766Sjkim ******************************************************************************/ 518204766Sjkim 519204766Sjkimstatic UINT32 520204766SjkimApCheckForSpecialName ( 521204766Sjkim ACPI_PARSE_OBJECT *Op, 522204766Sjkim char *Name) 523204766Sjkim{ 524204766Sjkim 525204766Sjkim /* 526207344Sjkim * Check for the "special" predefined names. We already know that the 527207344Sjkim * first character is an underscore. 528204766Sjkim * GPE: _Lxx 529204766Sjkim * GPE: _Exx 530207344Sjkim * GPE: _Wxx 531204766Sjkim * EC: _Qxx 532204766Sjkim */ 533204766Sjkim if ((Name[1] == 'L') || 534204766Sjkim (Name[1] == 'E') || 535207344Sjkim (Name[1] == 'W') || 536204766Sjkim (Name[1] == 'Q')) 537204766Sjkim { 538204766Sjkim /* The next two characters must be hex digits */ 539204766Sjkim 540204766Sjkim if ((isxdigit ((int) Name[2])) && 541204766Sjkim (isxdigit ((int) Name[3]))) 542204766Sjkim { 543204766Sjkim return (ACPI_EVENT_RESERVED_NAME); 544204766Sjkim } 545204766Sjkim } 546204766Sjkim 547204766Sjkim /* Check for the names reserved for the compiler itself: _T_x */ 548204766Sjkim 549204766Sjkim else if ((Op->Asl.ExternalName[1] == 'T') && 550204766Sjkim (Op->Asl.ExternalName[2] == '_')) 551204766Sjkim { 552204766Sjkim /* Ignore if actually emitted by the compiler */ 553204766Sjkim 554204766Sjkim if (Op->Asl.CompileFlags & NODE_COMPILER_EMITTED) 555204766Sjkim { 556204766Sjkim return (ACPI_NOT_RESERVED_NAME); 557204766Sjkim } 558204766Sjkim 559204766Sjkim /* 560204766Sjkim * Was not actually emitted by the compiler. This is a special case, 561204766Sjkim * however. If the ASL code being compiled was the result of a 562204766Sjkim * dissasembly, it may possibly contain valid compiler-emitted names 563204766Sjkim * of the form "_T_x". We don't want to issue an error or even a 564204766Sjkim * warning and force the user to manually change the names. So, we 565204766Sjkim * will issue a remark instead. 566204766Sjkim */ 567204766Sjkim AslError (ASL_REMARK, ASL_MSG_COMPILER_RESERVED, Op, Op->Asl.ExternalName); 568204766Sjkim return (ACPI_COMPILER_RESERVED_NAME); 569204766Sjkim } 570204766Sjkim 571204766Sjkim /* 572204766Sjkim * The name didn't match any of the known predefined names. Flag it as a 573204766Sjkim * warning, since the entire namespace starting with an underscore is 574204766Sjkim * reserved by the ACPI spec. 575204766Sjkim */ 576204766Sjkim AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Op, 577204766Sjkim Op->Asl.ExternalName); 578204766Sjkim 579204766Sjkim return (ACPI_NOT_RESERVED_NAME); 580204766Sjkim} 581204766Sjkim 582204766Sjkim 583204766Sjkim/******************************************************************************* 584204766Sjkim * 585204766Sjkim * FUNCTION: ApCheckObjectType 586204766Sjkim * 587245582Sjkim * PARAMETERS: PredefinedName - Name of the predefined object we are checking 588245582Sjkim * Op - Current parse node 589204766Sjkim * ExpectedBtypes - Bitmap of expected return type(s) 590246849Sjkim * PackageIndex - Index of object within parent package (if 591246849Sjkim * applicable - ACPI_NOT_PACKAGE_ELEMENT 592246849Sjkim * otherwise) 593204766Sjkim * 594204766Sjkim * RETURN: None 595204766Sjkim * 596204766Sjkim * DESCRIPTION: Check if the object type is one of the types that is expected 597204766Sjkim * by the predefined name. Only a limited number of object types 598204766Sjkim * can be returned by the predefined names. 599204766Sjkim * 600204766Sjkim ******************************************************************************/ 601204766Sjkim 602246849SjkimACPI_STATUS 603204766SjkimApCheckObjectType ( 604245582Sjkim const char *PredefinedName, 605204766Sjkim ACPI_PARSE_OBJECT *Op, 606246849Sjkim UINT32 ExpectedBtypes, 607246849Sjkim UINT32 PackageIndex) 608204766Sjkim{ 609204766Sjkim UINT32 ReturnBtype; 610246849Sjkim char *TypeName; 611204766Sjkim 612204766Sjkim 613246849Sjkim if (!Op) 614246849Sjkim { 615246849Sjkim return (AE_TYPE); 616246849Sjkim } 617246849Sjkim 618246849Sjkim /* Map the parse opcode to a bitmapped return type (RTYPE) */ 619246849Sjkim 620204766Sjkim switch (Op->Asl.ParseOpcode) 621204766Sjkim { 622206117Sjkim case PARSEOP_ZERO: 623206117Sjkim case PARSEOP_ONE: 624206117Sjkim case PARSEOP_ONES: 625204766Sjkim case PARSEOP_INTEGER: 626204766Sjkim ReturnBtype = ACPI_RTYPE_INTEGER; 627246849Sjkim TypeName = "Integer"; 628204766Sjkim break; 629204766Sjkim 630246849Sjkim case PARSEOP_STRING_LITERAL: 631246849Sjkim ReturnBtype = ACPI_RTYPE_STRING; 632246849Sjkim TypeName = "String"; 633246849Sjkim break; 634246849Sjkim 635204766Sjkim case PARSEOP_BUFFER: 636204766Sjkim ReturnBtype = ACPI_RTYPE_BUFFER; 637246849Sjkim TypeName = "Buffer"; 638204766Sjkim break; 639204766Sjkim 640204766Sjkim case PARSEOP_PACKAGE: 641228110Sjkim case PARSEOP_VAR_PACKAGE: 642204766Sjkim ReturnBtype = ACPI_RTYPE_PACKAGE; 643246849Sjkim TypeName = "Package"; 644204766Sjkim break; 645204766Sjkim 646246849Sjkim case PARSEOP_NAMESEG: 647246849Sjkim case PARSEOP_NAMESTRING: 648246849Sjkim ReturnBtype = ACPI_RTYPE_REFERENCE; 649246849Sjkim TypeName = "Reference"; 650246849Sjkim break; 651246849Sjkim 652204766Sjkim default: 653204766Sjkim /* Not one of the supported object types */ 654206117Sjkim 655246849Sjkim TypeName = UtGetOpName (Op->Asl.ParseOpcode); 656204766Sjkim goto TypeErrorExit; 657204766Sjkim } 658204766Sjkim 659206117Sjkim /* Exit if the object is one of the expected types */ 660204766Sjkim 661204766Sjkim if (ReturnBtype & ExpectedBtypes) 662204766Sjkim { 663246849Sjkim return (AE_OK); 664204766Sjkim } 665204766Sjkim 666204766Sjkim 667204766SjkimTypeErrorExit: 668204766Sjkim 669204766Sjkim /* Format the expected types and emit an error message */ 670204766Sjkim 671249112Sjkim AcpiUtGetExpectedReturnTypes (StringBuffer, ExpectedBtypes); 672204766Sjkim 673246849Sjkim if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT) 674246849Sjkim { 675249112Sjkim sprintf (MsgBuffer, "%4.4s: found %s, %s required", 676246849Sjkim PredefinedName, TypeName, StringBuffer); 677246849Sjkim } 678246849Sjkim else 679246849Sjkim { 680249112Sjkim sprintf (MsgBuffer, "%4.4s: found %s at index %u, %s required", 681246849Sjkim PredefinedName, TypeName, PackageIndex, StringBuffer); 682246849Sjkim } 683206117Sjkim 684246849Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op, MsgBuffer); 685246849Sjkim return (AE_TYPE); 686204766Sjkim} 687204766Sjkim 688204766Sjkim 689204766Sjkim/******************************************************************************* 690204766Sjkim * 691204766Sjkim * FUNCTION: ApDisplayReservedNames 692204766Sjkim * 693204766Sjkim * PARAMETERS: None 694204766Sjkim * 695204766Sjkim * RETURN: None 696204766Sjkim * 697204766Sjkim * DESCRIPTION: Dump information about the ACPI predefined names and predefined 698204766Sjkim * resource descriptor names. 699204766Sjkim * 700204766Sjkim ******************************************************************************/ 701204766Sjkim 702204766Sjkimvoid 703204766SjkimApDisplayReservedNames ( 704204766Sjkim void) 705204766Sjkim{ 706204766Sjkim const ACPI_PREDEFINED_INFO *ThisName; 707204766Sjkim UINT32 Count; 708249112Sjkim UINT32 NumTypes; 709204766Sjkim 710204766Sjkim 711204766Sjkim /* 712204766Sjkim * Predefined names/methods 713204766Sjkim */ 714204766Sjkim printf ("\nPredefined Name Information\n\n"); 715204766Sjkim 716204766Sjkim Count = 0; 717249112Sjkim ThisName = AcpiGbl_PredefinedMethods; 718204766Sjkim while (ThisName->Info.Name[0]) 719204766Sjkim { 720249112Sjkim AcpiUtDisplayPredefinedMethod (MsgBuffer, ThisName, FALSE); 721204766Sjkim Count++; 722249112Sjkim ThisName = AcpiUtGetNextPredefinedMethod (ThisName); 723204766Sjkim } 724204766Sjkim 725204766Sjkim printf ("%u Predefined Names are recognized\n", Count); 726204766Sjkim 727204766Sjkim /* 728204766Sjkim * Resource Descriptor names 729204766Sjkim */ 730249112Sjkim printf ("\nPredefined Names for Resource Descriptor Fields\n\n"); 731204766Sjkim 732204766Sjkim Count = 0; 733249112Sjkim ThisName = AcpiGbl_ResourceNames; 734204766Sjkim while (ThisName->Info.Name[0]) 735204766Sjkim { 736249112Sjkim NumTypes = AcpiUtGetResourceBitWidth (MsgBuffer, 737249112Sjkim ThisName->Info.ArgumentList); 738249112Sjkim 739249112Sjkim printf ("%4.4s Field is %s bits wide%s\n", 740249112Sjkim ThisName->Info.Name, MsgBuffer, 741249112Sjkim (NumTypes > 1) ? " (depending on descriptor type)" : ""); 742249112Sjkim 743204766Sjkim Count++; 744204766Sjkim ThisName++; 745204766Sjkim } 746204766Sjkim 747249112Sjkim printf ("%u Resource Descriptor Field Names are recognized\n", Count); 748204766Sjkim 749204766Sjkim /* 750204766Sjkim * Predefined scope names 751204766Sjkim */ 752249112Sjkim printf ("\nPredefined Scope/Device Names (automatically created at root)\n\n"); 753204766Sjkim 754249112Sjkim ThisName = AcpiGbl_ScopeNames; 755204766Sjkim while (ThisName->Info.Name[0]) 756204766Sjkim { 757249112Sjkim printf ("%4.4s Scope/Device\n", ThisName->Info.Name); 758204766Sjkim ThisName++; 759204766Sjkim } 760204766Sjkim} 761