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 /* 127249663Sjkim * Matched a predefined method name - validate the ASL-defined 128249663Sjkim * argument count against the ACPI specification. 129204766Sjkim * 130249663Sjkim * Some methods are allowed to have a "minimum" number of args 131249663Sjkim * (_SCP) because their definition in ACPI has changed over time. 132204766Sjkim */ 133204766Sjkim Gbl_ReservedMethods++; 134249112Sjkim ThisName = &AcpiGbl_PredefinedMethods[Index]; 135249663Sjkim RequiredArgCount = METHOD_GET_ARG_COUNT (ThisName->Info.ArgumentList); 136204766Sjkim 137249112Sjkim if (MethodInfo->NumArguments != RequiredArgCount) 138204766Sjkim { 139209746Sjkim sprintf (MsgBuffer, "%4.4s requires %u", 140249112Sjkim ThisName->Info.Name, RequiredArgCount); 141204766Sjkim 142249663Sjkim if (MethodInfo->NumArguments < RequiredArgCount) 143204766Sjkim { 144249663Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_LO, Op, 145204766Sjkim MsgBuffer); 146204766Sjkim } 147249663Sjkim else if ((MethodInfo->NumArguments > RequiredArgCount) && 148249663Sjkim !(ThisName->Info.ArgumentList & ARG_COUNT_IS_MINIMUM)) 149204766Sjkim { 150249663Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_ARG_COUNT_HI, Op, 151204766Sjkim MsgBuffer); 152204766Sjkim } 153204766Sjkim } 154204766Sjkim 155204766Sjkim /* 156204766Sjkim * Check if method returns no value, but the predefined name is 157204766Sjkim * required to return a value 158204766Sjkim */ 159204766Sjkim if (MethodInfo->NumReturnNoValue && 160249112Sjkim ThisName->Info.ExpectedBtypes) 161204766Sjkim { 162249112Sjkim AcpiUtGetExpectedReturnTypes (StringBuffer, 163249112Sjkim ThisName->Info.ExpectedBtypes); 164204766Sjkim 165206117Sjkim sprintf (MsgBuffer, "%s required for %4.4s", 166249112Sjkim StringBuffer, ThisName->Info.Name); 167206117Sjkim 168204766Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_RETURN_VALUE, Op, 169204766Sjkim MsgBuffer); 170204766Sjkim } 171204766Sjkim break; 172204766Sjkim } 173220663Sjkim 174220663Sjkim return (TRUE); 175204766Sjkim} 176204766Sjkim 177204766Sjkim 178204766Sjkim/******************************************************************************* 179204766Sjkim * 180218590Sjkim * FUNCTION: ApCheckForUnexpectedReturnValue 181218590Sjkim * 182218590Sjkim * PARAMETERS: Op - A parse node of type "RETURN". 183218590Sjkim * MethodInfo - Saved info about this method 184218590Sjkim * 185218590Sjkim * RETURN: None 186218590Sjkim * 187218590Sjkim * DESCRIPTION: Check for an unexpected return value from a predefined method. 188218590Sjkim * Invoked for predefined methods that are defined to not return 189218590Sjkim * any value. If there is a return value, issue a remark, since 190218590Sjkim * the ASL writer may be confused as to the method definition 191218590Sjkim * and/or functionality. 192218590Sjkim * 193218590Sjkim * Note: We ignore all return values of "Zero", since this is what a standalone 194218590Sjkim * Return() statement will always generate -- so we ignore it here -- 195218590Sjkim * i.e., there is no difference between Return() and Return(Zero). 196218590Sjkim * Also, a null Return() will be disassembled to return(Zero) -- so, we 197218590Sjkim * don't want to generate extraneous remarks/warnings for a disassembled 198218590Sjkim * ASL file. 199218590Sjkim * 200218590Sjkim ******************************************************************************/ 201218590Sjkim 202218590Sjkimstatic void 203218590SjkimApCheckForUnexpectedReturnValue ( 204218590Sjkim ACPI_PARSE_OBJECT *Op, 205218590Sjkim ASL_METHOD_INFO *MethodInfo) 206218590Sjkim{ 207218590Sjkim ACPI_PARSE_OBJECT *ReturnValueOp; 208218590Sjkim 209218590Sjkim 210218590Sjkim /* Ignore Return() and Return(Zero) (they are the same) */ 211218590Sjkim 212218590Sjkim ReturnValueOp = Op->Asl.Child; 213218590Sjkim if (ReturnValueOp->Asl.ParseOpcode == PARSEOP_ZERO) 214218590Sjkim { 215218590Sjkim return; 216218590Sjkim } 217218590Sjkim 218218590Sjkim /* We have a valid return value, but the reserved name did not expect it */ 219218590Sjkim 220218590Sjkim AslError (ASL_WARNING, ASL_MSG_RESERVED_NO_RETURN_VAL, 221218590Sjkim Op, MethodInfo->Op->Asl.ExternalName); 222218590Sjkim} 223218590Sjkim 224218590Sjkim 225218590Sjkim/******************************************************************************* 226218590Sjkim * 227206117Sjkim * FUNCTION: ApCheckPredefinedReturnValue 228206117Sjkim * 229206117Sjkim * PARAMETERS: Op - A parse node of type "RETURN". 230206117Sjkim * MethodInfo - Saved info about this method 231206117Sjkim * 232206117Sjkim * RETURN: None 233206117Sjkim * 234206117Sjkim * DESCRIPTION: If method is a predefined name, attempt to validate the return 235206117Sjkim * value. Only "static" types can be validated - a simple return 236206117Sjkim * of an integer/string/buffer/package or a named reference to 237206117Sjkim * a static object. Values such as a Localx or Argx or a control 238218590Sjkim * method invocation are not checked. Issue a warning if there is 239218590Sjkim * a valid return value, but the reserved method defines no 240218590Sjkim * return value. 241206117Sjkim * 242206117Sjkim ******************************************************************************/ 243206117Sjkim 244206117Sjkimvoid 245206117SjkimApCheckPredefinedReturnValue ( 246206117Sjkim ACPI_PARSE_OBJECT *Op, 247206117Sjkim ASL_METHOD_INFO *MethodInfo) 248206117Sjkim{ 249249112Sjkim UINT32 Index; 250249112Sjkim ACPI_PARSE_OBJECT *ReturnValueOp; 251249112Sjkim const ACPI_PREDEFINED_INFO *ThisName; 252206117Sjkim 253206117Sjkim 254206117Sjkim /* Check parent method for a match against the predefined name list */ 255206117Sjkim 256206117Sjkim Index = ApCheckForPredefinedName (MethodInfo->Op, 257206117Sjkim MethodInfo->Op->Asl.NameSeg); 258206117Sjkim 259206117Sjkim switch (Index) 260206117Sjkim { 261218590Sjkim case ACPI_EVENT_RESERVED_NAME: /* _Lxx/_Exx/_Wxx/_Qxx methods */ 262218590Sjkim 263218590Sjkim /* No return value expected, warn if there is one */ 264218590Sjkim 265218590Sjkim ApCheckForUnexpectedReturnValue (Op, MethodInfo); 266218590Sjkim return; 267218590Sjkim 268206117Sjkim case ACPI_NOT_RESERVED_NAME: /* No underscore or _Txx or _xxx name not matched */ 269206117Sjkim case ACPI_PREDEFINED_NAME: /* Resource Name or reserved scope name */ 270206117Sjkim case ACPI_COMPILER_RESERVED_NAME: /* A _Txx that was not emitted by compiler */ 271206117Sjkim 272206117Sjkim /* Just return, nothing to do */ 273206117Sjkim return; 274206117Sjkim 275207344Sjkim default: /* A standard predefined ACPI name */ 276206117Sjkim 277249112Sjkim ThisName = &AcpiGbl_PredefinedMethods[Index]; 278249112Sjkim if (!ThisName->Info.ExpectedBtypes) 279206117Sjkim { 280218590Sjkim /* No return value expected, warn if there is one */ 281218590Sjkim 282218590Sjkim ApCheckForUnexpectedReturnValue (Op, MethodInfo); 283206117Sjkim return; 284206117Sjkim } 285206117Sjkim 286206117Sjkim /* Get the object returned, it is the next argument */ 287206117Sjkim 288206117Sjkim ReturnValueOp = Op->Asl.Child; 289206117Sjkim switch (ReturnValueOp->Asl.ParseOpcode) 290206117Sjkim { 291206117Sjkim case PARSEOP_ZERO: 292206117Sjkim case PARSEOP_ONE: 293206117Sjkim case PARSEOP_ONES: 294206117Sjkim case PARSEOP_INTEGER: 295206117Sjkim case PARSEOP_STRING_LITERAL: 296206117Sjkim case PARSEOP_BUFFER: 297206117Sjkim case PARSEOP_PACKAGE: 298206117Sjkim 299206117Sjkim /* Static data return object - check against expected type */ 300206117Sjkim 301249112Sjkim ApCheckObjectType (ThisName->Info.Name, ReturnValueOp, 302249112Sjkim ThisName->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT); 303246849Sjkim 304246849Sjkim /* For packages, check the individual package elements */ 305246849Sjkim 306246849Sjkim if (ReturnValueOp->Asl.ParseOpcode == PARSEOP_PACKAGE) 307246849Sjkim { 308249112Sjkim ApCheckPackage (ReturnValueOp, ThisName); 309246849Sjkim } 310206117Sjkim break; 311206117Sjkim 312206117Sjkim default: 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: 381250838Sjkim 382246849Sjkim break; 383246849Sjkim } 384204766Sjkim 385246849Sjkim /* A standard predefined ACPI name */ 386207344Sjkim 387246849Sjkim /* 388246849Sjkim * If this predefined name requires input arguments, then 389246849Sjkim * it must be implemented as a control method 390246849Sjkim */ 391249112Sjkim ThisName = &AcpiGbl_PredefinedMethods[Index]; 392249663Sjkim if (METHOD_GET_ARG_COUNT (ThisName->Info.ArgumentList) > 0) 393246849Sjkim { 394246849Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 395246849Sjkim "with arguments"); 396246849Sjkim return; 397246849Sjkim } 398207344Sjkim 399246849Sjkim /* 400246849Sjkim * If no return value is expected from this predefined name, then 401246849Sjkim * it follows that it must be implemented as a control method 402246849Sjkim * (with zero args, because the args > 0 case was handled above) 403246849Sjkim * Examples are: _DIS, _INI, _IRC, _OFF, _ON, _PSx 404246849Sjkim */ 405249112Sjkim if (!ThisName->Info.ExpectedBtypes) 406246849Sjkim { 407246849Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_METHOD, Op, 408246849Sjkim "with zero arguments"); 409207344Sjkim return; 410207344Sjkim } 411246849Sjkim 412246849Sjkim /* Typecheck the actual object, it is the next argument */ 413246849Sjkim 414246849Sjkim ObjectOp = Op->Asl.Child->Asl.Next; 415249112Sjkim ApCheckObjectType (ThisName->Info.Name, Op->Asl.Child->Asl.Next, 416249112Sjkim ThisName->Info.ExpectedBtypes, ACPI_NOT_PACKAGE_ELEMENT); 417246849Sjkim 418246849Sjkim /* For packages, check the individual package elements */ 419246849Sjkim 420246849Sjkim if (ObjectOp->Asl.ParseOpcode == PARSEOP_PACKAGE) 421246849Sjkim { 422249112Sjkim ApCheckPackage (ObjectOp, ThisName); 423246849Sjkim } 424204766Sjkim} 425204766Sjkim 426204766Sjkim 427204766Sjkim/******************************************************************************* 428204766Sjkim * 429204766Sjkim * FUNCTION: ApCheckForPredefinedName 430204766Sjkim * 431204766Sjkim * PARAMETERS: Op - A parse node 432204766Sjkim * Name - NameSeg to check 433204766Sjkim * 434204766Sjkim * RETURN: None 435204766Sjkim * 436204766Sjkim * DESCRIPTION: Check a NameSeg against the reserved list. 437204766Sjkim * 438204766Sjkim ******************************************************************************/ 439204766Sjkim 440204766SjkimUINT32 441204766SjkimApCheckForPredefinedName ( 442204766Sjkim ACPI_PARSE_OBJECT *Op, 443204766Sjkim char *Name) 444204766Sjkim{ 445249112Sjkim UINT32 i; 446249112Sjkim const ACPI_PREDEFINED_INFO *ThisName; 447204766Sjkim 448204766Sjkim 449204766Sjkim if (Name[0] == 0) 450204766Sjkim { 451204766Sjkim AcpiOsPrintf ("Found a null name, external = %s\n", 452204766Sjkim Op->Asl.ExternalName); 453204766Sjkim } 454204766Sjkim 455204766Sjkim /* All reserved names are prefixed with a single underscore */ 456204766Sjkim 457204766Sjkim if (Name[0] != '_') 458204766Sjkim { 459204766Sjkim return (ACPI_NOT_RESERVED_NAME); 460204766Sjkim } 461204766Sjkim 462204766Sjkim /* Check for a standard predefined method name */ 463204766Sjkim 464249112Sjkim ThisName = AcpiGbl_PredefinedMethods; 465249112Sjkim for (i = 0; ThisName->Info.Name[0]; i++) 466204766Sjkim { 467249112Sjkim if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 468204766Sjkim { 469204766Sjkim /* Return index into predefined array */ 470204766Sjkim return (i); 471204766Sjkim } 472249112Sjkim 473249112Sjkim ThisName++; /* Does not account for extra package data, but is OK */ 474204766Sjkim } 475204766Sjkim 476204766Sjkim /* Check for resource names and predefined scope names */ 477204766Sjkim 478249112Sjkim ThisName = AcpiGbl_ResourceNames; 479249112Sjkim while (ThisName->Info.Name[0]) 480204766Sjkim { 481249112Sjkim if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 482204766Sjkim { 483204766Sjkim return (ACPI_PREDEFINED_NAME); 484204766Sjkim } 485249112Sjkim 486249112Sjkim ThisName++; 487204766Sjkim } 488204766Sjkim 489249112Sjkim ThisName = AcpiGbl_ScopeNames; 490249112Sjkim while (ThisName->Info.Name[0]) 491204766Sjkim { 492249112Sjkim if (ACPI_COMPARE_NAME (Name, ThisName->Info.Name)) 493204766Sjkim { 494204766Sjkim return (ACPI_PREDEFINED_NAME); 495204766Sjkim } 496249112Sjkim 497249112Sjkim ThisName++; 498204766Sjkim } 499204766Sjkim 500207344Sjkim /* Check for _Lxx/_Exx/_Wxx/_Qxx/_T_x. Warning if unknown predefined name */ 501204766Sjkim 502204766Sjkim return (ApCheckForSpecialName (Op, Name)); 503204766Sjkim} 504204766Sjkim 505204766Sjkim 506204766Sjkim/******************************************************************************* 507204766Sjkim * 508204766Sjkim * FUNCTION: ApCheckForSpecialName 509204766Sjkim * 510204766Sjkim * PARAMETERS: Op - A parse node 511204766Sjkim * Name - NameSeg to check 512204766Sjkim * 513204766Sjkim * RETURN: None 514204766Sjkim * 515206117Sjkim * DESCRIPTION: Check for the "special" predefined names - 516207344Sjkim * _Lxx, _Exx, _Qxx, _Wxx, and _T_x 517204766Sjkim * 518204766Sjkim ******************************************************************************/ 519204766Sjkim 520204766Sjkimstatic UINT32 521204766SjkimApCheckForSpecialName ( 522204766Sjkim ACPI_PARSE_OBJECT *Op, 523204766Sjkim char *Name) 524204766Sjkim{ 525204766Sjkim 526204766Sjkim /* 527207344Sjkim * Check for the "special" predefined names. We already know that the 528207344Sjkim * first character is an underscore. 529204766Sjkim * GPE: _Lxx 530204766Sjkim * GPE: _Exx 531207344Sjkim * GPE: _Wxx 532204766Sjkim * EC: _Qxx 533204766Sjkim */ 534204766Sjkim if ((Name[1] == 'L') || 535204766Sjkim (Name[1] == 'E') || 536207344Sjkim (Name[1] == 'W') || 537204766Sjkim (Name[1] == 'Q')) 538204766Sjkim { 539204766Sjkim /* The next two characters must be hex digits */ 540204766Sjkim 541204766Sjkim if ((isxdigit ((int) Name[2])) && 542204766Sjkim (isxdigit ((int) Name[3]))) 543204766Sjkim { 544204766Sjkim return (ACPI_EVENT_RESERVED_NAME); 545204766Sjkim } 546204766Sjkim } 547204766Sjkim 548204766Sjkim /* Check for the names reserved for the compiler itself: _T_x */ 549204766Sjkim 550204766Sjkim else if ((Op->Asl.ExternalName[1] == 'T') && 551204766Sjkim (Op->Asl.ExternalName[2] == '_')) 552204766Sjkim { 553204766Sjkim /* Ignore if actually emitted by the compiler */ 554204766Sjkim 555204766Sjkim if (Op->Asl.CompileFlags & NODE_COMPILER_EMITTED) 556204766Sjkim { 557204766Sjkim return (ACPI_NOT_RESERVED_NAME); 558204766Sjkim } 559204766Sjkim 560204766Sjkim /* 561204766Sjkim * Was not actually emitted by the compiler. This is a special case, 562204766Sjkim * however. If the ASL code being compiled was the result of a 563204766Sjkim * dissasembly, it may possibly contain valid compiler-emitted names 564204766Sjkim * of the form "_T_x". We don't want to issue an error or even a 565204766Sjkim * warning and force the user to manually change the names. So, we 566204766Sjkim * will issue a remark instead. 567204766Sjkim */ 568204766Sjkim AslError (ASL_REMARK, ASL_MSG_COMPILER_RESERVED, Op, Op->Asl.ExternalName); 569204766Sjkim return (ACPI_COMPILER_RESERVED_NAME); 570204766Sjkim } 571204766Sjkim 572204766Sjkim /* 573204766Sjkim * The name didn't match any of the known predefined names. Flag it as a 574204766Sjkim * warning, since the entire namespace starting with an underscore is 575204766Sjkim * reserved by the ACPI spec. 576204766Sjkim */ 577204766Sjkim AslError (ASL_WARNING, ASL_MSG_UNKNOWN_RESERVED_NAME, Op, 578204766Sjkim Op->Asl.ExternalName); 579204766Sjkim 580204766Sjkim return (ACPI_NOT_RESERVED_NAME); 581204766Sjkim} 582204766Sjkim 583204766Sjkim 584204766Sjkim/******************************************************************************* 585204766Sjkim * 586204766Sjkim * FUNCTION: ApCheckObjectType 587204766Sjkim * 588245582Sjkim * PARAMETERS: PredefinedName - Name of the predefined object we are checking 589245582Sjkim * Op - Current parse node 590204766Sjkim * ExpectedBtypes - Bitmap of expected return type(s) 591246849Sjkim * PackageIndex - Index of object within parent package (if 592246849Sjkim * applicable - ACPI_NOT_PACKAGE_ELEMENT 593246849Sjkim * otherwise) 594204766Sjkim * 595204766Sjkim * RETURN: None 596204766Sjkim * 597204766Sjkim * DESCRIPTION: Check if the object type is one of the types that is expected 598204766Sjkim * by the predefined name. Only a limited number of object types 599204766Sjkim * can be returned by the predefined names. 600204766Sjkim * 601204766Sjkim ******************************************************************************/ 602204766Sjkim 603246849SjkimACPI_STATUS 604204766SjkimApCheckObjectType ( 605245582Sjkim const char *PredefinedName, 606204766Sjkim ACPI_PARSE_OBJECT *Op, 607246849Sjkim UINT32 ExpectedBtypes, 608246849Sjkim UINT32 PackageIndex) 609204766Sjkim{ 610204766Sjkim UINT32 ReturnBtype; 611246849Sjkim char *TypeName; 612204766Sjkim 613204766Sjkim 614246849Sjkim if (!Op) 615246849Sjkim { 616246849Sjkim return (AE_TYPE); 617246849Sjkim } 618246849Sjkim 619246849Sjkim /* Map the parse opcode to a bitmapped return type (RTYPE) */ 620246849Sjkim 621204766Sjkim switch (Op->Asl.ParseOpcode) 622204766Sjkim { 623206117Sjkim case PARSEOP_ZERO: 624206117Sjkim case PARSEOP_ONE: 625206117Sjkim case PARSEOP_ONES: 626204766Sjkim case PARSEOP_INTEGER: 627250838Sjkim 628204766Sjkim ReturnBtype = ACPI_RTYPE_INTEGER; 629246849Sjkim TypeName = "Integer"; 630204766Sjkim break; 631204766Sjkim 632246849Sjkim case PARSEOP_STRING_LITERAL: 633250838Sjkim 634246849Sjkim ReturnBtype = ACPI_RTYPE_STRING; 635246849Sjkim TypeName = "String"; 636246849Sjkim break; 637246849Sjkim 638204766Sjkim case PARSEOP_BUFFER: 639250838Sjkim 640204766Sjkim ReturnBtype = ACPI_RTYPE_BUFFER; 641246849Sjkim TypeName = "Buffer"; 642204766Sjkim break; 643204766Sjkim 644204766Sjkim case PARSEOP_PACKAGE: 645228110Sjkim case PARSEOP_VAR_PACKAGE: 646250838Sjkim 647204766Sjkim ReturnBtype = ACPI_RTYPE_PACKAGE; 648246849Sjkim TypeName = "Package"; 649204766Sjkim break; 650204766Sjkim 651246849Sjkim case PARSEOP_NAMESEG: 652246849Sjkim case PARSEOP_NAMESTRING: 653250838Sjkim /* 654250838Sjkim * Ignore any named references within a package object. 655250838Sjkim * 656250838Sjkim * For Package objects, references are allowed instead of any of the 657250838Sjkim * standard data types (Integer/String/Buffer/Package). These 658250838Sjkim * references are resolved at runtime. NAMESEG and NAMESTRING are 659250838Sjkim * impossible to typecheck at compile time because the type of 660250838Sjkim * any named object can be changed at runtime (for example, 661250838Sjkim * CopyObject will change the type of the target object). 662250838Sjkim */ 663250838Sjkim if (PackageIndex != ACPI_NOT_PACKAGE_ELEMENT) 664250838Sjkim { 665250838Sjkim return (AE_OK); 666250838Sjkim } 667250838Sjkim 668246849Sjkim ReturnBtype = ACPI_RTYPE_REFERENCE; 669246849Sjkim TypeName = "Reference"; 670246849Sjkim break; 671246849Sjkim 672204766Sjkim default: 673250838Sjkim 674204766Sjkim /* Not one of the supported object types */ 675206117Sjkim 676246849Sjkim TypeName = UtGetOpName (Op->Asl.ParseOpcode); 677204766Sjkim goto TypeErrorExit; 678204766Sjkim } 679204766Sjkim 680206117Sjkim /* Exit if the object is one of the expected types */ 681204766Sjkim 682204766Sjkim if (ReturnBtype & ExpectedBtypes) 683204766Sjkim { 684246849Sjkim return (AE_OK); 685204766Sjkim } 686204766Sjkim 687204766Sjkim 688204766SjkimTypeErrorExit: 689204766Sjkim 690204766Sjkim /* Format the expected types and emit an error message */ 691204766Sjkim 692249112Sjkim AcpiUtGetExpectedReturnTypes (StringBuffer, ExpectedBtypes); 693204766Sjkim 694246849Sjkim if (PackageIndex == ACPI_NOT_PACKAGE_ELEMENT) 695246849Sjkim { 696249112Sjkim sprintf (MsgBuffer, "%4.4s: found %s, %s required", 697246849Sjkim PredefinedName, TypeName, StringBuffer); 698246849Sjkim } 699246849Sjkim else 700246849Sjkim { 701249112Sjkim sprintf (MsgBuffer, "%4.4s: found %s at index %u, %s required", 702246849Sjkim PredefinedName, TypeName, PackageIndex, StringBuffer); 703246849Sjkim } 704206117Sjkim 705246849Sjkim AslError (ASL_ERROR, ASL_MSG_RESERVED_OPERAND_TYPE, Op, MsgBuffer); 706246849Sjkim return (AE_TYPE); 707204766Sjkim} 708204766Sjkim 709204766Sjkim 710204766Sjkim/******************************************************************************* 711204766Sjkim * 712204766Sjkim * FUNCTION: ApDisplayReservedNames 713204766Sjkim * 714204766Sjkim * PARAMETERS: None 715204766Sjkim * 716204766Sjkim * RETURN: None 717204766Sjkim * 718204766Sjkim * DESCRIPTION: Dump information about the ACPI predefined names and predefined 719204766Sjkim * resource descriptor names. 720204766Sjkim * 721204766Sjkim ******************************************************************************/ 722204766Sjkim 723204766Sjkimvoid 724204766SjkimApDisplayReservedNames ( 725204766Sjkim void) 726204766Sjkim{ 727204766Sjkim const ACPI_PREDEFINED_INFO *ThisName; 728204766Sjkim UINT32 Count; 729249112Sjkim UINT32 NumTypes; 730204766Sjkim 731204766Sjkim 732204766Sjkim /* 733204766Sjkim * Predefined names/methods 734204766Sjkim */ 735204766Sjkim printf ("\nPredefined Name Information\n\n"); 736204766Sjkim 737204766Sjkim Count = 0; 738249112Sjkim ThisName = AcpiGbl_PredefinedMethods; 739204766Sjkim while (ThisName->Info.Name[0]) 740204766Sjkim { 741249112Sjkim AcpiUtDisplayPredefinedMethod (MsgBuffer, ThisName, FALSE); 742204766Sjkim Count++; 743249112Sjkim ThisName = AcpiUtGetNextPredefinedMethod (ThisName); 744204766Sjkim } 745204766Sjkim 746204766Sjkim printf ("%u Predefined Names are recognized\n", Count); 747204766Sjkim 748204766Sjkim /* 749204766Sjkim * Resource Descriptor names 750204766Sjkim */ 751249112Sjkim printf ("\nPredefined Names for Resource Descriptor Fields\n\n"); 752204766Sjkim 753204766Sjkim Count = 0; 754249112Sjkim ThisName = AcpiGbl_ResourceNames; 755204766Sjkim while (ThisName->Info.Name[0]) 756204766Sjkim { 757249112Sjkim NumTypes = AcpiUtGetResourceBitWidth (MsgBuffer, 758249112Sjkim ThisName->Info.ArgumentList); 759249112Sjkim 760249112Sjkim printf ("%4.4s Field is %s bits wide%s\n", 761249112Sjkim ThisName->Info.Name, MsgBuffer, 762249112Sjkim (NumTypes > 1) ? " (depending on descriptor type)" : ""); 763249112Sjkim 764204766Sjkim Count++; 765204766Sjkim ThisName++; 766204766Sjkim } 767204766Sjkim 768249112Sjkim printf ("%u Resource Descriptor Field Names are recognized\n", Count); 769204766Sjkim 770204766Sjkim /* 771204766Sjkim * Predefined scope names 772204766Sjkim */ 773249112Sjkim printf ("\nPredefined Scope/Device Names (automatically created at root)\n\n"); 774204766Sjkim 775249112Sjkim ThisName = AcpiGbl_ScopeNames; 776204766Sjkim while (ThisName->Info.Name[0]) 777204766Sjkim { 778249112Sjkim printf ("%4.4s Scope/Device\n", ThisName->Info.Name); 779204766Sjkim ThisName++; 780204766Sjkim } 781204766Sjkim} 782