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