1 | // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0 |
2 | /******************************************************************************* |
3 | * |
4 | * Module Name: dbtest - Various debug-related tests |
5 | * |
6 | ******************************************************************************/ |
7 | |
8 | #include <acpi/acpi.h> |
9 | #include "accommon.h" |
10 | #include "acdebug.h" |
11 | #include "acnamesp.h" |
12 | #include "acpredef.h" |
13 | #include "acinterp.h" |
14 | |
15 | #define _COMPONENT ACPI_CA_DEBUGGER |
16 | ACPI_MODULE_NAME("dbtest" ) |
17 | |
18 | /* Local prototypes */ |
19 | static void acpi_db_test_all_objects(void); |
20 | |
21 | static acpi_status |
22 | acpi_db_test_one_object(acpi_handle obj_handle, |
23 | u32 nesting_level, void *context, void **return_value); |
24 | |
25 | static acpi_status |
26 | acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length); |
27 | |
28 | static acpi_status |
29 | acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length); |
30 | |
31 | static acpi_status |
32 | acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length); |
33 | |
34 | static acpi_status acpi_db_test_package_type(struct acpi_namespace_node *node); |
35 | |
36 | static acpi_status |
37 | acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc); |
38 | |
39 | static acpi_status |
40 | acpi_db_read_from_object(struct acpi_namespace_node *node, |
41 | acpi_object_type expected_type, |
42 | union acpi_object **value); |
43 | |
44 | static acpi_status |
45 | acpi_db_write_to_object(struct acpi_namespace_node *node, |
46 | union acpi_object *value); |
47 | |
48 | static void acpi_db_evaluate_all_predefined_names(char *count_arg); |
49 | |
50 | static acpi_status |
51 | acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle, |
52 | u32 nesting_level, |
53 | void *context, void **return_value); |
54 | |
55 | /* |
56 | * Test subcommands |
57 | */ |
58 | static struct acpi_db_argument_info acpi_db_test_types[] = { |
59 | {"OBJECTS" }, |
60 | {"PREDEFINED" }, |
61 | {NULL} /* Must be null terminated */ |
62 | }; |
63 | |
64 | #define CMD_TEST_OBJECTS 0 |
65 | #define CMD_TEST_PREDEFINED 1 |
66 | |
67 | #define BUFFER_FILL_VALUE 0xFF |
68 | |
69 | /* |
70 | * Support for the special debugger read/write control methods. |
71 | * These methods are installed into the current namespace and are |
72 | * used to read and write the various namespace objects. The point |
73 | * is to force the AML interpreter do all of the work. |
74 | */ |
75 | #define ACPI_DB_READ_METHOD "\\_T98" |
76 | #define ACPI_DB_WRITE_METHOD "\\_T99" |
77 | |
78 | static acpi_handle read_handle = NULL; |
79 | static acpi_handle write_handle = NULL; |
80 | |
81 | /* ASL Definitions of the debugger read/write control methods. AML below. */ |
82 | |
83 | #if 0 |
84 | definition_block("ssdt.aml" , "SSDT" , 2, "Intel" , "DEBUG" , 0x00000001) |
85 | { |
86 | method(_T98, 1, not_serialized) { /* Read */ |
87 | return (de_ref_of(arg0)) |
88 | } |
89 | } |
90 | |
91 | definition_block("ssdt2.aml" , "SSDT" , 2, "Intel" , "DEBUG" , 0x00000001) |
92 | { |
93 | method(_T99, 2, not_serialized) { /* Write */ |
94 | store(arg1, arg0) |
95 | } |
96 | } |
97 | #endif |
98 | |
99 | static unsigned char read_method_code[] = { |
100 | 0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00, /* 00000000 "SSDT...." */ |
101 | 0x02, 0xC9, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00, /* 00000008 "..Intel." */ |
102 | 0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00, /* 00000010 "DEBUG..." */ |
103 | 0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* 00000018 "....INTL" */ |
104 | 0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54, /* 00000020 "... .._T" */ |
105 | 0x39, 0x38, 0x01, 0xA4, 0x83, 0x68 /* 00000028 "98...h" */ |
106 | }; |
107 | |
108 | static unsigned char write_method_code[] = { |
109 | 0x53, 0x53, 0x44, 0x54, 0x2E, 0x00, 0x00, 0x00, /* 00000000 "SSDT...." */ |
110 | 0x02, 0x15, 0x49, 0x6E, 0x74, 0x65, 0x6C, 0x00, /* 00000008 "..Intel." */ |
111 | 0x44, 0x45, 0x42, 0x55, 0x47, 0x00, 0x00, 0x00, /* 00000010 "DEBUG..." */ |
112 | 0x01, 0x00, 0x00, 0x00, 0x49, 0x4E, 0x54, 0x4C, /* 00000018 "....INTL" */ |
113 | 0x18, 0x12, 0x13, 0x20, 0x14, 0x09, 0x5F, 0x54, /* 00000020 "... .._T" */ |
114 | 0x39, 0x39, 0x02, 0x70, 0x69, 0x68 /* 00000028 "99.pih" */ |
115 | }; |
116 | |
117 | /******************************************************************************* |
118 | * |
119 | * FUNCTION: acpi_db_execute_test |
120 | * |
121 | * PARAMETERS: type_arg - Subcommand |
122 | * |
123 | * RETURN: None |
124 | * |
125 | * DESCRIPTION: Execute various debug tests. |
126 | * |
127 | * Note: Code is prepared for future expansion of the TEST command. |
128 | * |
129 | ******************************************************************************/ |
130 | |
131 | void acpi_db_execute_test(char *type_arg) |
132 | { |
133 | u32 temp; |
134 | |
135 | acpi_ut_strupr(src_string: type_arg); |
136 | temp = acpi_db_match_argument(user_argument: type_arg, arguments: acpi_db_test_types); |
137 | if (temp == ACPI_TYPE_NOT_FOUND) { |
138 | acpi_os_printf(format: "Invalid or unsupported argument\n" ); |
139 | return; |
140 | } |
141 | |
142 | switch (temp) { |
143 | case CMD_TEST_OBJECTS: |
144 | |
145 | acpi_db_test_all_objects(); |
146 | break; |
147 | |
148 | case CMD_TEST_PREDEFINED: |
149 | |
150 | acpi_db_evaluate_all_predefined_names(NULL); |
151 | break; |
152 | |
153 | default: |
154 | break; |
155 | } |
156 | } |
157 | |
158 | /******************************************************************************* |
159 | * |
160 | * FUNCTION: acpi_db_test_all_objects |
161 | * |
162 | * PARAMETERS: None |
163 | * |
164 | * RETURN: None |
165 | * |
166 | * DESCRIPTION: This test implements the OBJECTS subcommand. It exercises the |
167 | * namespace by reading/writing/comparing all data objects such |
168 | * as integers, strings, buffers, fields, buffer fields, etc. |
169 | * |
170 | ******************************************************************************/ |
171 | |
172 | static void acpi_db_test_all_objects(void) |
173 | { |
174 | acpi_status status; |
175 | |
176 | /* Install the debugger read-object control method if necessary */ |
177 | |
178 | if (!read_handle) { |
179 | status = acpi_install_method(buffer: read_method_code); |
180 | if (ACPI_FAILURE(status)) { |
181 | acpi_os_printf |
182 | (format: "%s, Could not install debugger read method\n" , |
183 | acpi_format_exception(exception: status)); |
184 | return; |
185 | } |
186 | |
187 | status = |
188 | acpi_get_handle(NULL, ACPI_DB_READ_METHOD, ret_handle: &read_handle); |
189 | if (ACPI_FAILURE(status)) { |
190 | acpi_os_printf |
191 | (format: "Could not obtain handle for debug method %s\n" , |
192 | ACPI_DB_READ_METHOD); |
193 | return; |
194 | } |
195 | } |
196 | |
197 | /* Install the debugger write-object control method if necessary */ |
198 | |
199 | if (!write_handle) { |
200 | status = acpi_install_method(buffer: write_method_code); |
201 | if (ACPI_FAILURE(status)) { |
202 | acpi_os_printf |
203 | (format: "%s, Could not install debugger write method\n" , |
204 | acpi_format_exception(exception: status)); |
205 | return; |
206 | } |
207 | |
208 | status = |
209 | acpi_get_handle(NULL, ACPI_DB_WRITE_METHOD, ret_handle: &write_handle); |
210 | if (ACPI_FAILURE(status)) { |
211 | acpi_os_printf |
212 | (format: "Could not obtain handle for debug method %s\n" , |
213 | ACPI_DB_WRITE_METHOD); |
214 | return; |
215 | } |
216 | } |
217 | |
218 | /* Walk the entire namespace, testing each supported named data object */ |
219 | |
220 | (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, |
221 | ACPI_UINT32_MAX, descending_callback: acpi_db_test_one_object, |
222 | NULL, NULL, NULL); |
223 | } |
224 | |
225 | /******************************************************************************* |
226 | * |
227 | * FUNCTION: acpi_db_test_one_object |
228 | * |
229 | * PARAMETERS: acpi_walk_callback |
230 | * |
231 | * RETURN: Status |
232 | * |
233 | * DESCRIPTION: Test one namespace object. Supported types are Integer, |
234 | * String, Buffer, Package, buffer_field, and field_unit. |
235 | * All other object types are simply ignored. |
236 | * |
237 | ******************************************************************************/ |
238 | |
239 | static acpi_status |
240 | acpi_db_test_one_object(acpi_handle obj_handle, |
241 | u32 nesting_level, void *context, void **return_value) |
242 | { |
243 | struct acpi_namespace_node *node; |
244 | union acpi_operand_object *obj_desc; |
245 | acpi_object_type local_type; |
246 | u32 bit_length = 0; |
247 | u32 byte_length = 0; |
248 | acpi_status status = AE_OK; |
249 | |
250 | node = ACPI_CAST_PTR(struct acpi_namespace_node, obj_handle); |
251 | obj_desc = node->object; |
252 | |
253 | /* |
254 | * For the supported types, get the actual bit length or |
255 | * byte length. Map the type to one of Integer/String/Buffer. |
256 | */ |
257 | switch (node->type) { |
258 | case ACPI_TYPE_INTEGER: |
259 | |
260 | /* Integer width is either 32 or 64 */ |
261 | |
262 | local_type = ACPI_TYPE_INTEGER; |
263 | bit_length = acpi_gbl_integer_bit_width; |
264 | break; |
265 | |
266 | case ACPI_TYPE_STRING: |
267 | |
268 | local_type = ACPI_TYPE_STRING; |
269 | byte_length = obj_desc->string.length; |
270 | break; |
271 | |
272 | case ACPI_TYPE_BUFFER: |
273 | |
274 | local_type = ACPI_TYPE_BUFFER; |
275 | byte_length = obj_desc->buffer.length; |
276 | bit_length = byte_length * 8; |
277 | break; |
278 | |
279 | case ACPI_TYPE_PACKAGE: |
280 | |
281 | local_type = ACPI_TYPE_PACKAGE; |
282 | break; |
283 | |
284 | case ACPI_TYPE_FIELD_UNIT: |
285 | case ACPI_TYPE_LOCAL_REGION_FIELD: |
286 | case ACPI_TYPE_LOCAL_INDEX_FIELD: |
287 | case ACPI_TYPE_LOCAL_BANK_FIELD: |
288 | |
289 | local_type = ACPI_TYPE_FIELD_UNIT; |
290 | break; |
291 | |
292 | case ACPI_TYPE_BUFFER_FIELD: |
293 | /* |
294 | * The returned object will be a Buffer if the field length |
295 | * is larger than the size of an Integer (32 or 64 bits |
296 | * depending on the DSDT version). |
297 | */ |
298 | local_type = ACPI_TYPE_INTEGER; |
299 | if (obj_desc) { |
300 | bit_length = obj_desc->common_field.bit_length; |
301 | byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length); |
302 | if (bit_length > acpi_gbl_integer_bit_width) { |
303 | local_type = ACPI_TYPE_BUFFER; |
304 | } |
305 | } |
306 | break; |
307 | |
308 | default: |
309 | |
310 | /* Ignore all non-data types - Methods, Devices, Scopes, etc. */ |
311 | |
312 | return (AE_OK); |
313 | } |
314 | |
315 | /* Emit the common prefix: Type:Name */ |
316 | |
317 | acpi_os_printf(format: "%14s: %4.4s" , |
318 | acpi_ut_get_type_name(type: node->type), node->name.ascii); |
319 | |
320 | if (!obj_desc) { |
321 | acpi_os_printf(format: " No attached sub-object, ignoring\n" ); |
322 | return (AE_OK); |
323 | } |
324 | |
325 | /* At this point, we have resolved the object to one of the major types */ |
326 | |
327 | switch (local_type) { |
328 | case ACPI_TYPE_INTEGER: |
329 | |
330 | status = acpi_db_test_integer_type(node, bit_length); |
331 | break; |
332 | |
333 | case ACPI_TYPE_STRING: |
334 | |
335 | status = acpi_db_test_string_type(node, byte_length); |
336 | break; |
337 | |
338 | case ACPI_TYPE_BUFFER: |
339 | |
340 | status = acpi_db_test_buffer_type(node, bit_length); |
341 | break; |
342 | |
343 | case ACPI_TYPE_PACKAGE: |
344 | |
345 | status = acpi_db_test_package_type(node); |
346 | break; |
347 | |
348 | case ACPI_TYPE_FIELD_UNIT: |
349 | |
350 | status = acpi_db_test_field_unit_type(obj_desc); |
351 | break; |
352 | |
353 | default: |
354 | |
355 | acpi_os_printf(format: " Ignoring, type not implemented (%2.2X)" , |
356 | local_type); |
357 | break; |
358 | } |
359 | |
360 | /* Exit on error, but don't abort the namespace walk */ |
361 | |
362 | if (ACPI_FAILURE(status)) { |
363 | status = AE_OK; |
364 | } |
365 | |
366 | acpi_os_printf(format: "\n" ); |
367 | return (status); |
368 | } |
369 | |
370 | /******************************************************************************* |
371 | * |
372 | * FUNCTION: acpi_db_test_integer_type |
373 | * |
374 | * PARAMETERS: node - Parent NS node for the object |
375 | * bit_length - Actual length of the object. Used for |
376 | * support of arbitrary length field_unit |
377 | * and buffer_field objects. |
378 | * |
379 | * RETURN: Status |
380 | * |
381 | * DESCRIPTION: Test read/write for an Integer-valued object. Performs a |
382 | * write/read/compare of an arbitrary new value, then performs |
383 | * a write/read/compare of the original value. |
384 | * |
385 | ******************************************************************************/ |
386 | |
387 | static acpi_status |
388 | acpi_db_test_integer_type(struct acpi_namespace_node *node, u32 bit_length) |
389 | { |
390 | union acpi_object *temp1 = NULL; |
391 | union acpi_object *temp2 = NULL; |
392 | union acpi_object *temp3 = NULL; |
393 | union acpi_object write_value; |
394 | u64 value_to_write; |
395 | acpi_status status; |
396 | |
397 | if (bit_length > 64) { |
398 | acpi_os_printf(format: " Invalid length for an Integer: %u" , |
399 | bit_length); |
400 | return (AE_OK); |
401 | } |
402 | |
403 | /* Read the original value */ |
404 | |
405 | status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, value: &temp1); |
406 | if (ACPI_FAILURE(status)) { |
407 | return (status); |
408 | } |
409 | |
410 | acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT " %8.8X%8.8X" , |
411 | bit_length, ACPI_ROUND_BITS_UP_TO_BYTES(bit_length), |
412 | ACPI_FORMAT_UINT64(temp1->integer.value)); |
413 | |
414 | value_to_write = ACPI_UINT64_MAX >> (64 - bit_length); |
415 | if (temp1->integer.value == value_to_write) { |
416 | value_to_write = 0; |
417 | } |
418 | /* Write a new value */ |
419 | |
420 | write_value.type = ACPI_TYPE_INTEGER; |
421 | write_value.integer.value = value_to_write; |
422 | status = acpi_db_write_to_object(node, value: &write_value); |
423 | if (ACPI_FAILURE(status)) { |
424 | goto exit; |
425 | } |
426 | |
427 | /* Ensure that we can read back the new value */ |
428 | |
429 | status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, value: &temp2); |
430 | if (ACPI_FAILURE(status)) { |
431 | goto exit; |
432 | } |
433 | |
434 | if (temp2->integer.value != value_to_write) { |
435 | acpi_os_printf(format: " MISMATCH 2: %8.8X%8.8X, expecting %8.8X%8.8X" , |
436 | ACPI_FORMAT_UINT64(temp2->integer.value), |
437 | ACPI_FORMAT_UINT64(value_to_write)); |
438 | } |
439 | |
440 | /* Write back the original value */ |
441 | |
442 | write_value.integer.value = temp1->integer.value; |
443 | status = acpi_db_write_to_object(node, value: &write_value); |
444 | if (ACPI_FAILURE(status)) { |
445 | goto exit; |
446 | } |
447 | |
448 | /* Ensure that we can read back the original value */ |
449 | |
450 | status = acpi_db_read_from_object(node, ACPI_TYPE_INTEGER, value: &temp3); |
451 | if (ACPI_FAILURE(status)) { |
452 | goto exit; |
453 | } |
454 | |
455 | if (temp3->integer.value != temp1->integer.value) { |
456 | acpi_os_printf(format: " MISMATCH 3: %8.8X%8.8X, expecting %8.8X%8.8X" , |
457 | ACPI_FORMAT_UINT64(temp3->integer.value), |
458 | ACPI_FORMAT_UINT64(temp1->integer.value)); |
459 | } |
460 | |
461 | exit: |
462 | if (temp1) { |
463 | acpi_os_free(memory: temp1); |
464 | } |
465 | if (temp2) { |
466 | acpi_os_free(memory: temp2); |
467 | } |
468 | if (temp3) { |
469 | acpi_os_free(memory: temp3); |
470 | } |
471 | return (AE_OK); |
472 | } |
473 | |
474 | /******************************************************************************* |
475 | * |
476 | * FUNCTION: acpi_db_test_buffer_type |
477 | * |
478 | * PARAMETERS: node - Parent NS node for the object |
479 | * bit_length - Actual length of the object. |
480 | * |
481 | * RETURN: Status |
482 | * |
483 | * DESCRIPTION: Test read/write for an Buffer-valued object. Performs a |
484 | * write/read/compare of an arbitrary new value, then performs |
485 | * a write/read/compare of the original value. |
486 | * |
487 | ******************************************************************************/ |
488 | |
489 | static acpi_status |
490 | acpi_db_test_buffer_type(struct acpi_namespace_node *node, u32 bit_length) |
491 | { |
492 | union acpi_object *temp1 = NULL; |
493 | union acpi_object *temp2 = NULL; |
494 | union acpi_object *temp3 = NULL; |
495 | u8 *buffer; |
496 | union acpi_object write_value; |
497 | acpi_status status; |
498 | u32 byte_length; |
499 | u32 i; |
500 | u8 ; |
501 | |
502 | byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length); |
503 | if (byte_length == 0) { |
504 | acpi_os_printf(format: " Ignoring zero length buffer" ); |
505 | return (AE_OK); |
506 | } |
507 | |
508 | /* Allocate a local buffer */ |
509 | |
510 | buffer = ACPI_ALLOCATE_ZEROED(byte_length); |
511 | if (!buffer) { |
512 | return (AE_NO_MEMORY); |
513 | } |
514 | |
515 | /* Read the original value */ |
516 | |
517 | status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, value: &temp1); |
518 | if (ACPI_FAILURE(status)) { |
519 | goto exit; |
520 | } |
521 | |
522 | /* Emit a few bytes of the buffer */ |
523 | |
524 | acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT, bit_length, |
525 | temp1->buffer.length); |
526 | for (i = 0; ((i < 8) && (i < byte_length)); i++) { |
527 | acpi_os_printf(format: " %2.2X" , temp1->buffer.pointer[i]); |
528 | } |
529 | acpi_os_printf(format: "... " ); |
530 | |
531 | /* |
532 | * Write a new value. |
533 | * |
534 | * Handle possible extra bits at the end of the buffer. Can |
535 | * happen for field_units larger than an integer, but the bit |
536 | * count is not an integral number of bytes. Zero out the |
537 | * unused bits. |
538 | */ |
539 | memset(buffer, BUFFER_FILL_VALUE, byte_length); |
540 | extra_bits = bit_length % 8; |
541 | if (extra_bits) { |
542 | buffer[byte_length - 1] = ACPI_MASK_BITS_ABOVE(extra_bits); |
543 | } |
544 | |
545 | write_value.type = ACPI_TYPE_BUFFER; |
546 | write_value.buffer.length = byte_length; |
547 | write_value.buffer.pointer = buffer; |
548 | |
549 | status = acpi_db_write_to_object(node, value: &write_value); |
550 | if (ACPI_FAILURE(status)) { |
551 | goto exit; |
552 | } |
553 | |
554 | /* Ensure that we can read back the new value */ |
555 | |
556 | status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, value: &temp2); |
557 | if (ACPI_FAILURE(status)) { |
558 | goto exit; |
559 | } |
560 | |
561 | if (memcmp(p: temp2->buffer.pointer, q: buffer, size: byte_length)) { |
562 | acpi_os_printf(format: " MISMATCH 2: New buffer value" ); |
563 | } |
564 | |
565 | /* Write back the original value */ |
566 | |
567 | write_value.buffer.length = byte_length; |
568 | write_value.buffer.pointer = temp1->buffer.pointer; |
569 | |
570 | status = acpi_db_write_to_object(node, value: &write_value); |
571 | if (ACPI_FAILURE(status)) { |
572 | goto exit; |
573 | } |
574 | |
575 | /* Ensure that we can read back the original value */ |
576 | |
577 | status = acpi_db_read_from_object(node, ACPI_TYPE_BUFFER, value: &temp3); |
578 | if (ACPI_FAILURE(status)) { |
579 | goto exit; |
580 | } |
581 | |
582 | if (memcmp(p: temp1->buffer.pointer, q: temp3->buffer.pointer, size: byte_length)) { |
583 | acpi_os_printf(format: " MISMATCH 3: While restoring original buffer" ); |
584 | } |
585 | |
586 | exit: |
587 | ACPI_FREE(buffer); |
588 | if (temp1) { |
589 | acpi_os_free(memory: temp1); |
590 | } |
591 | if (temp2) { |
592 | acpi_os_free(memory: temp2); |
593 | } |
594 | if (temp3) { |
595 | acpi_os_free(memory: temp3); |
596 | } |
597 | return (status); |
598 | } |
599 | |
600 | /******************************************************************************* |
601 | * |
602 | * FUNCTION: acpi_db_test_string_type |
603 | * |
604 | * PARAMETERS: node - Parent NS node for the object |
605 | * byte_length - Actual length of the object. |
606 | * |
607 | * RETURN: Status |
608 | * |
609 | * DESCRIPTION: Test read/write for an String-valued object. Performs a |
610 | * write/read/compare of an arbitrary new value, then performs |
611 | * a write/read/compare of the original value. |
612 | * |
613 | ******************************************************************************/ |
614 | |
615 | static acpi_status |
616 | acpi_db_test_string_type(struct acpi_namespace_node *node, u32 byte_length) |
617 | { |
618 | union acpi_object *temp1 = NULL; |
619 | union acpi_object *temp2 = NULL; |
620 | union acpi_object *temp3 = NULL; |
621 | char *value_to_write = "Test String from AML Debugger" ; |
622 | union acpi_object write_value; |
623 | acpi_status status; |
624 | |
625 | /* Read the original value */ |
626 | |
627 | status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, value: &temp1); |
628 | if (ACPI_FAILURE(status)) { |
629 | return (status); |
630 | } |
631 | |
632 | acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT " \"%s\"" , |
633 | (temp1->string.length * 8), temp1->string.length, |
634 | temp1->string.pointer); |
635 | |
636 | /* Write a new value */ |
637 | |
638 | write_value.type = ACPI_TYPE_STRING; |
639 | write_value.string.length = strlen(value_to_write); |
640 | write_value.string.pointer = value_to_write; |
641 | |
642 | status = acpi_db_write_to_object(node, value: &write_value); |
643 | if (ACPI_FAILURE(status)) { |
644 | goto exit; |
645 | } |
646 | |
647 | /* Ensure that we can read back the new value */ |
648 | |
649 | status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, value: &temp2); |
650 | if (ACPI_FAILURE(status)) { |
651 | goto exit; |
652 | } |
653 | |
654 | if (strcmp(temp2->string.pointer, value_to_write)) { |
655 | acpi_os_printf(format: " MISMATCH 2: %s, expecting %s" , |
656 | temp2->string.pointer, value_to_write); |
657 | } |
658 | |
659 | /* Write back the original value */ |
660 | |
661 | write_value.string.length = strlen(temp1->string.pointer); |
662 | write_value.string.pointer = temp1->string.pointer; |
663 | |
664 | status = acpi_db_write_to_object(node, value: &write_value); |
665 | if (ACPI_FAILURE(status)) { |
666 | goto exit; |
667 | } |
668 | |
669 | /* Ensure that we can read back the original value */ |
670 | |
671 | status = acpi_db_read_from_object(node, ACPI_TYPE_STRING, value: &temp3); |
672 | if (ACPI_FAILURE(status)) { |
673 | goto exit; |
674 | } |
675 | |
676 | if (strcmp(temp1->string.pointer, temp3->string.pointer)) { |
677 | acpi_os_printf(format: " MISMATCH 3: %s, expecting %s" , |
678 | temp3->string.pointer, temp1->string.pointer); |
679 | } |
680 | |
681 | exit: |
682 | if (temp1) { |
683 | acpi_os_free(memory: temp1); |
684 | } |
685 | if (temp2) { |
686 | acpi_os_free(memory: temp2); |
687 | } |
688 | if (temp3) { |
689 | acpi_os_free(memory: temp3); |
690 | } |
691 | return (status); |
692 | } |
693 | |
694 | /******************************************************************************* |
695 | * |
696 | * FUNCTION: acpi_db_test_package_type |
697 | * |
698 | * PARAMETERS: node - Parent NS node for the object |
699 | * |
700 | * RETURN: Status |
701 | * |
702 | * DESCRIPTION: Test read for a Package object. |
703 | * |
704 | ******************************************************************************/ |
705 | |
706 | static acpi_status acpi_db_test_package_type(struct acpi_namespace_node *node) |
707 | { |
708 | union acpi_object *temp1 = NULL; |
709 | acpi_status status; |
710 | |
711 | /* Read the original value */ |
712 | |
713 | status = acpi_db_read_from_object(node, ACPI_TYPE_PACKAGE, value: &temp1); |
714 | if (ACPI_FAILURE(status)) { |
715 | return (status); |
716 | } |
717 | |
718 | acpi_os_printf(format: " %.2X Elements" , temp1->package.count); |
719 | acpi_os_free(memory: temp1); |
720 | return (status); |
721 | } |
722 | |
723 | /******************************************************************************* |
724 | * |
725 | * FUNCTION: acpi_db_test_field_unit_type |
726 | * |
727 | * PARAMETERS: obj_desc - A field unit object |
728 | * |
729 | * RETURN: Status |
730 | * |
731 | * DESCRIPTION: Test read/write on a named field unit. |
732 | * |
733 | ******************************************************************************/ |
734 | |
735 | static acpi_status |
736 | acpi_db_test_field_unit_type(union acpi_operand_object *obj_desc) |
737 | { |
738 | union acpi_operand_object *region_obj; |
739 | u32 bit_length = 0; |
740 | u32 byte_length = 0; |
741 | acpi_status status = AE_OK; |
742 | union acpi_operand_object *ret_buffer_desc; |
743 | |
744 | /* Supported spaces are memory/io/pci_config */ |
745 | |
746 | region_obj = obj_desc->field.region_obj; |
747 | switch (region_obj->region.space_id) { |
748 | case ACPI_ADR_SPACE_SYSTEM_MEMORY: |
749 | case ACPI_ADR_SPACE_SYSTEM_IO: |
750 | case ACPI_ADR_SPACE_PCI_CONFIG: |
751 | |
752 | /* Need the interpreter to execute */ |
753 | |
754 | acpi_ut_acquire_mutex(ACPI_MTX_INTERPRETER); |
755 | acpi_ut_acquire_mutex(ACPI_MTX_NAMESPACE); |
756 | |
757 | /* Exercise read-then-write */ |
758 | |
759 | status = |
760 | acpi_ex_read_data_from_field(NULL, obj_desc, |
761 | ret_buffer_desc: &ret_buffer_desc); |
762 | if (status == AE_OK) { |
763 | acpi_ex_write_data_to_field(source_desc: ret_buffer_desc, obj_desc, |
764 | NULL); |
765 | acpi_ut_remove_reference(object: ret_buffer_desc); |
766 | } |
767 | |
768 | acpi_ut_release_mutex(ACPI_MTX_NAMESPACE); |
769 | acpi_ut_release_mutex(ACPI_MTX_INTERPRETER); |
770 | |
771 | bit_length = obj_desc->common_field.bit_length; |
772 | byte_length = ACPI_ROUND_BITS_UP_TO_BYTES(bit_length); |
773 | |
774 | acpi_os_printf(ACPI_DEBUG_LENGTH_FORMAT " [%s]" , bit_length, |
775 | byte_length, |
776 | acpi_ut_get_region_name(space_id: region_obj->region. |
777 | space_id)); |
778 | return (status); |
779 | |
780 | default: |
781 | |
782 | acpi_os_printf |
783 | (format: " %s address space is not supported in this command [%4.4s]" , |
784 | acpi_ut_get_region_name(space_id: region_obj->region.space_id), |
785 | region_obj->region.node->name.ascii); |
786 | return (AE_OK); |
787 | } |
788 | } |
789 | |
790 | /******************************************************************************* |
791 | * |
792 | * FUNCTION: acpi_db_read_from_object |
793 | * |
794 | * PARAMETERS: node - Parent NS node for the object |
795 | * expected_type - Object type expected from the read |
796 | * value - Where the value read is returned |
797 | * |
798 | * RETURN: Status |
799 | * |
800 | * DESCRIPTION: Performs a read from the specified object by invoking the |
801 | * special debugger control method that reads the object. Thus, |
802 | * the AML interpreter is doing all of the work, increasing the |
803 | * validity of the test. |
804 | * |
805 | ******************************************************************************/ |
806 | |
807 | static acpi_status |
808 | acpi_db_read_from_object(struct acpi_namespace_node *node, |
809 | acpi_object_type expected_type, |
810 | union acpi_object **value) |
811 | { |
812 | union acpi_object *ret_value; |
813 | struct acpi_object_list param_objects; |
814 | union acpi_object params[2]; |
815 | struct acpi_buffer return_obj; |
816 | acpi_status status; |
817 | |
818 | params[0].type = ACPI_TYPE_LOCAL_REFERENCE; |
819 | params[0].reference.actual_type = node->type; |
820 | params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node); |
821 | |
822 | param_objects.count = 1; |
823 | param_objects.pointer = params; |
824 | |
825 | return_obj.length = ACPI_ALLOCATE_BUFFER; |
826 | |
827 | acpi_gbl_method_executing = TRUE; |
828 | status = acpi_evaluate_object(object: read_handle, NULL, |
829 | parameter_objects: ¶m_objects, return_object_buffer: &return_obj); |
830 | |
831 | acpi_gbl_method_executing = FALSE; |
832 | if (ACPI_FAILURE(status)) { |
833 | acpi_os_printf(format: "Could not read from object, %s" , |
834 | acpi_format_exception(exception: status)); |
835 | return (status); |
836 | } |
837 | |
838 | ret_value = (union acpi_object *)return_obj.pointer; |
839 | |
840 | switch (ret_value->type) { |
841 | case ACPI_TYPE_INTEGER: |
842 | case ACPI_TYPE_BUFFER: |
843 | case ACPI_TYPE_STRING: |
844 | case ACPI_TYPE_PACKAGE: |
845 | /* |
846 | * Did we receive the type we wanted? Most important for the |
847 | * Integer/Buffer case (when a field is larger than an Integer, |
848 | * it should return a Buffer). |
849 | */ |
850 | if (ret_value->type != expected_type) { |
851 | acpi_os_printf |
852 | (format: " Type mismatch: Expected %s, Received %s" , |
853 | acpi_ut_get_type_name(type: expected_type), |
854 | acpi_ut_get_type_name(type: ret_value->type)); |
855 | |
856 | acpi_os_free(memory: return_obj.pointer); |
857 | return (AE_TYPE); |
858 | } |
859 | |
860 | *value = ret_value; |
861 | break; |
862 | |
863 | default: |
864 | |
865 | acpi_os_printf(format: " Unsupported return object type, %s" , |
866 | acpi_ut_get_type_name(type: ret_value->type)); |
867 | |
868 | acpi_os_free(memory: return_obj.pointer); |
869 | return (AE_TYPE); |
870 | } |
871 | |
872 | return (status); |
873 | } |
874 | |
875 | /******************************************************************************* |
876 | * |
877 | * FUNCTION: acpi_db_write_to_object |
878 | * |
879 | * PARAMETERS: node - Parent NS node for the object |
880 | * value - Value to be written |
881 | * |
882 | * RETURN: Status |
883 | * |
884 | * DESCRIPTION: Performs a write to the specified object by invoking the |
885 | * special debugger control method that writes the object. Thus, |
886 | * the AML interpreter is doing all of the work, increasing the |
887 | * validity of the test. |
888 | * |
889 | ******************************************************************************/ |
890 | |
891 | static acpi_status |
892 | acpi_db_write_to_object(struct acpi_namespace_node *node, |
893 | union acpi_object *value) |
894 | { |
895 | struct acpi_object_list param_objects; |
896 | union acpi_object params[2]; |
897 | acpi_status status; |
898 | |
899 | params[0].type = ACPI_TYPE_LOCAL_REFERENCE; |
900 | params[0].reference.actual_type = node->type; |
901 | params[0].reference.handle = ACPI_CAST_PTR(acpi_handle, node); |
902 | |
903 | /* Copy the incoming user parameter */ |
904 | |
905 | memcpy(¶ms[1], value, sizeof(union acpi_object)); |
906 | |
907 | param_objects.count = 2; |
908 | param_objects.pointer = params; |
909 | |
910 | acpi_gbl_method_executing = TRUE; |
911 | status = acpi_evaluate_object(object: write_handle, NULL, parameter_objects: ¶m_objects, NULL); |
912 | acpi_gbl_method_executing = FALSE; |
913 | |
914 | if (ACPI_FAILURE(status)) { |
915 | acpi_os_printf(format: "Could not write to object, %s" , |
916 | acpi_format_exception(exception: status)); |
917 | } |
918 | |
919 | return (status); |
920 | } |
921 | |
922 | /******************************************************************************* |
923 | * |
924 | * FUNCTION: acpi_db_evaluate_all_predefined_names |
925 | * |
926 | * PARAMETERS: count_arg - Max number of methods to execute |
927 | * |
928 | * RETURN: None |
929 | * |
930 | * DESCRIPTION: Namespace batch execution. Execute predefined names in the |
931 | * namespace, up to the max count, if specified. |
932 | * |
933 | ******************************************************************************/ |
934 | |
935 | static void acpi_db_evaluate_all_predefined_names(char *count_arg) |
936 | { |
937 | struct acpi_db_execute_walk info; |
938 | |
939 | info.count = 0; |
940 | info.max_count = ACPI_UINT32_MAX; |
941 | |
942 | if (count_arg) { |
943 | info.max_count = strtoul(count_arg, NULL, 0); |
944 | } |
945 | |
946 | /* Search all nodes in namespace */ |
947 | |
948 | (void)acpi_walk_namespace(ACPI_TYPE_ANY, ACPI_ROOT_OBJECT, |
949 | ACPI_UINT32_MAX, |
950 | descending_callback: acpi_db_evaluate_one_predefined_name, NULL, |
951 | context: (void *)&info, NULL); |
952 | |
953 | acpi_os_printf(format: "Evaluated %u predefined names in the namespace\n" , |
954 | info.count); |
955 | } |
956 | |
957 | /******************************************************************************* |
958 | * |
959 | * FUNCTION: acpi_db_evaluate_one_predefined_name |
960 | * |
961 | * PARAMETERS: Callback from walk_namespace |
962 | * |
963 | * RETURN: Status |
964 | * |
965 | * DESCRIPTION: Batch execution module. Currently only executes predefined |
966 | * ACPI names. |
967 | * |
968 | ******************************************************************************/ |
969 | |
970 | static acpi_status |
971 | acpi_db_evaluate_one_predefined_name(acpi_handle obj_handle, |
972 | u32 nesting_level, |
973 | void *context, void **return_value) |
974 | { |
975 | struct acpi_namespace_node *node = |
976 | (struct acpi_namespace_node *)obj_handle; |
977 | struct acpi_db_execute_walk *info = |
978 | (struct acpi_db_execute_walk *)context; |
979 | char *pathname; |
980 | const union acpi_predefined_info *predefined; |
981 | struct acpi_device_info *obj_info; |
982 | struct acpi_object_list param_objects; |
983 | union acpi_object params[ACPI_METHOD_NUM_ARGS]; |
984 | union acpi_object *this_param; |
985 | struct acpi_buffer return_obj; |
986 | acpi_status status; |
987 | u16 arg_type_list; |
988 | u8 arg_count; |
989 | u8 arg_type; |
990 | u32 i; |
991 | |
992 | /* The name must be a predefined ACPI name */ |
993 | |
994 | predefined = acpi_ut_match_predefined_method(name: node->name.ascii); |
995 | if (!predefined) { |
996 | return (AE_OK); |
997 | } |
998 | |
999 | if (node->type == ACPI_TYPE_LOCAL_SCOPE) { |
1000 | return (AE_OK); |
1001 | } |
1002 | |
1003 | pathname = acpi_ns_get_normalized_pathname(node, TRUE); |
1004 | if (!pathname) { |
1005 | return (AE_OK); |
1006 | } |
1007 | |
1008 | /* Get the object info for number of method parameters */ |
1009 | |
1010 | status = acpi_get_object_info(object: obj_handle, return_buffer: &obj_info); |
1011 | if (ACPI_FAILURE(status)) { |
1012 | ACPI_FREE(pathname); |
1013 | return (status); |
1014 | } |
1015 | |
1016 | param_objects.count = 0; |
1017 | param_objects.pointer = NULL; |
1018 | |
1019 | if (obj_info->type == ACPI_TYPE_METHOD) { |
1020 | |
1021 | /* Setup default parameters (with proper types) */ |
1022 | |
1023 | arg_type_list = predefined->info.argument_list; |
1024 | arg_count = METHOD_GET_ARG_COUNT(arg_type_list); |
1025 | |
1026 | /* |
1027 | * Setup the ACPI-required number of arguments, regardless of what |
1028 | * the actual method defines. If there is a difference, then the |
1029 | * method is wrong and a warning will be issued during execution. |
1030 | */ |
1031 | this_param = params; |
1032 | for (i = 0; i < arg_count; i++) { |
1033 | arg_type = METHOD_GET_NEXT_TYPE(arg_type_list); |
1034 | this_param->type = arg_type; |
1035 | |
1036 | switch (arg_type) { |
1037 | case ACPI_TYPE_INTEGER: |
1038 | |
1039 | this_param->integer.value = 1; |
1040 | break; |
1041 | |
1042 | case ACPI_TYPE_STRING: |
1043 | |
1044 | this_param->string.pointer = |
1045 | "This is the default argument string" ; |
1046 | this_param->string.length = |
1047 | strlen(this_param->string.pointer); |
1048 | break; |
1049 | |
1050 | case ACPI_TYPE_BUFFER: |
1051 | |
1052 | this_param->buffer.pointer = (u8 *)params; /* just a garbage buffer */ |
1053 | this_param->buffer.length = 48; |
1054 | break; |
1055 | |
1056 | case ACPI_TYPE_PACKAGE: |
1057 | |
1058 | this_param->package.elements = NULL; |
1059 | this_param->package.count = 0; |
1060 | break; |
1061 | |
1062 | default: |
1063 | |
1064 | acpi_os_printf |
1065 | (format: "%s: Unsupported argument type: %u\n" , |
1066 | pathname, arg_type); |
1067 | break; |
1068 | } |
1069 | |
1070 | this_param++; |
1071 | } |
1072 | |
1073 | param_objects.count = arg_count; |
1074 | param_objects.pointer = params; |
1075 | } |
1076 | |
1077 | ACPI_FREE(obj_info); |
1078 | return_obj.pointer = NULL; |
1079 | return_obj.length = ACPI_ALLOCATE_BUFFER; |
1080 | |
1081 | /* Do the actual method execution */ |
1082 | |
1083 | acpi_gbl_method_executing = TRUE; |
1084 | |
1085 | status = acpi_evaluate_object(object: node, NULL, parameter_objects: ¶m_objects, return_object_buffer: &return_obj); |
1086 | |
1087 | acpi_os_printf(format: "%-32s returned %s\n" , |
1088 | pathname, acpi_format_exception(exception: status)); |
1089 | acpi_gbl_method_executing = FALSE; |
1090 | ACPI_FREE(pathname); |
1091 | |
1092 | /* Ignore status from method execution */ |
1093 | |
1094 | status = AE_OK; |
1095 | |
1096 | /* Update count, check if we have executed enough methods */ |
1097 | |
1098 | info->count++; |
1099 | if (info->count >= info->max_count) { |
1100 | status = AE_CTRL_TERMINATE; |
1101 | } |
1102 | |
1103 | return (status); |
1104 | } |
1105 | |