1 /****************************************************************************** 2 * 3 * Module Name: utdecode - Utility decoding routines (value-to-string) 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2011, 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 #include <acpi/acpi.h> 45 #include "accommon.h" 46 #include "acnamesp.h" 47 48 #define _COMPONENT ACPI_UTILITIES 49 ACPI_MODULE_NAME("utdecode") 50 51 /******************************************************************************* 52 * 53 * FUNCTION: acpi_format_exception 54 * 55 * PARAMETERS: Status - The acpi_status code to be formatted 56 * 57 * RETURN: A string containing the exception text. A valid pointer is 58 * always returned. 59 * 60 * DESCRIPTION: This function translates an ACPI exception into an ASCII string 61 * It is here instead of utxface.c so it is always present. 62 * 63 ******************************************************************************/ 64 const char *acpi_format_exception(acpi_status status) 65 { 66 const char *exception = NULL; 67 68 ACPI_FUNCTION_ENTRY(); 69 70 exception = acpi_ut_validate_exception(status); 71 if (!exception) { 72 73 /* Exception code was not recognized */ 74 75 ACPI_ERROR((AE_INFO, 76 "Unknown exception code: 0x%8.8X", status)); 77 78 exception = "UNKNOWN_STATUS_CODE"; 79 } 80 81 return (ACPI_CAST_PTR(const char, exception)); 82 } 83 84 ACPI_EXPORT_SYMBOL(acpi_format_exception) 85 86 /* 87 * Properties of the ACPI Object Types, both internal and external. 88 * The table is indexed by values of acpi_object_type 89 */ 90 const u8 acpi_gbl_ns_properties[ACPI_NUM_NS_TYPES] = { 91 ACPI_NS_NORMAL, /* 00 Any */ 92 ACPI_NS_NORMAL, /* 01 Number */ 93 ACPI_NS_NORMAL, /* 02 String */ 94 ACPI_NS_NORMAL, /* 03 Buffer */ 95 ACPI_NS_NORMAL, /* 04 Package */ 96 ACPI_NS_NORMAL, /* 05 field_unit */ 97 ACPI_NS_NEWSCOPE, /* 06 Device */ 98 ACPI_NS_NORMAL, /* 07 Event */ 99 ACPI_NS_NEWSCOPE, /* 08 Method */ 100 ACPI_NS_NORMAL, /* 09 Mutex */ 101 ACPI_NS_NORMAL, /* 10 Region */ 102 ACPI_NS_NEWSCOPE, /* 11 Power */ 103 ACPI_NS_NEWSCOPE, /* 12 Processor */ 104 ACPI_NS_NEWSCOPE, /* 13 Thermal */ 105 ACPI_NS_NORMAL, /* 14 buffer_field */ 106 ACPI_NS_NORMAL, /* 15 ddb_handle */ 107 ACPI_NS_NORMAL, /* 16 Debug Object */ 108 ACPI_NS_NORMAL, /* 17 def_field */ 109 ACPI_NS_NORMAL, /* 18 bank_field */ 110 ACPI_NS_NORMAL, /* 19 index_field */ 111 ACPI_NS_NORMAL, /* 20 Reference */ 112 ACPI_NS_NORMAL, /* 21 Alias */ 113 ACPI_NS_NORMAL, /* 22 method_alias */ 114 ACPI_NS_NORMAL, /* 23 Notify */ 115 ACPI_NS_NORMAL, /* 24 Address Handler */ 116 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 25 Resource Desc */ 117 ACPI_NS_NEWSCOPE | ACPI_NS_LOCAL, /* 26 Resource Field */ 118 ACPI_NS_NEWSCOPE, /* 27 Scope */ 119 ACPI_NS_NORMAL, /* 28 Extra */ 120 ACPI_NS_NORMAL, /* 29 Data */ 121 ACPI_NS_NORMAL /* 30 Invalid */ 122 }; 123 124 /******************************************************************************* 125 * 126 * FUNCTION: acpi_ut_hex_to_ascii_char 127 * 128 * PARAMETERS: Integer - Contains the hex digit 129 * Position - bit position of the digit within the 130 * integer (multiple of 4) 131 * 132 * RETURN: The converted Ascii character 133 * 134 * DESCRIPTION: Convert a hex digit to an Ascii character 135 * 136 ******************************************************************************/ 137 138 /* Hex to ASCII conversion table */ 139 140 static const char acpi_gbl_hex_to_ascii[] = { 141 '0', '1', '2', '3', '4', '5', '6', '7', 142 '8', '9', 'A', 'B', 'C', 'D', 'E', 'F' 143 }; 144 145 char acpi_ut_hex_to_ascii_char(u64 integer, u32 position) 146 { 147 148 return (acpi_gbl_hex_to_ascii[(integer >> position) & 0xF]); 149 } 150 151 /******************************************************************************* 152 * 153 * FUNCTION: acpi_ut_get_region_name 154 * 155 * PARAMETERS: Space ID - ID for the region 156 * 157 * RETURN: Decoded region space_id name 158 * 159 * DESCRIPTION: Translate a Space ID into a name string (Debug only) 160 * 161 ******************************************************************************/ 162 163 /* Region type decoding */ 164 165 const char *acpi_gbl_region_types[ACPI_NUM_PREDEFINED_REGIONS] = { 166 "SystemMemory", 167 "SystemIO", 168 "PCI_Config", 169 "EmbeddedControl", 170 "SMBus", 171 "SystemCMOS", 172 "PCIBARTarget", 173 "IPMI" 174 }; 175 176 char *acpi_ut_get_region_name(u8 space_id) 177 { 178 179 if (space_id >= ACPI_USER_REGION_BEGIN) { 180 return ("UserDefinedRegion"); 181 } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) { 182 return ("DataTable"); 183 } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 184 return ("FunctionalFixedHW"); 185 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) { 186 return ("InvalidSpaceId"); 187 } 188 189 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id])); 190 } 191 192 /******************************************************************************* 193 * 194 * FUNCTION: acpi_ut_get_event_name 195 * 196 * PARAMETERS: event_id - Fixed event ID 197 * 198 * RETURN: Decoded event ID name 199 * 200 * DESCRIPTION: Translate a Event ID into a name string (Debug only) 201 * 202 ******************************************************************************/ 203 204 /* Event type decoding */ 205 206 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = { 207 "PM_Timer", 208 "GlobalLock", 209 "PowerButton", 210 "SleepButton", 211 "RealTimeClock", 212 }; 213 214 char *acpi_ut_get_event_name(u32 event_id) 215 { 216 217 if (event_id > ACPI_EVENT_MAX) { 218 return ("InvalidEventID"); 219 } 220 221 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id])); 222 } 223 224 /******************************************************************************* 225 * 226 * FUNCTION: acpi_ut_get_type_name 227 * 228 * PARAMETERS: Type - An ACPI object type 229 * 230 * RETURN: Decoded ACPI object type name 231 * 232 * DESCRIPTION: Translate a Type ID into a name string (Debug only) 233 * 234 ******************************************************************************/ 235 236 /* 237 * Elements of acpi_gbl_ns_type_names below must match 238 * one-to-one with values of acpi_object_type 239 * 240 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching; 241 * when stored in a table it really means that we have thus far seen no 242 * evidence to indicate what type is actually going to be stored for this entry. 243 */ 244 static const char acpi_gbl_bad_type[] = "UNDEFINED"; 245 246 /* Printable names of the ACPI object types */ 247 248 static const char *acpi_gbl_ns_type_names[] = { 249 /* 00 */ "Untyped", 250 /* 01 */ "Integer", 251 /* 02 */ "String", 252 /* 03 */ "Buffer", 253 /* 04 */ "Package", 254 /* 05 */ "FieldUnit", 255 /* 06 */ "Device", 256 /* 07 */ "Event", 257 /* 08 */ "Method", 258 /* 09 */ "Mutex", 259 /* 10 */ "Region", 260 /* 11 */ "Power", 261 /* 12 */ "Processor", 262 /* 13 */ "Thermal", 263 /* 14 */ "BufferField", 264 /* 15 */ "DdbHandle", 265 /* 16 */ "DebugObject", 266 /* 17 */ "RegionField", 267 /* 18 */ "BankField", 268 /* 19 */ "IndexField", 269 /* 20 */ "Reference", 270 /* 21 */ "Alias", 271 /* 22 */ "MethodAlias", 272 /* 23 */ "Notify", 273 /* 24 */ "AddrHandler", 274 /* 25 */ "ResourceDesc", 275 /* 26 */ "ResourceFld", 276 /* 27 */ "Scope", 277 /* 28 */ "Extra", 278 /* 29 */ "Data", 279 /* 30 */ "Invalid" 280 }; 281 282 char *acpi_ut_get_type_name(acpi_object_type type) 283 { 284 285 if (type > ACPI_TYPE_INVALID) { 286 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type)); 287 } 288 289 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type])); 290 } 291 292 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc) 293 { 294 295 if (!obj_desc) { 296 return ("[NULL Object Descriptor]"); 297 } 298 299 return (acpi_ut_get_type_name(obj_desc->common.type)); 300 } 301 302 /******************************************************************************* 303 * 304 * FUNCTION: acpi_ut_get_node_name 305 * 306 * PARAMETERS: Object - A namespace node 307 * 308 * RETURN: ASCII name of the node 309 * 310 * DESCRIPTION: Validate the node and return the node's ACPI name. 311 * 312 ******************************************************************************/ 313 314 char *acpi_ut_get_node_name(void *object) 315 { 316 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object; 317 318 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */ 319 320 if (!object) { 321 return ("NULL"); 322 } 323 324 /* Check for Root node */ 325 326 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) { 327 return ("\"\\\" "); 328 } 329 330 /* Descriptor must be a namespace node */ 331 332 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) { 333 return ("####"); 334 } 335 336 /* 337 * Ensure name is valid. The name was validated/repaired when the node 338 * was created, but make sure it has not been corrupted. 339 */ 340 acpi_ut_repair_name(node->name.ascii); 341 342 /* Return the name */ 343 344 return (node->name.ascii); 345 } 346 347 /******************************************************************************* 348 * 349 * FUNCTION: acpi_ut_get_descriptor_name 350 * 351 * PARAMETERS: Object - An ACPI object 352 * 353 * RETURN: Decoded name of the descriptor type 354 * 355 * DESCRIPTION: Validate object and return the descriptor type 356 * 357 ******************************************************************************/ 358 359 /* Printable names of object descriptor types */ 360 361 static const char *acpi_gbl_desc_type_names[] = { 362 /* 00 */ "Not a Descriptor", 363 /* 01 */ "Cached", 364 /* 02 */ "State-Generic", 365 /* 03 */ "State-Update", 366 /* 04 */ "State-Package", 367 /* 05 */ "State-Control", 368 /* 06 */ "State-RootParseScope", 369 /* 07 */ "State-ParseScope", 370 /* 08 */ "State-WalkScope", 371 /* 09 */ "State-Result", 372 /* 10 */ "State-Notify", 373 /* 11 */ "State-Thread", 374 /* 12 */ "Walk", 375 /* 13 */ "Parser", 376 /* 14 */ "Operand", 377 /* 15 */ "Node" 378 }; 379 380 char *acpi_ut_get_descriptor_name(void *object) 381 { 382 383 if (!object) { 384 return ("NULL OBJECT"); 385 } 386 387 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) { 388 return ("Not a Descriptor"); 389 } 390 391 return (ACPI_CAST_PTR(char, 392 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE 393 (object)])); 394 395 } 396 397 /******************************************************************************* 398 * 399 * FUNCTION: acpi_ut_get_reference_name 400 * 401 * PARAMETERS: Object - An ACPI reference object 402 * 403 * RETURN: Decoded name of the type of reference 404 * 405 * DESCRIPTION: Decode a reference object sub-type to a string. 406 * 407 ******************************************************************************/ 408 409 /* Printable names of reference object sub-types */ 410 411 static const char *acpi_gbl_ref_class_names[] = { 412 /* 00 */ "Local", 413 /* 01 */ "Argument", 414 /* 02 */ "RefOf", 415 /* 03 */ "Index", 416 /* 04 */ "DdbHandle", 417 /* 05 */ "Named Object", 418 /* 06 */ "Debug" 419 }; 420 421 const char *acpi_ut_get_reference_name(union acpi_operand_object *object) 422 { 423 424 if (!object) { 425 return ("NULL Object"); 426 } 427 428 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) { 429 return ("Not an Operand object"); 430 } 431 432 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) { 433 return ("Not a Reference object"); 434 } 435 436 if (object->reference.class > ACPI_REFCLASS_MAX) { 437 return ("Unknown Reference class"); 438 } 439 440 return (acpi_gbl_ref_class_names[object->reference.class]); 441 } 442 443 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 444 /* 445 * Strings and procedures used for debug only 446 */ 447 448 /******************************************************************************* 449 * 450 * FUNCTION: acpi_ut_get_mutex_name 451 * 452 * PARAMETERS: mutex_id - The predefined ID for this mutex. 453 * 454 * RETURN: Decoded name of the internal mutex 455 * 456 * DESCRIPTION: Translate a mutex ID into a name string (Debug only) 457 * 458 ******************************************************************************/ 459 460 /* Names for internal mutex objects, used for debug output */ 461 462 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = { 463 "ACPI_MTX_Interpreter", 464 "ACPI_MTX_Namespace", 465 "ACPI_MTX_Tables", 466 "ACPI_MTX_Events", 467 "ACPI_MTX_Caches", 468 "ACPI_MTX_Memory", 469 "ACPI_MTX_CommandComplete", 470 "ACPI_MTX_CommandReady" 471 }; 472 473 char *acpi_ut_get_mutex_name(u32 mutex_id) 474 { 475 476 if (mutex_id > ACPI_MAX_MUTEX) { 477 return ("Invalid Mutex ID"); 478 } 479 480 return (acpi_gbl_mutex_names[mutex_id]); 481 } 482 483 /******************************************************************************* 484 * 485 * FUNCTION: acpi_ut_get_notify_name 486 * 487 * PARAMETERS: notify_value - Value from the Notify() request 488 * 489 * RETURN: Decoded name for the notify value 490 * 491 * DESCRIPTION: Translate a Notify Value to a notify namestring. 492 * 493 ******************************************************************************/ 494 495 /* Names for Notify() values, used for debug output */ 496 497 static const char *acpi_gbl_notify_value_names[] = { 498 "Bus Check", 499 "Device Check", 500 "Device Wake", 501 "Eject Request", 502 "Device Check Light", 503 "Frequency Mismatch", 504 "Bus Mode Mismatch", 505 "Power Fault", 506 "Capabilities Check", 507 "Device PLD Check", 508 "Reserved", 509 "System Locality Update" 510 }; 511 512 const char *acpi_ut_get_notify_name(u32 notify_value) 513 { 514 515 if (notify_value <= ACPI_NOTIFY_MAX) { 516 return (acpi_gbl_notify_value_names[notify_value]); 517 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) { 518 return ("Reserved"); 519 } else { /* Greater or equal to 0x80 */ 520 521 return ("**Device Specific**"); 522 } 523 } 524 #endif 525 526 /******************************************************************************* 527 * 528 * FUNCTION: acpi_ut_valid_object_type 529 * 530 * PARAMETERS: Type - Object type to be validated 531 * 532 * RETURN: TRUE if valid object type, FALSE otherwise 533 * 534 * DESCRIPTION: Validate an object type 535 * 536 ******************************************************************************/ 537 538 u8 acpi_ut_valid_object_type(acpi_object_type type) 539 { 540 541 if (type > ACPI_TYPE_LOCAL_MAX) { 542 543 /* Note: Assumes all TYPEs are contiguous (external/local) */ 544 545 return (FALSE); 546 } 547 548 return (TRUE); 549 } 550