1 /*******************************************************************************
2 *
3 * Module Name: dmresrcl2.c - "Large" Resource Descriptor disassembly (#2)
4 *
5 ******************************************************************************/
6
7 /******************************************************************************
8 *
9 * 1. Copyright Notice
10 *
11 * Some or all of this work - Copyright (c) 1999 - 2024, Intel Corp.
12 * All rights reserved.
13 *
14 * 2. License
15 *
16 * 2.1. This is your license from Intel Corp. under its intellectual property
17 * rights. You may have additional license terms from the party that provided
18 * you this software, covering your right to use that party's intellectual
19 * property rights.
20 *
21 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22 * copy of the source code appearing in this file ("Covered Code") an
23 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24 * base code distributed originally by Intel ("Original Intel Code") to copy,
25 * make derivatives, distribute, use and display any portion of the Covered
26 * Code in any form, with the right to sublicense such rights; and
27 *
28 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29 * license (with the right to sublicense), under only those claims of Intel
30 * patents that are infringed by the Original Intel Code, to make, use, sell,
31 * offer to sell, and import the Covered Code and derivative works thereof
32 * solely to the minimum extent necessary to exercise the above copyright
33 * license, and in no event shall the patent license extend to any additions
34 * to or modifications of the Original Intel Code. No other license or right
35 * is granted directly or by implication, estoppel or otherwise;
36 *
37 * The above copyright and patent license is granted only if the following
38 * conditions are met:
39 *
40 * 3. Conditions
41 *
42 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43 * Redistribution of source code of any substantial portion of the Covered
44 * Code or modification with rights to further distribute source must include
45 * the above Copyright Notice, the above License, this list of Conditions,
46 * and the following Disclaimer and Export Compliance provision. In addition,
47 * Licensee must cause all Covered Code to which Licensee contributes to
48 * contain a file documenting the changes Licensee made to create that Covered
49 * Code and the date of any change. Licensee must include in that file the
50 * documentation of any changes made by any predecessor Licensee. Licensee
51 * must include a prominent statement that the modification is derived,
52 * directly or indirectly, from Original Intel Code.
53 *
54 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55 * Redistribution of source code of any substantial portion of the Covered
56 * Code or modification without rights to further distribute source must
57 * include the following Disclaimer and Export Compliance provision in the
58 * documentation and/or other materials provided with distribution. In
59 * addition, Licensee may not authorize further sublicense of source of any
60 * portion of the Covered Code, and must include terms to the effect that the
61 * license from Licensee to its licensee is limited to the intellectual
62 * property embodied in the software Licensee provides to its licensee, and
63 * not to intellectual property embodied in modifications its licensee may
64 * make.
65 *
66 * 3.3. Redistribution of Executable. Redistribution in executable form of any
67 * substantial portion of the Covered Code or modification must reproduce the
68 * above Copyright Notice, and the following Disclaimer and Export Compliance
69 * provision in the documentation and/or other materials provided with the
70 * distribution.
71 *
72 * 3.4. Intel retains all right, title, and interest in and to the Original
73 * Intel Code.
74 *
75 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76 * Intel shall be used in advertising or otherwise to promote the sale, use or
77 * other dealings in products derived from or relating to the Covered Code
78 * without prior written authorization from Intel.
79 *
80 * 4. Disclaimer and Export Compliance
81 *
82 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88 * PARTICULAR PURPOSE.
89 *
90 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97 * LIMITED REMEDY.
98 *
99 * 4.3. Licensee shall not export, either directly or indirectly, any of this
100 * software or system incorporating such software without first obtaining any
101 * required license or other approval from the U. S. Department of Commerce or
102 * any other agency or department of the United States Government. In the
103 * event Licensee exports any such software from the United States or
104 * re-exports any such software from a foreign destination, Licensee shall
105 * ensure that the distribution and export/re-export of the software is in
106 * compliance with all laws, regulations, orders, or other restrictions of the
107 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108 * any of its subsidiaries will export/re-export any technical data, process,
109 * software, or service, directly or indirectly, to any country for which the
110 * United States government or any agency thereof requires an export license,
111 * other governmental approval, or letter of assurance, without first obtaining
112 * such license, approval or letter.
113 *
114 *****************************************************************************
115 *
116 * Alternatively, you may choose to be licensed under the terms of the
117 * following license:
118 *
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
121 * are met:
122 * 1. Redistributions of source code must retain the above copyright
123 * notice, this list of conditions, and the following disclaimer,
124 * without modification.
125 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126 * substantially similar to the "NO WARRANTY" disclaimer below
127 * ("Disclaimer") and any redistribution must be conditioned upon
128 * including a substantially similar Disclaimer requirement for further
129 * binary redistribution.
130 * 3. Neither the names of the above-listed copyright holders nor the names
131 * of any contributors may be used to endorse or promote products derived
132 * from this software without specific prior written permission.
133 *
134 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145 *
146 * Alternatively, you may choose to be licensed under the terms of the
147 * GNU General Public License ("GPL") version 2 as published by the Free
148 * Software Foundation.
149 *
150 *****************************************************************************/
151
152 #include "acpi.h"
153 #include "accommon.h"
154 #include "acdisasm.h"
155
156 #ifdef _KERNEL
157 #define MpSaveGpioInfo(a, b, c, d, e)
158 #define MpSaveSerialInfo(a, b, c)
159 #endif
160
161 #define _COMPONENT ACPI_CA_DEBUGGER
162 ACPI_MODULE_NAME ("dbresrcl2")
163
164 /* Local prototypes */
165
166 static void
167 AcpiDmCsi2SerialBusDescriptor (
168 ACPI_OP_WALK_INFO *Info,
169 AML_RESOURCE *Resource,
170 UINT32 Length,
171 UINT32 Level);
172
173 static void
174 AcpiDmI2cSerialBusDescriptor (
175 ACPI_OP_WALK_INFO *Info,
176 AML_RESOURCE *Resource,
177 UINT32 Length,
178 UINT32 Level);
179
180 static void
181 AcpiDmSpiSerialBusDescriptor (
182 ACPI_OP_WALK_INFO *Info,
183 AML_RESOURCE *Resource,
184 UINT32 Length,
185 UINT32 Level);
186
187 static void
188 AcpiDmUartSerialBusDescriptor (
189 ACPI_OP_WALK_INFO *Info,
190 AML_RESOURCE *Resource,
191 UINT32 Length,
192 UINT32 Level);
193
194 static void
195 AcpiDmGpioCommon (
196 ACPI_OP_WALK_INFO *Info,
197 AML_RESOURCE *Resource,
198 UINT32 Level);
199
200 static void
201 AcpiDmDumpRawDataBuffer (
202 UINT8 *Buffer,
203 UINT32 Length,
204 UINT32 Level);
205
206
207 /* Dispatch table for the serial bus descriptors */
208
209 static ACPI_RESOURCE_HANDLER SerialBusResourceDispatch [] =
210 {
211 NULL,
212 AcpiDmI2cSerialBusDescriptor,
213 AcpiDmSpiSerialBusDescriptor,
214 AcpiDmUartSerialBusDescriptor,
215 AcpiDmCsi2SerialBusDescriptor
216 };
217
218
219 /*******************************************************************************
220 *
221 * FUNCTION: AcpiDmDumpRawDataBuffer
222 *
223 * PARAMETERS: Buffer - Pointer to the data bytes
224 * Length - Length of the descriptor in bytes
225 * Level - Current source code indentation level
226 *
227 * RETURN: None
228 *
229 * DESCRIPTION: Dump a data buffer as a RawDataBuffer() object. Used for
230 * vendor data bytes.
231 *
232 ******************************************************************************/
233
234 static void
AcpiDmDumpRawDataBuffer(UINT8 * Buffer,UINT32 Length,UINT32 Level)235 AcpiDmDumpRawDataBuffer (
236 UINT8 *Buffer,
237 UINT32 Length,
238 UINT32 Level)
239 {
240 UINT32 Index;
241 UINT32 i;
242 UINT32 j;
243
244
245 if (!Length)
246 {
247 return;
248 }
249
250 AcpiOsPrintf ("RawDataBuffer (0x%.2X) // Vendor Data", Length);
251
252 AcpiOsPrintf ("\n");
253 AcpiDmIndent (Level + 1);
254 AcpiOsPrintf ("{\n");
255 AcpiDmIndent (Level + 2);
256
257 for (i = 0; i < Length;)
258 {
259 for (j = 0; j < 8; j++)
260 {
261 Index = i + j;
262 if (Index >= Length)
263 {
264 goto Finish;
265 }
266
267 AcpiOsPrintf ("0x%2.2X", Buffer[Index]);
268 if ((Index + 1) >= Length)
269 {
270 goto Finish;
271 }
272
273 AcpiOsPrintf (", ");
274 }
275
276 AcpiOsPrintf ("\n");
277 AcpiDmIndent (Level + 2);
278
279 i += 8;
280 }
281
282 Finish:
283 AcpiOsPrintf ("\n");
284 AcpiDmIndent (Level + 1);
285 AcpiOsPrintf ("}");
286 }
287
288
289 /*******************************************************************************
290 *
291 * FUNCTION: AcpiDmGpioCommon
292 *
293 * PARAMETERS: Info - Extra resource info
294 * Resource - Pointer to the resource descriptor
295 * Level - Current source code indentation level
296 *
297 * RETURN: None
298 *
299 * DESCRIPTION: Decode common parts of a GPIO Interrupt descriptor
300 *
301 ******************************************************************************/
302
303 static void
AcpiDmGpioCommon(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Level)304 AcpiDmGpioCommon (
305 ACPI_OP_WALK_INFO *Info,
306 AML_RESOURCE *Resource,
307 UINT32 Level)
308 {
309 UINT16 *PinList;
310 UINT8 *VendorData;
311 char *DeviceName = NULL;
312 UINT32 PinCount;
313 UINT32 i;
314
315
316 /* ResourceSource, ResourceSourceIndex, ResourceType */
317
318 AcpiDmIndent (Level + 1);
319 if (Resource->Gpio.ResSourceOffset)
320 {
321 DeviceName = ACPI_ADD_PTR (char,
322 Resource, Resource->Gpio.ResSourceOffset);
323 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
324 }
325
326 AcpiOsPrintf (", ");
327 AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.ResSourceIndex);
328 AcpiOsPrintf ("%s, ",
329 AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Resource->Gpio.Flags)]);
330
331 /* Insert a descriptor name */
332
333 AcpiDmDescriptorName ();
334 AcpiOsPrintf (",");
335
336 /* Dump the vendor data */
337
338 if (Resource->Gpio.VendorOffset)
339 {
340 AcpiOsPrintf ("\n");
341 AcpiDmIndent (Level + 1);
342 VendorData = ACPI_ADD_PTR (UINT8, Resource,
343 Resource->Gpio.VendorOffset);
344
345 AcpiDmDumpRawDataBuffer (VendorData,
346 Resource->Gpio.VendorLength, Level);
347 }
348
349 AcpiOsPrintf (")\n");
350
351 /* Dump the interrupt list */
352
353 AcpiDmIndent (Level + 1);
354 AcpiOsPrintf ("{ // Pin list\n");
355
356 PinCount = ((UINT32) (Resource->Gpio.ResSourceOffset -
357 Resource->Gpio.PinTableOffset)) /
358 sizeof (UINT16);
359
360 PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource,
361 Resource->Gpio.PinTableOffset);
362
363 for (i = 0; i < PinCount; i++)
364 {
365 AcpiDmIndent (Level + 2);
366 AcpiOsPrintf ("0x%4.4X%s\n", PinList[i],
367 ((i + 1) < PinCount) ? "," : "");
368 }
369
370 AcpiDmIndent (Level + 1);
371 AcpiOsPrintf ("}\n");
372
373 MpSaveGpioInfo (Info->MappingOp, Resource,
374 PinCount, PinList, DeviceName);
375 }
376
377
378 /*******************************************************************************
379 *
380 * FUNCTION: AcpiDmGpioIntDescriptor
381 *
382 * PARAMETERS: Info - Extra resource info
383 * Resource - Pointer to the resource descriptor
384 * Length - Length of the descriptor in bytes
385 * Level - Current source code indentation level
386 *
387 * RETURN: None
388 *
389 * DESCRIPTION: Decode a GPIO Interrupt descriptor
390 *
391 ******************************************************************************/
392
393 static void
AcpiDmGpioIntDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)394 AcpiDmGpioIntDescriptor (
395 ACPI_OP_WALK_INFO *Info,
396 AML_RESOURCE *Resource,
397 UINT32 Length,
398 UINT32 Level)
399 {
400
401 /* Dump the GpioInt-specific portion of the descriptor */
402
403 /* EdgeLevel, ActiveLevel, Shared */
404
405 AcpiDmIndent (Level);
406 AcpiOsPrintf ("GpioInt (%s, %s, %s, ",
407 AcpiGbl_HeDecode [ACPI_GET_1BIT_FLAG (Resource->Gpio.IntFlags)],
408 AcpiGbl_LlDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 1)],
409 AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 3)]);
410
411 /* PinConfig, DebounceTimeout */
412
413 if (Resource->Gpio.PinConfig <= 3)
414 {
415 AcpiOsPrintf ("%s, ",
416 AcpiGbl_PpcDecode[Resource->Gpio.PinConfig]);
417 }
418 else
419 {
420 AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.PinConfig);
421 }
422 AcpiOsPrintf ("0x%4.4X,\n", Resource->Gpio.DebounceTimeout);
423
424 /* Dump the GpioInt/GpioIo common portion of the descriptor */
425
426 AcpiDmGpioCommon (Info, Resource, Level);
427 }
428
429
430 /*******************************************************************************
431 *
432 * FUNCTION: AcpiDmGpioIoDescriptor
433 *
434 * PARAMETERS: Info - Extra resource info
435 * Resource - Pointer to the resource descriptor
436 * Length - Length of the descriptor in bytes
437 * Level - Current source code indentation level
438 *
439 * RETURN: None
440 *
441 * DESCRIPTION: Decode a GPIO I/O descriptor
442 *
443 ******************************************************************************/
444
445 static void
AcpiDmGpioIoDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)446 AcpiDmGpioIoDescriptor (
447 ACPI_OP_WALK_INFO *Info,
448 AML_RESOURCE *Resource,
449 UINT32 Length,
450 UINT32 Level)
451 {
452
453 /* Dump the GpioIo-specific portion of the descriptor */
454
455 /* Shared, PinConfig */
456
457 AcpiDmIndent (Level);
458 AcpiOsPrintf ("GpioIo (%s, ",
459 AcpiGbl_ShrDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->Gpio.IntFlags, 3)]);
460
461 if (Resource->Gpio.PinConfig <= 3)
462 {
463 AcpiOsPrintf ("%s, ",
464 AcpiGbl_PpcDecode[Resource->Gpio.PinConfig]);
465 }
466 else
467 {
468 AcpiOsPrintf ("0x%2.2X, ", Resource->Gpio.PinConfig);
469 }
470
471 /* DebounceTimeout, DriveStrength, IoRestriction */
472
473 AcpiOsPrintf ("0x%4.4X, ", Resource->Gpio.DebounceTimeout);
474 AcpiOsPrintf ("0x%4.4X, ", Resource->Gpio.DriveStrength);
475 AcpiOsPrintf ("%s,\n",
476 AcpiGbl_IorDecode [ACPI_GET_2BIT_FLAG (Resource->Gpio.IntFlags)]);
477
478 /* Dump the GpioInt/GpioIo common portion of the descriptor */
479
480 AcpiDmGpioCommon (Info, Resource, Level);
481 }
482
483
484 /*******************************************************************************
485 *
486 * FUNCTION: AcpiDmGpioDescriptor
487 *
488 * PARAMETERS: Info - Extra resource info
489 * Resource - Pointer to the resource descriptor
490 * Length - Length of the descriptor in bytes
491 * Level - Current source code indentation level
492 *
493 * RETURN: None
494 *
495 * DESCRIPTION: Decode a GpioInt/GpioIo GPIO Interrupt/IO descriptor
496 *
497 ******************************************************************************/
498
499 void
AcpiDmGpioDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)500 AcpiDmGpioDescriptor (
501 ACPI_OP_WALK_INFO *Info,
502 AML_RESOURCE *Resource,
503 UINT32 Length,
504 UINT32 Level)
505 {
506 UINT8 ConnectionType;
507
508
509 ConnectionType = Resource->Gpio.ConnectionType;
510
511 switch (ConnectionType)
512 {
513 case AML_RESOURCE_GPIO_TYPE_INT:
514
515 AcpiDmGpioIntDescriptor (Info, Resource, Length, Level);
516 break;
517
518 case AML_RESOURCE_GPIO_TYPE_IO:
519
520 AcpiDmGpioIoDescriptor (Info, Resource, Length, Level);
521 break;
522
523 default:
524
525 AcpiOsPrintf ("Unknown GPIO type\n");
526 break;
527 }
528 }
529
530 void
AcpiDmClockInputDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)531 AcpiDmClockInputDescriptor (
532 ACPI_OP_WALK_INFO *Info,
533 AML_RESOURCE *Resource,
534 UINT32 Length,
535 UINT32 Level)
536 {
537 char *DeviceName = NULL;
538 UINT8 *ResourceIndex = NULL;
539 AcpiDmIndent (Level);
540
541 AcpiOsPrintf ("ClockInput (");
542
543 AcpiOsPrintf ("0x%8.8X, ", Resource->ClockInput.FrequencyNumerator);
544
545 AcpiOsPrintf ("0x%4.4X, ", Resource->ClockInput.FrequencyDivisor);
546
547 AcpiOsPrintf ("%s, ",
548 AcpiGbl_ClockInputScale [ACPI_EXTRACT_2BIT_FLAG (Resource->ClockInput.Flags, 1)]);
549
550 AcpiOsPrintf ("%s, ",
551 AcpiGbl_ClockInputMode [ACPI_GET_1BIT_FLAG (Resource->ClockInput.Flags)]);
552
553 if (Length > sizeof(Resource->ClockInput))
554 {
555 DeviceName = ACPI_ADD_PTR (char,
556 Resource, sizeof(Resource->ClockInput)+1),
557 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
558
559 AcpiOsPrintf (", ");
560 ResourceIndex = ACPI_ADD_PTR (UINT8,
561 Resource, sizeof(Resource->ClockInput)),
562
563 AcpiOsPrintf ("0x%2.2X", *ResourceIndex);
564 }
565
566 AcpiOsPrintf (")\n");
567
568 }
569
570 /*******************************************************************************
571 *
572 * FUNCTION: AcpiDmPinFunctionDescriptor
573 *
574 * PARAMETERS: Info - Extra resource info
575 * Resource - Pointer to the resource descriptor
576 * Length - Length of the descriptor in bytes
577 * Level - Current source code indentation level
578 *
579 * RETURN: None
580 *
581 * DESCRIPTION: Decode a PinFunction descriptor
582 *
583 ******************************************************************************/
584
585 void
AcpiDmPinFunctionDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)586 AcpiDmPinFunctionDescriptor (
587 ACPI_OP_WALK_INFO *Info,
588 AML_RESOURCE *Resource,
589 UINT32 Length,
590 UINT32 Level)
591 {
592 UINT16 *PinList;
593 UINT8 *VendorData;
594 char *DeviceName = NULL;
595 UINT32 PinCount;
596 UINT32 i;
597
598 AcpiDmIndent (Level);
599 AcpiOsPrintf ("PinFunction (%s, ",
600 AcpiGbl_ShrDecode [ACPI_GET_1BIT_FLAG (Resource->PinFunction.Flags)]);
601
602 if (Resource->PinFunction.PinConfig <= 3)
603 {
604 AcpiOsPrintf ("%s, ",
605 AcpiGbl_PpcDecode[Resource->PinFunction.PinConfig]);
606 }
607 else
608 {
609 AcpiOsPrintf ("0x%2.2X, ", Resource->PinFunction.PinConfig);
610 }
611
612 /* FunctionNumber */
613
614 AcpiOsPrintf ("0x%4.4X, ", Resource->PinFunction.FunctionNumber);
615
616 if (Resource->PinFunction.ResSourceOffset)
617 {
618 DeviceName = ACPI_ADD_PTR (char,
619 Resource, Resource->PinFunction.ResSourceOffset),
620 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
621 }
622
623 AcpiOsPrintf (", ");
624 AcpiOsPrintf ("0x%2.2X,\n", Resource->PinFunction.ResSourceIndex);
625
626 AcpiDmIndent (Level + 1);
627
628 /* Always ResourceConsumer */
629 AcpiOsPrintf ("%s, ", AcpiGbl_ConsumeDecode [ACPI_CONSUMER]);
630
631 /* Insert a descriptor name */
632
633 AcpiDmDescriptorName ();
634
635 AcpiOsPrintf (",");
636
637 /* Dump the vendor data */
638
639 if (Resource->PinFunction.VendorLength)
640 {
641 AcpiOsPrintf ("\n");
642 AcpiDmIndent (Level + 1);
643 VendorData = ACPI_ADD_PTR (UINT8, Resource,
644 Resource->PinFunction.VendorOffset);
645
646 AcpiDmDumpRawDataBuffer (VendorData,
647 Resource->PinFunction.VendorLength, Level);
648 }
649
650 AcpiOsPrintf (")\n");
651
652 AcpiDmIndent (Level + 1);
653
654 /* Dump the interrupt list */
655
656 AcpiOsPrintf ("{ // Pin list\n");
657
658 PinCount = ((UINT32) (Resource->PinFunction.ResSourceOffset -
659 Resource->PinFunction.PinTableOffset)) /
660 sizeof (UINT16);
661
662 PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource,
663 Resource->PinFunction.PinTableOffset);
664
665 for (i = 0; i < PinCount; i++)
666 {
667 AcpiDmIndent (Level + 2);
668 AcpiOsPrintf ("0x%4.4X%s\n", PinList[i],
669 ((i + 1) < PinCount) ? "," : "");
670 }
671
672 AcpiDmIndent (Level + 1);
673 AcpiOsPrintf ("}\n");
674 }
675
676
677 /*******************************************************************************
678 *
679 * FUNCTION: AcpiDmDumpSerialBusVendorData
680 *
681 * PARAMETERS: Resource - Pointer to the resource descriptor
682 *
683 * RETURN: None
684 *
685 * DESCRIPTION: Dump optional serial bus vendor data
686 *
687 ******************************************************************************/
688
689 static void
AcpiDmDumpSerialBusVendorData(AML_RESOURCE * Resource,UINT32 Level)690 AcpiDmDumpSerialBusVendorData (
691 AML_RESOURCE *Resource,
692 UINT32 Level)
693 {
694 UINT8 *VendorData;
695 UINT32 VendorLength;
696
697
698 /* Get the (optional) vendor data and length */
699
700 switch (Resource->CommonSerialBus.Type)
701 {
702 case AML_RESOURCE_I2C_SERIALBUSTYPE:
703
704 VendorLength = Resource->CommonSerialBus.TypeDataLength -
705 AML_RESOURCE_I2C_MIN_DATA_LEN;
706
707 VendorData = ACPI_ADD_PTR (UINT8, Resource,
708 sizeof (AML_RESOURCE_I2C_SERIALBUS));
709 break;
710
711 case AML_RESOURCE_SPI_SERIALBUSTYPE:
712
713 VendorLength = Resource->CommonSerialBus.TypeDataLength -
714 AML_RESOURCE_SPI_MIN_DATA_LEN;
715
716 VendorData = ACPI_ADD_PTR (UINT8, Resource,
717 sizeof (AML_RESOURCE_SPI_SERIALBUS));
718 break;
719
720 case AML_RESOURCE_UART_SERIALBUSTYPE:
721
722 VendorLength = Resource->CommonSerialBus.TypeDataLength -
723 AML_RESOURCE_UART_MIN_DATA_LEN;
724
725 VendorData = ACPI_ADD_PTR (UINT8, Resource,
726 sizeof (AML_RESOURCE_UART_SERIALBUS));
727 break;
728
729 case AML_RESOURCE_CSI2_SERIALBUSTYPE:
730
731 VendorLength = Resource->CommonSerialBus.TypeDataLength -
732 AML_RESOURCE_CSI2_MIN_DATA_LEN;
733
734 VendorData = ACPI_ADD_PTR (UINT8, Resource,
735 sizeof (AML_RESOURCE_CSI2_SERIALBUS));
736 break;
737
738 default:
739
740 return;
741 }
742
743 /* Dump the vendor bytes as a RawDataBuffer object */
744
745 AcpiDmDumpRawDataBuffer (VendorData, VendorLength, Level);
746 }
747
748
749 /*******************************************************************************
750 *
751 * FUNCTION: AcpiDmCsi2SerialBusDescriptor
752 *
753 * PARAMETERS: Info - Extra resource info
754 * Resource - Pointer to the resource descriptor
755 * Length - Length of the descriptor in bytes
756 * Level - Current source code indentation level
757 *
758 * RETURN: None
759 *
760 * DESCRIPTION: Decode a CSI2 serial bus descriptor
761 *
762 ******************************************************************************/
763
764 static void
AcpiDmCsi2SerialBusDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)765 AcpiDmCsi2SerialBusDescriptor (
766 ACPI_OP_WALK_INFO *Info,
767 AML_RESOURCE *Resource,
768 UINT32 Length,
769 UINT32 Level)
770 {
771 UINT32 ResourceSourceOffset;
772 char *DeviceName;
773
774
775 /* SlaveMode, PhyType, LocalPortInstance */
776
777 AcpiDmIndent (Level);
778 AcpiOsPrintf ("Csi2Bus (%s,",
779 AcpiGbl_SmDecode [ACPI_GET_1BIT_FLAG (Resource->Csi2SerialBus.Flags)]);
780
781 AcpiOsPrintf (" 0x%2.2X, 0x%2.2X,\n",
782 Resource->Csi2SerialBus.TypeSpecificFlags & 0x03,
783 Resource->Csi2SerialBus.TypeSpecificFlags & 0xFC);
784
785 /* ResourceSource is a required field */
786
787 ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
788 Resource->CommonSerialBus.TypeDataLength;
789
790 AcpiDmIndent (Level + 1);
791 DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
792 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
793
794 /* ResourceSourceIndex, ResourceUsage */
795
796 AcpiOsPrintf (",\n");
797 AcpiDmIndent (Level + 1);
798 AcpiOsPrintf ("0x%2.2X, ", Resource->Csi2SerialBus.ResSourceIndex);
799
800 AcpiOsPrintf ("%s, ",
801 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->Csi2SerialBus.Flags, 1)]);
802
803 /* Insert a descriptor name */
804
805 AcpiDmDescriptorName ();
806
807 /* Dump the vendor data */
808
809 AcpiOsPrintf (",\n");
810 AcpiDmIndent (Level + 1);
811 AcpiDmDumpSerialBusVendorData (Resource, Level);
812 AcpiOsPrintf (")\n");
813
814 MpSaveSerialInfo (Info->MappingOp, Resource, DeviceName);
815 }
816
817
818 /*******************************************************************************
819 *
820 * FUNCTION: AcpiDmI2cSerialBusDescriptor
821 *
822 * PARAMETERS: Info - Extra resource info
823 * Resource - Pointer to the resource descriptor
824 * Length - Length of the descriptor in bytes
825 * Level - Current source code indentation level
826 *
827 * RETURN: None
828 *
829 * DESCRIPTION: Decode a I2C serial bus descriptor
830 *
831 ******************************************************************************/
832
833 static void
AcpiDmI2cSerialBusDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)834 AcpiDmI2cSerialBusDescriptor (
835 ACPI_OP_WALK_INFO *Info,
836 AML_RESOURCE *Resource,
837 UINT32 Length,
838 UINT32 Level)
839 {
840 UINT32 ResourceSourceOffset;
841 char *DeviceName;
842
843
844 /* SlaveAddress, SlaveMode, ConnectionSpeed, AddressingMode */
845
846 AcpiDmIndent (Level);
847 AcpiOsPrintf ("I2cSerialBusV2 (0x%4.4X, %s, 0x%8.8X,\n",
848 Resource->I2cSerialBus.SlaveAddress,
849 AcpiGbl_SmDecode [ACPI_GET_1BIT_FLAG (Resource->I2cSerialBus.Flags)],
850 Resource->I2cSerialBus.ConnectionSpeed);
851
852 AcpiDmIndent (Level + 1);
853 AcpiOsPrintf ("%s, ",
854 AcpiGbl_AmDecode [ACPI_GET_1BIT_FLAG (Resource->I2cSerialBus.TypeSpecificFlags)]);
855
856 /* ResourceSource is a required field */
857
858 ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
859 Resource->CommonSerialBus.TypeDataLength;
860
861 DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
862 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
863
864 /* ResourceSourceIndex, ResourceUsage */
865
866 AcpiOsPrintf (",\n");
867 AcpiDmIndent (Level + 1);
868 AcpiOsPrintf ("0x%2.2X, ", Resource->I2cSerialBus.ResSourceIndex);
869
870 AcpiOsPrintf ("%s, ",
871 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->I2cSerialBus.Flags, 1)]);
872
873 /* Insert a descriptor name */
874
875 AcpiDmDescriptorName ();
876
877 /* Share */
878
879 AcpiOsPrintf (", %s,\n",
880 AcpiGbl_ShrDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->I2cSerialBus.Flags, 2)]);
881
882 /* Dump the vendor data */
883
884 AcpiDmIndent (Level + 1);
885 AcpiDmDumpSerialBusVendorData (Resource, Level);
886 AcpiOsPrintf (")\n");
887
888 MpSaveSerialInfo (Info->MappingOp, Resource, DeviceName);
889 }
890
891
892 /*******************************************************************************
893 *
894 * FUNCTION: AcpiDmSpiSerialBusDescriptor
895 *
896 * PARAMETERS: Info - Extra resource info
897 * Resource - Pointer to the resource descriptor
898 * Length - Length of the descriptor in bytes
899 * Level - Current source code indentation level
900 *
901 * RETURN: None
902 *
903 * DESCRIPTION: Decode a SPI serial bus descriptor
904 *
905 ******************************************************************************/
906
907 static void
AcpiDmSpiSerialBusDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)908 AcpiDmSpiSerialBusDescriptor (
909 ACPI_OP_WALK_INFO *Info,
910 AML_RESOURCE *Resource,
911 UINT32 Length,
912 UINT32 Level)
913 {
914 UINT32 ResourceSourceOffset;
915 char *DeviceName;
916
917
918 /* DeviceSelection, DeviceSelectionPolarity, WireMode, DataBitLength */
919
920 AcpiDmIndent (Level);
921 AcpiOsPrintf ("SpiSerialBusV2 (0x%4.4X, %s, %s, 0x%2.2X,\n",
922 Resource->SpiSerialBus.DeviceSelection,
923 AcpiGbl_DpDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->SpiSerialBus.TypeSpecificFlags, 1)],
924 AcpiGbl_WmDecode [ACPI_GET_1BIT_FLAG (Resource->SpiSerialBus.TypeSpecificFlags)],
925 Resource->SpiSerialBus.DataBitLength);
926
927 /* SlaveMode, ConnectionSpeed, ClockPolarity, ClockPhase */
928
929 AcpiDmIndent (Level + 1);
930 AcpiOsPrintf ("%s, 0x%8.8X, %s,\n",
931 AcpiGbl_SmDecode [ACPI_GET_1BIT_FLAG (Resource->SpiSerialBus.Flags)],
932 Resource->SpiSerialBus.ConnectionSpeed,
933 AcpiGbl_CpoDecode [ACPI_GET_1BIT_FLAG (Resource->SpiSerialBus.ClockPolarity)]);
934
935 AcpiDmIndent (Level + 1);
936 AcpiOsPrintf ("%s, ",
937 AcpiGbl_CphDecode [ACPI_GET_1BIT_FLAG (Resource->SpiSerialBus.ClockPhase)]);
938
939 /* ResourceSource is a required field */
940
941 ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
942 Resource->CommonSerialBus.TypeDataLength;
943
944 DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
945 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
946
947 /* ResourceSourceIndex, ResourceUsage */
948
949 AcpiOsPrintf (",\n");
950 AcpiDmIndent (Level + 1);
951 AcpiOsPrintf ("0x%2.2X, ", Resource->SpiSerialBus.ResSourceIndex);
952
953 AcpiOsPrintf ("%s, ",
954 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->SpiSerialBus.Flags, 1)]);
955
956 /* Insert a descriptor name */
957
958 AcpiDmDescriptorName ();
959
960 /* Share */
961
962 AcpiOsPrintf (", %s,\n",
963 AcpiGbl_ShrDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->SpiSerialBus.Flags, 2)]);
964
965 /* Dump the vendor data */
966
967 AcpiDmIndent (Level + 1);
968 AcpiDmDumpSerialBusVendorData (Resource, Level);
969 AcpiOsPrintf (")\n");
970
971 MpSaveSerialInfo (Info->MappingOp, Resource, DeviceName);
972 }
973
974
975 /*******************************************************************************
976 *
977 * FUNCTION: AcpiDmUartSerialBusDescriptor
978 *
979 * PARAMETERS: Info - Extra resource info
980 * Resource - Pointer to the resource descriptor
981 * Length - Length of the descriptor in bytes
982 * Level - Current source code indentation level
983 *
984 * RETURN: None
985 *
986 * DESCRIPTION: Decode a UART serial bus descriptor
987 *
988 ******************************************************************************/
989
990 static void
AcpiDmUartSerialBusDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)991 AcpiDmUartSerialBusDescriptor (
992 ACPI_OP_WALK_INFO *Info,
993 AML_RESOURCE *Resource,
994 UINT32 Length,
995 UINT32 Level)
996 {
997 UINT32 ResourceSourceOffset;
998 char *DeviceName;
999
1000
1001 /* ConnectionSpeed, BitsPerByte, StopBits */
1002
1003 AcpiDmIndent (Level);
1004 AcpiOsPrintf ("UartSerialBusV2 (0x%8.8X, %s, %s,\n",
1005 Resource->UartSerialBus.DefaultBaudRate,
1006 AcpiGbl_BpbDecode [ACPI_EXTRACT_3BIT_FLAG (Resource->UartSerialBus.TypeSpecificFlags, 4)],
1007 AcpiGbl_SbDecode [ACPI_EXTRACT_2BIT_FLAG (Resource->UartSerialBus.TypeSpecificFlags, 2)]);
1008
1009 /* LinesInUse, IsBigEndian, Parity, FlowControl */
1010
1011 AcpiDmIndent (Level + 1);
1012 AcpiOsPrintf ("0x%2.2X, %s, %s, %s,\n",
1013 Resource->UartSerialBus.LinesEnabled,
1014 AcpiGbl_EdDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->UartSerialBus.TypeSpecificFlags, 7)],
1015 AcpiGbl_PtDecode [ACPI_GET_3BIT_FLAG (Resource->UartSerialBus.Parity)],
1016 AcpiGbl_FcDecode [ACPI_GET_2BIT_FLAG (Resource->UartSerialBus.TypeSpecificFlags)]);
1017
1018 /* ReceiveBufferSize, TransmitBufferSize */
1019
1020 AcpiDmIndent (Level + 1);
1021 AcpiOsPrintf ("0x%4.4X, 0x%4.4X, ",
1022 Resource->UartSerialBus.RxFifoSize,
1023 Resource->UartSerialBus.TxFifoSize);
1024
1025 /* ResourceSource is a required field */
1026
1027 ResourceSourceOffset = sizeof (AML_RESOURCE_COMMON_SERIALBUS) +
1028 Resource->CommonSerialBus.TypeDataLength;
1029
1030 DeviceName = ACPI_ADD_PTR (char, Resource, ResourceSourceOffset);
1031 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
1032
1033 /* ResourceSourceIndex, ResourceUsage */
1034
1035 AcpiOsPrintf (",\n");
1036 AcpiDmIndent (Level + 1);
1037 AcpiOsPrintf ("0x%2.2X, ", Resource->UartSerialBus.ResSourceIndex);
1038
1039 AcpiOsPrintf ("%s, ",
1040 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->UartSerialBus.Flags, 1)]);
1041
1042 /* Insert a descriptor name */
1043
1044 AcpiDmDescriptorName ();
1045
1046 /* Share */
1047
1048 AcpiOsPrintf (", %s,\n",
1049 AcpiGbl_ShrDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->UartSerialBus.Flags, 2)]);
1050
1051 /* Dump the vendor data */
1052
1053 AcpiDmIndent (Level + 1);
1054 AcpiDmDumpSerialBusVendorData (Resource, Level);
1055 AcpiOsPrintf (")\n");
1056
1057 MpSaveSerialInfo (Info->MappingOp, Resource, DeviceName);
1058 }
1059
1060
1061 /*******************************************************************************
1062 *
1063 * FUNCTION: AcpiDmSerialBusDescriptor
1064 *
1065 * PARAMETERS: Info - Extra resource info
1066 * Resource - Pointer to the resource descriptor
1067 * Length - Length of the descriptor in bytes
1068 * Level - Current source code indentation level
1069 *
1070 * RETURN: None
1071 *
1072 * DESCRIPTION: Decode a I2C/SPI/UART/CSI2 serial bus descriptor
1073 *
1074 ******************************************************************************/
1075
1076 void
AcpiDmSerialBusDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)1077 AcpiDmSerialBusDescriptor (
1078 ACPI_OP_WALK_INFO *Info,
1079 AML_RESOURCE *Resource,
1080 UINT32 Length,
1081 UINT32 Level)
1082 {
1083
1084 SerialBusResourceDispatch [Resource->CommonSerialBus.Type] (
1085 Info, Resource, Length, Level);
1086 }
1087
1088 /*******************************************************************************
1089 *
1090 * FUNCTION: AcpiDmPinConfig
1091 *
1092 * PARAMETERS: PinConfigType - Pin configuration type
1093 * PinConfigValue - Pin configuration value
1094 *
1095 * RETURN: None
1096 *
1097 * DESCRIPTION: Pretty prints PinConfig type and value.
1098 *
1099 ******************************************************************************/
1100
1101 static void
AcpiDmPinConfig(UINT8 PinConfigType,UINT32 PinConfigValue)1102 AcpiDmPinConfig(
1103 UINT8 PinConfigType,
1104 UINT32 PinConfigValue)
1105 {
1106 if (PinConfigType <= 13)
1107 {
1108 AcpiOsPrintf ("0x%2.2X /* %s */, ", PinConfigType,
1109 AcpiGbl_PtypDecode[PinConfigType]);
1110 }
1111 else
1112 {
1113 AcpiOsPrintf ("0x%2.2X, /* Vendor Defined */ ", PinConfigType);
1114 }
1115
1116 /* PinConfigValue */
1117
1118 AcpiOsPrintf ("0x%4.4X,\n", PinConfigValue);
1119 }
1120
1121 /*******************************************************************************
1122 *
1123 * FUNCTION: AcpiDmPinConfigDescriptor
1124 *
1125 * PARAMETERS: Info - Extra resource info
1126 * Resource - Pointer to the resource descriptor
1127 * Length - Length of the descriptor in bytes
1128 * Level - Current source code indentation level
1129 *
1130 * RETURN: None
1131 *
1132 * DESCRIPTION: Decode a PinConfig descriptor
1133 *
1134 ******************************************************************************/
1135
1136 void
AcpiDmPinConfigDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)1137 AcpiDmPinConfigDescriptor (
1138 ACPI_OP_WALK_INFO *Info,
1139 AML_RESOURCE *Resource,
1140 UINT32 Length,
1141 UINT32 Level)
1142 {
1143 UINT16 *PinList;
1144 UINT8 *VendorData;
1145 char *DeviceName = NULL;
1146 UINT32 PinCount;
1147 UINT32 i;
1148
1149 AcpiDmIndent (Level);
1150 AcpiOsPrintf ("PinConfig (%s, ",
1151 AcpiGbl_ShrDecode [ACPI_GET_1BIT_FLAG (Resource->PinConfig.Flags)]);
1152
1153 AcpiDmPinConfig (Resource->PinConfig.PinConfigType,
1154 Resource->PinConfig.PinConfigValue);
1155
1156 AcpiDmIndent (Level + 1);
1157
1158 if (Resource->PinConfig.ResSourceOffset)
1159 {
1160 DeviceName = ACPI_ADD_PTR (char,
1161 Resource, Resource->PinConfig.ResSourceOffset),
1162 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
1163 }
1164
1165 AcpiOsPrintf (", ");
1166 AcpiOsPrintf ("0x%2.2X, ", Resource->PinConfig.ResSourceIndex);
1167
1168 AcpiOsPrintf ("%s, ",
1169 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->PinConfig.Flags, 1)]);
1170
1171 /* Insert a descriptor name */
1172
1173 AcpiDmDescriptorName ();
1174
1175 AcpiOsPrintf (",");
1176
1177 /* Dump the vendor data */
1178
1179 if (Resource->PinConfig.VendorLength)
1180 {
1181 AcpiOsPrintf ("\n");
1182 AcpiDmIndent (Level + 1);
1183 VendorData = ACPI_ADD_PTR (UINT8, Resource,
1184 Resource->PinConfig.VendorOffset);
1185
1186 AcpiDmDumpRawDataBuffer (VendorData,
1187 Resource->PinConfig.VendorLength, Level);
1188 }
1189
1190 AcpiOsPrintf (")\n");
1191
1192 AcpiDmIndent (Level + 1);
1193
1194 /* Dump the interrupt list */
1195
1196 AcpiOsPrintf ("{ // Pin list\n");
1197
1198 PinCount = ((UINT32) (Resource->PinConfig.ResSourceOffset -
1199 Resource->PinConfig.PinTableOffset)) /
1200 sizeof (UINT16);
1201
1202 PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource,
1203 Resource->PinConfig.PinTableOffset);
1204
1205 for (i = 0; i < PinCount; i++)
1206 {
1207 AcpiDmIndent (Level + 2);
1208 AcpiOsPrintf ("0x%4.4X%s\n", PinList[i],
1209 ((i + 1) < PinCount) ? "," : "");
1210 }
1211
1212 AcpiDmIndent (Level + 1);
1213 AcpiOsPrintf ("}\n");
1214 }
1215
1216 /*******************************************************************************
1217 *
1218 * FUNCTION: AcpiDmPinGroupDescriptor
1219 *
1220 * PARAMETERS: Info - Extra resource info
1221 * Resource - Pointer to the resource descriptor
1222 * Length - Length of the descriptor in bytes
1223 * Level - Current source code indentation level
1224 *
1225 * RETURN: None
1226 *
1227 * DESCRIPTION: Decode a PinGroup descriptor
1228 *
1229 ******************************************************************************/
1230
1231 void
AcpiDmPinGroupDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)1232 AcpiDmPinGroupDescriptor (
1233 ACPI_OP_WALK_INFO *Info,
1234 AML_RESOURCE *Resource,
1235 UINT32 Length,
1236 UINT32 Level)
1237 {
1238 char *Label;
1239 UINT16 *PinList;
1240 UINT8 *VendorData;
1241 UINT32 PinCount;
1242 UINT32 i;
1243
1244 AcpiDmIndent (Level);
1245 /* Always producer */
1246 AcpiOsPrintf ("PinGroup (");
1247
1248 Label = ACPI_ADD_PTR (char,
1249 Resource, Resource->PinGroup.LabelOffset),
1250 AcpiUtPrintString (Label, ACPI_UINT16_MAX);
1251
1252 AcpiOsPrintf (", ");
1253
1254 AcpiOsPrintf ("%s, ",
1255 AcpiGbl_ConsumeDecode [ACPI_GET_1BIT_FLAG (Resource->PinGroup.Flags)]);
1256
1257 /* Insert a descriptor name */
1258
1259 AcpiDmDescriptorName ();
1260
1261 AcpiOsPrintf (",");
1262
1263 /* Dump the vendor data */
1264
1265 if (Resource->PinGroup.VendorLength)
1266 {
1267 AcpiOsPrintf ("\n");
1268 AcpiDmIndent (Level + 1);
1269 VendorData = ACPI_ADD_PTR (UINT8, Resource,
1270 Resource->PinGroup.VendorOffset);
1271
1272 AcpiDmDumpRawDataBuffer (VendorData,
1273 Resource->PinGroup.VendorLength, Level);
1274 }
1275
1276 AcpiOsPrintf (")\n");
1277
1278 AcpiDmIndent (Level + 1);
1279
1280 /* Dump the interrupt list */
1281
1282 AcpiOsPrintf ("{ // Pin list\n");
1283
1284 PinCount = (Resource->PinGroup.LabelOffset -
1285 Resource->PinGroup.PinTableOffset) / sizeof (UINT16);
1286
1287 PinList = (UINT16 *) ACPI_ADD_PTR (char, Resource,
1288 Resource->PinGroup.PinTableOffset);
1289
1290 for (i = 0; i < PinCount; i++)
1291 {
1292 AcpiDmIndent (Level + 2);
1293 AcpiOsPrintf ("0x%4.4X%s\n", PinList[i],
1294 ((i + 1) < PinCount) ? "," : "");
1295 }
1296
1297 AcpiDmIndent (Level + 1);
1298 AcpiOsPrintf ("}\n");
1299 }
1300
1301 /*******************************************************************************
1302 *
1303 * FUNCTION: AcpiDmPinGroupFunctionDescriptor
1304 *
1305 * PARAMETERS: Info - Extra resource info
1306 * Resource - Pointer to the resource descriptor
1307 * Length - Length of the descriptor in bytes
1308 * Level - Current source code indentation level
1309 *
1310 * RETURN: None
1311 *
1312 * DESCRIPTION: Decode a PinGroupFunction descriptor
1313 *
1314 ******************************************************************************/
1315
1316 void
AcpiDmPinGroupFunctionDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)1317 AcpiDmPinGroupFunctionDescriptor (
1318 ACPI_OP_WALK_INFO *Info,
1319 AML_RESOURCE *Resource,
1320 UINT32 Length,
1321 UINT32 Level)
1322 {
1323 UINT8 *VendorData;
1324 char *DeviceName = NULL;
1325 char *Label = NULL;
1326
1327 AcpiDmIndent (Level);
1328 AcpiOsPrintf ("PinGroupFunction (%s, ",
1329 AcpiGbl_ShrDecode [ACPI_GET_1BIT_FLAG (Resource->PinGroupFunction.Flags)]);
1330
1331 /* FunctionNumber */
1332
1333 AcpiOsPrintf ("0x%4.4X, ", Resource->PinGroupFunction.FunctionNumber);
1334
1335 DeviceName = ACPI_ADD_PTR (char,
1336 Resource, Resource->PinGroupFunction.ResSourceOffset),
1337 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
1338
1339 AcpiOsPrintf (", ");
1340 AcpiOsPrintf ("0x%2.2X,\n", Resource->PinGroupFunction.ResSourceIndex);
1341
1342 AcpiDmIndent (Level + 1);
1343
1344 Label = ACPI_ADD_PTR (char, Resource,
1345 Resource->PinGroupFunction.ResSourceLabelOffset);
1346 AcpiUtPrintString (Label, ACPI_UINT16_MAX);
1347
1348 AcpiOsPrintf (", ");
1349
1350 AcpiOsPrintf ("%s, ",
1351 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->PinGroupFunction.Flags, 1)]);
1352
1353 /* Insert a descriptor name */
1354
1355 AcpiDmDescriptorName ();
1356
1357 AcpiOsPrintf (",");
1358
1359 /* Dump the vendor data */
1360
1361 if (Resource->PinGroupFunction.VendorLength)
1362 {
1363 AcpiOsPrintf ("\n");
1364 AcpiDmIndent (Level + 1);
1365 VendorData = ACPI_ADD_PTR (UINT8, Resource,
1366 Resource->PinGroupFunction.VendorOffset);
1367
1368 AcpiDmDumpRawDataBuffer (VendorData,
1369 Resource->PinGroupFunction.VendorLength, Level);
1370 }
1371
1372 AcpiOsPrintf (")\n");
1373 }
1374
1375 /*******************************************************************************
1376 *
1377 * FUNCTION: AcpiDmPinGroupConfigDescriptor
1378 *
1379 * PARAMETERS: Info - Extra resource info
1380 * Resource - Pointer to the resource descriptor
1381 * Length - Length of the descriptor in bytes
1382 * Level - Current source code indentation level
1383 *
1384 * RETURN: None
1385 *
1386 * DESCRIPTION: Decode a PinGroupConfig descriptor
1387 *
1388 ******************************************************************************/
1389
1390 void
AcpiDmPinGroupConfigDescriptor(ACPI_OP_WALK_INFO * Info,AML_RESOURCE * Resource,UINT32 Length,UINT32 Level)1391 AcpiDmPinGroupConfigDescriptor (
1392 ACPI_OP_WALK_INFO *Info,
1393 AML_RESOURCE *Resource,
1394 UINT32 Length,
1395 UINT32 Level)
1396 {
1397 UINT8 *VendorData;
1398 char *DeviceName = NULL;
1399 char *Label = NULL;
1400
1401 AcpiDmIndent (Level);
1402 AcpiOsPrintf ("PinGroupConfig (%s, ",
1403 AcpiGbl_ShrDecode [ACPI_GET_1BIT_FLAG (Resource->PinGroupConfig.Flags)]);
1404
1405 AcpiDmPinConfig(Resource->PinGroupConfig.PinConfigType,
1406 Resource->PinGroupConfig.PinConfigValue);
1407
1408 AcpiDmIndent (Level + 1);
1409
1410 DeviceName = ACPI_ADD_PTR (char,
1411 Resource, Resource->PinGroupConfig.ResSourceOffset),
1412 AcpiUtPrintString (DeviceName, ACPI_UINT16_MAX);
1413
1414 AcpiOsPrintf (", ");
1415 AcpiOsPrintf ("0x%2.2X, ", Resource->PinGroupConfig.ResSourceIndex);
1416
1417 Label = ACPI_ADD_PTR (char, Resource,
1418 Resource->PinGroupConfig.ResSourceLabelOffset);
1419 AcpiUtPrintString (Label, ACPI_UINT16_MAX);
1420
1421 AcpiOsPrintf (", ");
1422
1423 AcpiOsPrintf ("%s, ",
1424 AcpiGbl_ConsumeDecode [ACPI_EXTRACT_1BIT_FLAG (Resource->PinGroupConfig.Flags, 1)]);
1425
1426 /* Insert a descriptor name */
1427
1428 AcpiDmDescriptorName ();
1429
1430 AcpiOsPrintf (",");
1431
1432 /* Dump the vendor data */
1433
1434 if (Resource->PinGroupConfig.VendorLength)
1435 {
1436 AcpiOsPrintf ("\n");
1437 AcpiDmIndent (Level + 1);
1438 VendorData = ACPI_ADD_PTR (UINT8, Resource,
1439 Resource->PinGroupConfig.VendorOffset);
1440
1441 AcpiDmDumpRawDataBuffer (VendorData,
1442 Resource->PinGroupConfig.VendorLength, Level);
1443 }
1444
1445 AcpiOsPrintf (")\n");
1446 }
1447