1 /******************************************************************************
3 * Module Name: aslrestype2s - Serial Large resource descriptors
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2016, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <contrib/dev/acpica/compiler/aslcompiler.h>
45 #include "aslcompiler.y.h"
46 #include <contrib/dev/acpica/include/amlcode.h>
48 #define _COMPONENT ACPI_COMPILER
49 ACPI_MODULE_NAME ("aslrestype2s")
53 RsGetBufferDataLength (
54 ACPI_PARSE_OBJECT *InitializerOp);
57 RsGetInterruptDataLength (
58 ACPI_PARSE_OBJECT *InitializerOp);
62 ACPI_PARSE_OBJECT *InitializerOp,
64 ACPI_SIZE DescriptorOffset);
67 * This module contains descriptors for serial buses and GPIO:
77 /*******************************************************************************
79 * FUNCTION: RsGetBufferDataLength
81 * PARAMETERS: InitializerOp - Current parse op, start of the resource
84 * RETURN: Length of the data buffer
86 * DESCRIPTION: Get the length of a RawDataBuffer, used for vendor data.
88 ******************************************************************************/
91 RsGetBufferDataLength (
92 ACPI_PARSE_OBJECT *InitializerOp)
94 UINT16 ExtraDataSize = 0;
95 ACPI_PARSE_OBJECT *DataList;
98 /* Find the byte-initializer list */
100 while (InitializerOp)
102 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DATABUFFER)
104 /* First child is the optional length (ignore it here) */
106 DataList = InitializerOp->Asl.Child;
107 DataList = ASL_GET_PEER_NODE (DataList);
109 /* Count the data items (each one is a byte of data) */
114 DataList = ASL_GET_PEER_NODE (DataList);
117 return (ExtraDataSize);
120 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
123 return (ExtraDataSize);
127 /*******************************************************************************
129 * FUNCTION: RsGetInterruptDataLength
131 * PARAMETERS: InitializerOp - Current parse op, start of the resource
134 * RETURN: Length of the interrupt data list
136 * DESCRIPTION: Get the length of a list of interrupt DWORDs for the GPIO
139 ******************************************************************************/
142 RsGetInterruptDataLength (
143 ACPI_PARSE_OBJECT *InitializerOp)
145 UINT16 InterruptLength;
149 /* Count the interrupt numbers */
152 for (i = 0; InitializerOp; i++)
154 InitializerOp = ASL_GET_PEER_NODE (InitializerOp);
156 /* Interrupt list starts at offset 10 (Gpio descriptors) */
160 InterruptLength += 2;
164 return (InterruptLength);
168 /*******************************************************************************
170 * FUNCTION: RsGetVendorData
172 * PARAMETERS: InitializerOp - Current parse op, start of the resource
174 * VendorData - Where the vendor data is returned
175 * DescriptorOffset - Where vendor data begins in descriptor
177 * RETURN: TRUE if valid vendor data was returned, FALSE otherwise.
179 * DESCRIPTION: Extract the vendor data and construct a vendor data buffer.
181 ******************************************************************************/
185 ACPI_PARSE_OBJECT *InitializerOp,
187 ACPI_SIZE DescriptorOffset)
189 ACPI_PARSE_OBJECT *BufferOp;
190 UINT32 SpecifiedLength = ACPI_UINT32_MAX;
191 UINT16 ActualLength = 0;
194 /* Vendor Data field is always optional */
196 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
201 BufferOp = InitializerOp->Asl.Child;
204 AslError (ASL_ERROR, ASL_MSG_SYNTAX, InitializerOp, "");
208 /* First child is the optional buffer length (WORD) */
210 if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
212 SpecifiedLength = (UINT16) BufferOp->Asl.Value.Integer;
215 /* Insert field tag _VEN */
217 RsCreateByteField (InitializerOp, ACPI_RESTAG_VENDORDATA,
218 (UINT16) DescriptorOffset);
220 /* Walk the list of buffer initializers (each is one byte) */
222 BufferOp = RsCompleteNodeAndGetNext (BufferOp);
223 if (BufferOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
227 *VendorData = (UINT8) BufferOp->Asl.Value.Integer;
230 BufferOp = RsCompleteNodeAndGetNext (BufferOp);
234 /* Length validation. Buffer cannot be of zero length */
236 if ((SpecifiedLength == 0) ||
237 ((SpecifiedLength == ACPI_UINT32_MAX) && (ActualLength == 0)))
239 AslError (ASL_ERROR, ASL_MSG_BUFFER_LENGTH, InitializerOp, NULL);
243 if (SpecifiedLength != ACPI_UINT32_MAX)
245 /* ActualLength > SpecifiedLength -> error */
247 if (ActualLength > SpecifiedLength)
249 AslError (ASL_ERROR, ASL_MSG_LIST_LENGTH_LONG, InitializerOp, NULL);
253 /* ActualLength < SpecifiedLength -> remark */
255 else if (ActualLength < SpecifiedLength)
257 AslError (ASL_REMARK, ASL_MSG_LIST_LENGTH_SHORT, InitializerOp, NULL);
266 /*******************************************************************************
268 * FUNCTION: RsDoGpioIntDescriptor
270 * PARAMETERS: Info - Parse Op and resource template offset
272 * RETURN: Completed resource node
274 * DESCRIPTION: Construct a long "GpioInt" descriptor
276 ******************************************************************************/
279 RsDoGpioIntDescriptor (
280 ASL_RESOURCE_INFO *Info)
282 AML_RESOURCE *Descriptor;
283 ACPI_PARSE_OBJECT *InitializerOp;
284 ASL_RESOURCE_NODE *Rnode;
285 char *ResourceSource = NULL;
286 UINT8 *VendorData = NULL;
287 UINT16 *InterruptList = NULL;
288 UINT16 *PinList = NULL;
289 UINT16 ResSourceLength;
291 UINT16 InterruptLength;
292 UINT16 DescriptorSize;
293 UINT32 CurrentByteOffset;
298 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
299 CurrentByteOffset = Info->CurrentByteOffset;
302 * Calculate lengths for fields that have variable length:
303 * 1) Resource Source string
304 * 2) Vendor Data buffer
305 * 3) PIN (interrupt) list
307 ResSourceLength = RsGetStringDataLength (InitializerOp);
308 VendorLength = RsGetBufferDataLength (InitializerOp);
309 InterruptLength = RsGetInterruptDataLength (InitializerOp);
311 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
312 ResSourceLength + VendorLength + InterruptLength;
314 /* Allocate the local resource node and initialize */
316 Rnode = RsAllocateResourceNode (DescriptorSize +
317 sizeof (AML_RESOURCE_LARGE_HEADER));
319 Descriptor = Rnode->Buffer;
320 Descriptor->Gpio.ResourceLength = DescriptorSize;
321 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
322 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
323 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_INT;
325 /* Build pointers to optional areas */
327 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor,
328 sizeof (AML_RESOURCE_GPIO));
329 PinList = InterruptList;
330 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
331 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
333 /* Setup offsets within the descriptor */
335 Descriptor->Gpio.PinTableOffset = (UINT16)
336 ACPI_PTR_DIFF (InterruptList, Descriptor);
338 Descriptor->Gpio.ResSourceOffset = (UINT16)
339 ACPI_PTR_DIFF (ResourceSource, Descriptor);
341 /* Process all child initialization nodes */
343 for (i = 0; InitializerOp; i++)
347 case 0: /* Interrupt Mode - edge/level [Flag] (_MOD) */
349 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
350 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
351 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0);
354 case 1: /* Interrupt Polarity - Active high/low [Flags] (_POL) */
356 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 1, 0);
357 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_POLARITY,
358 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 1, 2);
361 case 2: /* Share Type - Default: exclusive (0) [Flags] (_SHR) */
363 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
364 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
365 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3, 2);
368 case 3: /* Pin Config [BYTE] (_PPI) */
370 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
371 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
372 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
375 case 4: /* Debounce Timeout [WORD] (_DBT) */
377 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
378 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
379 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
382 case 5: /* ResSource [Optional Field - STRING] */
386 /* Copy string to the descriptor */
388 strcpy (ResourceSource,
389 InitializerOp->Asl.Value.String);
393 case 6: /* Resource Index */
395 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
397 Descriptor->Gpio.ResSourceIndex =
398 (UINT8) InitializerOp->Asl.Value.Integer;
402 case 7: /* Resource Usage (consumer/producer) */
404 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
407 case 8: /* Resource Tag (Descriptor Name) */
409 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
412 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
415 * Always set the VendorOffset even if there is no Vendor Data.
416 * This field is required in order to calculate the length
417 * of the ResourceSource at runtime.
419 Descriptor->Gpio.VendorOffset = (UINT16)
420 ACPI_PTR_DIFF (VendorData, Descriptor);
422 if (RsGetVendorData (InitializerOp, VendorData,
423 (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
425 Descriptor->Gpio.VendorLength = VendorLength;
431 * PINs come through here, repeatedly. Each PIN must be a WORD.
432 * NOTE: there is no "length" field for this, so from ACPI spec:
433 * The number of pins in the table can be calculated from:
434 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
435 * (implies resource source must immediately follow the pin list.)
438 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
442 /* Case 10: First interrupt number in list */
446 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
448 /* Must be at least one interrupt */
450 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
451 InitializerOp, NULL);
454 /* Check now for duplicates in list */
456 RsCheckListForDuplicates (InitializerOp);
458 /* Create a named field at the start of the list */
460 RsCreateWordField (InitializerOp, ACPI_RESTAG_PIN,
461 CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
466 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
469 MpSaveGpioInfo (Info->MappingOp, Descriptor,
470 PinCount, PinList, ResourceSource);
475 /*******************************************************************************
477 * FUNCTION: RsDoGpioIoDescriptor
479 * PARAMETERS: Info - Parse Op and resource template offset
481 * RETURN: Completed resource node
483 * DESCRIPTION: Construct a long "GpioIo" descriptor
485 ******************************************************************************/
488 RsDoGpioIoDescriptor (
489 ASL_RESOURCE_INFO *Info)
491 AML_RESOURCE *Descriptor;
492 ACPI_PARSE_OBJECT *InitializerOp;
493 ASL_RESOURCE_NODE *Rnode;
494 char *ResourceSource = NULL;
495 UINT8 *VendorData = NULL;
496 UINT16 *InterruptList = NULL;
497 UINT16 *PinList = NULL;
498 UINT16 ResSourceLength;
500 UINT16 InterruptLength;
501 UINT16 DescriptorSize;
502 UINT32 CurrentByteOffset;
507 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
508 CurrentByteOffset = Info->CurrentByteOffset;
511 * Calculate lengths for fields that have variable length:
512 * 1) Resource Source string
513 * 2) Vendor Data buffer
514 * 3) PIN (interrupt) list
516 ResSourceLength = RsGetStringDataLength (InitializerOp);
517 VendorLength = RsGetBufferDataLength (InitializerOp);
518 InterruptLength = RsGetInterruptDataLength (InitializerOp);
519 PinList = InterruptList;
521 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
522 ResSourceLength + VendorLength + InterruptLength;
524 /* Allocate the local resource node and initialize */
526 Rnode = RsAllocateResourceNode (DescriptorSize +
527 sizeof (AML_RESOURCE_LARGE_HEADER));
529 Descriptor = Rnode->Buffer;
530 Descriptor->Gpio.ResourceLength = DescriptorSize;
531 Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
532 Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
533 Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO;
535 /* Build pointers to optional areas */
537 InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
538 PinList = InterruptList;
539 ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
540 VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
542 /* Setup offsets within the descriptor */
544 Descriptor->Gpio.PinTableOffset = (UINT16)
545 ACPI_PTR_DIFF (InterruptList, Descriptor);
547 Descriptor->Gpio.ResSourceOffset = (UINT16)
548 ACPI_PTR_DIFF (ResourceSource, Descriptor);
550 /* Process all child initialization nodes */
552 for (i = 0; InitializerOp; i++)
556 case 0: /* Share Type [Flags] (_SHR) */
558 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
559 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
560 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3);
563 case 1: /* Pin Config [BYTE] (_PPI) */
565 Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
566 RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
567 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
570 case 2: /* Debounce Timeout [WORD] (_DBT) */
572 Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
573 RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
574 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
577 case 3: /* Drive Strength [WORD] (_DRS) */
579 Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer;
580 RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH,
581 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength));
584 case 4: /* I/O Restriction [Flag] (_IOR) */
586 RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
587 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION,
588 CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2);
591 case 5: /* ResSource [Optional Field - STRING] */
595 /* Copy string to the descriptor */
597 strcpy (ResourceSource,
598 InitializerOp->Asl.Value.String);
602 case 6: /* Resource Index */
604 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
606 Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
610 case 7: /* Resource Usage (consumer/producer) */
612 RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
615 case 8: /* Resource Tag (Descriptor Name) */
617 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
620 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
622 * Always set the VendorOffset even if there is no Vendor Data.
623 * This field is required in order to calculate the length
624 * of the ResourceSource at runtime.
626 Descriptor->Gpio.VendorOffset = (UINT16)
627 ACPI_PTR_DIFF (VendorData, Descriptor);
629 if (RsGetVendorData (InitializerOp, VendorData,
630 (CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
632 Descriptor->Gpio.VendorLength = VendorLength;
638 * PINs come through here, repeatedly. Each PIN must be a WORD.
639 * NOTE: there is no "length" field for this, so from ACPI spec:
640 * The number of pins in the table can be calculated from:
641 * PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
642 * (implies resource source must immediately follow the pin list.)
645 *InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
649 /* Case 10: First interrupt number in list */
653 if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
655 /* Must be at least one interrupt */
657 AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
658 InitializerOp, NULL);
661 /* Check now for duplicates in list */
663 RsCheckListForDuplicates (InitializerOp);
665 /* Create a named field at the start of the list */
667 RsCreateWordField (InitializerOp, ACPI_RESTAG_PIN,
668 CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
673 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
676 MpSaveGpioInfo (Info->MappingOp, Descriptor,
677 PinCount, PinList, ResourceSource);
682 /*******************************************************************************
684 * FUNCTION: RsDoI2cSerialBusDescriptor
686 * PARAMETERS: Info - Parse Op and resource template offset
688 * RETURN: Completed resource node
690 * DESCRIPTION: Construct a long "I2cSerialBus" descriptor
692 ******************************************************************************/
695 RsDoI2cSerialBusDescriptor (
696 ASL_RESOURCE_INFO *Info)
698 AML_RESOURCE *Descriptor;
699 ACPI_PARSE_OBJECT *InitializerOp;
700 ASL_RESOURCE_NODE *Rnode;
701 char *ResourceSource = NULL;
702 UINT8 *VendorData = NULL;
703 UINT16 ResSourceLength;
705 UINT16 DescriptorSize;
706 UINT32 CurrentByteOffset;
710 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
711 CurrentByteOffset = Info->CurrentByteOffset;
714 * Calculate lengths for fields that have variable length:
715 * 1) Resource Source string
716 * 2) Vendor Data buffer
718 ResSourceLength = RsGetStringDataLength (InitializerOp);
719 VendorLength = RsGetBufferDataLength (InitializerOp);
721 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_I2C_SERIALBUS) +
722 ResSourceLength + VendorLength;
724 /* Allocate the local resource node and initialize */
726 Rnode = RsAllocateResourceNode (DescriptorSize +
727 sizeof (AML_RESOURCE_LARGE_HEADER));
729 Descriptor = Rnode->Buffer;
730 Descriptor->I2cSerialBus.ResourceLength = DescriptorSize;
731 Descriptor->I2cSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
732 Descriptor->I2cSerialBus.RevisionId = AML_RESOURCE_I2C_REVISION;
733 Descriptor->I2cSerialBus.TypeRevisionId = AML_RESOURCE_I2C_TYPE_REVISION;
734 Descriptor->I2cSerialBus.Type = AML_RESOURCE_I2C_SERIALBUSTYPE;
735 Descriptor->I2cSerialBus.TypeDataLength = AML_RESOURCE_I2C_MIN_DATA_LEN + VendorLength;
737 if (Info->DescriptorTypeOp->Asl.ParseOpcode == PARSEOP_I2C_SERIALBUS_V2)
739 Descriptor->I2cSerialBus.RevisionId = 2;
742 /* Build pointers to optional areas */
744 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_I2C_SERIALBUS));
745 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
747 /* Process all child initialization nodes */
749 for (i = 0; InitializerOp; i++)
753 case 0: /* Slave Address [WORD] (_ADR) */
755 Descriptor->I2cSerialBus.SlaveAddress = (UINT16) InitializerOp->Asl.Value.Integer;
756 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
757 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.SlaveAddress));
760 case 1: /* Slave Mode [Flag] (_SLV) */
762 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 0, 0);
763 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
764 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 0);
767 case 2: /* Connection Speed [DWORD] (_SPE) */
769 Descriptor->I2cSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
770 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
771 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.ConnectionSpeed));
774 case 3: /* Addressing Mode [Flag] (_MOD) */
776 RsSetFlagBits16 (&Descriptor->I2cSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
777 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
778 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.TypeSpecificFlags), 0);
781 case 4: /* ResSource [Optional Field - STRING] */
785 /* Copy string to the descriptor */
787 strcpy (ResourceSource,
788 InitializerOp->Asl.Value.String);
792 case 5: /* Resource Index */
794 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
796 Descriptor->I2cSerialBus.ResSourceIndex =
797 (UINT8) InitializerOp->Asl.Value.Integer;
801 case 6: /* Resource Usage (consumer/producer) */
803 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 1, 1);
806 case 7: /* Resource Tag (Descriptor Name) */
808 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
813 * Connection Share - Added for V2 (ACPI 6.0) version of the descriptor
814 * Note: For V1, the share bit will be zero (Op is DEFAULT_ARG from
817 RsSetFlagBits (&Descriptor->I2cSerialBus.Flags, InitializerOp, 2, 0);
818 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
819 CurrentByteOffset + ASL_RESDESC_OFFSET (I2cSerialBus.Flags), 2);
822 case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
824 RsGetVendorData (InitializerOp, VendorData,
825 CurrentByteOffset + sizeof (AML_RESOURCE_I2C_SERIALBUS));
828 default: /* Ignore any extra nodes */
833 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
836 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
841 /*******************************************************************************
843 * FUNCTION: RsDoSpiSerialBusDescriptor
845 * PARAMETERS: Info - Parse Op and resource template offset
847 * RETURN: Completed resource node
849 * DESCRIPTION: Construct a long "SPI Serial Bus" descriptor
851 ******************************************************************************/
854 RsDoSpiSerialBusDescriptor (
855 ASL_RESOURCE_INFO *Info)
857 AML_RESOURCE *Descriptor;
858 ACPI_PARSE_OBJECT *InitializerOp;
859 ASL_RESOURCE_NODE *Rnode;
860 char *ResourceSource = NULL;
861 UINT8 *VendorData = NULL;
862 UINT16 ResSourceLength;
864 UINT16 DescriptorSize;
865 UINT32 CurrentByteOffset;
869 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
870 CurrentByteOffset = Info->CurrentByteOffset;
873 * Calculate lengths for fields that have variable length:
874 * 1) Resource Source string
875 * 2) Vendor Data buffer
877 ResSourceLength = RsGetStringDataLength (InitializerOp);
878 VendorLength = RsGetBufferDataLength (InitializerOp);
880 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_SPI_SERIALBUS) +
881 ResSourceLength + VendorLength;
883 /* Allocate the local resource node and initialize */
885 Rnode = RsAllocateResourceNode (DescriptorSize +
886 sizeof (AML_RESOURCE_LARGE_HEADER));
888 Descriptor = Rnode->Buffer;
889 Descriptor->SpiSerialBus.ResourceLength = DescriptorSize;
890 Descriptor->SpiSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
891 Descriptor->SpiSerialBus.RevisionId = AML_RESOURCE_SPI_REVISION;
892 Descriptor->SpiSerialBus.TypeRevisionId = AML_RESOURCE_SPI_TYPE_REVISION;
893 Descriptor->SpiSerialBus.Type = AML_RESOURCE_SPI_SERIALBUSTYPE;
894 Descriptor->SpiSerialBus.TypeDataLength = AML_RESOURCE_SPI_MIN_DATA_LEN + VendorLength;
896 if (Info->DescriptorTypeOp->Asl.ParseOpcode == PARSEOP_SPI_SERIALBUS_V2)
898 Descriptor->I2cSerialBus.RevisionId = 2;
901 /* Build pointers to optional areas */
903 VendorData = ACPI_ADD_PTR (UINT8, Descriptor,
904 sizeof (AML_RESOURCE_SPI_SERIALBUS));
905 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
907 /* Process all child initialization nodes */
909 for (i = 0; InitializerOp; i++)
913 case 0: /* Device Selection [WORD] (_ADR) */
915 Descriptor->SpiSerialBus.DeviceSelection = (UINT16) InitializerOp->Asl.Value.Integer;
916 RsCreateWordField (InitializerOp, ACPI_RESTAG_ADDRESS,
917 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DeviceSelection));
920 case 1: /* Device Polarity [Flag] (_DPL) */
922 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 1, 0);
923 RsCreateBitField (InitializerOp, ACPI_RESTAG_DEVICEPOLARITY,
924 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 1);
927 case 2: /* Wire Mode [Flag] (_MOD) */
929 RsSetFlagBits16 (&Descriptor->SpiSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
930 RsCreateBitField (InitializerOp, ACPI_RESTAG_MODE,
931 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.TypeSpecificFlags), 0);
934 case 3: /* Device Bit Length [BYTE] (_LEN) */
936 Descriptor->SpiSerialBus.DataBitLength = (UINT8) InitializerOp->Asl.Value.Integer;
937 RsCreateByteField (InitializerOp, ACPI_RESTAG_LENGTH,
938 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.DataBitLength));
941 case 4: /* Slave Mode [Flag] (_SLV) */
943 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 0, 0);
944 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
945 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 0);
948 case 5: /* Connection Speed [DWORD] (_SPE) */
950 Descriptor->SpiSerialBus.ConnectionSpeed = (UINT32) InitializerOp->Asl.Value.Integer;
951 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
952 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ConnectionSpeed));
955 case 6: /* Clock Polarity [BYTE] (_POL) */
957 Descriptor->SpiSerialBus.ClockPolarity = (UINT8) InitializerOp->Asl.Value.Integer;
958 RsCreateByteField (InitializerOp, ACPI_RESTAG_POLARITY,
959 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPolarity));
962 case 7: /* Clock Phase [BYTE] (_PHA) */
964 Descriptor->SpiSerialBus.ClockPhase = (UINT8) InitializerOp->Asl.Value.Integer;
965 RsCreateByteField (InitializerOp, ACPI_RESTAG_PHASE,
966 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.ClockPhase));
969 case 8: /* ResSource [Optional Field - STRING] */
973 /* Copy string to the descriptor */
975 strcpy (ResourceSource,
976 InitializerOp->Asl.Value.String);
980 case 9: /* Resource Index */
982 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
984 Descriptor->SpiSerialBus.ResSourceIndex =
985 (UINT8) InitializerOp->Asl.Value.Integer;
989 case 10: /* Resource Usage (consumer/producer) */
991 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 1, 1);
994 case 11: /* Resource Tag (Descriptor Name) */
996 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
1001 * Connection Share - Added for V2 (ACPI 6.0) version of the descriptor
1002 * Note: For V1, the share bit will be zero (Op is DEFAULT_ARG from
1005 RsSetFlagBits (&Descriptor->SpiSerialBus.Flags, InitializerOp, 2, 0);
1006 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
1007 CurrentByteOffset + ASL_RESDESC_OFFSET (SpiSerialBus.Flags), 2);
1010 case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
1012 RsGetVendorData (InitializerOp, VendorData,
1013 CurrentByteOffset + sizeof (AML_RESOURCE_SPI_SERIALBUS));
1016 default: /* Ignore any extra nodes */
1021 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1024 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
1029 /*******************************************************************************
1031 * FUNCTION: RsDoUartSerialBusDescriptor
1033 * PARAMETERS: Info - Parse Op and resource template offset
1035 * RETURN: Completed resource node
1037 * DESCRIPTION: Construct a long "UART Serial Bus" descriptor
1039 ******************************************************************************/
1042 RsDoUartSerialBusDescriptor (
1043 ASL_RESOURCE_INFO *Info)
1045 AML_RESOURCE *Descriptor;
1046 ACPI_PARSE_OBJECT *InitializerOp;
1047 ASL_RESOURCE_NODE *Rnode;
1048 char *ResourceSource = NULL;
1049 UINT8 *VendorData = NULL;
1050 UINT16 ResSourceLength;
1051 UINT16 VendorLength;
1052 UINT16 DescriptorSize;
1053 UINT32 CurrentByteOffset;
1057 InitializerOp = Info->DescriptorTypeOp->Asl.Child;
1058 CurrentByteOffset = Info->CurrentByteOffset;
1061 * Calculate lengths for fields that have variable length:
1062 * 1) Resource Source string
1063 * 2) Vendor Data buffer
1065 ResSourceLength = RsGetStringDataLength (InitializerOp);
1066 VendorLength = RsGetBufferDataLength (InitializerOp);
1068 DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) +
1069 ResSourceLength + VendorLength;
1071 /* Allocate the local resource node and initialize */
1073 Rnode = RsAllocateResourceNode (DescriptorSize +
1074 sizeof (AML_RESOURCE_LARGE_HEADER));
1076 Descriptor = Rnode->Buffer;
1077 Descriptor->UartSerialBus.ResourceLength = DescriptorSize;
1078 Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
1079 Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION;
1080 Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION;
1081 Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE;
1082 Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength;
1084 if (Info->DescriptorTypeOp->Asl.ParseOpcode == PARSEOP_UART_SERIALBUS_V2)
1086 Descriptor->I2cSerialBus.RevisionId = 2;
1089 /* Build pointers to optional areas */
1091 VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS));
1092 ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
1094 /* Process all child initialization nodes */
1096 for (i = 0; InitializerOp; i++)
1100 case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */
1102 Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer;
1103 RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
1104 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate));
1107 case 1: /* Bits Per Byte [Flags] (_LEN) */
1109 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3);
1110 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH,
1111 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3);
1114 case 2: /* Stop Bits [Flags] (_STB) */
1116 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1);
1117 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS,
1118 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2);
1121 case 3: /* Lines In Use [BYTE] (_LIN) */
1123 Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer;
1124 RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE,
1125 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled));
1128 case 4: /* Endianness [Flag] (_END) */
1130 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0);
1131 RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS,
1132 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7);
1135 case 5: /* Parity [BYTE] (_PAR) */
1137 Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer;
1138 RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY,
1139 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity));
1142 case 6: /* Flow Control [Flags] (_FLC) */
1144 RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
1145 RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL,
1146 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2);
1149 case 7: /* Rx Buffer Size [WORD] (_RXL) */
1151 Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1152 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX,
1153 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize));
1156 case 8: /* Tx Buffer Size [WORD] (_TXL) */
1158 Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
1159 RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX,
1160 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize));
1163 case 9: /* ResSource [Optional Field - STRING] */
1165 if (ResSourceLength)
1167 /* Copy string to the descriptor */
1169 strcpy (ResourceSource,
1170 InitializerOp->Asl.Value.String);
1174 case 10: /* Resource Index */
1176 if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
1178 Descriptor->UartSerialBus.ResSourceIndex =
1179 (UINT8) InitializerOp->Asl.Value.Integer;
1183 case 11: /* Resource Usage (consumer/producer) */
1185 RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1);
1188 * Slave Mode [Flag] (_SLV)
1190 * Note: There is no SlaveMode argument to the UartSerialBus macro, but
1191 * we add this name anyway to allow the flag to be set by ASL in the
1192 * rare case where there is a slave mode associated with the UART.
1194 RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
1195 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0);
1198 case 12: /* Resource Tag (Descriptor Name) */
1200 UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
1205 * Connection Share - Added for V2 (ACPI 6.0) version of the descriptor
1206 * Note: For V1, the share bit will be zero (Op is DEFAULT_ARG from
1209 RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 2, 0);
1210 RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
1211 CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 2);
1214 case 14: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
1216 RsGetVendorData (InitializerOp, VendorData,
1217 CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS));
1220 default: /* Ignore any extra nodes */
1225 InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
1228 MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);