1 /****************************************************************************** 2 * 3 * Module Name: cmclib - Local implementation of C library functions 4 * 5 *****************************************************************************/ 6 7 /****************************************************************************** 8 * 9 * 1. Copyright Notice 10 * 11 * Some or all of this work - Copyright (c) 1999 - 2014, Intel Corp. 12 * All rights reserved. 13 * 14 * 2. License 15 * 16 * 2.1. This is your license from Intel Corp. under its intellectual property 17 * rights. You may have additional license terms from the party that provided 18 * you this software, covering your right to use that party's intellectual 19 * property rights. 20 * 21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 22 * copy of the source code appearing in this file ("Covered Code") an 23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the 24 * base code distributed originally by Intel ("Original Intel Code") to copy, 25 * make derivatives, distribute, use and display any portion of the Covered 26 * Code in any form, with the right to sublicense such rights; and 27 * 28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 29 * license (with the right to sublicense), under only those claims of Intel 30 * patents that are infringed by the Original Intel Code, to make, use, sell, 31 * offer to sell, and import the Covered Code and derivative works thereof 32 * solely to the minimum extent necessary to exercise the above copyright 33 * license, and in no event shall the patent license extend to any additions 34 * to or modifications of the Original Intel Code. No other license or right 35 * is granted directly or by implication, estoppel or otherwise; 36 * 37 * The above copyright and patent license is granted only if the following 38 * conditions are met: 39 * 40 * 3. Conditions 41 * 42 * 3.1. Redistribution of Source with Rights to Further Distribute Source. 43 * Redistribution of source code of any substantial portion of the Covered 44 * Code or modification with rights to further distribute source must include 45 * the above Copyright Notice, the above License, this list of Conditions, 46 * and the following Disclaimer and Export Compliance provision. In addition, 47 * Licensee must cause all Covered Code to which Licensee contributes to 48 * contain a file documenting the changes Licensee made to create that Covered 49 * Code and the date of any change. Licensee must include in that file the 50 * documentation of any changes made by any predecessor Licensee. Licensee 51 * must include a prominent statement that the modification is derived, 52 * directly or indirectly, from Original Intel Code. 53 * 54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 55 * Redistribution of source code of any substantial portion of the Covered 56 * Code or modification without rights to further distribute source must 57 * include the following Disclaimer and Export Compliance provision in the 58 * documentation and/or other materials provided with distribution. In 59 * addition, Licensee may not authorize further sublicense of source of any 60 * portion of the Covered Code, and must include terms to the effect that the 61 * license from Licensee to its licensee is limited to the intellectual 62 * property embodied in the software Licensee provides to its licensee, and 63 * not to intellectual property embodied in modifications its licensee may 64 * make. 65 * 66 * 3.3. Redistribution of Executable. Redistribution in executable form of any 67 * substantial portion of the Covered Code or modification must reproduce the 68 * above Copyright Notice, and the following Disclaimer and Export Compliance 69 * provision in the documentation and/or other materials provided with the 70 * distribution. 71 * 72 * 3.4. Intel retains all right, title, and interest in and to the Original 73 * Intel Code. 74 * 75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by 76 * Intel shall be used in advertising or otherwise to promote the sale, use or 77 * other dealings in products derived from or relating to the Covered Code 78 * without prior written authorization from Intel. 79 * 80 * 4. Disclaimer and Export Compliance 81 * 82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 88 * PARTICULAR PURPOSE. 89 * 90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 97 * LIMITED REMEDY. 98 * 99 * 4.3. Licensee shall not export, either directly or indirectly, any of this 100 * software or system incorporating such software without first obtaining any 101 * required license or other approval from the U. S. Department of Commerce or 102 * any other agency or department of the United States Government. In the 103 * event Licensee exports any such software from the United States or 104 * re-exports any such software from a foreign destination, Licensee shall 105 * ensure that the distribution and export/re-export of the software is in 106 * compliance with all laws, regulations, orders, or other restrictions of the 107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor 108 * any of its subsidiaries will export/re-export any technical data, process, 109 * software, or service, directly or indirectly, to any country for which the 110 * United States government or any agency thereof requires an export license, 111 * other governmental approval, or letter of assurance, without first obtaining 112 * such license, approval or letter. 113 * 114 *****************************************************************************/ 115 116 117 #define __CMCLIB_C__ 118 119 #include "acpi.h" 120 #include "accommon.h" 121 122 /* 123 * These implementations of standard C Library routines can optionally be 124 * used if a C library is not available. In general, they are less efficient 125 * than an inline or assembly implementation 126 */ 127 128 #define _COMPONENT ACPI_UTILITIES 129 ACPI_MODULE_NAME ("cmclib") 130 131 132 #ifndef ACPI_USE_SYSTEM_CLIBRARY 133 134 #define NEGATIVE 1 135 #define POSITIVE 0 136 137 138 /******************************************************************************* 139 * 140 * FUNCTION: AcpiUtMemcmp (memcmp) 141 * 142 * PARAMETERS: Buffer1 - First Buffer 143 * Buffer2 - Second Buffer 144 * Count - Maximum # of bytes to compare 145 * 146 * RETURN: Index where Buffers mismatched, or 0 if Buffers matched 147 * 148 * DESCRIPTION: Compare two Buffers, with a maximum length 149 * 150 ******************************************************************************/ 151 152 int 153 AcpiUtMemcmp ( 154 const char *Buffer1, 155 const char *Buffer2, 156 ACPI_SIZE Count) 157 { 158 159 for ( ; Count-- && (*Buffer1 == *Buffer2); Buffer1++, Buffer2++) 160 { 161 } 162 163 return ((Count == ACPI_SIZE_MAX) ? 0 : ((unsigned char) *Buffer1 - 164 (unsigned char) *Buffer2)); 165 } 166 167 168 /******************************************************************************* 169 * 170 * FUNCTION: AcpiUtMemcpy (memcpy) 171 * 172 * PARAMETERS: Dest - Target of the copy 173 * Src - Source buffer to copy 174 * Count - Number of bytes to copy 175 * 176 * RETURN: Dest 177 * 178 * DESCRIPTION: Copy arbitrary bytes of memory 179 * 180 ******************************************************************************/ 181 182 void * 183 AcpiUtMemcpy ( 184 void *Dest, 185 const void *Src, 186 ACPI_SIZE Count) 187 { 188 char *New = (char *) Dest; 189 char *Old = (char *) Src; 190 191 192 while (Count) 193 { 194 *New = *Old; 195 New++; 196 Old++; 197 Count--; 198 } 199 200 return (Dest); 201 } 202 203 204 /******************************************************************************* 205 * 206 * FUNCTION: AcpiUtMemset (memset) 207 * 208 * PARAMETERS: Dest - Buffer to set 209 * Value - Value to set each byte of memory 210 * Count - Number of bytes to set 211 * 212 * RETURN: Dest 213 * 214 * DESCRIPTION: Initialize a buffer to a known value. 215 * 216 ******************************************************************************/ 217 218 void * 219 AcpiUtMemset ( 220 void *Dest, 221 UINT8 Value, 222 ACPI_SIZE Count) 223 { 224 char *New = (char *) Dest; 225 226 227 while (Count) 228 { 229 *New = (char) Value; 230 New++; 231 Count--; 232 } 233 234 return (Dest); 235 } 236 237 238 /******************************************************************************* 239 * 240 * FUNCTION: AcpiUtStrlen (strlen) 241 * 242 * PARAMETERS: String - Null terminated string 243 * 244 * RETURN: Length 245 * 246 * DESCRIPTION: Returns the length of the input string 247 * 248 ******************************************************************************/ 249 250 251 ACPI_SIZE 252 AcpiUtStrlen ( 253 const char *String) 254 { 255 UINT32 Length = 0; 256 257 258 /* Count the string until a null is encountered */ 259 260 while (*String) 261 { 262 Length++; 263 String++; 264 } 265 266 return (Length); 267 } 268 269 270 /******************************************************************************* 271 * 272 * FUNCTION: AcpiUtStrcpy (strcpy) 273 * 274 * PARAMETERS: DstString - Target of the copy 275 * SrcString - The source string to copy 276 * 277 * RETURN: DstString 278 * 279 * DESCRIPTION: Copy a null terminated string 280 * 281 ******************************************************************************/ 282 283 char * 284 AcpiUtStrcpy ( 285 char *DstString, 286 const char *SrcString) 287 { 288 char *String = DstString; 289 290 291 /* Move bytes brute force */ 292 293 while (*SrcString) 294 { 295 *String = *SrcString; 296 297 String++; 298 SrcString++; 299 } 300 301 /* Null terminate */ 302 303 *String = 0; 304 return (DstString); 305 } 306 307 308 /******************************************************************************* 309 * 310 * FUNCTION: AcpiUtStrncpy (strncpy) 311 * 312 * PARAMETERS: DstString - Target of the copy 313 * SrcString - The source string to copy 314 * Count - Maximum # of bytes to copy 315 * 316 * RETURN: DstString 317 * 318 * DESCRIPTION: Copy a null terminated string, with a maximum length 319 * 320 ******************************************************************************/ 321 322 char * 323 AcpiUtStrncpy ( 324 char *DstString, 325 const char *SrcString, 326 ACPI_SIZE Count) 327 { 328 char *String = DstString; 329 330 331 /* Copy the string */ 332 333 for (String = DstString; 334 Count && (Count--, (*String++ = *SrcString++)); ) 335 {;} 336 337 /* Pad with nulls if necessary */ 338 339 while (Count--) 340 { 341 *String = 0; 342 String++; 343 } 344 345 /* Return original pointer */ 346 347 return (DstString); 348 } 349 350 351 /******************************************************************************* 352 * 353 * FUNCTION: AcpiUtStrcmp (strcmp) 354 * 355 * PARAMETERS: String1 - First string 356 * String2 - Second string 357 * 358 * RETURN: Index where strings mismatched, or 0 if strings matched 359 * 360 * DESCRIPTION: Compare two null terminated strings 361 * 362 ******************************************************************************/ 363 364 int 365 AcpiUtStrcmp ( 366 const char *String1, 367 const char *String2) 368 { 369 370 371 for ( ; (*String1 == *String2); String2++) 372 { 373 if (!*String1++) 374 { 375 return (0); 376 } 377 } 378 379 return ((unsigned char) *String1 - (unsigned char) *String2); 380 } 381 382 383 /******************************************************************************* 384 * 385 * FUNCTION: AcpiUtStrchr (strchr) 386 * 387 * PARAMETERS: String - Search string 388 * ch - character to search for 389 * 390 * RETURN: Ptr to char or NULL if not found 391 * 392 * DESCRIPTION: Search a string for a character 393 * 394 ******************************************************************************/ 395 396 char * 397 AcpiUtStrchr ( 398 const char *String, 399 int ch) 400 { 401 402 403 for ( ; (*String); String++) 404 { 405 if ((*String) == (char) ch) 406 { 407 return ((char *) String); 408 } 409 } 410 411 return (NULL); 412 } 413 414 415 /******************************************************************************* 416 * 417 * FUNCTION: AcpiUtStrncmp (strncmp) 418 * 419 * PARAMETERS: String1 - First string 420 * String2 - Second string 421 * Count - Maximum # of bytes to compare 422 * 423 * RETURN: Index where strings mismatched, or 0 if strings matched 424 * 425 * DESCRIPTION: Compare two null terminated strings, with a maximum length 426 * 427 ******************************************************************************/ 428 429 int 430 AcpiUtStrncmp ( 431 const char *String1, 432 const char *String2, 433 ACPI_SIZE Count) 434 { 435 436 437 for ( ; Count-- && (*String1 == *String2); String2++) 438 { 439 if (!*String1++) 440 { 441 return (0); 442 } 443 } 444 445 return ((Count == ACPI_SIZE_MAX) ? 0 : ((unsigned char) *String1 - 446 (unsigned char) *String2)); 447 } 448 449 450 /******************************************************************************* 451 * 452 * FUNCTION: AcpiUtStrcat (Strcat) 453 * 454 * PARAMETERS: DstString - Target of the copy 455 * SrcString - The source string to copy 456 * 457 * RETURN: DstString 458 * 459 * DESCRIPTION: Append a null terminated string to a null terminated string 460 * 461 ******************************************************************************/ 462 463 char * 464 AcpiUtStrcat ( 465 char *DstString, 466 const char *SrcString) 467 { 468 char *String; 469 470 471 /* Find end of the destination string */ 472 473 for (String = DstString; *String++; ) 474 { ; } 475 476 /* Concatenate the string */ 477 478 for (--String; (*String++ = *SrcString++); ) 479 { ; } 480 481 return (DstString); 482 } 483 484 485 /******************************************************************************* 486 * 487 * FUNCTION: AcpiUtStrncat (strncat) 488 * 489 * PARAMETERS: DstString - Target of the copy 490 * SrcString - The source string to copy 491 * Count - Maximum # of bytes to copy 492 * 493 * RETURN: DstString 494 * 495 * DESCRIPTION: Append a null terminated string to a null terminated string, 496 * with a maximum count. 497 * 498 ******************************************************************************/ 499 500 char * 501 AcpiUtStrncat ( 502 char *DstString, 503 const char *SrcString, 504 ACPI_SIZE Count) 505 { 506 char *String; 507 508 509 if (Count) 510 { 511 /* Find end of the destination string */ 512 513 for (String = DstString; *String++; ) 514 { ; } 515 516 /* Concatenate the string */ 517 518 for (--String; (*String++ = *SrcString++) && --Count; ) 519 { ; } 520 521 /* Null terminate if necessary */ 522 523 if (!Count) 524 { 525 *String = 0; 526 } 527 } 528 529 return (DstString); 530 } 531 532 533 /******************************************************************************* 534 * 535 * FUNCTION: AcpiUtStrstr (strstr) 536 * 537 * PARAMETERS: String1 - Target string 538 * String2 - Substring to search for 539 * 540 * RETURN: Where substring match starts, Null if no match found 541 * 542 * DESCRIPTION: Checks if String2 occurs in String1. This is not really a 543 * full implementation of strstr, only sufficient for command 544 * matching 545 * 546 ******************************************************************************/ 547 548 char * 549 AcpiUtStrstr ( 550 char *String1, 551 char *String2) 552 { 553 char *String; 554 555 556 if (AcpiUtStrlen (String2) > AcpiUtStrlen (String1)) 557 { 558 return (NULL); 559 } 560 561 /* Walk entire string, comparing the letters */ 562 563 for (String = String1; *String2; ) 564 { 565 if (*String2 != *String) 566 { 567 return (NULL); 568 } 569 570 String2++; 571 String++; 572 } 573 574 return (String1); 575 } 576 577 578 /******************************************************************************* 579 * 580 * FUNCTION: AcpiUtStrtoul (strtoul) 581 * 582 * PARAMETERS: String - Null terminated string 583 * Terminater - Where a pointer to the terminating byte is 584 * returned 585 * Base - Radix of the string 586 * 587 * RETURN: Converted value 588 * 589 * DESCRIPTION: Convert a string into a 32-bit unsigned value. 590 * Note: use AcpiUtStrtoul64 for 64-bit integers. 591 * 592 ******************************************************************************/ 593 594 UINT32 595 AcpiUtStrtoul ( 596 const char *String, 597 char **Terminator, 598 UINT32 Base) 599 { 600 UINT32 converted = 0; 601 UINT32 index; 602 UINT32 sign; 603 const char *StringStart; 604 UINT32 ReturnValue = 0; 605 ACPI_STATUS Status = AE_OK; 606 607 608 /* 609 * Save the value of the pointer to the buffer's first 610 * character, save the current errno value, and then 611 * skip over any white space in the buffer: 612 */ 613 StringStart = String; 614 while (ACPI_IS_SPACE (*String) || *String == '\t') 615 { 616 ++String; 617 } 618 619 /* 620 * The buffer may contain an optional plus or minus sign. 621 * If it does, then skip over it but remember what is was: 622 */ 623 if (*String == '-') 624 { 625 sign = NEGATIVE; 626 ++String; 627 } 628 else if (*String == '+') 629 { 630 ++String; 631 sign = POSITIVE; 632 } 633 else 634 { 635 sign = POSITIVE; 636 } 637 638 /* 639 * If the input parameter Base is zero, then we need to 640 * determine if it is octal, decimal, or hexadecimal: 641 */ 642 if (Base == 0) 643 { 644 if (*String == '0') 645 { 646 if (AcpiUtToLower (*(++String)) == 'x') 647 { 648 Base = 16; 649 ++String; 650 } 651 else 652 { 653 Base = 8; 654 } 655 } 656 else 657 { 658 Base = 10; 659 } 660 } 661 else if (Base < 2 || Base > 36) 662 { 663 /* 664 * The specified Base parameter is not in the domain of 665 * this function: 666 */ 667 goto done; 668 } 669 670 /* 671 * For octal and hexadecimal bases, skip over the leading 672 * 0 or 0x, if they are present. 673 */ 674 if (Base == 8 && *String == '0') 675 { 676 String++; 677 } 678 679 if (Base == 16 && 680 *String == '0' && 681 AcpiUtToLower (*(++String)) == 'x') 682 { 683 String++; 684 } 685 686 /* 687 * Main loop: convert the string to an unsigned long: 688 */ 689 while (*String) 690 { 691 if (ACPI_IS_DIGIT (*String)) 692 { 693 index = (UINT32) ((UINT8) *String - '0'); 694 } 695 else 696 { 697 index = (UINT32) AcpiUtToUpper (*String); 698 if (ACPI_IS_UPPER (index)) 699 { 700 index = index - 'A' + 10; 701 } 702 else 703 { 704 goto done; 705 } 706 } 707 708 if (index >= Base) 709 { 710 goto done; 711 } 712 713 /* 714 * Check to see if value is out of range: 715 */ 716 717 if (ReturnValue > ((ACPI_UINT32_MAX - (UINT32) index) / 718 (UINT32) Base)) 719 { 720 Status = AE_ERROR; 721 ReturnValue = 0; /* reset */ 722 } 723 else 724 { 725 ReturnValue *= Base; 726 ReturnValue += index; 727 converted = 1; 728 } 729 730 ++String; 731 } 732 733 done: 734 /* 735 * If appropriate, update the caller's pointer to the next 736 * unconverted character in the buffer. 737 */ 738 if (Terminator) 739 { 740 if (converted == 0 && ReturnValue == 0 && String != NULL) 741 { 742 *Terminator = (char *) StringStart; 743 } 744 else 745 { 746 *Terminator = (char *) String; 747 } 748 } 749 750 if (Status == AE_ERROR) 751 { 752 ReturnValue = ACPI_UINT32_MAX; 753 } 754 755 /* 756 * If a minus sign was present, then "the conversion is negated": 757 */ 758 if (sign == NEGATIVE) 759 { 760 ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1; 761 } 762 763 return (ReturnValue); 764 } 765 766 767 /******************************************************************************* 768 * 769 * FUNCTION: AcpiUtToUpper (TOUPPER) 770 * 771 * PARAMETERS: c - Character to convert 772 * 773 * RETURN: Converted character as an int 774 * 775 * DESCRIPTION: Convert character to uppercase 776 * 777 ******************************************************************************/ 778 779 int 780 AcpiUtToUpper ( 781 int c) 782 { 783 784 return (ACPI_IS_LOWER(c) ? ((c)-0x20) : (c)); 785 } 786 787 788 /******************************************************************************* 789 * 790 * FUNCTION: AcpiUtToLower (TOLOWER) 791 * 792 * PARAMETERS: c - Character to convert 793 * 794 * RETURN: Converted character as an int 795 * 796 * DESCRIPTION: Convert character to lowercase 797 * 798 ******************************************************************************/ 799 800 int 801 AcpiUtToLower ( 802 int c) 803 { 804 805 return (ACPI_IS_UPPER(c) ? ((c)+0x20) : (c)); 806 } 807 808 809 /******************************************************************************* 810 * 811 * FUNCTION: is* functions 812 * 813 * DESCRIPTION: is* functions use the ctype table below 814 * 815 ******************************************************************************/ 816 817 const UINT8 _acpi_ctype[257] = { 818 _ACPI_CN, /* 0x00 0 NUL */ 819 _ACPI_CN, /* 0x01 1 SOH */ 820 _ACPI_CN, /* 0x02 2 STX */ 821 _ACPI_CN, /* 0x03 3 ETX */ 822 _ACPI_CN, /* 0x04 4 EOT */ 823 _ACPI_CN, /* 0x05 5 ENQ */ 824 _ACPI_CN, /* 0x06 6 ACK */ 825 _ACPI_CN, /* 0x07 7 BEL */ 826 _ACPI_CN, /* 0x08 8 BS */ 827 _ACPI_CN|_ACPI_SP, /* 0x09 9 TAB */ 828 _ACPI_CN|_ACPI_SP, /* 0x0A 10 LF */ 829 _ACPI_CN|_ACPI_SP, /* 0x0B 11 VT */ 830 _ACPI_CN|_ACPI_SP, /* 0x0C 12 FF */ 831 _ACPI_CN|_ACPI_SP, /* 0x0D 13 CR */ 832 _ACPI_CN, /* 0x0E 14 SO */ 833 _ACPI_CN, /* 0x0F 15 SI */ 834 _ACPI_CN, /* 0x10 16 DLE */ 835 _ACPI_CN, /* 0x11 17 DC1 */ 836 _ACPI_CN, /* 0x12 18 DC2 */ 837 _ACPI_CN, /* 0x13 19 DC3 */ 838 _ACPI_CN, /* 0x14 20 DC4 */ 839 _ACPI_CN, /* 0x15 21 NAK */ 840 _ACPI_CN, /* 0x16 22 SYN */ 841 _ACPI_CN, /* 0x17 23 ETB */ 842 _ACPI_CN, /* 0x18 24 CAN */ 843 _ACPI_CN, /* 0x19 25 EM */ 844 _ACPI_CN, /* 0x1A 26 SUB */ 845 _ACPI_CN, /* 0x1B 27 ESC */ 846 _ACPI_CN, /* 0x1C 28 FS */ 847 _ACPI_CN, /* 0x1D 29 GS */ 848 _ACPI_CN, /* 0x1E 30 RS */ 849 _ACPI_CN, /* 0x1F 31 US */ 850 _ACPI_XS|_ACPI_SP, /* 0x20 32 ' ' */ 851 _ACPI_PU, /* 0x21 33 '!' */ 852 _ACPI_PU, /* 0x22 34 '"' */ 853 _ACPI_PU, /* 0x23 35 '#' */ 854 _ACPI_PU, /* 0x24 36 '$' */ 855 _ACPI_PU, /* 0x25 37 '%' */ 856 _ACPI_PU, /* 0x26 38 '&' */ 857 _ACPI_PU, /* 0x27 39 ''' */ 858 _ACPI_PU, /* 0x28 40 '(' */ 859 _ACPI_PU, /* 0x29 41 ')' */ 860 _ACPI_PU, /* 0x2A 42 '*' */ 861 _ACPI_PU, /* 0x2B 43 '+' */ 862 _ACPI_PU, /* 0x2C 44 ',' */ 863 _ACPI_PU, /* 0x2D 45 '-' */ 864 _ACPI_PU, /* 0x2E 46 '.' */ 865 _ACPI_PU, /* 0x2F 47 '/' */ 866 _ACPI_XD|_ACPI_DI, /* 0x30 48 '0' */ 867 _ACPI_XD|_ACPI_DI, /* 0x31 49 '1' */ 868 _ACPI_XD|_ACPI_DI, /* 0x32 50 '2' */ 869 _ACPI_XD|_ACPI_DI, /* 0x33 51 '3' */ 870 _ACPI_XD|_ACPI_DI, /* 0x34 52 '4' */ 871 _ACPI_XD|_ACPI_DI, /* 0x35 53 '5' */ 872 _ACPI_XD|_ACPI_DI, /* 0x36 54 '6' */ 873 _ACPI_XD|_ACPI_DI, /* 0x37 55 '7' */ 874 _ACPI_XD|_ACPI_DI, /* 0x38 56 '8' */ 875 _ACPI_XD|_ACPI_DI, /* 0x39 57 '9' */ 876 _ACPI_PU, /* 0x3A 58 ':' */ 877 _ACPI_PU, /* 0x3B 59 ';' */ 878 _ACPI_PU, /* 0x3C 60 '<' */ 879 _ACPI_PU, /* 0x3D 61 '=' */ 880 _ACPI_PU, /* 0x3E 62 '>' */ 881 _ACPI_PU, /* 0x3F 63 '?' */ 882 _ACPI_PU, /* 0x40 64 '@' */ 883 _ACPI_XD|_ACPI_UP, /* 0x41 65 'A' */ 884 _ACPI_XD|_ACPI_UP, /* 0x42 66 'B' */ 885 _ACPI_XD|_ACPI_UP, /* 0x43 67 'C' */ 886 _ACPI_XD|_ACPI_UP, /* 0x44 68 'D' */ 887 _ACPI_XD|_ACPI_UP, /* 0x45 69 'E' */ 888 _ACPI_XD|_ACPI_UP, /* 0x46 70 'F' */ 889 _ACPI_UP, /* 0x47 71 'G' */ 890 _ACPI_UP, /* 0x48 72 'H' */ 891 _ACPI_UP, /* 0x49 73 'I' */ 892 _ACPI_UP, /* 0x4A 74 'J' */ 893 _ACPI_UP, /* 0x4B 75 'K' */ 894 _ACPI_UP, /* 0x4C 76 'L' */ 895 _ACPI_UP, /* 0x4D 77 'M' */ 896 _ACPI_UP, /* 0x4E 78 'N' */ 897 _ACPI_UP, /* 0x4F 79 'O' */ 898 _ACPI_UP, /* 0x50 80 'P' */ 899 _ACPI_UP, /* 0x51 81 'Q' */ 900 _ACPI_UP, /* 0x52 82 'R' */ 901 _ACPI_UP, /* 0x53 83 'S' */ 902 _ACPI_UP, /* 0x54 84 'T' */ 903 _ACPI_UP, /* 0x55 85 'U' */ 904 _ACPI_UP, /* 0x56 86 'V' */ 905 _ACPI_UP, /* 0x57 87 'W' */ 906 _ACPI_UP, /* 0x58 88 'X' */ 907 _ACPI_UP, /* 0x59 89 'Y' */ 908 _ACPI_UP, /* 0x5A 90 'Z' */ 909 _ACPI_PU, /* 0x5B 91 '[' */ 910 _ACPI_PU, /* 0x5C 92 '\' */ 911 _ACPI_PU, /* 0x5D 93 ']' */ 912 _ACPI_PU, /* 0x5E 94 '^' */ 913 _ACPI_PU, /* 0x5F 95 '_' */ 914 _ACPI_PU, /* 0x60 96 '`' */ 915 _ACPI_XD|_ACPI_LO, /* 0x61 97 'a' */ 916 _ACPI_XD|_ACPI_LO, /* 0x62 98 'b' */ 917 _ACPI_XD|_ACPI_LO, /* 0x63 99 'c' */ 918 _ACPI_XD|_ACPI_LO, /* 0x64 100 'd' */ 919 _ACPI_XD|_ACPI_LO, /* 0x65 101 'e' */ 920 _ACPI_XD|_ACPI_LO, /* 0x66 102 'f' */ 921 _ACPI_LO, /* 0x67 103 'g' */ 922 _ACPI_LO, /* 0x68 104 'h' */ 923 _ACPI_LO, /* 0x69 105 'i' */ 924 _ACPI_LO, /* 0x6A 106 'j' */ 925 _ACPI_LO, /* 0x6B 107 'k' */ 926 _ACPI_LO, /* 0x6C 108 'l' */ 927 _ACPI_LO, /* 0x6D 109 'm' */ 928 _ACPI_LO, /* 0x6E 110 'n' */ 929 _ACPI_LO, /* 0x6F 111 'o' */ 930 _ACPI_LO, /* 0x70 112 'p' */ 931 _ACPI_LO, /* 0x71 113 'q' */ 932 _ACPI_LO, /* 0x72 114 'r' */ 933 _ACPI_LO, /* 0x73 115 's' */ 934 _ACPI_LO, /* 0x74 116 't' */ 935 _ACPI_LO, /* 0x75 117 'u' */ 936 _ACPI_LO, /* 0x76 118 'v' */ 937 _ACPI_LO, /* 0x77 119 'w' */ 938 _ACPI_LO, /* 0x78 120 'x' */ 939 _ACPI_LO, /* 0x79 121 'y' */ 940 _ACPI_LO, /* 0x7A 122 'z' */ 941 _ACPI_PU, /* 0x7B 123 '{' */ 942 _ACPI_PU, /* 0x7C 124 '|' */ 943 _ACPI_PU, /* 0x7D 125 '}' */ 944 _ACPI_PU, /* 0x7E 126 '~' */ 945 _ACPI_CN, /* 0x7F 127 DEL */ 946 947 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x80 to 0x8F */ 948 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0x90 to 0x9F */ 949 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xA0 to 0xAF */ 950 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xB0 to 0xBF */ 951 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xC0 to 0xCF */ 952 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xD0 to 0xDF */ 953 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xE0 to 0xEF */ 954 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* 0xF0 to 0xFF */ 955 0 /* 0x100 */ 956 }; 957 958 959 #endif /* ACPI_USE_SYSTEM_CLIBRARY */ 960