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 <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 }; 176 177 char *acpi_ut_get_region_name(u8 space_id) 178 { 179 180 if (space_id >= ACPI_USER_REGION_BEGIN) { 181 return ("UserDefinedRegion"); 182 } else if (space_id == ACPI_ADR_SPACE_DATA_TABLE) { 183 return ("DataTable"); 184 } else if (space_id == ACPI_ADR_SPACE_FIXED_HARDWARE) { 185 return ("FunctionalFixedHW"); 186 } else if (space_id >= ACPI_NUM_PREDEFINED_REGIONS) { 187 return ("InvalidSpaceId"); 188 } 189 190 return (ACPI_CAST_PTR(char, acpi_gbl_region_types[space_id])); 191 } 192 193 /******************************************************************************* 194 * 195 * FUNCTION: acpi_ut_get_event_name 196 * 197 * PARAMETERS: event_id - Fixed event ID 198 * 199 * RETURN: Decoded event ID name 200 * 201 * DESCRIPTION: Translate a Event ID into a name string (Debug only) 202 * 203 ******************************************************************************/ 204 205 /* Event type decoding */ 206 207 static const char *acpi_gbl_event_types[ACPI_NUM_FIXED_EVENTS] = { 208 "PM_Timer", 209 "GlobalLock", 210 "PowerButton", 211 "SleepButton", 212 "RealTimeClock", 213 }; 214 215 char *acpi_ut_get_event_name(u32 event_id) 216 { 217 218 if (event_id > ACPI_EVENT_MAX) { 219 return ("InvalidEventID"); 220 } 221 222 return (ACPI_CAST_PTR(char, acpi_gbl_event_types[event_id])); 223 } 224 225 /******************************************************************************* 226 * 227 * FUNCTION: acpi_ut_get_type_name 228 * 229 * PARAMETERS: Type - An ACPI object type 230 * 231 * RETURN: Decoded ACPI object type name 232 * 233 * DESCRIPTION: Translate a Type ID into a name string (Debug only) 234 * 235 ******************************************************************************/ 236 237 /* 238 * Elements of acpi_gbl_ns_type_names below must match 239 * one-to-one with values of acpi_object_type 240 * 241 * The type ACPI_TYPE_ANY (Untyped) is used as a "don't care" when searching; 242 * when stored in a table it really means that we have thus far seen no 243 * evidence to indicate what type is actually going to be stored for this entry. 244 */ 245 static const char acpi_gbl_bad_type[] = "UNDEFINED"; 246 247 /* Printable names of the ACPI object types */ 248 249 static const char *acpi_gbl_ns_type_names[] = { 250 /* 00 */ "Untyped", 251 /* 01 */ "Integer", 252 /* 02 */ "String", 253 /* 03 */ "Buffer", 254 /* 04 */ "Package", 255 /* 05 */ "FieldUnit", 256 /* 06 */ "Device", 257 /* 07 */ "Event", 258 /* 08 */ "Method", 259 /* 09 */ "Mutex", 260 /* 10 */ "Region", 261 /* 11 */ "Power", 262 /* 12 */ "Processor", 263 /* 13 */ "Thermal", 264 /* 14 */ "BufferField", 265 /* 15 */ "DdbHandle", 266 /* 16 */ "DebugObject", 267 /* 17 */ "RegionField", 268 /* 18 */ "BankField", 269 /* 19 */ "IndexField", 270 /* 20 */ "Reference", 271 /* 21 */ "Alias", 272 /* 22 */ "MethodAlias", 273 /* 23 */ "Notify", 274 /* 24 */ "AddrHandler", 275 /* 25 */ "ResourceDesc", 276 /* 26 */ "ResourceFld", 277 /* 27 */ "Scope", 278 /* 28 */ "Extra", 279 /* 29 */ "Data", 280 /* 30 */ "Invalid" 281 }; 282 283 char *acpi_ut_get_type_name(acpi_object_type type) 284 { 285 286 if (type > ACPI_TYPE_INVALID) { 287 return (ACPI_CAST_PTR(char, acpi_gbl_bad_type)); 288 } 289 290 return (ACPI_CAST_PTR(char, acpi_gbl_ns_type_names[type])); 291 } 292 293 char *acpi_ut_get_object_type_name(union acpi_operand_object *obj_desc) 294 { 295 296 if (!obj_desc) { 297 return ("[NULL Object Descriptor]"); 298 } 299 300 return (acpi_ut_get_type_name(obj_desc->common.type)); 301 } 302 303 /******************************************************************************* 304 * 305 * FUNCTION: acpi_ut_get_node_name 306 * 307 * PARAMETERS: Object - A namespace node 308 * 309 * RETURN: ASCII name of the node 310 * 311 * DESCRIPTION: Validate the node and return the node's ACPI name. 312 * 313 ******************************************************************************/ 314 315 char *acpi_ut_get_node_name(void *object) 316 { 317 struct acpi_namespace_node *node = (struct acpi_namespace_node *)object; 318 319 /* Must return a string of exactly 4 characters == ACPI_NAME_SIZE */ 320 321 if (!object) { 322 return ("NULL"); 323 } 324 325 /* Check for Root node */ 326 327 if ((object == ACPI_ROOT_OBJECT) || (object == acpi_gbl_root_node)) { 328 return ("\"\\\" "); 329 } 330 331 /* Descriptor must be a namespace node */ 332 333 if (ACPI_GET_DESCRIPTOR_TYPE(node) != ACPI_DESC_TYPE_NAMED) { 334 return ("####"); 335 } 336 337 /* 338 * Ensure name is valid. The name was validated/repaired when the node 339 * was created, but make sure it has not been corrupted. 340 */ 341 acpi_ut_repair_name(node->name.ascii); 342 343 /* Return the name */ 344 345 return (node->name.ascii); 346 } 347 348 /******************************************************************************* 349 * 350 * FUNCTION: acpi_ut_get_descriptor_name 351 * 352 * PARAMETERS: Object - An ACPI object 353 * 354 * RETURN: Decoded name of the descriptor type 355 * 356 * DESCRIPTION: Validate object and return the descriptor type 357 * 358 ******************************************************************************/ 359 360 /* Printable names of object descriptor types */ 361 362 static const char *acpi_gbl_desc_type_names[] = { 363 /* 00 */ "Not a Descriptor", 364 /* 01 */ "Cached", 365 /* 02 */ "State-Generic", 366 /* 03 */ "State-Update", 367 /* 04 */ "State-Package", 368 /* 05 */ "State-Control", 369 /* 06 */ "State-RootParseScope", 370 /* 07 */ "State-ParseScope", 371 /* 08 */ "State-WalkScope", 372 /* 09 */ "State-Result", 373 /* 10 */ "State-Notify", 374 /* 11 */ "State-Thread", 375 /* 12 */ "Walk", 376 /* 13 */ "Parser", 377 /* 14 */ "Operand", 378 /* 15 */ "Node" 379 }; 380 381 char *acpi_ut_get_descriptor_name(void *object) 382 { 383 384 if (!object) { 385 return ("NULL OBJECT"); 386 } 387 388 if (ACPI_GET_DESCRIPTOR_TYPE(object) > ACPI_DESC_TYPE_MAX) { 389 return ("Not a Descriptor"); 390 } 391 392 return (ACPI_CAST_PTR(char, 393 acpi_gbl_desc_type_names[ACPI_GET_DESCRIPTOR_TYPE 394 (object)])); 395 396 } 397 398 /******************************************************************************* 399 * 400 * FUNCTION: acpi_ut_get_reference_name 401 * 402 * PARAMETERS: Object - An ACPI reference object 403 * 404 * RETURN: Decoded name of the type of reference 405 * 406 * DESCRIPTION: Decode a reference object sub-type to a string. 407 * 408 ******************************************************************************/ 409 410 /* Printable names of reference object sub-types */ 411 412 static const char *acpi_gbl_ref_class_names[] = { 413 /* 00 */ "Local", 414 /* 01 */ "Argument", 415 /* 02 */ "RefOf", 416 /* 03 */ "Index", 417 /* 04 */ "DdbHandle", 418 /* 05 */ "Named Object", 419 /* 06 */ "Debug" 420 }; 421 422 const char *acpi_ut_get_reference_name(union acpi_operand_object *object) 423 { 424 425 if (!object) { 426 return ("NULL Object"); 427 } 428 429 if (ACPI_GET_DESCRIPTOR_TYPE(object) != ACPI_DESC_TYPE_OPERAND) { 430 return ("Not an Operand object"); 431 } 432 433 if (object->common.type != ACPI_TYPE_LOCAL_REFERENCE) { 434 return ("Not a Reference object"); 435 } 436 437 if (object->reference.class > ACPI_REFCLASS_MAX) { 438 return ("Unknown Reference class"); 439 } 440 441 return (acpi_gbl_ref_class_names[object->reference.class]); 442 } 443 444 #if defined(ACPI_DEBUG_OUTPUT) || defined(ACPI_DEBUGGER) 445 /* 446 * Strings and procedures used for debug only 447 */ 448 449 /******************************************************************************* 450 * 451 * FUNCTION: acpi_ut_get_mutex_name 452 * 453 * PARAMETERS: mutex_id - The predefined ID for this mutex. 454 * 455 * RETURN: Decoded name of the internal mutex 456 * 457 * DESCRIPTION: Translate a mutex ID into a name string (Debug only) 458 * 459 ******************************************************************************/ 460 461 /* Names for internal mutex objects, used for debug output */ 462 463 static char *acpi_gbl_mutex_names[ACPI_NUM_MUTEX] = { 464 "ACPI_MTX_Interpreter", 465 "ACPI_MTX_Namespace", 466 "ACPI_MTX_Tables", 467 "ACPI_MTX_Events", 468 "ACPI_MTX_Caches", 469 "ACPI_MTX_Memory", 470 "ACPI_MTX_CommandComplete", 471 "ACPI_MTX_CommandReady" 472 }; 473 474 char *acpi_ut_get_mutex_name(u32 mutex_id) 475 { 476 477 if (mutex_id > ACPI_MAX_MUTEX) { 478 return ("Invalid Mutex ID"); 479 } 480 481 return (acpi_gbl_mutex_names[mutex_id]); 482 } 483 484 /******************************************************************************* 485 * 486 * FUNCTION: acpi_ut_get_notify_name 487 * 488 * PARAMETERS: notify_value - Value from the Notify() request 489 * 490 * RETURN: Decoded name for the notify value 491 * 492 * DESCRIPTION: Translate a Notify Value to a notify namestring. 493 * 494 ******************************************************************************/ 495 496 /* Names for Notify() values, used for debug output */ 497 498 static const char *acpi_gbl_notify_value_names[] = { 499 "Bus Check", 500 "Device Check", 501 "Device Wake", 502 "Eject Request", 503 "Device Check Light", 504 "Frequency Mismatch", 505 "Bus Mode Mismatch", 506 "Power Fault", 507 "Capabilities Check", 508 "Device PLD Check", 509 "Reserved", 510 "System Locality Update" 511 }; 512 513 const char *acpi_ut_get_notify_name(u32 notify_value) 514 { 515 516 if (notify_value <= ACPI_NOTIFY_MAX) { 517 return (acpi_gbl_notify_value_names[notify_value]); 518 } else if (notify_value <= ACPI_MAX_SYS_NOTIFY) { 519 return ("Reserved"); 520 } else { /* Greater or equal to 0x80 */ 521 522 return ("**Device Specific**"); 523 } 524 } 525 #endif 526 527 /******************************************************************************* 528 * 529 * FUNCTION: acpi_ut_valid_object_type 530 * 531 * PARAMETERS: Type - Object type to be validated 532 * 533 * RETURN: TRUE if valid object type, FALSE otherwise 534 * 535 * DESCRIPTION: Validate an object type 536 * 537 ******************************************************************************/ 538 539 u8 acpi_ut_valid_object_type(acpi_object_type type) 540 { 541 542 if (type > ACPI_TYPE_LOCAL_MAX) { 543 544 /* Note: Assumes all TYPEs are contiguous (external/local) */ 545 546 return (FALSE); 547 } 548 549 return (TRUE); 550 } 551