drivers/acpi/acpica/exutils.c

   1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
   2 /******************************************************************************
   3  *
   4  * Module Name: exutils - interpreter/scanner utilities
   5  *
   6  * Copyright (C) 2000 - 2018, Intel Corp.
   7  *
   8  *****************************************************************************/
   9
  10 /*
  11  * DEFINE_AML_GLOBALS is tested in amlcode.h
  12  * to determine whether certain global names should be "defined" or only
  13  * "declared" in the current compilation. This enhances maintainability
  14  * by enabling a single header file to embody all knowledge of the names
  15  * in question.
  16  *
  17  * Exactly one module of any executable should #define DEFINE_GLOBALS
  18  * before #including the header files which use this convention. The
  19  * names in question will be defined and initialized in that module,
  20  * and declared as extern in all other modules which #include those
  21  * header files.
  22  */
  23
  24 #define DEFINE_AML_GLOBALS
  25
  26 #include <acpi/acpi.h>
  27 #include "accommon.h"
  28 #include "acinterp.h"
  29 #include "amlcode.h"
  30
  31 #define _COMPONENT          ACPI_EXECUTER
  32 ACPI_MODULE_NAME("exutils")
  33
  34 /* Local prototypes */
  35 static u32 acpi_ex_digits_needed(u64 value, u32 base);
  36
  37 #ifndef ACPI_NO_METHOD_EXECUTION
  38 /*******************************************************************************
  39  *
  40  * FUNCTION:    acpi_ex_enter_interpreter
  41  *
  42  * PARAMETERS:  None
  43  *
  44  * RETURN:      None
  45  *
  46  * DESCRIPTION: Enter the interpreter execution region. Failure to enter
  47  *              the interpreter region is a fatal system error. Used in
  48  *              conjunction with exit_interpreter.
  49  *
  50  ******************************************************************************/
  51
  52 void acpi_ex_enter_interpreter(void)
  53 {
  54         acpi_status status;
  55
  56         ACPI_FUNCTION_TRACE(ex_enter_interpreter);
  57
  58         status = acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER);
  59         if (ACPI_FAILURE(status)) {
  60                 ACPI_ERROR((AE_INFO,
  61                             "Could not acquire AML Interpreter mutex"));
  62         }
  63         status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE);
  64         if (ACPI_FAILURE(status)) {
  65                 ACPI_ERROR((AE_INFO, "Could not acquire AML Namespace mutex"));
  66         }
  67
  68         return_VOID;
  69 }
  70
  71 /*******************************************************************************
  72  *
  73  * FUNCTION:    acpi_ex_exit_interpreter
  74  *
  75  * PARAMETERS:  None
  76  *
  77  * RETURN:      None
  78  *
  79  * DESCRIPTION: Exit the interpreter execution region. This is the top level
  80  *              routine used to exit the interpreter when all processing has
  81  *              been completed, or when the method blocks.
  82  *
  83  * Cases where the interpreter is unlocked internally:
  84  *      1) Method will be blocked on a Sleep() AML opcode
  85  *      2) Method will be blocked on an Acquire() AML opcode
  86  *      3) Method will be blocked on a Wait() AML opcode
  87  *      4) Method will be blocked to acquire the global lock
  88  *      5) Method will be blocked waiting to execute a serialized control
  89  *          method that is currently executing
  90  *      6) About to invoke a user-installed opregion handler
  91  *
  92  ******************************************************************************/
  93
  94 void acpi_ex_exit_interpreter(void)
  95 {
  96         acpi_status status;
  97
  98         ACPI_FUNCTION_TRACE(ex_exit_interpreter);
  99
 100         status = acpi_ut_release_mutex(ACPI_MTX_NAMESPACE);
 101         if (ACPI_FAILURE(status)) {
 102                 ACPI_ERROR((AE_INFO, "Could not release AML Namespace mutex"));
 103         }
 104         status = acpi_ut_release_mutex(ACPI_MTX_INTERPRETER);
 105         if (ACPI_FAILURE(status)) {
 106                 ACPI_ERROR((AE_INFO,
 107                             "Could not release AML Interpreter mutex"));
 108         }
 109
 110         return_VOID;
 111 }
 112
 113 /*******************************************************************************
 114  *
 115  * FUNCTION:    acpi_ex_truncate_for32bit_table
 116  *
 117  * PARAMETERS:  obj_desc        - Object to be truncated
 118  *
 119  * RETURN:      TRUE if a truncation was performed, FALSE otherwise.
 120  *
 121  * DESCRIPTION: Truncate an ACPI Integer to 32 bits if the execution mode is
 122  *              32-bit, as determined by the revision of the DSDT.
 123  *
 124  ******************************************************************************/
 125
 126 u8 acpi_ex_truncate_for32bit_table(union acpi_operand_object *obj_desc)
 127 {
 128
 129         ACPI_FUNCTION_ENTRY();
 130
 131         /*
 132          * Object must be a valid number and we must be executing
 133          * a control method. Object could be NS node for AML_INT_NAMEPATH_OP.
 134          */
 135         if ((!obj_desc) ||
 136             (ACPI_GET_DESCRIPTOR_TYPE(obj_desc) != ACPI_DESC_TYPE_OPERAND) ||
 137             (obj_desc->common.type != ACPI_TYPE_INTEGER)) {
 138                 return (FALSE);
 139         }
 140
 141         if ((acpi_gbl_integer_byte_width == 4) &&
 142             (obj_desc->integer.value > (u64)ACPI_UINT32_MAX)) {
 143                 /*
 144                  * We are executing in a 32-bit ACPI table. Truncate
 145                  * the value to 32 bits by zeroing out the upper 32-bit field
 146                  */
 147                 obj_desc->integer.value &= (u64)ACPI_UINT32_MAX;
 148                 return (TRUE);
 149         }
 150
 151         return (FALSE);
 152 }
 153
 154 /*******************************************************************************
 155  *
 156  * FUNCTION:    acpi_ex_acquire_global_lock
 157  *
 158  * PARAMETERS:  field_flags           - Flags with Lock rule:
 159  *                                      always_lock or never_lock
 160  *
 161  * RETURN:      None
 162  *
 163  * DESCRIPTION: Obtain the ACPI hardware Global Lock, only if the field
 164  *              flags specifiy that it is to be obtained before field access.
 165  *
 166  ******************************************************************************/
 167
 168 void acpi_ex_acquire_global_lock(u32 field_flags)
 169 {
 170         acpi_status status;
 171
 172         ACPI_FUNCTION_TRACE(ex_acquire_global_lock);
 173
 174         /* Only use the lock if the always_lock bit is set */
 175
 176         if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
 177                 return_VOID;
 178         }
 179
 180         /* Attempt to get the global lock, wait forever */
 181
 182         status = acpi_ex_acquire_mutex_object(ACPI_WAIT_FOREVER,
 183                                               acpi_gbl_global_lock_mutex,
 184                                               acpi_os_get_thread_id());
 185
 186         if (ACPI_FAILURE(status)) {
 187                 ACPI_EXCEPTION((AE_INFO, status,
 188                                 "Could not acquire Global Lock"));
 189         }
 190
 191         return_VOID;
 192 }
 193
 194 /*******************************************************************************
 195  *
 196  * FUNCTION:    acpi_ex_release_global_lock
 197  *
 198  * PARAMETERS:  field_flags           - Flags with Lock rule:
 199  *                                      always_lock or never_lock
 200  *
 201  * RETURN:      None
 202  *
 203  * DESCRIPTION: Release the ACPI hardware Global Lock
 204  *
 205  ******************************************************************************/
 206
 207 void acpi_ex_release_global_lock(u32 field_flags)
 208 {
 209         acpi_status status;
 210
 211         ACPI_FUNCTION_TRACE(ex_release_global_lock);
 212
 213         /* Only use the lock if the always_lock bit is set */
 214
 215         if (!(field_flags & AML_FIELD_LOCK_RULE_MASK)) {
 216                 return_VOID;
 217         }
 218
 219         /* Release the global lock */
 220
 221         status = acpi_ex_release_mutex_object(acpi_gbl_global_lock_mutex);
 222         if (ACPI_FAILURE(status)) {
 223
 224                 /* Report the error, but there isn't much else we can do */
 225
 226                 ACPI_EXCEPTION((AE_INFO, status,
 227                                 "Could not release Global Lock"));
 228         }
 229
 230         return_VOID;
 231 }
 232
 233 /*******************************************************************************
 234  *
 235  * FUNCTION:    acpi_ex_digits_needed
 236  *
 237  * PARAMETERS:  value           - Value to be represented
 238  *              base            - Base of representation
 239  *
 240  * RETURN:      The number of digits.
 241  *
 242  * DESCRIPTION: Calculate the number of digits needed to represent the Value
 243  *              in the given Base (Radix)
 244  *
 245  ******************************************************************************/
 246
 247 static u32 acpi_ex_digits_needed(u64 value, u32 base)
 248 {
 249         u32 num_digits;
 250         u64 current_value;
 251
 252         ACPI_FUNCTION_TRACE(ex_digits_needed);
 253
 254         /* u64 is unsigned, so we don't worry about a '-' prefix */
 255
 256         if (value == 0) {
 257                 return_UINT32(1);
 258         }
 259
 260         current_value = value;
 261         num_digits = 0;
 262
 263         /* Count the digits in the requested base */
 264
 265         while (current_value) {
 266                 (void)acpi_ut_short_divide(current_value, base, &current_value,
 267                                            NULL);
 268                 num_digits++;
 269         }
 270
 271         return_UINT32(num_digits);
 272 }
 273
 274 /*******************************************************************************
 275  *
 276  * FUNCTION:    acpi_ex_eisa_id_to_string
 277  *
 278  * PARAMETERS:  out_string      - Where to put the converted string (8 bytes)
 279  *              compressed_id   - EISAID to be converted
 280  *
 281  * RETURN:      None
 282  *
 283  * DESCRIPTION: Convert a numeric EISAID to string representation. Return
 284  *              buffer must be large enough to hold the string. The string
 285  *              returned is always exactly of length ACPI_EISAID_STRING_SIZE
 286  *              (includes null terminator). The EISAID is always 32 bits.
 287  *
 288  ******************************************************************************/
 289
 290 void acpi_ex_eisa_id_to_string(char *out_string, u64 compressed_id)
 291 {
 292         u32 swapped_id;
 293
 294         ACPI_FUNCTION_ENTRY();
 295
 296         /* The EISAID should be a 32-bit integer */
 297
 298         if (compressed_id > ACPI_UINT32_MAX) {
 299                 ACPI_WARNING((AE_INFO,
 300                               "Expected EISAID is larger than 32 bits: "
 301                               "0x%8.8X%8.8X, truncating",
 302                               ACPI_FORMAT_UINT64(compressed_id)));
 303         }
 304
 305         /* Swap ID to big-endian to get contiguous bits */
 306
 307         swapped_id = acpi_ut_dword_byte_swap((u32)compressed_id);
 308
 309         /* First 3 bytes are uppercase letters. Next 4 bytes are hexadecimal */
 310
 311         out_string[0] =
 312             (char)(0x40 + (((unsigned long)swapped_id >> 26) & 0x1F));
 313         out_string[1] = (char)(0x40 + ((swapped_id >> 21) & 0x1F));
 314         out_string[2] = (char)(0x40 + ((swapped_id >> 16) & 0x1F));
 315         out_string[3] = acpi_ut_hex_to_ascii_char((u64) swapped_id, 12);
 316         out_string[4] = acpi_ut_hex_to_ascii_char((u64) swapped_id, 8);
 317         out_string[5] = acpi_ut_hex_to_ascii_char((u64) swapped_id, 4);
 318         out_string[6] = acpi_ut_hex_to_ascii_char((u64) swapped_id, 0);
 319         out_string[7] = 0;
 320 }
 321
 322 /*******************************************************************************
 323  *
 324  * FUNCTION:    acpi_ex_integer_to_string
 325  *
 326  * PARAMETERS:  out_string      - Where to put the converted string. At least
 327  *                                21 bytes are needed to hold the largest
 328  *                                possible 64-bit integer.
 329  *              value           - Value to be converted
 330  *
 331  * RETURN:      Converted string in out_string
 332  *
 333  * DESCRIPTION: Convert a 64-bit integer to decimal string representation.
 334  *              Assumes string buffer is large enough to hold the string. The
 335  *              largest string is (ACPI_MAX64_DECIMAL_DIGITS + 1).
 336  *
 337  ******************************************************************************/
 338
 339 void acpi_ex_integer_to_string(char *out_string, u64 value)
 340 {
 341         u32 count;
 342         u32 digits_needed;
 343         u32 remainder;
 344
 345         ACPI_FUNCTION_ENTRY();
 346
 347         digits_needed = acpi_ex_digits_needed(value, 10);
 348         out_string[digits_needed] = 0;
 349
 350         for (count = digits_needed; count > 0; count--) {
 351                 (void)acpi_ut_short_divide(value, 10, &value, &remainder);
 352                 out_string[count - 1] = (char)('0' + remainder);
 353         }
 354 }
 355
 356 /*******************************************************************************
 357  *
 358  * FUNCTION:    acpi_ex_pci_cls_to_string
 359  *
 360  * PARAMETERS:  out_string      - Where to put the converted string (7 bytes)
 361  *              class_code      - PCI class code to be converted (3 bytes)
 362  *
 363  * RETURN:      Converted string in out_string
 364  *
 365  * DESCRIPTION: Convert 3-bytes PCI class code to string representation.
 366  *              Return buffer must be large enough to hold the string. The
 367  *              string returned is always exactly of length
 368  *              ACPI_PCICLS_STRING_SIZE (includes null terminator).
 369  *
 370  ******************************************************************************/
 371
 372 void acpi_ex_pci_cls_to_string(char *out_string, u8 class_code[3])
 373 {
 374
 375         ACPI_FUNCTION_ENTRY();
 376
 377         /* All 3 bytes are hexadecimal */
 378
 379         out_string[0] = acpi_ut_hex_to_ascii_char((u64)class_code[0], 4);
 380         out_string[1] = acpi_ut_hex_to_ascii_char((u64)class_code[0], 0);
 381         out_string[2] = acpi_ut_hex_to_ascii_char((u64)class_code[1], 4);
 382         out_string[3] = acpi_ut_hex_to_ascii_char((u64)class_code[1], 0);
 383         out_string[4] = acpi_ut_hex_to_ascii_char((u64)class_code[2], 4);
 384         out_string[5] = acpi_ut_hex_to_ascii_char((u64)class_code[2], 0);
 385         out_string[6] = 0;
 386 }
 387
 388 /*******************************************************************************
 389  *
 390  * FUNCTION:    acpi_is_valid_space_id
 391  *
 392  * PARAMETERS:  space_id            - ID to be validated
 393  *
 394  * RETURN:      TRUE if space_id is a valid/supported ID.
 395  *
 396  * DESCRIPTION: Validate an operation region space_ID.
 397  *
 398  ******************************************************************************/
 399
 400 u8 acpi_is_valid_space_id(u8 space_id)
 401 {
 402
 403         if ((space_id >= ACPI_NUM_PREDEFINED_REGIONS) &&
 404             (space_id < ACPI_USER_REGION_BEGIN) &&
 405             (space_id != ACPI_ADR_SPACE_DATA_TABLE) &&
 406             (space_id != ACPI_ADR_SPACE_FIXED_HARDWARE)) {
 407                 return (FALSE);
 408         }
 409
 410         return (TRUE);
 411 }
 412
 413 #endif