ASL_RESOURCE_NODE *
RsDoQwordMemoryDescriptor (
ACPI_PARSE_OBJECT *Op,
UINT32 CurrentByteOffset)
{
AML_RESOURCE *Descriptor;
ACPI_PARSE_OBJECT *InitializerOp;
ACPI_PARSE_OBJECT *MinOp = NULL;
ACPI_PARSE_OBJECT *MaxOp = NULL;
ACPI_PARSE_OBJECT *LengthOp = NULL;
ACPI_PARSE_OBJECT *GranOp = NULL;
ASL_RESOURCE_NODE *Rnode;
UINT8 *OptionalFields;
UINT16 StringLength = 0;
UINT32 OptionIndex = 0;
UINT32 i;
BOOLEAN ResSourceIndex = FALSE;
InitializerOp = Op->Asl.Child;
StringLength = RsGetStringDataLength (InitializerOp);
Rnode = RsAllocateResourceNode (
sizeof (AML_RESOURCE_ADDRESS64) + 1 + StringLength);
Descriptor = Rnode->Buffer;
Descriptor->Address64.DescriptorType = ACPI_RESOURCE_NAME_ADDRESS64;
Descriptor->Address64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
/*
* Initial descriptor length -- may be enlarged if there are
* optional fields present
*/
OptionalFields = ((UINT8 *) Descriptor) + sizeof (AML_RESOURCE_ADDRESS64);
Descriptor->Address64.ResourceLength = (UINT16)
(sizeof (AML_RESOURCE_ADDRESS64) -
sizeof (AML_RESOURCE_LARGE_HEADER));
/* Process all child initialization nodes */
for (i = 0; InitializerOp; i++)
{
switch (i)
{
case 0: /* Resource Usage */
RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 0, 1);
break;
case 1: /* DecodeType */
RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 1, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 1);
break;
case 2: /* MinType */
RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 2, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 2);
break;
case 3: /* MaxType */
RsSetFlagBits (&Descriptor->Address64.Flags, InitializerOp, 3, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Flags), 3);
break;
case 4: /* Memory Type */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 1, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 1, 2);
break;
case 5: /* Read/Write Type */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 0, 1);
RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 0);
break;
case 6: /* Address Granularity */
Descriptor->Address64.Granularity = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Granularity));
GranOp = InitializerOp;
break;
case 7: /* Min Address */
Descriptor->Address64.Minimum = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Minimum));
MinOp = InitializerOp;
break;
case 8: /* Max Address */
Descriptor->Address64.Maximum = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.Maximum));
MaxOp = InitializerOp;
break;
case 9: /* Translation Offset */
Descriptor->Address64.TranslationOffset = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.TranslationOffset));
break;
case 10: /* Address Length */
Descriptor->Address64.AddressLength = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.AddressLength));
LengthOp = InitializerOp;
break;
case 11: /* ResSourceIndex [Optional Field - BYTE] */
if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
{
OptionalFields[0] = (UINT8) InitializerOp->Asl.Value.Integer;
OptionIndex++;
Descriptor->Address64.ResourceLength++;
ResSourceIndex = TRUE;
}
break;
case 12: /* ResSource [Optional Field - STRING] */
if ((InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG) &&
(InitializerOp->Asl.Value.String))
{
if (StringLength)
{
Descriptor->Address64.ResourceLength = (UINT16)
(Descriptor->Address64.ResourceLength + StringLength);
strcpy ((char *)
&OptionalFields[OptionIndex],
InitializerOp->Asl.Value.String);
/* ResourceSourceIndex must also be valid */
if (!ResSourceIndex)
{
AslError (ASL_ERROR, ASL_MSG_RESOURCE_INDEX,
InitializerOp, NULL);
}
}
}
#if 0
/*
* Not a valid ResourceSource, ResourceSourceIndex must also
* be invalid
*/
else if (ResSourceIndex)
{
AslError (ASL_ERROR, ASL_MSG_RESOURCE_SOURCE,
InitializerOp, NULL);
}
#endif
break;
case 13: /* ResourceTag */
UtAttachNamepathToOwner (Op, InitializerOp);
break;
case 14: /* Address Range */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 3, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 3, 2);
break;
case 15: /* Type */
RsSetFlagBits (&Descriptor->Address64.SpecificFlags, InitializerOp, 5, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Address64.SpecificFlags), 5);
break;
default:
AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
break;
}
InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
}
/* Validate the Min/Max/Len/Gran values */
RsLargeAddressCheck (
Descriptor->Address64.Minimum,
Descriptor->Address64.Maximum,
Descriptor->Address64.AddressLength,
Descriptor->Address64.Granularity,
Descriptor->Address64.Flags,
MinOp, MaxOp, LengthOp, GranOp, Op);
Rnode->BufferLength = sizeof (AML_RESOURCE_ADDRESS64) +
OptionIndex + StringLength;
return (Rnode);
}
ASL_RESOURCE_NODE *
RsDoDmaDescriptor (
ACPI_PARSE_OBJECT *Op,
UINT32 CurrentByteOffset)
{
AML_RESOURCE *Descriptor;
ACPI_PARSE_OBJECT *InitializerOp;
ASL_RESOURCE_NODE *Rnode;
UINT32 i;
UINT8 DmaChannelMask = 0;
UINT8 DmaChannels = 0;
InitializerOp = Op->Asl.Child;
Rnode = RsAllocateResourceNode (sizeof (AML_RESOURCE_DMA));
Descriptor = Rnode->Buffer;
Descriptor->Dma.DescriptorType = ACPI_RESOURCE_NAME_DMA |
ASL_RDESC_DMA_SIZE;
/* Process all child initialization nodes */
for (i = 0; InitializerOp; i++)
{
switch (i)
{
case 0: /* DMA type */
RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 5, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_DMATYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 5, 2);
break;
case 1: /* Bus Master */
RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 2, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_BUSMASTER,
CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 2);
break;
case 2: /* Xfer Type (transfer width) */
RsSetFlagBits (&Descriptor->Dma.Flags, InitializerOp, 0, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_XFERTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Dma.Flags), 0, 2);
break;
case 3: /* Name */
UtAttachNamepathToOwner (Op, InitializerOp);
break;
default:
/* All DMA channel bytes are handled here, after flags and name */
if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
{
/* Up to 8 channels can be specified in the list */
DmaChannels++;
if (DmaChannels > 8)
{
AslError (ASL_ERROR, ASL_MSG_DMA_LIST,
InitializerOp, NULL);
return (Rnode);
}
/* Only DMA channels 0-7 are allowed (mask is 8 bits) */
if (InitializerOp->Asl.Value.Integer > 7)
{
AslError (ASL_ERROR, ASL_MSG_DMA_CHANNEL,
InitializerOp, NULL);
}
/* Build the mask */
DmaChannelMask |=
(1 << ((UINT8) InitializerOp->Asl.Value.Integer));
}
if (i == 4) /* case 4: First DMA byte */
{
/* Check now for duplicates in list */
RsCheckListForDuplicates (InitializerOp);
/* Create a named field at the start of the list */
RsCreateByteField (InitializerOp, ACPI_RESTAG_DMA,
CurrentByteOffset +
ASL_RESDESC_OFFSET (Dma.DmaChannelMask));
}
break;
}
InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
}
/* Now we can set the channel mask */
Descriptor->Dma.DmaChannelMask = DmaChannelMask;
return (Rnode);
}
ASL_RESOURCE_NODE *
RsDoGpioIoDescriptor (
ASL_RESOURCE_INFO *Info)
{
AML_RESOURCE *Descriptor;
ACPI_PARSE_OBJECT *InitializerOp;
ASL_RESOURCE_NODE *Rnode;
char *ResourceSource = NULL;
UINT8 *VendorData = NULL;
UINT16 *InterruptList = NULL;
UINT16 *PinList = NULL;
UINT16 ResSourceLength;
UINT16 VendorLength;
UINT16 InterruptLength;
UINT16 DescriptorSize;
UINT32 CurrentByteOffset;
UINT32 PinCount = 0;
UINT32 i;
InitializerOp = Info->DescriptorTypeOp->Asl.Child;
CurrentByteOffset = Info->CurrentByteOffset;
/*
* Calculate lengths for fields that have variable length:
* 1) Resource Source string
* 2) Vendor Data buffer
* 3) PIN (interrupt) list
*/
ResSourceLength = RsGetStringDataLength (InitializerOp);
VendorLength = RsGetBufferDataLength (InitializerOp);
InterruptLength = RsGetInterruptDataLength (InitializerOp);
PinList = InterruptList;
DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_GPIO) +
ResSourceLength + VendorLength + InterruptLength;
/* Allocate the local resource node and initialize */
Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
Descriptor = Rnode->Buffer;
Descriptor->Gpio.ResourceLength = DescriptorSize;
Descriptor->Gpio.DescriptorType = ACPI_RESOURCE_NAME_GPIO;
Descriptor->Gpio.RevisionId = AML_RESOURCE_GPIO_REVISION;
Descriptor->Gpio.ConnectionType = AML_RESOURCE_GPIO_TYPE_IO;
/* Build pointers to optional areas */
InterruptList = ACPI_ADD_PTR (UINT16, Descriptor, sizeof (AML_RESOURCE_GPIO));
PinList = InterruptList;
ResourceSource = ACPI_ADD_PTR (char, InterruptList, InterruptLength);
VendorData = ACPI_ADD_PTR (UINT8, ResourceSource, ResSourceLength);
/* Setup offsets within the descriptor */
Descriptor->Gpio.PinTableOffset = (UINT16)
ACPI_PTR_DIFF (InterruptList, Descriptor);
Descriptor->Gpio.ResSourceOffset = (UINT16)
ACPI_PTR_DIFF (ResourceSource, Descriptor);
DbgPrint (ASL_DEBUG_OUTPUT,
"%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, IntLen: %.2X\n",
"GpioIo", Descriptor->Gpio.ResourceLength, (UINT16) sizeof (AML_RESOURCE_GPIO),
ResSourceLength, VendorLength, InterruptLength);
/* Process all child initialization nodes */
for (i = 0; InitializerOp; i++)
{
switch (i)
{
case 0: /* Share Type [Flags] (_SHR) */
RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 3, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_INTERRUPTSHARE,
CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 3);
break;
case 1: /* Pin Config [BYTE] (_PPI) */
Descriptor->Gpio.PinConfig = (UINT8) InitializerOp->Asl.Value.Integer;
RsCreateByteField (InitializerOp, ACPI_RESTAG_PINCONFIG,
CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.PinConfig));
break;
case 2: /* Debounce Timeout [WORD] (_DBT) */
Descriptor->Gpio.DebounceTimeout = (UINT16) InitializerOp->Asl.Value.Integer;
RsCreateWordField (InitializerOp, ACPI_RESTAG_DEBOUNCETIME,
CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DebounceTimeout));
break;
case 3: /* Drive Strength [WORD] (_DRS) */
Descriptor->Gpio.DriveStrength = (UINT16) InitializerOp->Asl.Value.Integer;
RsCreateWordField (InitializerOp, ACPI_RESTAG_DRIVESTRENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.DriveStrength));
break;
case 4: /* I/O Restriction [Flag] (_IOR) */
RsSetFlagBits16 (&Descriptor->Gpio.IntFlags, InitializerOp, 0, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_IORESTRICTION,
CurrentByteOffset + ASL_RESDESC_OFFSET (Gpio.IntFlags), 0, 2);
break;
case 5: /* ResSource [Optional Field - STRING] */
if (ResSourceLength)
{
/* Copy string to the descriptor */
strcpy (ResourceSource,
InitializerOp->Asl.Value.String);
}
break;
case 6: /* Resource Index */
if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
{
Descriptor->Gpio.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
}
break;
case 7: /* Resource Usage (consumer/producer) */
RsSetFlagBits16 (&Descriptor->Gpio.Flags, InitializerOp, 0, 1);
break;
case 8: /* Resource Tag (Descriptor Name) */
UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
break;
case 9: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
/*
* Always set the VendorOffset even if there is no Vendor Data.
* This field is required in order to calculate the length
* of the ResourceSource at runtime.
*/
Descriptor->Gpio.VendorOffset = (UINT16)
ACPI_PTR_DIFF (VendorData, Descriptor);
if (RsGetVendorData (InitializerOp, VendorData,
(CurrentByteOffset + Descriptor->Gpio.VendorOffset)))
{
Descriptor->Gpio.VendorLength = VendorLength;
}
break;
default:
/*
* PINs come through here, repeatedly. Each PIN must be a DWORD.
* NOTE: there is no "length" field for this, so from ACPI spec:
* The number of pins in the table can be calculated from:
* PinCount = (Resource Source Name Offset - Pin Table Offset) / 2
* (implies resource source must immediately follow the pin list.)
* Name: _PIN
*/
*InterruptList = (UINT16) InitializerOp->Asl.Value.Integer;
InterruptList++;
PinCount++;
/* Case 10: First interrupt number in list */
if (i == 10)
{
if (InitializerOp->Asl.ParseOpcode == PARSEOP_DEFAULT_ARG)
{
/* Must be at least one interrupt */
AslError (ASL_ERROR, ASL_MSG_EX_INTERRUPT_LIST_MIN,
InitializerOp, NULL);
}
/* Check now for duplicates in list */
RsCheckListForDuplicates (InitializerOp);
/* Create a named field at the start of the list */
RsCreateDwordField (InitializerOp, ACPI_RESTAG_PIN,
CurrentByteOffset + Descriptor->Gpio.PinTableOffset);
}
break;
}
InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
}
MpSaveGpioInfo (Info->MappingOp, Descriptor, PinCount, PinList, ResourceSource);
return (Rnode);
}
ASL_RESOURCE_NODE *
RsDoExtendedMemoryDescriptor (
ACPI_PARSE_OBJECT *Op,
UINT32 CurrentByteOffset)
{
AML_RESOURCE *Descriptor;
ACPI_PARSE_OBJECT *InitializerOp;
ACPI_PARSE_OBJECT *MinOp = NULL;
ACPI_PARSE_OBJECT *MaxOp = NULL;
ACPI_PARSE_OBJECT *LengthOp = NULL;
ACPI_PARSE_OBJECT *GranOp = NULL;
ASL_RESOURCE_NODE *Rnode;
UINT16 StringLength = 0;
UINT32 i;
InitializerOp = Op->Asl.Child;
StringLength = RsGetStringDataLength (InitializerOp);
Rnode = RsAllocateResourceNode (
sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + 1 + StringLength);
Descriptor = Rnode->Buffer;
Descriptor->ExtAddress64.DescriptorType = ACPI_RESOURCE_NAME_EXTENDED_ADDRESS64;
Descriptor->ExtAddress64.ResourceType = ACPI_ADDRESS_TYPE_MEMORY_RANGE;
Descriptor->ExtAddress64.RevisionID = AML_RESOURCE_EXTENDED_ADDRESS_REVISION;
Descriptor->ExtAddress64.ResourceLength = (UINT16)
(sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) -
sizeof (AML_RESOURCE_LARGE_HEADER));
/* Process all child initialization nodes */
for (i = 0; InitializerOp; i++)
{
switch (i)
{
case 0: /* Resource Usage */
RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 0, 1);
break;
case 1: /* DecodeType */
RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 1, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_DECODE,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 1);
break;
case 2: /* MinType */
RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 2, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_MINTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 2);
break;
case 3: /* MaxType */
RsSetFlagBits (&Descriptor->ExtAddress64.Flags, InitializerOp, 3, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_MAXTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Flags), 3);
break;
case 4: /* Memory Type */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 1, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMTYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 1, 2);
break;
case 5: /* Read/Write Type */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 0, 1);
RsCreateBitField (InitializerOp, ACPI_RESTAG_READWRITETYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 0);
break;
case 6: /* Address Granularity */
Descriptor->ExtAddress64.Granularity = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_GRANULARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Granularity));
GranOp = InitializerOp;
break;
case 7: /* Min Address */
Descriptor->ExtAddress64.Minimum = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_MINADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Minimum));
MinOp = InitializerOp;
break;
case 8: /* Max Address */
Descriptor->ExtAddress64.Maximum = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_MAXADDR,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.Maximum));
MaxOp = InitializerOp;
break;
case 9: /* Translation Offset */
Descriptor->ExtAddress64.TranslationOffset = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_TRANSLATION,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TranslationOffset));
break;
case 10: /* Address Length */
Descriptor->ExtAddress64.AddressLength = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.AddressLength));
LengthOp = InitializerOp;
break;
case 11: /* Type-Specific Attributes */
Descriptor->ExtAddress64.TypeSpecific = InitializerOp->Asl.Value.Integer;
RsCreateQwordField (InitializerOp, ACPI_RESTAG_TYPESPECIFICATTRIBUTES,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.TypeSpecific));
break;
case 12: /* ResourceTag */
UtAttachNamepathToOwner (Op, InitializerOp);
break;
case 13: /* Address Range */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 3, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_MEMATTRIBUTES,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 3, 2);
break;
case 14: /* Type */
RsSetFlagBits (&Descriptor->ExtAddress64.SpecificFlags, InitializerOp, 5, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_TYPE,
CurrentByteOffset + ASL_RESDESC_OFFSET (ExtAddress64.SpecificFlags), 5);
break;
default:
AslError (ASL_ERROR, ASL_MSG_RESOURCE_LIST, InitializerOp, NULL);
break;
}
InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
}
/* Validate the Min/Max/Len/Gran values */
RsLargeAddressCheck (
Descriptor->ExtAddress64.Minimum,
Descriptor->ExtAddress64.Maximum,
Descriptor->ExtAddress64.AddressLength,
Descriptor->ExtAddress64.Granularity,
Descriptor->ExtAddress64.Flags,
MinOp, MaxOp, LengthOp, GranOp, Op);
Rnode->BufferLength = sizeof (AML_RESOURCE_EXTENDED_ADDRESS64) + StringLength;
return (Rnode);
}
ASL_RESOURCE_NODE *
RsDoUartSerialBusDescriptor (
ASL_RESOURCE_INFO *Info)
{
AML_RESOURCE *Descriptor;
ACPI_PARSE_OBJECT *InitializerOp;
ASL_RESOURCE_NODE *Rnode;
char *ResourceSource = NULL;
UINT8 *VendorData = NULL;
UINT16 ResSourceLength;
UINT16 VendorLength;
UINT16 DescriptorSize;
UINT32 CurrentByteOffset;
UINT32 i;
InitializerOp = Info->DescriptorTypeOp->Asl.Child;
CurrentByteOffset = Info->CurrentByteOffset;
/*
* Calculate lengths for fields that have variable length:
* 1) Resource Source string
* 2) Vendor Data buffer
*/
ResSourceLength = RsGetStringDataLength (InitializerOp);
VendorLength = RsGetBufferDataLength (InitializerOp);
DescriptorSize = ACPI_AML_SIZE_LARGE (AML_RESOURCE_UART_SERIALBUS) +
ResSourceLength + VendorLength;
/* Allocate the local resource node and initialize */
Rnode = RsAllocateResourceNode (DescriptorSize + sizeof (AML_RESOURCE_LARGE_HEADER));
Descriptor = Rnode->Buffer;
Descriptor->UartSerialBus.ResourceLength = DescriptorSize;
Descriptor->UartSerialBus.DescriptorType = ACPI_RESOURCE_NAME_SERIAL_BUS;
Descriptor->UartSerialBus.RevisionId = AML_RESOURCE_UART_REVISION;
Descriptor->UartSerialBus.TypeRevisionId = AML_RESOURCE_UART_TYPE_REVISION;
Descriptor->UartSerialBus.Type = AML_RESOURCE_UART_SERIALBUSTYPE;
Descriptor->UartSerialBus.TypeDataLength = AML_RESOURCE_UART_MIN_DATA_LEN + VendorLength;
/* Build pointers to optional areas */
VendorData = ACPI_ADD_PTR (UINT8, Descriptor, sizeof (AML_RESOURCE_UART_SERIALBUS));
ResourceSource = ACPI_ADD_PTR (char, VendorData, VendorLength);
DbgPrint (ASL_DEBUG_OUTPUT,
"%16s - Actual: %.2X, Base: %.2X, ResLen: %.2X, VendLen: %.2X, TypLen: %.2X\n",
"UartSerialBus", Descriptor->UartSerialBus.ResourceLength,
(UINT16) sizeof (AML_RESOURCE_UART_SERIALBUS), ResSourceLength,
VendorLength, Descriptor->UartSerialBus.TypeDataLength);
/* Process all child initialization nodes */
for (i = 0; InitializerOp; i++)
{
switch (i)
{
case 0: /* Connection Speed (Baud Rate) [DWORD] (_SPE) */
Descriptor->UartSerialBus.DefaultBaudRate = (UINT32) InitializerOp->Asl.Value.Integer;
RsCreateDwordField (InitializerOp, ACPI_RESTAG_SPEED,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.DefaultBaudRate));
break;
case 1: /* Bits Per Byte [Flags] (_LEN) */
RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 4, 3);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_LENGTH,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 4, 3);
break;
case 2: /* Stop Bits [Flags] (_STB) */
RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 2, 1);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_STOPBITS,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 2, 2);
break;
case 3: /* Lines In Use [BYTE] (_LIN) */
Descriptor->UartSerialBus.LinesEnabled = (UINT8) InitializerOp->Asl.Value.Integer;
RsCreateByteField (InitializerOp, ACPI_RESTAG_LINE,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.LinesEnabled));
break;
case 4: /* Endianness [Flag] (_END) */
RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 7, 0);
RsCreateBitField (InitializerOp, ACPI_RESTAG_ENDIANNESS,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 7);
break;
case 5: /* Parity [BYTE] (_PAR) */
Descriptor->UartSerialBus.Parity = (UINT8) InitializerOp->Asl.Value.Integer;
RsCreateByteField (InitializerOp, ACPI_RESTAG_PARITY,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Parity));
break;
case 6: /* Flow Control [Flags] (_FLC) */
RsSetFlagBits16 (&Descriptor->UartSerialBus.TypeSpecificFlags, InitializerOp, 0, 0);
RsCreateMultiBitField (InitializerOp, ACPI_RESTAG_FLOWCONTROL,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TypeSpecificFlags), 0, 2);
break;
case 7: /* Rx Buffer Size [WORD] (_RXL) */
Descriptor->UartSerialBus.RxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_RX,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.RxFifoSize));
break;
case 8: /* Tx Buffer Size [WORD] (_TXL) */
Descriptor->UartSerialBus.TxFifoSize = (UINT16) InitializerOp->Asl.Value.Integer;
RsCreateWordField (InitializerOp, ACPI_RESTAG_LENGTH_TX,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.TxFifoSize));
break;
case 9: /* ResSource [Optional Field - STRING] */
if (ResSourceLength)
{
/* Copy string to the descriptor */
strcpy (ResourceSource,
InitializerOp->Asl.Value.String);
}
break;
case 10: /* Resource Index */
if (InitializerOp->Asl.ParseOpcode != PARSEOP_DEFAULT_ARG)
{
Descriptor->UartSerialBus.ResSourceIndex = (UINT8) InitializerOp->Asl.Value.Integer;
}
break;
case 11: /* Resource Usage (consumer/producer) */
RsSetFlagBits (&Descriptor->UartSerialBus.Flags, InitializerOp, 1, 1);
/*
* Slave Mode [Flag] (_SLV)
*
* Note: There is no SlaveMode argument to the UartSerialBus macro, but
* we add this name anyway to allow the flag to be set by ASL in the
* rare case where there is a slave mode associated with the UART.
*/
RsCreateBitField (InitializerOp, ACPI_RESTAG_SLAVEMODE,
CurrentByteOffset + ASL_RESDESC_OFFSET (UartSerialBus.Flags), 0);
break;
case 12: /* Resource Tag (Descriptor Name) */
UtAttachNamepathToOwner (Info->DescriptorTypeOp, InitializerOp);
break;
case 13: /* Vendor Data (Optional - Buffer of BYTEs) (_VEN) */
RsGetVendorData (InitializerOp, VendorData,
CurrentByteOffset + sizeof (AML_RESOURCE_UART_SERIALBUS));
break;
default: /* Ignore any extra nodes */
break;
}
InitializerOp = RsCompleteNodeAndGetNext (InitializerOp);
}
MpSaveSerialInfo (Info->MappingOp, Descriptor, ResourceSource);
return (Rnode);
}
