1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 2 /****************************************************************************** 3 * 4 * Module Name: psscope - Parser scope stack management routines 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 14 #define _COMPONENT ACPI_PARSER 15 ACPI_MODULE_NAME("psscope") 16 17 /******************************************************************************* 18 * 19 * FUNCTION: acpi_ps_get_parent_scope 20 * 21 * PARAMETERS: parser_state - Current parser state object 22 * 23 * RETURN: Pointer to an Op object 24 * 25 * DESCRIPTION: Get parent of current op being parsed 26 * 27 ******************************************************************************/ 28 union acpi_parse_object *acpi_ps_get_parent_scope(struct acpi_parse_state 29 *parser_state) 30 { 31 32 return (parser_state->scope->parse_scope.op); 33 } 34 35 /******************************************************************************* 36 * 37 * FUNCTION: acpi_ps_has_completed_scope 38 * 39 * PARAMETERS: parser_state - Current parser state object 40 * 41 * RETURN: Boolean, TRUE = scope completed. 42 * 43 * DESCRIPTION: Is parsing of current argument complete? Determined by 44 * 1) AML pointer is at or beyond the end of the scope 45 * 2) The scope argument count has reached zero. 46 * 47 ******************************************************************************/ 48 49 u8 acpi_ps_has_completed_scope(struct acpi_parse_state * parser_state) 50 { 51 52 return ((u8) 53 ((parser_state->aml >= parser_state->scope->parse_scope.arg_end 54 || !parser_state->scope->parse_scope.arg_count))); 55 } 56 57 /******************************************************************************* 58 * 59 * FUNCTION: acpi_ps_init_scope 60 * 61 * PARAMETERS: parser_state - Current parser state object 62 * root - the Root Node of this new scope 63 * 64 * RETURN: Status 65 * 66 * DESCRIPTION: Allocate and init a new scope object 67 * 68 ******************************************************************************/ 69 70 acpi_status 71 acpi_ps_init_scope(struct acpi_parse_state * parser_state, 72 union acpi_parse_object * root_op) 73 { 74 union acpi_generic_state *scope; 75 76 ACPI_FUNCTION_TRACE_PTR(ps_init_scope, root_op); 77 78 scope = acpi_ut_create_generic_state(); 79 if (!scope) { 80 return_ACPI_STATUS(AE_NO_MEMORY); 81 } 82 83 scope->common.descriptor_type = ACPI_DESC_TYPE_STATE_RPSCOPE; 84 scope->parse_scope.op = root_op; 85 scope->parse_scope.arg_count = ACPI_VAR_ARGS; 86 scope->parse_scope.arg_end = parser_state->aml_end; 87 scope->parse_scope.pkg_end = parser_state->aml_end; 88 89 parser_state->scope = scope; 90 parser_state->start_op = root_op; 91 92 return_ACPI_STATUS(AE_OK); 93 } 94 95 /******************************************************************************* 96 * 97 * FUNCTION: acpi_ps_push_scope 98 * 99 * PARAMETERS: parser_state - Current parser state object 100 * op - Current op to be pushed 101 * remaining_args - List of args remaining 102 * arg_count - Fixed or variable number of args 103 * 104 * RETURN: Status 105 * 106 * DESCRIPTION: Push current op to begin parsing its argument 107 * 108 ******************************************************************************/ 109 110 acpi_status 111 acpi_ps_push_scope(struct acpi_parse_state *parser_state, 112 union acpi_parse_object *op, 113 u32 remaining_args, u32 arg_count) 114 { 115 union acpi_generic_state *scope; 116 117 ACPI_FUNCTION_TRACE_PTR(ps_push_scope, op); 118 119 scope = acpi_ut_create_generic_state(); 120 if (!scope) { 121 return_ACPI_STATUS(AE_NO_MEMORY); 122 } 123 124 scope->common.descriptor_type = ACPI_DESC_TYPE_STATE_PSCOPE; 125 scope->parse_scope.op = op; 126 scope->parse_scope.arg_list = remaining_args; 127 scope->parse_scope.arg_count = arg_count; 128 scope->parse_scope.pkg_end = parser_state->pkg_end; 129 130 /* Push onto scope stack */ 131 132 acpi_ut_push_generic_state(&parser_state->scope, scope); 133 134 if (arg_count == ACPI_VAR_ARGS) { 135 136 /* Multiple arguments */ 137 138 scope->parse_scope.arg_end = parser_state->pkg_end; 139 } else { 140 /* Single argument */ 141 142 scope->parse_scope.arg_end = ACPI_TO_POINTER(ACPI_MAX_PTR); 143 } 144 145 return_ACPI_STATUS(AE_OK); 146 } 147 148 /******************************************************************************* 149 * 150 * FUNCTION: acpi_ps_pop_scope 151 * 152 * PARAMETERS: parser_state - Current parser state object 153 * op - Where the popped op is returned 154 * arg_list - Where the popped "next argument" is 155 * returned 156 * arg_count - Count of objects in arg_list 157 * 158 * RETURN: Status 159 * 160 * DESCRIPTION: Return to parsing a previous op 161 * 162 ******************************************************************************/ 163 164 void 165 acpi_ps_pop_scope(struct acpi_parse_state *parser_state, 166 union acpi_parse_object **op, u32 * arg_list, u32 * arg_count) 167 { 168 union acpi_generic_state *scope = parser_state->scope; 169 170 ACPI_FUNCTION_TRACE(ps_pop_scope); 171 172 /* Only pop the scope if there is in fact a next scope */ 173 174 if (scope->common.next) { 175 scope = acpi_ut_pop_generic_state(&parser_state->scope); 176 177 /* Return to parsing previous op */ 178 179 *op = scope->parse_scope.op; 180 *arg_list = scope->parse_scope.arg_list; 181 *arg_count = scope->parse_scope.arg_count; 182 parser_state->pkg_end = scope->parse_scope.pkg_end; 183 184 /* All done with this scope state structure */ 185 186 acpi_ut_delete_generic_state(scope); 187 } else { 188 /* Empty parse stack, prepare to fetch next opcode */ 189 190 *op = NULL; 191 *arg_list = 0; 192 *arg_count = 0; 193 } 194 195 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, 196 "Popped Op %p Args %X\n", *op, *arg_count)); 197 return_VOID; 198 } 199 200 /******************************************************************************* 201 * 202 * FUNCTION: acpi_ps_cleanup_scope 203 * 204 * PARAMETERS: parser_state - Current parser state object 205 * 206 * RETURN: None 207 * 208 * DESCRIPTION: Destroy available list, remaining stack levels, and return 209 * root scope 210 * 211 ******************************************************************************/ 212 213 void acpi_ps_cleanup_scope(struct acpi_parse_state *parser_state) 214 { 215 union acpi_generic_state *scope; 216 217 ACPI_FUNCTION_TRACE_PTR(ps_cleanup_scope, parser_state); 218 219 if (!parser_state) { 220 return_VOID; 221 } 222 223 /* Delete anything on the scope stack */ 224 225 while (parser_state->scope) { 226 scope = acpi_ut_pop_generic_state(&parser_state->scope); 227 acpi_ut_delete_generic_state(scope); 228 } 229 230 return_VOID; 231 } 232