1 /****************************************************************************** 2 * 3 * Module Name: aslcodegen - AML code generation 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2013, 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 45 #include <contrib/dev/acpica/compiler/aslcompiler.h> 46 #include "aslcompiler.y.h" 47 #include <contrib/dev/acpica/include/amlcode.h> 48 49 #define _COMPONENT ACPI_COMPILER 50 ACPI_MODULE_NAME ("aslcodegen") 51 52 /* Local prototypes */ 53 54 static ACPI_STATUS 55 CgAmlWriteWalk ( 56 ACPI_PARSE_OBJECT *Op, 57 UINT32 Level, 58 void *Context); 59 60 static void 61 CgLocalWriteAmlData ( 62 ACPI_PARSE_OBJECT *Op, 63 void *Buffer, 64 UINT32 Length); 65 66 static void 67 CgWriteAmlOpcode ( 68 ACPI_PARSE_OBJECT *Op); 69 70 static void 71 CgWriteTableHeader ( 72 ACPI_PARSE_OBJECT *Op); 73 74 static void 75 CgCloseTable ( 76 void); 77 78 static void 79 CgWriteNode ( 80 ACPI_PARSE_OBJECT *Op); 81 82 83 /******************************************************************************* 84 * 85 * FUNCTION: CgGenerateAmlOutput 86 * 87 * PARAMETERS: None. 88 * 89 * RETURN: None 90 * 91 * DESCRIPTION: Generate AML code. Currently generates the listing file 92 * simultaneously. 93 * 94 ******************************************************************************/ 95 96 void 97 CgGenerateAmlOutput ( 98 void) 99 { 100 101 DbgPrint (ASL_DEBUG_OUTPUT, "\nWriting AML\n\n"); 102 103 /* Generate the AML output file */ 104 105 FlSeekFile (ASL_FILE_SOURCE_OUTPUT, 0); 106 Gbl_SourceLine = 0; 107 Gbl_NextError = Gbl_ErrorLog; 108 109 TrWalkParseTree (RootNode, ASL_WALK_VISIT_DOWNWARD, 110 CgAmlWriteWalk, NULL, NULL); 111 CgCloseTable (); 112 } 113 114 115 /******************************************************************************* 116 * 117 * FUNCTION: CgAmlWriteWalk 118 * 119 * PARAMETERS: ASL_WALK_CALLBACK 120 * 121 * RETURN: Status 122 * 123 * DESCRIPTION: Parse tree walk to generate the AML code. 124 * 125 ******************************************************************************/ 126 127 static ACPI_STATUS 128 CgAmlWriteWalk ( 129 ACPI_PARSE_OBJECT *Op, 130 UINT32 Level, 131 void *Context) 132 { 133 134 /* 135 * Print header at level 0. Alignment assumes 32-bit pointers 136 */ 137 if (!Level) 138 { 139 DbgPrint (ASL_TREE_OUTPUT, 140 "Final parse tree used for AML output:\n"); 141 DbgPrint (ASL_TREE_OUTPUT, 142 "%*s Value P_Op A_Op OpLen PByts Len SubLen PSubLen OpPtr Child Parent Flags AcTyp Final Col L\n", 143 76, " "); 144 } 145 146 /* Debug output */ 147 148 DbgPrint (ASL_TREE_OUTPUT, 149 "%5.5d [%2d]", Op->Asl.LogicalLineNumber, Level); 150 UtPrintFormattedName (Op->Asl.ParseOpcode, Level); 151 152 if (Op->Asl.ParseOpcode == PARSEOP_NAMESEG || 153 Op->Asl.ParseOpcode == PARSEOP_NAMESTRING || 154 Op->Asl.ParseOpcode == PARSEOP_METHODCALL) 155 { 156 DbgPrint (ASL_TREE_OUTPUT, 157 "%10.32s ", Op->Asl.ExternalName); 158 } 159 else 160 { 161 DbgPrint (ASL_TREE_OUTPUT, " "); 162 } 163 164 DbgPrint (ASL_TREE_OUTPUT, 165 "%08X %04X %04X %01X %04X %04X %04X %04X %08X %08X %08X %08X %08X %04X %02d %02d\n", 166 /* 1 */ (UINT32) Op->Asl.Value.Integer, 167 /* 2 */ Op->Asl.ParseOpcode, 168 /* 3 */ Op->Asl.AmlOpcode, 169 /* 4 */ Op->Asl.AmlOpcodeLength, 170 /* 5 */ Op->Asl.AmlPkgLenBytes, 171 /* 6 */ Op->Asl.AmlLength, 172 /* 7 */ Op->Asl.AmlSubtreeLength, 173 /* 8 */ Op->Asl.Parent ? Op->Asl.Parent->Asl.AmlSubtreeLength : 0, 174 /* 9 */ Op, 175 /* 10 */ Op->Asl.Child, 176 /* 11 */ Op->Asl.Parent, 177 /* 12 */ Op->Asl.CompileFlags, 178 /* 13 */ Op->Asl.AcpiBtype, 179 /* 14 */ Op->Asl.FinalAmlLength, 180 /* 15 */ Op->Asl.Column, 181 /* 16 */ Op->Asl.LineNumber); 182 183 /* Generate the AML for this node */ 184 185 CgWriteNode (Op); 186 return (AE_OK); 187 } 188 189 190 /******************************************************************************* 191 * 192 * FUNCTION: CgLocalWriteAmlData 193 * 194 * PARAMETERS: Op - Current parse op 195 * Buffer - Buffer to write 196 * Length - Size of data in buffer 197 * 198 * RETURN: None 199 * 200 * DESCRIPTION: Write a buffer of AML data to the AML output file. 201 * 202 ******************************************************************************/ 203 204 static void 205 CgLocalWriteAmlData ( 206 ACPI_PARSE_OBJECT *Op, 207 void *Buffer, 208 UINT32 Length) 209 { 210 211 /* Write the raw data to the AML file */ 212 213 FlWriteFile (ASL_FILE_AML_OUTPUT, Buffer, Length); 214 215 /* Update the final AML length for this node (used for listings) */ 216 217 if (Op) 218 { 219 Op->Asl.FinalAmlLength += Length; 220 } 221 } 222 223 224 /******************************************************************************* 225 * 226 * FUNCTION: CgWriteAmlOpcode 227 * 228 * PARAMETERS: Op - Parse node with an AML opcode 229 * 230 * RETURN: None. 231 * 232 * DESCRIPTION: Write the AML opcode corresponding to a parse node. 233 * 234 ******************************************************************************/ 235 236 static void 237 CgWriteAmlOpcode ( 238 ACPI_PARSE_OBJECT *Op) 239 { 240 UINT8 PkgLenFirstByte; 241 UINT32 i; 242 union { 243 UINT16 Opcode; 244 UINT8 OpcodeBytes[2]; 245 } Aml; 246 union { 247 UINT32 Len; 248 UINT8 LenBytes[4]; 249 } PkgLen; 250 251 252 /* We expect some DEFAULT_ARGs, just ignore them */ 253 254 if (Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) 255 { 256 return; 257 } 258 259 switch (Op->Asl.AmlOpcode) 260 { 261 case AML_UNASSIGNED_OPCODE: 262 263 /* These opcodes should not get here */ 264 265 printf ("Found a node with an unassigned AML opcode\n"); 266 FlPrintFile (ASL_FILE_STDERR, "Found a node with an unassigned AML opcode\n"); 267 return; 268 269 case AML_INT_RESERVEDFIELD_OP: 270 271 /* Special opcodes for within a field definition */ 272 273 Aml.Opcode = AML_FIELD_OFFSET_OP; 274 break; 275 276 case AML_INT_ACCESSFIELD_OP: 277 278 Aml.Opcode = AML_FIELD_ACCESS_OP; 279 break; 280 281 case AML_INT_CONNECTION_OP: 282 283 Aml.Opcode = AML_FIELD_CONNECTION_OP; 284 break; 285 286 default: 287 288 Aml.Opcode = Op->Asl.AmlOpcode; 289 break; 290 } 291 292 293 switch (Aml.Opcode) 294 { 295 case AML_PACKAGE_LENGTH: 296 297 /* Value is the length to be encoded (Used in field definitions) */ 298 299 PkgLen.Len = (UINT32) Op->Asl.Value.Integer; 300 break; 301 302 default: 303 304 /* Check for two-byte opcode */ 305 306 if (Aml.Opcode > 0x00FF) 307 { 308 /* Write the high byte first */ 309 310 CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[1], 1); 311 } 312 313 CgLocalWriteAmlData (Op, &Aml.OpcodeBytes[0], 1); 314 315 /* Subtreelength doesn't include length of package length bytes */ 316 317 PkgLen.Len = Op->Asl.AmlSubtreeLength + Op->Asl.AmlPkgLenBytes; 318 break; 319 } 320 321 /* Does this opcode have an associated "PackageLength" field? */ 322 323 if (Op->Asl.CompileFlags & NODE_AML_PACKAGE) 324 { 325 if (Op->Asl.AmlPkgLenBytes == 1) 326 { 327 /* Simplest case -- no bytes to follow, just write the count */ 328 329 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[0], 1); 330 } 331 else if (Op->Asl.AmlPkgLenBytes != 0) 332 { 333 /* 334 * Encode the "bytes to follow" in the first byte, top two bits. 335 * The low-order nybble of the length is in the bottom 4 bits 336 */ 337 PkgLenFirstByte = (UINT8) 338 (((UINT32) (Op->Asl.AmlPkgLenBytes - 1) << 6) | 339 (PkgLen.LenBytes[0] & 0x0F)); 340 341 CgLocalWriteAmlData (Op, &PkgLenFirstByte, 1); 342 343 /* 344 * Shift the length over by the 4 bits we just stuffed 345 * in the first byte 346 */ 347 PkgLen.Len >>= 4; 348 349 /* Now we can write the remaining bytes - either 1, 2, or 3 bytes */ 350 351 for (i = 0; i < (UINT32) (Op->Asl.AmlPkgLenBytes - 1); i++) 352 { 353 CgLocalWriteAmlData (Op, &PkgLen.LenBytes[i], 1); 354 } 355 } 356 } 357 358 switch (Aml.Opcode) 359 { 360 case AML_BYTE_OP: 361 362 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 1); 363 break; 364 365 case AML_WORD_OP: 366 367 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 2); 368 break; 369 370 case AML_DWORD_OP: 371 372 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 4); 373 break; 374 375 case AML_QWORD_OP: 376 377 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, 8); 378 break; 379 380 case AML_STRING_OP: 381 382 CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength); 383 break; 384 385 default: 386 387 /* All data opcodes must appear above */ 388 389 break; 390 } 391 } 392 393 394 /******************************************************************************* 395 * 396 * FUNCTION: CgWriteTableHeader 397 * 398 * PARAMETERS: Op - The DEFINITIONBLOCK node 399 * 400 * RETURN: None 401 * 402 * DESCRIPTION: Write a table header corresponding to the DEFINITIONBLOCK 403 * 404 ******************************************************************************/ 405 406 static void 407 CgWriteTableHeader ( 408 ACPI_PARSE_OBJECT *Op) 409 { 410 ACPI_PARSE_OBJECT *Child; 411 412 413 /* AML filename */ 414 415 Child = Op->Asl.Child; 416 417 /* Signature */ 418 419 Child = Child->Asl.Next; 420 strncpy (TableHeader.Signature, Child->Asl.Value.String, 4); 421 422 /* Revision */ 423 424 Child = Child->Asl.Next; 425 TableHeader.Revision = (UINT8) Child->Asl.Value.Integer; 426 427 /* Command-line Revision override */ 428 429 if (Gbl_RevisionOverride) 430 { 431 TableHeader.Revision = Gbl_RevisionOverride; 432 } 433 434 /* OEMID */ 435 436 Child = Child->Asl.Next; 437 strncpy (TableHeader.OemId, Child->Asl.Value.String, 6); 438 439 /* OEM TableID */ 440 441 Child = Child->Asl.Next; 442 strncpy (TableHeader.OemTableId, Child->Asl.Value.String, 8); 443 444 /* OEM Revision */ 445 446 Child = Child->Asl.Next; 447 TableHeader.OemRevision = (UINT32) Child->Asl.Value.Integer; 448 449 /* Compiler ID */ 450 451 ACPI_MOVE_NAME (TableHeader.AslCompilerId, ASL_CREATOR_ID); 452 453 /* Compiler version */ 454 455 TableHeader.AslCompilerRevision = ASL_REVISION; 456 457 /* Table length. Checksum zero for now, will rewrite later */ 458 459 TableHeader.Length = Gbl_TableLength; 460 TableHeader.Checksum = 0; 461 462 CgLocalWriteAmlData (Op, &TableHeader, sizeof (ACPI_TABLE_HEADER)); 463 } 464 465 466 /******************************************************************************* 467 * 468 * FUNCTION: CgCloseTable 469 * 470 * PARAMETERS: None. 471 * 472 * RETURN: None. 473 * 474 * DESCRIPTION: Complete the ACPI table by calculating the checksum and 475 * re-writing the header. 476 * 477 ******************************************************************************/ 478 479 static void 480 CgCloseTable ( 481 void) 482 { 483 signed char Sum; 484 UINT8 FileByte; 485 486 487 FlSeekFile (ASL_FILE_AML_OUTPUT, 0); 488 Sum = 0; 489 490 /* Calculate the checksum over the entire file */ 491 492 while (FlReadFile (ASL_FILE_AML_OUTPUT, &FileByte, 1) == AE_OK) 493 { 494 Sum = (signed char) (Sum + FileByte); 495 } 496 497 /* Re-write the table header with the checksum */ 498 499 TableHeader.Checksum = (UINT8) (0 - Sum); 500 501 FlSeekFile (ASL_FILE_AML_OUTPUT, 0); 502 CgLocalWriteAmlData (NULL, &TableHeader, sizeof (ACPI_TABLE_HEADER)); 503 } 504 505 506 /******************************************************************************* 507 * 508 * FUNCTION: CgWriteNode 509 * 510 * PARAMETERS: Op - Parse node to write. 511 * 512 * RETURN: None. 513 * 514 * DESCRIPTION: Write the AML that corresponds to a parse node. 515 * 516 ******************************************************************************/ 517 518 static void 519 CgWriteNode ( 520 ACPI_PARSE_OBJECT *Op) 521 { 522 ASL_RESOURCE_NODE *Rnode; 523 524 525 /* Always check for DEFAULT_ARG and other "Noop" nodes */ 526 /* TBD: this may not be the best place for this check */ 527 528 if ((Op->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG) || 529 (Op->Asl.ParseOpcode == PARSEOP_EXTERNAL) || 530 (Op->Asl.ParseOpcode == PARSEOP_INCLUDE) || 531 (Op->Asl.ParseOpcode == PARSEOP_INCLUDE_END)) 532 { 533 return; 534 } 535 536 Op->Asl.FinalAmlLength = 0; 537 538 switch (Op->Asl.AmlOpcode) 539 { 540 case AML_RAW_DATA_BYTE: 541 case AML_RAW_DATA_WORD: 542 case AML_RAW_DATA_DWORD: 543 case AML_RAW_DATA_QWORD: 544 545 CgLocalWriteAmlData (Op, &Op->Asl.Value.Integer, Op->Asl.AmlLength); 546 return; 547 548 549 case AML_RAW_DATA_BUFFER: 550 551 CgLocalWriteAmlData (Op, Op->Asl.Value.Buffer, Op->Asl.AmlLength); 552 return; 553 554 555 case AML_RAW_DATA_CHAIN: 556 557 Rnode = ACPI_CAST_PTR (ASL_RESOURCE_NODE, Op->Asl.Value.Buffer); 558 while (Rnode) 559 { 560 CgLocalWriteAmlData (Op, Rnode->Buffer, Rnode->BufferLength); 561 Rnode = Rnode->Next; 562 } 563 return; 564 565 default: 566 567 /* Internal data opcodes must all appear above */ 568 569 break; 570 } 571 572 switch (Op->Asl.ParseOpcode) 573 { 574 case PARSEOP_DEFAULT_ARG: 575 576 break; 577 578 case PARSEOP_DEFINITIONBLOCK: 579 580 CgWriteTableHeader (Op); 581 break; 582 583 case PARSEOP_NAMESEG: 584 case PARSEOP_NAMESTRING: 585 case PARSEOP_METHODCALL: 586 587 CgLocalWriteAmlData (Op, Op->Asl.Value.String, Op->Asl.AmlLength); 588 break; 589 590 default: 591 592 CgWriteAmlOpcode (Op); 593 break; 594 } 595 } 596