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