id.c

Go to the documentation of this file.

/*
 * PROJECT:         ReactOS PCI Bus Driver
 * LICENSE:         BSD - See COPYING.ARM in the top level directory
 * FILE:            drivers/bus/pci/pci/id.c
 * PURPOSE:         PCI Device Identification
 * PROGRAMMERS:     ReactOS Portable Systems Group
 */
 
/* INCLUDES *******************************************************************/
 
#include <pci.h>
#include <stdio.h>
 
#define NDEBUG
#include <debug.h>
 
/* FUNCTIONS ******************************************************************/
 
PWCHAR
NTAPI
PciGetDescriptionMessage(IN ULONG Identifier,
                         OUT PULONG Length)
{
    PMESSAGE_RESOURCE_ENTRY Entry;
    ULONG MaxCount, Count;
    PWCHAR Description, Buffer;
    ANSI_STRING MessageString;
    UNICODE_STRING UnicodeString;
    NTSTATUS Status;
 
    /* Find the message identifier in the message table */
    MessageString.Buffer = NULL;
    Status = RtlFindMessage(PciDriverObject->DriverStart,
                            RT_MESSAGETABLE,
                            MAKELANGID(LANG_NEUTRAL, SUBLANG_NEUTRAL),
                            Identifier,
                            &Entry);
    if (!NT_SUCCESS(Status)) return NULL;
 
    /* Check if the resource data is Unicode or ANSI */
    if (Entry->Flags & MESSAGE_RESOURCE_UNICODE)
    {
        ASSERT(Entry->Length >= FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text));
 
        /* The entry is padded after its terminator, so measure up to the first NUL */
        Description = (PWCHAR)Entry->Text;
        MaxCount = (Entry->Length - FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text)) / sizeof(*Description);
        Count = 0;
        while ((Count < MaxCount) && (Description[Count] != UNICODE_NULL))
        {
            Count++;
        }
 
        /* Drop the trailing line break, where there is one */
        while (Count && ((Description[Count - 1] == L'\n') ||
                         (Description[Count - 1] == L'\r')))
        {
            Count--;
        }
 
        /* Allocate the buffer to hold the message string */
        Buffer = ExAllocatePoolWithTag(PagedPool,
                                       (Count + 1) * sizeof(*Buffer),
                                       'BicP');
        if (!Buffer) return NULL;
 
        /* Copy the message across and terminate it */
        RtlCopyMemory(Buffer, Description, Count * sizeof(*Buffer));
        Buffer[Count] = UNICODE_NULL;
 
        /* Return the length to the caller, minus the terminating NULL */
        if (Length)
            *Length = Count * sizeof(*Buffer);
    }
    else
    {
        /* Initialize the entry as a string */
        RtlInitAnsiString(&MessageString, (PCHAR)Entry->Text);
 
        /* Drop the trailing line break, where there is one */
        while (MessageString.Length &&
               ((MessageString.Buffer[MessageString.Length - 1] == '\n') ||
                (MessageString.Buffer[MessageString.Length - 1] == '\r')))
        {
            MessageString.Length -= sizeof(*MessageString.Buffer);
        }
 
        /* Convert it to Unicode */
        Status = RtlAnsiStringToUnicodeString(&UnicodeString, &MessageString, TRUE);
        if (!NT_SUCCESS(Status))
            return NULL;
 
        Buffer = UnicodeString.Buffer;
 
        /* Return the length to the caller */
        if (Length) *Length = UnicodeString.Length;
    }
 
    /* Return the message buffer to the caller */
    return Buffer;
}
 
PWCHAR
NTAPI
PciGetDeviceDescriptionMessage(IN UCHAR BaseClass,
                               IN UCHAR SubClass)
{
    PWCHAR Message;
    ULONG Identifier;
 
    /* The message identifier in the table is encoded based on the PCI class */
    Identifier = (BaseClass << 8) | SubClass;
 
    /* Go grab the description message for this device */
    Message = PciGetDescriptionMessage(Identifier, NULL);
    if (!Message)
    {
        /* It wasn't found, allocate a buffer for a generic description */
        Message = ExAllocatePoolWithTag(PagedPool, sizeof(L"PCI Device"), 'bicP');
        if (Message) RtlCopyMemory(Message, L"PCI Device", sizeof(L"PCI Device"));
    }
 
    /* Return the description message */
    return Message;
}
 
