1 /****************************************************************************** 2 * 3 * Module Name: psxface - Parser external interfaces 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2008, 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 <acpi/acpi.h> 45 #include "accommon.h" 46 #include "acparser.h" 47 #include "acdispat.h" 48 #include "acinterp.h" 49 #include "amlcode.h" 50 51 #define _COMPONENT ACPI_PARSER 52 ACPI_MODULE_NAME("psxface") 53 54 /* Local Prototypes */ 55 static void acpi_ps_start_trace(struct acpi_evaluate_info *info); 56 57 static void acpi_ps_stop_trace(struct acpi_evaluate_info *info); 58 59 static void 60 acpi_ps_update_parameter_list(struct acpi_evaluate_info *info, u16 action); 61 62 /******************************************************************************* 63 * 64 * FUNCTION: acpi_debug_trace 65 * 66 * PARAMETERS: method_name - Valid ACPI name string 67 * debug_level - Optional level mask. 0 to use default 68 * debug_layer - Optional layer mask. 0 to use default 69 * Flags - bit 1: one shot(1) or persistent(0) 70 * 71 * RETURN: Status 72 * 73 * DESCRIPTION: External interface to enable debug tracing during control 74 * method execution 75 * 76 ******************************************************************************/ 77 78 acpi_status 79 acpi_debug_trace(char *name, u32 debug_level, u32 debug_layer, u32 flags) 80 { 81 acpi_status status; 82 83 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 84 if (ACPI_FAILURE(status)) { 85 return (status); 86 } 87 88 /* TBDs: Validate name, allow full path or just nameseg */ 89 90 acpi_gbl_trace_method_name = *ACPI_CAST_PTR(u32, name); 91 acpi_gbl_trace_flags = flags; 92 93 if (debug_level) { 94 acpi_gbl_trace_dbg_level = debug_level; 95 } 96 if (debug_layer) { 97 acpi_gbl_trace_dbg_layer = debug_layer; 98 } 99 100 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 101 return (AE_OK); 102 } 103 104 /******************************************************************************* 105 * 106 * FUNCTION: acpi_ps_start_trace 107 * 108 * PARAMETERS: Info - Method info struct 109 * 110 * RETURN: None 111 * 112 * DESCRIPTION: Start control method execution trace 113 * 114 ******************************************************************************/ 115 116 static void acpi_ps_start_trace(struct acpi_evaluate_info *info) 117 { 118 acpi_status status; 119 120 ACPI_FUNCTION_ENTRY(); 121 122 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 123 if (ACPI_FAILURE(status)) { 124 return; 125 } 126 127 if ((!acpi_gbl_trace_method_name) || 128 (acpi_gbl_trace_method_name != info->resolved_node->name.integer)) { 129 goto exit; 130 } 131 132 acpi_gbl_original_dbg_level = acpi_dbg_level; 133 acpi_gbl_original_dbg_layer = acpi_dbg_layer; 134 135 acpi_dbg_level = 0x00FFFFFF; 136 acpi_dbg_layer = ACPI_UINT32_MAX; 137 138 if (acpi_gbl_trace_dbg_level) { 139 acpi_dbg_level = acpi_gbl_trace_dbg_level; 140 } 141 if (acpi_gbl_trace_dbg_layer) { 142 acpi_dbg_layer = acpi_gbl_trace_dbg_layer; 143 } 144 145 exit: 146 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 147 } 148 149 /******************************************************************************* 150 * 151 * FUNCTION: acpi_ps_stop_trace 152 * 153 * PARAMETERS: Info - Method info struct 154 * 155 * RETURN: None 156 * 157 * DESCRIPTION: Stop control method execution trace 158 * 159 ******************************************************************************/ 160 161 static void acpi_ps_stop_trace(struct acpi_evaluate_info *info) 162 { 163 acpi_status status; 164 165 ACPI_FUNCTION_ENTRY(); 166 167 status = acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); 168 if (ACPI_FAILURE(status)) { 169 return; 170 } 171 172 if ((!acpi_gbl_trace_method_name) || 173 (acpi_gbl_trace_method_name != info->resolved_node->name.integer)) { 174 goto exit; 175 } 176 177 /* Disable further tracing if type is one-shot */ 178 179 if (acpi_gbl_trace_flags & 1) { 180 acpi_gbl_trace_method_name = 0; 181 acpi_gbl_trace_dbg_level = 0; 182 acpi_gbl_trace_dbg_layer = 0; 183 } 184 185 acpi_dbg_level = acpi_gbl_original_dbg_level; 186 acpi_dbg_layer = acpi_gbl_original_dbg_layer; 187 188 exit: 189 (void)acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); 190 } 191 192 /******************************************************************************* 193 * 194 * FUNCTION: acpi_ps_execute_method 195 * 196 * PARAMETERS: Info - Method info block, contains: 197 * Node - Method Node to execute 198 * obj_desc - Method object 199 * Parameters - List of parameters to pass to the method, 200 * terminated by NULL. Params itself may be 201 * NULL if no parameters are being passed. 202 * return_object - Where to put method's return value (if 203 * any). If NULL, no value is returned. 204 * parameter_type - Type of Parameter list 205 * return_object - Where to put method's return value (if 206 * any). If NULL, no value is returned. 207 * pass_number - Parse or execute pass 208 * 209 * RETURN: Status 210 * 211 * DESCRIPTION: Execute a control method 212 * 213 ******************************************************************************/ 214 215 acpi_status acpi_ps_execute_method(struct acpi_evaluate_info *info) 216 { 217 acpi_status status; 218 union acpi_parse_object *op; 219 struct acpi_walk_state *walk_state; 220 221 ACPI_FUNCTION_TRACE(ps_execute_method); 222 223 /* Validate the Info and method Node */ 224 225 if (!info || !info->resolved_node) { 226 return_ACPI_STATUS(AE_NULL_ENTRY); 227 } 228 229 /* Init for new method, wait on concurrency semaphore */ 230 231 status = 232 acpi_ds_begin_method_execution(info->resolved_node, info->obj_desc, 233 NULL); 234 if (ACPI_FAILURE(status)) { 235 return_ACPI_STATUS(status); 236 } 237 238 /* 239 * The caller "owns" the parameters, so give each one an extra reference 240 */ 241 acpi_ps_update_parameter_list(info, REF_INCREMENT); 242 243 /* Begin tracing if requested */ 244 245 acpi_ps_start_trace(info); 246 247 /* 248 * Execute the method. Performs parse simultaneously 249 */ 250 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, 251 "**** Begin Method Parse/Execute [%4.4s] **** Node=%p Obj=%p\n", 252 info->resolved_node->name.ascii, info->resolved_node, 253 info->obj_desc)); 254 255 /* Create and init a Root Node */ 256 257 op = acpi_ps_create_scope_op(); 258 if (!op) { 259 status = AE_NO_MEMORY; 260 goto cleanup; 261 } 262 263 /* Create and initialize a new walk state */ 264 265 info->pass_number = ACPI_IMODE_EXECUTE; 266 walk_state = 267 acpi_ds_create_walk_state(info->obj_desc->method.owner_id, NULL, 268 NULL, NULL); 269 if (!walk_state) { 270 status = AE_NO_MEMORY; 271 goto cleanup; 272 } 273 274 status = acpi_ds_init_aml_walk(walk_state, op, info->resolved_node, 275 info->obj_desc->method.aml_start, 276 info->obj_desc->method.aml_length, info, 277 info->pass_number); 278 if (ACPI_FAILURE(status)) { 279 acpi_ds_delete_walk_state(walk_state); 280 goto cleanup; 281 } 282 283 if (info->obj_desc->method.flags & AOPOBJ_MODULE_LEVEL) { 284 walk_state->parse_flags |= ACPI_PARSE_MODULE_LEVEL; 285 } 286 287 /* Invoke an internal method if necessary */ 288 289 if (info->obj_desc->method.method_flags & AML_METHOD_INTERNAL_ONLY) { 290 status = info->obj_desc->method.implementation(walk_state); 291 info->return_object = walk_state->return_desc; 292 293 /* Cleanup states */ 294 295 acpi_ds_scope_stack_clear(walk_state); 296 acpi_ps_cleanup_scope(&walk_state->parser_state); 297 acpi_ds_terminate_control_method(walk_state->method_desc, 298 walk_state); 299 acpi_ds_delete_walk_state(walk_state); 300 goto cleanup; 301 } 302 303 /* 304 * Start method evaluation with an implicit return of zero. 305 * This is done for Windows compatibility. 306 */ 307 if (acpi_gbl_enable_interpreter_slack) { 308 walk_state->implicit_return_obj = 309 acpi_ut_create_internal_object(ACPI_TYPE_INTEGER); 310 if (!walk_state->implicit_return_obj) { 311 status = AE_NO_MEMORY; 312 acpi_ds_delete_walk_state(walk_state); 313 goto cleanup; 314 } 315 316 walk_state->implicit_return_obj->integer.value = 0; 317 } 318 319 /* Parse the AML */ 320 321 status = acpi_ps_parse_aml(walk_state); 322 323 /* walk_state was deleted by parse_aml */ 324 325 cleanup: 326 acpi_ps_delete_parse_tree(op); 327 328 /* End optional tracing */ 329 330 acpi_ps_stop_trace(info); 331 332 /* Take away the extra reference that we gave the parameters above */ 333 334 acpi_ps_update_parameter_list(info, REF_DECREMENT); 335 336 /* Exit now if error above */ 337 338 if (ACPI_FAILURE(status)) { 339 return_ACPI_STATUS(status); 340 } 341 342 /* 343 * If the method has returned an object, signal this to the caller with 344 * a control exception code 345 */ 346 if (info->return_object) { 347 ACPI_DEBUG_PRINT((ACPI_DB_PARSE, "Method returned ObjDesc=%p\n", 348 info->return_object)); 349 ACPI_DUMP_STACK_ENTRY(info->return_object); 350 351 status = AE_CTRL_RETURN_VALUE; 352 } 353 354 return_ACPI_STATUS(status); 355 } 356 357 /******************************************************************************* 358 * 359 * FUNCTION: acpi_ps_update_parameter_list 360 * 361 * PARAMETERS: Info - See struct acpi_evaluate_info 362 * (Used: parameter_type and Parameters) 363 * Action - Add or Remove reference 364 * 365 * RETURN: Status 366 * 367 * DESCRIPTION: Update reference count on all method parameter objects 368 * 369 ******************************************************************************/ 370 371 static void 372 acpi_ps_update_parameter_list(struct acpi_evaluate_info *info, u16 action) 373 { 374 u32 i; 375 376 if (info->parameters) { 377 378 /* Update reference count for each parameter */ 379 380 for (i = 0; info->parameters[i]; i++) { 381 382 /* Ignore errors, just do them all */ 383 384 (void)acpi_ut_update_object_reference(info-> 385 parameters[i], 386 action); 387 } 388 } 389 } 390