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); }