VOID
NTAPI
PciInitIdBuffer(IN PPCI_ID_BUFFER IdBuffer)
{
    /* Initialize the sizes to zero and the pointer to the start of the buffer */
    IdBuffer->TotalLength = 0;
    IdBuffer->Count = 0;
    IdBuffer->CharBuffer = IdBuffer->BufferData;
}
 
ULONG
__cdecl
PciIdPrintf(IN PPCI_ID_BUFFER IdBuffer,
            IN PCCH Format,
            ...)
{
    ULONG Size, Length;
    PANSI_STRING AnsiString;
    va_list va;
 
    ASSERT(IdBuffer->Count < MAX_ANSI_STRINGS);
 
    /* Do the actual string formatting into the character buffer */
    va_start(va, Format);
    vsprintf(IdBuffer->CharBuffer, Format, va);
    va_end(va);
 
    /* Initialize the ANSI_STRING that will hold this string buffer */
    AnsiString = &IdBuffer->Strings[IdBuffer->Count];
    RtlInitAnsiString(AnsiString, IdBuffer->CharBuffer);
 
    /* Calculate the final size of the string, in Unicode */
    Size = RtlAnsiStringToUnicodeSize(AnsiString);
 
    /* Update hte buffer with the size,and update the character pointer */
    IdBuffer->StringSize[IdBuffer->Count] = Size;
    IdBuffer->TotalLength += Size;
    Length = AnsiString->Length + sizeof(ANSI_NULL);
    IdBuffer->CharBuffer += Length;
 
    /* Move to the next string for next time */
    IdBuffer->Count++;
 
    /* Return the length */
    return Length;
}
 
ULONG
__cdecl
PciIdPrintfAppend(IN PPCI_ID_BUFFER IdBuffer,
                  IN PCCH Format,
                  ...)
{
    ULONG NextId, Size, Length, MaxLength;
    PANSI_STRING AnsiString;
    va_list va;
 
    ASSERT(IdBuffer->Count);
 
    /* Choose the next static ANSI_STRING to use */
    NextId = IdBuffer->Count - 1;
 
    /* Max length is from the end of the buffer up until the current pointer */
    MaxLength = (PCHAR)(IdBuffer + 1) - IdBuffer->CharBuffer;
 
    /* Do the actual append, and return the length this string took */
    va_start(va, Format);
    Length = vsprintf(IdBuffer->CharBuffer - 1, Format, va);
    va_end(va);
    ASSERT(Length < MaxLength);
 
    /* Select the static ANSI_STRING, and update its length information */
    AnsiString = &IdBuffer->Strings[NextId];
    AnsiString->Length += Length;
    AnsiString->MaximumLength += Length;
 
    /* Calculate the final size of the string, in Unicode */
    Size = RtlAnsiStringToUnicodeSize(AnsiString);
 
    /* Only the growth of this string adds to the total, then move the character pointer */
    IdBuffer->TotalLength += Size - IdBuffer->StringSize[NextId];
    IdBuffer->StringSize[NextId] = Size;
    IdBuffer->CharBuffer += Length;
 
    /* Return the size */
    return Size;
}
 
