1 /****************************************************************************** 2 * 3 * Module Name: dtutils.c - Utility routines for the data table compiler 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 #define __DTUTILS_C__ 45 46 #include <contrib/dev/acpica/compiler/aslcompiler.h> 47 #include <contrib/dev/acpica/compiler/dtcompiler.h> 48 #include <contrib/dev/acpica/include/actables.h> 49 50 #define _COMPONENT DT_COMPILER 51 ACPI_MODULE_NAME ("dtutils") 52 53 /* Local prototypes */ 54 55 static void 56 DtSum ( 57 DT_SUBTABLE *Subtable, 58 void *Context, 59 void *ReturnValue); 60 61 62 /****************************************************************************** 63 * 64 * FUNCTION: DtError 65 * 66 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 67 * MessageId - Index into global message buffer 68 * Op - Parse node where error happened 69 * ExtraMessage - additional error message 70 * 71 * RETURN: None 72 * 73 * DESCRIPTION: Common error interface for data table compiler 74 * 75 *****************************************************************************/ 76 77 void 78 DtError ( 79 UINT8 Level, 80 UINT8 MessageId, 81 DT_FIELD *FieldObject, 82 char *ExtraMessage) 83 { 84 85 /* Check if user wants to ignore this exception */ 86 87 if (AslIsExceptionDisabled (Level, MessageId)) 88 { 89 return; 90 } 91 92 if (FieldObject) 93 { 94 AslCommonError (Level, MessageId, 95 FieldObject->Line, 96 FieldObject->Line, 97 FieldObject->ByteOffset, 98 FieldObject->Column, 99 Gbl_Files[ASL_FILE_INPUT].Filename, ExtraMessage); 100 } 101 else 102 { 103 AslCommonError (Level, MessageId, 0, 104 0, 0, 0, 0, ExtraMessage); 105 } 106 } 107 108 109 /****************************************************************************** 110 * 111 * FUNCTION: DtNameError 112 * 113 * PARAMETERS: Level - Seriousness (Warning/error, etc.) 114 * MessageId - Index into global message buffer 115 * Op - Parse node where error happened 116 * ExtraMessage - additional error message 117 * 118 * RETURN: None 119 * 120 * DESCRIPTION: Error interface for named objects 121 * 122 *****************************************************************************/ 123 124 void 125 DtNameError ( 126 UINT8 Level, 127 UINT8 MessageId, 128 DT_FIELD *FieldObject, 129 char *ExtraMessage) 130 { 131 132 switch (Level) 133 { 134 case ASL_WARNING2: 135 case ASL_WARNING3: 136 137 if (Gbl_WarningLevel < Level) 138 { 139 return; 140 } 141 break; 142 143 default: 144 145 break; 146 } 147 148 if (FieldObject) 149 { 150 AslCommonError (Level, MessageId, 151 FieldObject->Line, 152 FieldObject->Line, 153 FieldObject->ByteOffset, 154 FieldObject->NameColumn, 155 Gbl_Files[ASL_FILE_INPUT].Filename, ExtraMessage); 156 } 157 else 158 { 159 AslCommonError (Level, MessageId, 0, 160 0, 0, 0, 0, ExtraMessage); 161 } 162 } 163 164 165 /******************************************************************************* 166 * 167 * FUNCTION: DtFatal 168 * 169 * PARAMETERS: None 170 * 171 * RETURN: None 172 * 173 * DESCRIPTION: Dump the error log and abort the compiler. Used for serious 174 * compile or I/O errors 175 * 176 ******************************************************************************/ 177 178 void 179 DtFatal ( 180 UINT8 MessageId, 181 DT_FIELD *FieldObject, 182 char *ExtraMessage) 183 { 184 185 DtError (ASL_ERROR, MessageId, FieldObject, ExtraMessage); 186 187 /* 188 * TBD: remove this entire function, DtFatal 189 * 190 * We cannot abort the compiler on error, because we may be compiling a 191 * list of files. We must move on to the next file. 192 */ 193 #ifdef __OBSOLETE 194 CmCleanupAndExit (); 195 exit (1); 196 #endif 197 } 198 199 200 /****************************************************************************** 201 * 202 * FUNCTION: DtStrtoul64 203 * 204 * PARAMETERS: String - Null terminated string 205 * ReturnInteger - Where the converted integer is returned 206 * 207 * RETURN: Status 208 * 209 * DESCRIPTION: Simple conversion of a string hex integer constant to unsigned 210 * value. Assumes no leading "0x" for the constant. 211 * 212 * Portability note: The reason this function exists is because a 64-bit 213 * sscanf is not available in all environments. 214 * 215 *****************************************************************************/ 216 217 ACPI_STATUS 218 DtStrtoul64 ( 219 char *String, 220 UINT64 *ReturnInteger) 221 { 222 char *ThisChar = String; 223 UINT32 ThisDigit; 224 UINT64 ReturnValue = 0; 225 int DigitCount = 0; 226 227 228 /* Skip over any white space in the buffer */ 229 230 while ((*ThisChar == ' ') || (*ThisChar == '\t')) 231 { 232 ThisChar++; 233 } 234 235 /* Skip leading zeros */ 236 237 while ((*ThisChar) == '0') 238 { 239 ThisChar++; 240 } 241 242 /* Convert character-by-character */ 243 244 while (*ThisChar) 245 { 246 if (ACPI_IS_DIGIT (*ThisChar)) 247 { 248 /* Convert ASCII 0-9 to Decimal value */ 249 250 ThisDigit = ((UINT8) *ThisChar) - '0'; 251 } 252 else /* Letter */ 253 { 254 ThisDigit = (UINT32) ACPI_TOUPPER (*ThisChar); 255 if (!ACPI_IS_XDIGIT ((char) ThisDigit)) 256 { 257 /* Not A-F */ 258 259 return (AE_BAD_CHARACTER); 260 } 261 262 /* Convert ASCII Hex char (A-F) to value */ 263 264 ThisDigit = (ThisDigit - 'A') + 10; 265 } 266 267 /* Insert the 4-bit hex digit */ 268 269 ReturnValue <<= 4; 270 ReturnValue += ThisDigit; 271 272 ThisChar++; 273 DigitCount++; 274 if (DigitCount > 16) 275 { 276 /* Value is too large (> 64 bits/8 bytes/16 hex digits) */ 277 278 return (AE_LIMIT); 279 } 280 } 281 282 *ReturnInteger = ReturnValue; 283 return (AE_OK); 284 } 285 286 287 /****************************************************************************** 288 * 289 * FUNCTION: DtGetFileSize 290 * 291 * PARAMETERS: Handle - Open file handler 292 * 293 * RETURN: Current file size 294 * 295 * DESCRIPTION: Get the current size of a file. Seek to the EOF and get the 296 * offset. Seek back to the original location. 297 * 298 *****************************************************************************/ 299 300 UINT32 301 DtGetFileSize ( 302 FILE *Handle) 303 { 304 int CurrentOffset; 305 int LastOffset; 306 307 308 CurrentOffset = ftell (Handle); 309 fseek (Handle, 0, SEEK_END); 310 LastOffset = ftell (Handle); 311 fseek (Handle, CurrentOffset, SEEK_SET); 312 313 return ((UINT32) LastOffset); 314 } 315 316 317 /****************************************************************************** 318 * 319 * FUNCTION: DtGetFieldValue 320 * 321 * PARAMETERS: Field - Current field list pointer 322 * 323 * RETURN: Field value 324 * 325 * DESCRIPTION: Get field value 326 * 327 *****************************************************************************/ 328 329 char * 330 DtGetFieldValue ( 331 DT_FIELD *Field) 332 { 333 if (!Field) 334 { 335 return (NULL); 336 } 337 338 return (Field->Value); 339 } 340 341 342 /****************************************************************************** 343 * 344 * FUNCTION: DtGetFieldType 345 * 346 * PARAMETERS: Info - Data table info 347 * 348 * RETURN: Field type 349 * 350 * DESCRIPTION: Get field type 351 * 352 *****************************************************************************/ 353 354 UINT8 355 DtGetFieldType ( 356 ACPI_DMTABLE_INFO *Info) 357 { 358 UINT8 Type; 359 360 361 /* DT_FLAG means that this is the start of a block of flag bits */ 362 /* TBD - we can make these a separate opcode later */ 363 364 if (Info->Flags & DT_FLAG) 365 { 366 return (DT_FIELD_TYPE_FLAGS_INTEGER); 367 } 368 369 /* Type is based upon the opcode for this field in the info table */ 370 371 switch (Info->Opcode) 372 { 373 case ACPI_DMT_FLAG0: 374 case ACPI_DMT_FLAG1: 375 case ACPI_DMT_FLAG2: 376 case ACPI_DMT_FLAG3: 377 case ACPI_DMT_FLAG4: 378 case ACPI_DMT_FLAG5: 379 case ACPI_DMT_FLAG6: 380 case ACPI_DMT_FLAG7: 381 case ACPI_DMT_FLAGS0: 382 case ACPI_DMT_FLAGS1: 383 case ACPI_DMT_FLAGS2: 384 case ACPI_DMT_FLAGS4: 385 386 Type = DT_FIELD_TYPE_FLAG; 387 break; 388 389 case ACPI_DMT_NAME4: 390 case ACPI_DMT_SIG: 391 case ACPI_DMT_NAME6: 392 case ACPI_DMT_NAME8: 393 case ACPI_DMT_STRING: 394 395 Type = DT_FIELD_TYPE_STRING; 396 break; 397 398 case ACPI_DMT_BUFFER: 399 case ACPI_DMT_BUF7: 400 case ACPI_DMT_BUF10: 401 case ACPI_DMT_BUF16: 402 case ACPI_DMT_BUF128: 403 case ACPI_DMT_PCI_PATH: 404 405 Type = DT_FIELD_TYPE_BUFFER; 406 break; 407 408 case ACPI_DMT_GAS: 409 case ACPI_DMT_HESTNTFY: 410 411 Type = DT_FIELD_TYPE_INLINE_SUBTABLE; 412 break; 413 414 case ACPI_DMT_UNICODE: 415 416 Type = DT_FIELD_TYPE_UNICODE; 417 break; 418 419 case ACPI_DMT_UUID: 420 421 Type = DT_FIELD_TYPE_UUID; 422 break; 423 424 case ACPI_DMT_DEVICE_PATH: 425 426 Type = DT_FIELD_TYPE_DEVICE_PATH; 427 break; 428 429 case ACPI_DMT_LABEL: 430 431 Type = DT_FIELD_TYPE_LABEL; 432 break; 433 434 default: 435 436 Type = DT_FIELD_TYPE_INTEGER; 437 break; 438 } 439 440 return (Type); 441 } 442 443 444 /****************************************************************************** 445 * 446 * FUNCTION: DtGetBufferLength 447 * 448 * PARAMETERS: Buffer - List of integers, 449 * for example "10 3A 4F 2E" 450 * 451 * RETURN: Count of integer 452 * 453 * DESCRIPTION: Get length of bytes needed to store the integers 454 * 455 *****************************************************************************/ 456 457 UINT32 458 DtGetBufferLength ( 459 char *Buffer) 460 { 461 UINT32 ByteLength = 0; 462 463 464 while (*Buffer) 465 { 466 if (*Buffer == ' ') 467 { 468 ByteLength++; 469 470 while (*Buffer == ' ') 471 { 472 Buffer++; 473 } 474 } 475 476 Buffer++; 477 } 478 479 return (++ByteLength); 480 } 481 482 483 /****************************************************************************** 484 * 485 * FUNCTION: DtGetFieldLength 486 * 487 * PARAMETERS: Field - Current field 488 * Info - Data table info 489 * 490 * RETURN: Field length 491 * 492 * DESCRIPTION: Get length of bytes needed to compile the field 493 * 494 * Note: This function must remain in sync with AcpiDmDumpTable. 495 * 496 *****************************************************************************/ 497 498 UINT32 499 DtGetFieldLength ( 500 DT_FIELD *Field, 501 ACPI_DMTABLE_INFO *Info) 502 { 503 UINT32 ByteLength = 0; 504 char *Value; 505 506 507 /* Length is based upon the opcode for this field in the info table */ 508 509 switch (Info->Opcode) 510 { 511 case ACPI_DMT_FLAG0: 512 case ACPI_DMT_FLAG1: 513 case ACPI_DMT_FLAG2: 514 case ACPI_DMT_FLAG3: 515 case ACPI_DMT_FLAG4: 516 case ACPI_DMT_FLAG5: 517 case ACPI_DMT_FLAG6: 518 case ACPI_DMT_FLAG7: 519 case ACPI_DMT_FLAGS0: 520 case ACPI_DMT_FLAGS1: 521 case ACPI_DMT_FLAGS2: 522 case ACPI_DMT_FLAGS4: 523 case ACPI_DMT_LABEL: 524 case ACPI_DMT_EXTRA_TEXT: 525 526 ByteLength = 0; 527 break; 528 529 case ACPI_DMT_UINT8: 530 case ACPI_DMT_CHKSUM: 531 case ACPI_DMT_SPACEID: 532 case ACPI_DMT_ACCWIDTH: 533 case ACPI_DMT_IVRS: 534 case ACPI_DMT_MADT: 535 case ACPI_DMT_PMTT: 536 case ACPI_DMT_SRAT: 537 case ACPI_DMT_ASF: 538 case ACPI_DMT_HESTNTYP: 539 case ACPI_DMT_FADTPM: 540 case ACPI_DMT_EINJACT: 541 case ACPI_DMT_EINJINST: 542 case ACPI_DMT_ERSTACT: 543 case ACPI_DMT_ERSTINST: 544 545 ByteLength = 1; 546 break; 547 548 case ACPI_DMT_UINT16: 549 case ACPI_DMT_DMAR: 550 case ACPI_DMT_HEST: 551 case ACPI_DMT_PCI_PATH: 552 553 ByteLength = 2; 554 break; 555 556 case ACPI_DMT_UINT24: 557 558 ByteLength = 3; 559 break; 560 561 case ACPI_DMT_UINT32: 562 case ACPI_DMT_NAME4: 563 case ACPI_DMT_SLIC: 564 case ACPI_DMT_SIG: 565 566 ByteLength = 4; 567 break; 568 569 case ACPI_DMT_UINT40: 570 571 ByteLength = 5; 572 break; 573 574 case ACPI_DMT_UINT48: 575 case ACPI_DMT_NAME6: 576 577 ByteLength = 6; 578 break; 579 580 case ACPI_DMT_UINT56: 581 case ACPI_DMT_BUF7: 582 583 ByteLength = 7; 584 break; 585 586 case ACPI_DMT_UINT64: 587 case ACPI_DMT_NAME8: 588 589 ByteLength = 8; 590 break; 591 592 case ACPI_DMT_STRING: 593 594 Value = DtGetFieldValue (Field); 595 if (Value) 596 { 597 ByteLength = ACPI_STRLEN (Value) + 1; 598 } 599 else 600 { /* At this point, this is a fatal error */ 601 602 sprintf (MsgBuffer, "Expected \"%s\"", Info->Name); 603 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer); 604 return (0); 605 } 606 break; 607 608 case ACPI_DMT_GAS: 609 610 ByteLength = sizeof (ACPI_GENERIC_ADDRESS); 611 break; 612 613 case ACPI_DMT_HESTNTFY: 614 615 ByteLength = sizeof (ACPI_HEST_NOTIFY); 616 break; 617 618 case ACPI_DMT_BUFFER: 619 620 Value = DtGetFieldValue (Field); 621 if (Value) 622 { 623 ByteLength = DtGetBufferLength (Value); 624 } 625 else 626 { /* At this point, this is a fatal error */ 627 628 sprintf (MsgBuffer, "Expected \"%s\"", Info->Name); 629 DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, MsgBuffer); 630 return (0); 631 } 632 break; 633 634 case ACPI_DMT_BUF10: 635 636 ByteLength = 10; 637 break; 638 639 case ACPI_DMT_BUF16: 640 case ACPI_DMT_UUID: 641 642 ByteLength = 16; 643 break; 644 645 case ACPI_DMT_BUF128: 646 647 ByteLength = 128; 648 break; 649 650 case ACPI_DMT_UNICODE: 651 652 Value = DtGetFieldValue (Field); 653 654 /* TBD: error if Value is NULL? (as below?) */ 655 656 ByteLength = (ACPI_STRLEN (Value) + 1) * sizeof(UINT16); 657 break; 658 659 default: 660 661 DtFatal (ASL_MSG_COMPILER_INTERNAL, Field, "Invalid table opcode"); 662 return (0); 663 } 664 665 return (ByteLength); 666 } 667 668 669 /****************************************************************************** 670 * 671 * FUNCTION: DtSum 672 * 673 * PARAMETERS: DT_WALK_CALLBACK: 674 * Subtable - Subtable 675 * Context - Unused 676 * ReturnValue - Store the checksum of subtable 677 * 678 * RETURN: Status 679 * 680 * DESCRIPTION: Get the checksum of subtable 681 * 682 *****************************************************************************/ 683 684 static void 685 DtSum ( 686 DT_SUBTABLE *Subtable, 687 void *Context, 688 void *ReturnValue) 689 { 690 UINT8 Checksum; 691 UINT8 *Sum = ReturnValue; 692 693 694 Checksum = AcpiTbChecksum (Subtable->Buffer, Subtable->Length); 695 *Sum = (UINT8) (*Sum + Checksum); 696 } 697 698 699 /****************************************************************************** 700 * 701 * FUNCTION: DtSetTableChecksum 702 * 703 * PARAMETERS: ChecksumPointer - Where to return the checksum 704 * 705 * RETURN: None 706 * 707 * DESCRIPTION: Set checksum of the whole data table into the checksum field 708 * 709 *****************************************************************************/ 710 711 void 712 DtSetTableChecksum ( 713 UINT8 *ChecksumPointer) 714 { 715 UINT8 Checksum = 0; 716 UINT8 OldSum; 717 718 719 DtWalkTableTree (Gbl_RootTable, DtSum, NULL, &Checksum); 720 721 OldSum = *ChecksumPointer; 722 Checksum = (UINT8) (Checksum - OldSum); 723 724 /* Compute the final checksum */ 725 726 Checksum = (UINT8) (0 - Checksum); 727 *ChecksumPointer = Checksum; 728 } 729 730 731 /****************************************************************************** 732 * 733 * FUNCTION: DtSetTableLength 734 * 735 * PARAMETERS: None 736 * 737 * RETURN: None 738 * 739 * DESCRIPTION: Walk the subtables and set all the length fields 740 * 741 *****************************************************************************/ 742 743 void 744 DtSetTableLength ( 745 void) 746 { 747 DT_SUBTABLE *ParentTable; 748 DT_SUBTABLE *ChildTable; 749 750 751 ParentTable = Gbl_RootTable; 752 ChildTable = NULL; 753 754 if (!ParentTable) 755 { 756 return; 757 } 758 759 DtSetSubtableLength (ParentTable); 760 761 while (1) 762 { 763 ChildTable = DtGetNextSubtable (ParentTable, ChildTable); 764 if (ChildTable) 765 { 766 if (ChildTable->LengthField) 767 { 768 DtSetSubtableLength (ChildTable); 769 } 770 771 if (ChildTable->Child) 772 { 773 ParentTable = ChildTable; 774 ChildTable = NULL; 775 } 776 else 777 { 778 ParentTable->TotalLength += ChildTable->TotalLength; 779 if (ParentTable->LengthField) 780 { 781 DtSetSubtableLength (ParentTable); 782 } 783 } 784 } 785 else 786 { 787 ChildTable = ParentTable; 788 789 if (ChildTable == Gbl_RootTable) 790 { 791 break; 792 } 793 794 ParentTable = DtGetParentSubtable (ParentTable); 795 796 ParentTable->TotalLength += ChildTable->TotalLength; 797 if (ParentTable->LengthField) 798 { 799 DtSetSubtableLength (ParentTable); 800 } 801 } 802 } 803 } 804 805 806 /****************************************************************************** 807 * 808 * FUNCTION: DtWalkTableTree 809 * 810 * PARAMETERS: StartTable - Subtable in the tree where walking begins 811 * UserFunction - Called during the walk 812 * Context - Passed to user function 813 * ReturnValue - The return value of UserFunction 814 * 815 * RETURN: None 816 * 817 * DESCRIPTION: Performs a depth-first walk of the subtable tree 818 * 819 *****************************************************************************/ 820 821 void 822 DtWalkTableTree ( 823 DT_SUBTABLE *StartTable, 824 DT_WALK_CALLBACK UserFunction, 825 void *Context, 826 void *ReturnValue) 827 { 828 DT_SUBTABLE *ParentTable; 829 DT_SUBTABLE *ChildTable; 830 831 832 ParentTable = StartTable; 833 ChildTable = NULL; 834 835 if (!ParentTable) 836 { 837 return; 838 } 839 840 UserFunction (ParentTable, Context, ReturnValue); 841 842 while (1) 843 { 844 ChildTable = DtGetNextSubtable (ParentTable, ChildTable); 845 if (ChildTable) 846 { 847 UserFunction (ChildTable, Context, ReturnValue); 848 849 if (ChildTable->Child) 850 { 851 ParentTable = ChildTable; 852 ChildTable = NULL; 853 } 854 } 855 else 856 { 857 ChildTable = ParentTable; 858 if (ChildTable == Gbl_RootTable) 859 { 860 break; 861 } 862 863 ParentTable = DtGetParentSubtable (ParentTable); 864 865 if (ChildTable->Peer == StartTable) 866 { 867 break; 868 } 869 } 870 } 871 } 872 873 874 /****************************************************************************** 875 * 876 * FUNCTION: DtFreeFieldList 877 * 878 * PARAMETERS: None 879 * 880 * RETURN: None 881 * 882 * DESCRIPTION: Free the field list 883 * 884 *****************************************************************************/ 885 886 void 887 DtFreeFieldList ( 888 void) 889 { 890 DT_FIELD *Field = Gbl_FieldList; 891 DT_FIELD *NextField; 892 893 894 /* Walk and free entire field list */ 895 896 while (Field) 897 { 898 NextField = Field->Next; /* Save link */ 899 900 if (!(Field->Flags & DT_FIELD_NOT_ALLOCATED)) 901 { 902 ACPI_FREE (Field->Name); 903 ACPI_FREE (Field->Value); 904 } 905 906 ACPI_FREE (Field); 907 Field = NextField; 908 } 909 } 910