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