NTSTATUS
NTAPI
PciQueryId(IN PPCI_PDO_EXTENSION DeviceExtension,
           IN BUS_QUERY_ID_TYPE QueryType,
           OUT PWCHAR *Buffer)
{
    ULONG SubsysId;
    CHAR VendorString[22];
    PPCI_PDO_EXTENSION PdoExtension;
    PPCI_FDO_EXTENSION ParentExtension;
    PWCHAR StringBuffer;
    ULONG i, Size;
    NTSTATUS Status;
    PANSI_STRING NextString;
    UNICODE_STRING DestinationString;
    PCI_ID_BUFFER IdBuffer;
    PAGED_CODE();
 
    /* Assume failure */
    Status = STATUS_SUCCESS;
    *Buffer = NULL;
 
    /* Start with the genric vendor string, which is the vendor ID + device ID */
    sprintf(VendorString,
            "PCI\\VEN_%04X&DEV_%04X",
            DeviceExtension->VendorId,
            DeviceExtension->DeviceId);
 
    /* Initialize the PCI ID Buffer */
    PciInitIdBuffer(&IdBuffer);
 
    /* Build the subsystem ID as shown in PCI ID Strings */
    SubsysId = DeviceExtension->SubsystemVendorId | (DeviceExtension->SubsystemId << 16);
 
    /* Check what the caller is requesting */
    switch (QueryType)
    {
        case BusQueryDeviceID:
 
            /* A single ID, the vendor string + the revision ID */
            PciIdPrintf(&IdBuffer,
                        "%s&SUBSYS_%08X&REV_%02X",
                        VendorString,
                        SubsysId,
                        DeviceExtension->RevisionId);
            break;
 
        case BusQueryHardwareIDs:
 
            /* First the vendor string + the subsystem ID + the revision ID */
            PciIdPrintf(&IdBuffer,
                        "%s&SUBSYS_%08X&REV_%02X",
                        VendorString,
                        SubsysId,
                        DeviceExtension->RevisionId);
 
            /* Next, without the revision */
            PciIdPrintf(&IdBuffer,
                        "%s&SUBSYS_%08X",
                        VendorString,
                        SubsysId);
 
            /* Next, the vendor string + the base class + sub class + progif */
            PciIdPrintf(&IdBuffer,
                        "%s&CC_%02X%02X%02X",
                        VendorString,
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass,
                        DeviceExtension->ProgIf);
 
            /* Next, without the progif */
            PciIdPrintf(&IdBuffer,
                        "%s&CC_%02X%02X",
                        VendorString,
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass);
 
            /* And finally, a terminator */
            PciIdPrintf(&IdBuffer, "\0");
            break;
 
        case BusQueryCompatibleIDs:
 
            /* First, the vendor + revision ID only */
            PciIdPrintf(&IdBuffer,
                        "%s&REV_%02X",
                        VendorString,
                        DeviceExtension->RevisionId);
 
            /* Next, the vendor string alone */
            PciIdPrintf(&IdBuffer, "%s", VendorString);
 
            /* Next, the vendor ID + the base class + the sub class + progif */
            PciIdPrintf(&IdBuffer,
                         "PCI\\VEN_%04X&CC_%02X%02X%02X",
                         DeviceExtension->VendorId,
                         DeviceExtension->BaseClass,
                         DeviceExtension->SubClass,
                         DeviceExtension->ProgIf);
 
            /* Now without the progif */
            PciIdPrintf(&IdBuffer,
                        "PCI\\VEN_%04X&CC_%02X%02X",
                        DeviceExtension->VendorId,
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass);
 
            /* And then just the vendor ID itself */
            PciIdPrintf(&IdBuffer,
                        "PCI\\VEN_%04X",
                        DeviceExtension->VendorId);
 
            /* Then the base class + subclass + progif, without any vendor */
            PciIdPrintf(&IdBuffer,
                        "PCI\\CC_%02X%02X%02X",
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass,
                        DeviceExtension->ProgIf);
 
            /* Next, without the progif */
            PciIdPrintf(&IdBuffer,
                        "PCI\\CC_%02X%02X",
                        DeviceExtension->BaseClass,
                        DeviceExtension->SubClass);
 
            /* And finally, a terminator */
            PciIdPrintf(&IdBuffer, "\0");
            break;
 
        case BusQueryInstanceID:
 
            /* Start with a terminator */
            PciIdPrintf(&IdBuffer, "\0");
 
            /* And then encode the device and function number */
            PciIdPrintfAppend(&IdBuffer,
                              "%02X",
                              (DeviceExtension->Slot.u.bits.DeviceNumber << 3) |
                              DeviceExtension->Slot.u.bits.FunctionNumber);
 
            /* Loop every parent until the root */
            ParentExtension = DeviceExtension->ParentFdoExtension;
            while (!PCI_IS_ROOT_FDO(ParentExtension))
            {
                /* Two more digits and their terminator have to fit */
                if ((IdBuffer.CharBuffer + 2) >
                    (IdBuffer.BufferData + sizeof(IdBuffer.BufferData)))
                {
                    DPRINT1("PCIX - Bridge chain too deep for an instance ID\n");
                    return STATUS_BUFFER_OVERFLOW;
                }
 
                /* And encode the parent's device and function number as well */
                PdoExtension = ParentExtension->PhysicalDeviceObject->DeviceExtension;
                PciIdPrintfAppend(&IdBuffer,
                                  "%02X",
                                  (PdoExtension->Slot.u.bits.DeviceNumber << 3) |
                                  PdoExtension->Slot.u.bits.FunctionNumber);
 
                /* Move up to the next bridge */
                ParentExtension = PdoExtension->ParentFdoExtension;
            }
            break;
 
        default:
 
            /* Unknown query type */
            DPRINT1("PCIX - PciQueryId expected ID type = %d\n", QueryType);
            return STATUS_NOT_SUPPORTED;
    }
 
    /* Something should've been generated if this has been reached */
    ASSERT(IdBuffer.Count > 0);
 
    /* Allocate the final string buffer to hold the ID */
    StringBuffer = ExAllocatePoolWithTag(PagedPool, IdBuffer.TotalLength, 'BicP');
    if (!StringBuffer) return STATUS_INSUFFICIENT_RESOURCES;
 
    /* Build the UNICODE_STRING structure for it */
    DPRINT("PCIX - PciQueryId(%d)\n", QueryType);
    DestinationString.Buffer = StringBuffer;
    DestinationString.MaximumLength = IdBuffer.TotalLength;
 
    /* Loop every ID in the buffer */
    for (i = 0; i < IdBuffer.Count; i++)
    {
        /* Select the ANSI_STRING for the ID */
        NextString = &IdBuffer.Strings[i];
        DPRINT("    <- \"%s\"\n", NextString->Buffer);
 
        /* Convert it to a UNICODE_STRING */
        Status = RtlAnsiStringToUnicodeString(&DestinationString, NextString, FALSE);
        ASSERT(NT_SUCCESS(Status));
 
        /* Add it into the final destination buffer */
        Size = IdBuffer.StringSize[i];
        DestinationString.MaximumLength -= Size;
        DestinationString.Buffer += (Size / sizeof(WCHAR));
    }
 
    /* Return the buffer to the caller and return status (should be success) */
    *Buffer = StringBuffer;
    return Status;
}
 
