1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: psutils - Parser miscellaneous utilities (Parser only) 5 * 6 * Copyright (C) 2000 - 2020, Intel Corp. 7 * 8 *****************************************************************************/ 9 10 #include <acpi/acpi.h> 11 #include "accommon.h" 12 #include "acparser.h" 13 #include "amlcode.h" 14 #include "acconvert.h" 15 16 #define _COMPONENT ACPI_PARSER 17 ACPI_MODULE_NAME("psutils") 18 19 /******************************************************************************* 20 * 21 * FUNCTION: acpi_ps_create_scope_op 22 * 23 * PARAMETERS: None 24 * 25 * RETURN: A new Scope object, null on failure 26 * 27 * DESCRIPTION: Create a Scope and associated namepath op with the root name 28 * 29 ******************************************************************************/ 30 union acpi_parse_object *acpi_ps_create_scope_op(u8 *aml) 31 { 32 union acpi_parse_object *scope_op; 33 34 scope_op = acpi_ps_alloc_op(AML_SCOPE_OP, aml); 35 if (!scope_op) { 36 return (NULL); 37 } 38 39 scope_op->named.name = ACPI_ROOT_NAME; 40 return (scope_op); 41 } 42 43 /******************************************************************************* 44 * 45 * FUNCTION: acpi_ps_init_op 46 * 47 * PARAMETERS: op - A newly allocated Op object 48 * opcode - Opcode to store in the Op 49 * 50 * RETURN: None 51 * 52 * DESCRIPTION: Initialize a parse (Op) object 53 * 54 ******************************************************************************/ 55 56 void acpi_ps_init_op(union acpi_parse_object *op, u16 opcode) 57 { 58 ACPI_FUNCTION_ENTRY(); 59 60 op->common.descriptor_type = ACPI_DESC_TYPE_PARSER; 61 op->common.aml_opcode = opcode; 62 63 ACPI_DISASM_ONLY_MEMBERS(acpi_ut_safe_strncpy(op->common.aml_op_name, 64 (acpi_ps_get_opcode_info 65 (opcode))->name, 66 sizeof(op->common. 67 aml_op_name))); 68 } 69 70 /******************************************************************************* 71 * 72 * FUNCTION: acpi_ps_alloc_op 73 * 74 * PARAMETERS: opcode - Opcode that will be stored in the new Op 75 * aml - Address of the opcode 76 * 77 * RETURN: Pointer to the new Op, null on failure 78 * 79 * DESCRIPTION: Allocate an acpi_op, choose op type (and thus size) based on 80 * opcode. A cache of opcodes is available for the pure 81 * GENERIC_OP, since this is by far the most commonly used. 82 * 83 ******************************************************************************/ 84 85 union acpi_parse_object *acpi_ps_alloc_op(u16 opcode, u8 *aml) 86 { 87 union acpi_parse_object *op; 88 const struct acpi_opcode_info *op_info; 89 u8 flags = ACPI_PARSEOP_GENERIC; 90 91 ACPI_FUNCTION_ENTRY(); 92 93 op_info = acpi_ps_get_opcode_info(opcode); 94 95 /* Determine type of parse_op required */ 96 97 if (op_info->flags & AML_DEFER) { 98 flags = ACPI_PARSEOP_DEFERRED; 99 } else if (op_info->flags & AML_NAMED) { 100 flags = ACPI_PARSEOP_NAMED_OBJECT; 101 } else if (opcode == AML_INT_BYTELIST_OP) { 102 flags = ACPI_PARSEOP_BYTELIST; 103 } 104 105 /* Allocate the minimum required size object */ 106 107 if (flags == ACPI_PARSEOP_GENERIC) { 108 109 /* The generic op (default) is by far the most common (16 to 1) */ 110 111 op = acpi_os_acquire_object(acpi_gbl_ps_node_cache); 112 } else { 113 /* Extended parseop */ 114 115 op = acpi_os_acquire_object(acpi_gbl_ps_node_ext_cache); 116 } 117 118 /* Initialize the Op */ 119 120 if (op) { 121 acpi_ps_init_op(op, opcode); 122 op->common.aml = aml; 123 op->common.flags = flags; 124 ASL_CV_CLEAR_OP_COMMENTS(op); 125 126 if (opcode == AML_SCOPE_OP) { 127 acpi_gbl_current_scope = op; 128 } 129 130 if (acpi_gbl_capture_comments) { 131 ASL_CV_TRANSFER_COMMENTS(op); 132 } 133 } 134 135 return (op); 136 } 137 138 /******************************************************************************* 139 * 140 * FUNCTION: acpi_ps_free_op 141 * 142 * PARAMETERS: op - Op to be freed 143 * 144 * RETURN: None. 145 * 146 * DESCRIPTION: Free an Op object. Either put it on the GENERIC_OP cache list 147 * or actually free it. 148 * 149 ******************************************************************************/ 150 151 void acpi_ps_free_op(union acpi_parse_object *op) 152 { 153 ACPI_FUNCTION_NAME(ps_free_op); 154 155 ASL_CV_CLEAR_OP_COMMENTS(op); 156 if (op->common.aml_opcode == AML_INT_RETURN_VALUE_OP) { 157 ACPI_DEBUG_PRINT((ACPI_DB_ALLOCATIONS, 158 "Free retval op: %p\n", op)); 159 } 160 161 if (op->common.flags & ACPI_PARSEOP_GENERIC) { 162 (void)acpi_os_release_object(acpi_gbl_ps_node_cache, op); 163 } else { 164 (void)acpi_os_release_object(acpi_gbl_ps_node_ext_cache, op); 165 } 166 } 167 168 /******************************************************************************* 169 * 170 * FUNCTION: Utility functions 171 * 172 * DESCRIPTION: Low level character and object functions 173 * 174 ******************************************************************************/ 175 176 /* 177 * Is "c" a namestring lead character? 178 */ 179 u8 acpi_ps_is_leading_char(u32 c) 180 { 181 return ((u8) (c == '_' || (c >= 'A' && c <= 'Z'))); 182 } 183 184 /* 185 * Get op's name (4-byte name segment) or 0 if unnamed 186 */ 187 u32 acpi_ps_get_name(union acpi_parse_object * op) 188 { 189 190 /* The "generic" object has no name associated with it */ 191 192 if (op->common.flags & ACPI_PARSEOP_GENERIC) { 193 return (0); 194 } 195 196 /* Only the "Extended" parse objects have a name */ 197 198 return (op->named.name); 199 } 200 201 /* 202 * Set op's name 203 */ 204 void acpi_ps_set_name(union acpi_parse_object *op, u32 name) 205 { 206 207 /* The "generic" object has no name associated with it */ 208 209 if (op->common.flags & ACPI_PARSEOP_GENERIC) { 210 return; 211 } 212 213 op->named.name = name; 214 } 215