1 | // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
2 | /******************************************************************************* |
3 | * |
4 | * Module Name: dbutils - AML debugger utilities |
5 | * |
6 | ******************************************************************************/ |
7 | |
8 | #include <acpi/acpi.h> |
9 | #include "accommon.h" |
10 | #include "acnamesp.h" |
11 | #include "acdebug.h" |
12 | |
13 | #define _COMPONENT ACPI_CA_DEBUGGER |
14 | ACPI_MODULE_NAME("dbutils" ) |
15 | |
16 | /* Local prototypes */ |
17 | #ifdef ACPI_OBSOLETE_FUNCTIONS |
18 | acpi_status acpi_db_second_pass_parse(union acpi_parse_object *root); |
19 | |
20 | void acpi_db_dump_buffer(u32 address); |
21 | #endif |
22 | |
23 | /******************************************************************************* |
24 | * |
25 | * FUNCTION: acpi_db_match_argument |
26 | * |
27 | * PARAMETERS: user_argument - User command line |
28 | * arguments - Array of commands to match against |
29 | * |
30 | * RETURN: Index into command array or ACPI_TYPE_NOT_FOUND if not found |
31 | * |
32 | * DESCRIPTION: Search command array for a command match |
33 | * |
34 | ******************************************************************************/ |
35 | |
36 | acpi_object_type |
37 | acpi_db_match_argument(char *user_argument, |
38 | struct acpi_db_argument_info *arguments) |
39 | { |
40 | u32 i; |
41 | |
42 | if (!user_argument || user_argument[0] == 0) { |
43 | return (ACPI_TYPE_NOT_FOUND); |
44 | } |
45 | |
46 | for (i = 0; arguments[i].name; i++) { |
47 | if (strstr(ACPI_CAST_PTR(char, arguments[i].name), |
48 | ACPI_CAST_PTR(char, |
49 | user_argument)) == arguments[i].name) { |
50 | return (i); |
51 | } |
52 | } |
53 | |
54 | /* Argument not recognized */ |
55 | |
56 | return (ACPI_TYPE_NOT_FOUND); |
57 | } |
58 | |
59 | /******************************************************************************* |
60 | * |
61 | * FUNCTION: acpi_db_set_output_destination |
62 | * |
63 | * PARAMETERS: output_flags - Current flags word |
64 | * |
65 | * RETURN: None |
66 | * |
67 | * DESCRIPTION: Set the current destination for debugger output. Also sets |
68 | * the debug output level accordingly. |
69 | * |
70 | ******************************************************************************/ |
71 | |
72 | void acpi_db_set_output_destination(u32 output_flags) |
73 | { |
74 | |
75 | acpi_gbl_db_output_flags = (u8)output_flags; |
76 | |
77 | if ((output_flags & ACPI_DB_REDIRECTABLE_OUTPUT) && |
78 | acpi_gbl_db_output_to_file) { |
79 | acpi_dbg_level = acpi_gbl_db_debug_level; |
80 | } else { |
81 | acpi_dbg_level = acpi_gbl_db_console_debug_level; |
82 | } |
83 | } |
84 | |
85 | /******************************************************************************* |
86 | * |
87 | * FUNCTION: acpi_db_dump_external_object |
88 | * |
89 | * PARAMETERS: obj_desc - External ACPI object to dump |
90 | * level - Nesting level. |
91 | * |
92 | * RETURN: None |
93 | * |
94 | * DESCRIPTION: Dump the contents of an ACPI external object |
95 | * |
96 | ******************************************************************************/ |
97 | |
98 | void acpi_db_dump_external_object(union acpi_object *obj_desc, u32 level) |
99 | { |
100 | u32 i; |
101 | |
102 | if (!obj_desc) { |
103 | acpi_os_printf(format: "[Null Object]\n" ); |
104 | return; |
105 | } |
106 | |
107 | for (i = 0; i < level; i++) { |
108 | acpi_os_printf(format: " " ); |
109 | } |
110 | |
111 | switch (obj_desc->type) { |
112 | case ACPI_TYPE_ANY: |
113 | |
114 | acpi_os_printf(format: "[Null Object] (Type=0)\n" ); |
115 | break; |
116 | |
117 | case ACPI_TYPE_INTEGER: |
118 | |
119 | acpi_os_printf(format: "[Integer] = %8.8X%8.8X\n" , |
120 | ACPI_FORMAT_UINT64(obj_desc->integer.value)); |
121 | break; |
122 | |
123 | case ACPI_TYPE_STRING: |
124 | |
125 | acpi_os_printf(format: "[String] Length %.2X = " , |
126 | obj_desc->string.length); |
127 | acpi_ut_print_string(string: obj_desc->string.pointer, ACPI_UINT8_MAX); |
128 | acpi_os_printf(format: "\n" ); |
129 | break; |
130 | |
131 | case ACPI_TYPE_BUFFER: |
132 | |
133 | acpi_os_printf(format: "[Buffer] Length %.2X = " , |
134 | obj_desc->buffer.length); |
135 | if (obj_desc->buffer.length) { |
136 | if (obj_desc->buffer.length > 16) { |
137 | acpi_os_printf(format: "\n" ); |
138 | } |
139 | |
140 | acpi_ut_debug_dump_buffer(ACPI_CAST_PTR |
141 | (u8, |
142 | obj_desc->buffer.pointer), |
143 | count: obj_desc->buffer.length, |
144 | DB_BYTE_DISPLAY, _COMPONENT); |
145 | } else { |
146 | acpi_os_printf(format: "\n" ); |
147 | } |
148 | break; |
149 | |
150 | case ACPI_TYPE_PACKAGE: |
151 | |
152 | acpi_os_printf(format: "[Package] Contains %u Elements:\n" , |
153 | obj_desc->package.count); |
154 | |
155 | for (i = 0; i < obj_desc->package.count; i++) { |
156 | acpi_db_dump_external_object(obj_desc: &obj_desc->package. |
157 | elements[i], level: level + 1); |
158 | } |
159 | break; |
160 | |
161 | case ACPI_TYPE_LOCAL_REFERENCE: |
162 | |
163 | acpi_os_printf(format: "[Object Reference] = " ); |
164 | acpi_db_display_internal_object(obj_desc: obj_desc->reference.handle, |
165 | NULL); |
166 | break; |
167 | |
168 | case ACPI_TYPE_PROCESSOR: |
169 | |
170 | acpi_os_printf(format: "[Processor]\n" ); |
171 | break; |
172 | |
173 | case ACPI_TYPE_POWER: |
174 | |
175 | acpi_os_printf(format: "[Power Resource]\n" ); |
176 | break; |
177 | |
178 | default: |
179 | |
180 | acpi_os_printf(format: "[Unknown Type] %X\n" , obj_desc->type); |
181 | break; |
182 | } |
183 | } |
184 | |
185 | /******************************************************************************* |
186 | * |
187 | * FUNCTION: acpi_db_prep_namestring |
188 | * |
189 | * PARAMETERS: name - String to prepare |
190 | * |
191 | * RETURN: None |
192 | * |
193 | * DESCRIPTION: Translate all forward slashes and dots to backslashes. |
194 | * |
195 | ******************************************************************************/ |
196 | |
197 | void acpi_db_prep_namestring(char *name) |
198 | { |
199 | |
200 | if (!name) { |
201 | return; |
202 | } |
203 | |
204 | acpi_ut_strupr(src_string: name); |
205 | |
206 | /* Convert a leading forward slash to a backslash */ |
207 | |
208 | if (*name == '/') { |
209 | *name = '\\'; |
210 | } |
211 | |
212 | /* Ignore a leading backslash, this is the root prefix */ |
213 | |
214 | if (ACPI_IS_ROOT_PREFIX(*name)) { |
215 | name++; |
216 | } |
217 | |
218 | /* Convert all slash path separators to dots */ |
219 | |
220 | while (*name) { |
221 | if ((*name == '/') || (*name == '\\')) { |
222 | *name = '.'; |
223 | } |
224 | |
225 | name++; |
226 | } |
227 | } |
228 | |
229 | /******************************************************************************* |
230 | * |
231 | * FUNCTION: acpi_db_local_ns_lookup |
232 | * |
233 | * PARAMETERS: name - Name to lookup |
234 | * |
235 | * RETURN: Pointer to a namespace node, null on failure |
236 | * |
237 | * DESCRIPTION: Lookup a name in the ACPI namespace |
238 | * |
239 | * Note: Currently begins search from the root. Could be enhanced to use |
240 | * the current prefix (scope) node as the search beginning point. |
241 | * |
242 | ******************************************************************************/ |
243 | |
244 | struct acpi_namespace_node *acpi_db_local_ns_lookup(char *name) |
245 | { |
246 | char *internal_path; |
247 | acpi_status status; |
248 | struct acpi_namespace_node *node = NULL; |
249 | |
250 | acpi_db_prep_namestring(name); |
251 | |
252 | /* Build an internal namestring */ |
253 | |
254 | status = acpi_ns_internalize_name(dotted_name: name, converted_name: &internal_path); |
255 | if (ACPI_FAILURE(status)) { |
256 | acpi_os_printf(format: "Invalid namestring: %s\n" , name); |
257 | return (NULL); |
258 | } |
259 | |
260 | /* |
261 | * Lookup the name. |
262 | * (Uses root node as the search starting point) |
263 | */ |
264 | status = acpi_ns_lookup(NULL, name: internal_path, ACPI_TYPE_ANY, |
265 | interpreter_mode: ACPI_IMODE_EXECUTE, |
266 | ACPI_NS_NO_UPSEARCH | ACPI_NS_DONT_OPEN_SCOPE, |
267 | NULL, ret_node: &node); |
268 | if (ACPI_FAILURE(status)) { |
269 | acpi_os_printf(format: "Could not locate name: %s, %s\n" , |
270 | name, acpi_format_exception(exception: status)); |
271 | } |
272 | |
273 | ACPI_FREE(internal_path); |
274 | return (node); |
275 | } |
276 | |
277 | /******************************************************************************* |
278 | * |
279 | * FUNCTION: acpi_db_uint32_to_hex_string |
280 | * |
281 | * PARAMETERS: value - The value to be converted to string |
282 | * buffer - Buffer for result (not less than 11 bytes) |
283 | * |
284 | * RETURN: None |
285 | * |
286 | * DESCRIPTION: Convert the unsigned 32-bit value to the hexadecimal image |
287 | * |
288 | * NOTE: It is the caller's responsibility to ensure that the length of buffer |
289 | * is sufficient. |
290 | * |
291 | ******************************************************************************/ |
292 | |
293 | void acpi_db_uint32_to_hex_string(u32 value, char *buffer) |
294 | { |
295 | int i; |
296 | |
297 | if (value == 0) { |
298 | strcpy(p: buffer, q: "0" ); |
299 | return; |
300 | } |
301 | |
302 | buffer[8] = '\0'; |
303 | |
304 | for (i = 7; i >= 0; i--) { |
305 | buffer[i] = acpi_gbl_upper_hex_digits[value & 0x0F]; |
306 | value = value >> 4; |
307 | } |
308 | } |
309 | |
310 | #ifdef ACPI_OBSOLETE_FUNCTIONS |
311 | /******************************************************************************* |
312 | * |
313 | * FUNCTION: acpi_db_second_pass_parse |
314 | * |
315 | * PARAMETERS: root - Root of the parse tree |
316 | * |
317 | * RETURN: Status |
318 | * |
319 | * DESCRIPTION: Second pass parse of the ACPI tables. We need to wait until |
320 | * second pass to parse the control methods |
321 | * |
322 | ******************************************************************************/ |
323 | |
324 | acpi_status acpi_db_second_pass_parse(union acpi_parse_object *root) |
325 | { |
326 | union acpi_parse_object *op = root; |
327 | union acpi_parse_object *method; |
328 | union acpi_parse_object *search_op; |
329 | union acpi_parse_object *start_op; |
330 | acpi_status status = AE_OK; |
331 | u32 base_aml_offset; |
332 | struct acpi_walk_state *walk_state; |
333 | |
334 | ACPI_FUNCTION_ENTRY(); |
335 | |
336 | acpi_os_printf("Pass two parse ....\n" ); |
337 | |
338 | while (op) { |
339 | if (op->common.aml_opcode == AML_METHOD_OP) { |
340 | method = op; |
341 | |
342 | /* Create a new walk state for the parse */ |
343 | |
344 | walk_state = |
345 | acpi_ds_create_walk_state(0, NULL, NULL, NULL); |
346 | if (!walk_state) { |
347 | return (AE_NO_MEMORY); |
348 | } |
349 | |
350 | /* Init the Walk State */ |
351 | |
352 | walk_state->parser_state.aml = |
353 | walk_state->parser_state.aml_start = |
354 | method->named.data; |
355 | walk_state->parser_state.aml_end = |
356 | walk_state->parser_state.pkg_end = |
357 | method->named.data + method->named.length; |
358 | walk_state->parser_state.start_scope = op; |
359 | |
360 | walk_state->descending_callback = |
361 | acpi_ds_load1_begin_op; |
362 | walk_state->ascending_callback = acpi_ds_load1_end_op; |
363 | |
364 | /* Perform the AML parse */ |
365 | |
366 | status = acpi_ps_parse_aml(walk_state); |
367 | |
368 | base_aml_offset = |
369 | (method->common.value.arg)->common.aml_offset + 1; |
370 | start_op = (method->common.value.arg)->common.next; |
371 | search_op = start_op; |
372 | |
373 | while (search_op) { |
374 | search_op->common.aml_offset += base_aml_offset; |
375 | search_op = |
376 | acpi_ps_get_depth_next(start_op, search_op); |
377 | } |
378 | } |
379 | |
380 | if (op->common.aml_opcode == AML_REGION_OP) { |
381 | |
382 | /* TBD: [Investigate] this isn't quite the right thing to do! */ |
383 | /* |
384 | * |
385 | * Method = (ACPI_DEFERRED_OP *) Op; |
386 | * Status = acpi_ps_parse_aml (Op, Method->Body, Method->body_length); |
387 | */ |
388 | } |
389 | |
390 | if (ACPI_FAILURE(status)) { |
391 | break; |
392 | } |
393 | |
394 | op = acpi_ps_get_depth_next(root, op); |
395 | } |
396 | |
397 | return (status); |
398 | } |
399 | |
400 | /******************************************************************************* |
401 | * |
402 | * FUNCTION: acpi_db_dump_buffer |
403 | * |
404 | * PARAMETERS: address - Pointer to the buffer |
405 | * |
406 | * RETURN: None |
407 | * |
408 | * DESCRIPTION: Print a portion of a buffer |
409 | * |
410 | ******************************************************************************/ |
411 | |
412 | void acpi_db_dump_buffer(u32 address) |
413 | { |
414 | |
415 | acpi_os_printf("\nLocation %X:\n" , address); |
416 | |
417 | acpi_dbg_level |= ACPI_LV_TABLES; |
418 | acpi_ut_debug_dump_buffer(ACPI_TO_POINTER(address), 64, DB_BYTE_DISPLAY, |
419 | ACPI_UINT32_MAX); |
420 | } |
421 | #endif |
422 | |