NTSTATUS
NTAPI
PciQueryDeviceText(IN PPCI_PDO_EXTENSION PdoExtension,
                   IN DEVICE_TEXT_TYPE QueryType,
                   IN ULONG Locale,
                   OUT PWCHAR *Buffer)
{
    PWCHAR MessageBuffer, LocationBuffer;
    ULONG Length;
    NTSTATUS Status;
 
    UNREFERENCED_PARAMETER(Locale);
 
    /* Check what the caller is requesting */
    switch (QueryType)
    {
        case DeviceTextDescription:
 
            /* Get the message from the resource section */
            MessageBuffer = PciGetDeviceDescriptionMessage(PdoExtension->BaseClass,
                                                           PdoExtension->SubClass);
 
            /* Return it to the caller, and select proper status code */
            *Buffer = MessageBuffer;
            Status = MessageBuffer ? STATUS_SUCCESS : STATUS_NOT_SUPPORTED;
            break;
 
        case DeviceTextLocationInformation:
 
            /* Get the message from the resource section */
            MessageBuffer = PciGetDescriptionMessage(0x10000, &Length);
            if (!MessageBuffer)
            {
                /* It should be there, but fail if it wasn't found for some reason */
                Status = STATUS_NOT_SUPPORTED;
                break;
            }
 
            /* Add space for a null-terminator, and allocate the buffer */
            Length += 2 * sizeof(UNICODE_NULL);
            LocationBuffer = ExAllocatePoolWithTag(PagedPool,
                                                   Length * sizeof(WCHAR),
                                                   'BicP');
            *Buffer = LocationBuffer;
 
            /* Check if the allocation succeeded */
            if (LocationBuffer)
            {
                /* Build the location string based on bus, function, and device */
                _swprintf(LocationBuffer,
                          MessageBuffer,
                          PdoExtension->ParentFdoExtension->BaseBus,
                          PdoExtension->Slot.u.bits.FunctionNumber,
                          PdoExtension->Slot.u.bits.DeviceNumber);
            }
 
            /* Free the original string from the resource section */
            ExFreePoolWithTag(MessageBuffer, 0);
 
            /* Select the correct status */
            Status = LocationBuffer ? STATUS_SUCCESS : STATUS_INSUFFICIENT_RESOURCES;
            break;
 
        default:
 
            /* Anything else is unsupported */
            Status = STATUS_NOT_SUPPORTED;
            break;
    }
 
    /* Return whether or not a device text string was indeed found */
    return Status;
}
 
/* EOF */